Api

type Api struct {
	// contains filtered or unexported fields
}

Api is a loaded runtime: the shared library plus its abi-version table. The library stays mapped for the process's lifetime (a runtime that loads device driver stacks must never be unloaded mid-process).

Constructors and associated declarations

Load

func Load(path string) (*Api, error)

Load opens the runtime shared library at path (libClikaRT.so; libClikaRT.dylib on macOS) and runs the two-arm handshake: the runtime must serve AbiVersion, and its api table must carry LayoutFingerprint, the layout fingerprint this package's generated surface was emitted from.

LoadWithAbi

func LoadWithAbi(path string, abiVersion uint32) (*Api, error)

LoadWithAbi loads with an explicit abi version and this package's LayoutFingerprint; a runtime that cannot serve the version is refused here, before the first call.

LoadWithStamp

func LoadWithStamp(path string, abiVersion uint32, layoutFingerprint string) (*Api, error)

LoadWithStamp loads with an explicit abi version and an explicit expected layout fingerprint. The runtime is refused with an Error whose Status is StatusUnsupported, before any api-table slot is called, when it does not serve abiVersion, when its table's layout fingerprint differs from the C header this package compiled against, or when it differs from layoutFingerprint. The message names the comparison that failed and whether to rebuild or regenerate the bindings.

Methods

AddScalar

func (a *Api) AddScalar(t *Tensor, s float64) (*Tensor, error)

AddScalar computes t + s elementwise. Non-consuming: the wrapper retains t before the consuming C call (retain-before-consuming-op), so t stays valid; the caller releases both t and the result.

BFloat16FromBits

func (a *Api) BFloat16FromBits(bits []uint16, shape []int64) (*Tensor, error)

BFloat16FromBits builds a bfloat16 tensor from the 16-bit patterns (one bfloat16 pattern per uint16).

CaptureScopeAddMarker

func (api *Api) CaptureScopeAddMarker(self *CaptureScope, label string) (error)

CaptureScopeAddMarker wraps api-table member `capture_scope_add_marker`. ClikaRT::ProfileSession::CaptureScope::add_marker <- ClikaRT/profiler/profiler.h

CaptureScopeFree

func (api *Api) CaptureScopeFree(h *CaptureScope)

CaptureScopeFree wraps api-table member `capture_scope_free`.

CompiledFunctionCall

func (api *Api) CompiledFunctionCall(self *CompiledFunction, inputs []*Tensor) (*TensorList, error)

CompiledFunctionCall wraps api-table member `compiled_function_call`. call the function: inputs are BORROWED; returns the function's own outputs (surfaced state rides take_graph, never the call)

CompiledFunctionFree

func (api *Api) CompiledFunctionFree(h *CompiledFunction)

CompiledFunctionFree wraps api-table member `compiled_function_free`.

CompiledFunctionFromGraph

func (api *Api) CompiledFunctionFromGraph(graph *ModelGraph) (*CompiledFunction, error)

CompiledFunctionFromGraph wraps api-table member `compiled_function_from_graph`. wrap an already-captured graph: born in the Compiled state, serving shape-matching calls from the graph; consumes `graph` (contract §6). No callable is attached; shape drift refuses readably, never an eager fallback or a silent re-capture

CompiledFunctionRecaptureCount

func (api *Api) CompiledFunctionRecaptureCount(self *CompiledFunction) int64

CompiledFunctionRecaptureCount wraps api-table member `compiled_function_recapture_count`. ClikaRT::graph::CompiledFunction::recapture_count <- ClikaRT/graph/compile.h

CompiledFunctionState

func (api *Api) CompiledFunctionState(self *CompiledFunction) State

CompiledFunctionState wraps api-table member `compiled_function_state`. ClikaRT::graph::CompiledFunction::state <- ClikaRT/graph/compile.h

CompiledFunctionTakeGraph

func (api *Api) CompiledFunctionTakeGraph(self *CompiledFunction) (*ModelGraph, error)

CompiledFunctionTakeGraph wraps api-table member `compiled_function_take_graph`. ClikaRT::graph::CompiledFunction::take_graph <- ClikaRT/graph/compile.h

DeviceCpu

func (api *Api) DeviceCpu(i int32) Device

DeviceCpu wraps api-table member `device_cpu`. ClikaRT::Device::cpu <- ClikaRT/compute/device.h

DeviceCuda

func (api *Api) DeviceCuda(i int32) Device

DeviceCuda wraps api-table member `device_cuda`. ClikaRT::Device::cuda <- ClikaRT/compute/device.h

DeviceGpu

func (api *Api) DeviceGpu(index int32) Device

DeviceGpu wraps api-table member `device_gpu`. ClikaRT::Device::gpu <- ClikaRT/compute/device.h

DeviceHtp

func (api *Api) DeviceHtp(i int32) Device

DeviceHtp wraps api-table member `device_htp`. ClikaRT::Device::htp <- ClikaRT/compute/device.h

DeviceIsCpu

func (api *Api) DeviceIsCpu(self Device) bool

DeviceIsCpu wraps api-table member `device_is_cpu`. ClikaRT::Device::is_cpu <- ClikaRT/compute/device.h

DeviceIsCuda

func (api *Api) DeviceIsCuda(self Device) bool

DeviceIsCuda wraps api-table member `device_is_cuda`. ClikaRT::Device::is_cuda <- ClikaRT/compute/device.h

DeviceIsHtp

func (api *Api) DeviceIsHtp(self Device) bool

DeviceIsHtp wraps api-table member `device_is_htp`. ClikaRT::Device::is_htp <- ClikaRT/compute/device.h

DeviceIsMetal

func (api *Api) DeviceIsMetal(self Device) bool

DeviceIsMetal wraps api-table member `device_is_metal`. ClikaRT::Device::is_metal <- ClikaRT/compute/device.h

DeviceIsTpu

func (api *Api) DeviceIsTpu(self Device) bool

DeviceIsTpu wraps api-table member `device_is_tpu`. ClikaRT::Device::is_tpu <- ClikaRT/compute/device.h

DeviceIsVulkan

func (api *Api) DeviceIsVulkan(self Device) bool

DeviceIsVulkan wraps api-table member `device_is_vulkan`. ClikaRT::Device::is_vulkan <- ClikaRT/compute/device.h

DeviceMetal

func (api *Api) DeviceMetal(i int32) Device

DeviceMetal wraps api-table member `device_metal`. ClikaRT::Device::metal <- ClikaRT/compute/device.h

DeviceTpu

func (api *Api) DeviceTpu(i int32) Device

DeviceTpu wraps api-table member `device_tpu`. ClikaRT::Device::tpu <- ClikaRT/compute/device.h

DeviceVulkan

func (api *Api) DeviceVulkan(i int32) Device

DeviceVulkan wraps api-table member `device_vulkan`. ClikaRT::Device::vulkan <- ClikaRT/compute/device.h

EagerScopeClose

func (api *Api) EagerScopeClose(scope *EagerScope)

EagerScopeClose wraps api-table member `eager_scope_close`. exit: restores the mode this thread had at open, and frees the handle (NULL is a no-op)

EagerScopeOpen

func (api *Api) EagerScopeOpen() (*EagerScope, error)

EagerScopeOpen wraps api-table member `eager_scope_open`. enter: this thread runs every op eagerly until close, even inside an outer tracing scope; close on the SAME thread

EncodeAudio

func (api *Api) EncodeAudio(samples *Tensor, sampleRate int32) ([]byte, error)

EncodeAudio wraps api-table member `encode_audio`. ClikaRT::io::encode_audio <- ClikaRT/io/io.h

EncodeImage

func (api *Api) EncodeImage(image *Tensor) ([]byte, error)

EncodeImage wraps api-table member `encode_image`. ClikaRT::io::encode_image <- ClikaRT/io/io.h

EncodedAttentionMask

func (api *Api) EncodedAttentionMask(e *Encoded) *Tensor

EncodedAttentionMask wraps api-table member `encoded_attention_mask`. the attention mask, or NULL (padded path only); a non-NULL return is RETAINED; the caller releases it

EncodedCuSeqlens

func (api *Api) EncodedCuSeqlens(e *Encoded) *Tensor

EncodedCuSeqlens wraps api-table member `encoded_cu_seqlens`. exclusive prefix sums (the varlen offset table), or NULL; a non-NULL return is RETAINED; the caller releases it

EncodedFree

func (api *Api) EncodedFree(e *Encoded)

EncodedFree wraps api-table member `encoded_free`.

EncodedIdsAt

func (api *Api) EncodedIdsAt(e *Encoded, i uint) ([]int32, error)

EncodedIdsAt wraps api-table member `encoded_ids_at`. row i's token ids; two-call sizing (buf NULL sizes; count carries capacity in, required count out)

EncodedInputIds

func (api *Api) EncodedInputIds(e *Encoded) *Tensor

EncodedInputIds wraps api-table member `encoded_input_ids`. the input-id tensor, or NULL when the encode did not build tensors; a non-NULL return is RETAINED; the caller releases it

EncodedNumSequences

func (api *Api) EncodedNumSequences(e *Encoded) uint

EncodedNumSequences wraps api-table member `encoded_num_sequences`. how many id rows the encode produced

EncodedSeqLengths

func (api *Api) EncodedSeqLengths(e *Encoded) *Tensor

EncodedSeqLengths wraps api-table member `encoded_seq_lengths`. per-sequence token counts, or NULL; a non-NULL return is RETAINED ; the caller releases it

Float16FromBits

func (a *Api) Float16FromBits(bits []uint16, shape []int64) (*Tensor, error)

Float16FromBits builds a float16 tensor from the 16-bit patterns (one IEEE-754 binary16 pattern per uint16, the bit-carrier form for a dtype this language has no native element for).

FromBytes

func (a *Api) FromBytes(data []byte, shape []int64, dtype DataType,
	where StreamOrDevice) (*Tensor, error)

FromBytes copies raw payload bytes (row-major over shape, at dtype's own layout) into a new tensor placed at where, the full-control entry form. The byte count must match shape x dtype; the runtime validates.

GgufCheckpointFree

func (api *Api) GgufCheckpointFree(c *GgufCheckpoint)

GgufCheckpointFree wraps api-table member `gguf_checkpoint_free`.

GgufCheckpointMetadata

func (api *Api) GgufCheckpointMetadata(c *GgufCheckpoint) (string, error)

GgufCheckpointMetadata wraps api-table member `gguf_checkpoint_metadata`. the file's metadata key/value pairs as a JSON document (sized-string protocol)

GgufCheckpointTakeTensors

func (api *Api) GgufCheckpointTakeTensors(c *GgufCheckpoint) (*TensorsContainer, error)

GgufCheckpointTakeTensors wraps api-table member `gguf_checkpoint_take_tensors`. moves the lazy tensor container out; valid ONCE; a second take is an error

LoadAudioBytes

func (api *Api) LoadAudioBytes(bytes []byte, targetSampleRate int32, targetChannels int32) (*Tensor, AudioInfo, error)

LoadAudioBytes wraps api-table member `load_audio_bytes`. ClikaRT::io::load_audio <- ClikaRT/io/io.h

LoadAudioPath

func (api *Api) LoadAudioPath(path string, targetSampleRate int32, targetChannels int32) (*Tensor, AudioInfo, error)

LoadAudioPath wraps api-table member `load_audio_path`. ClikaRT::io::load_audio <- ClikaRT/io/io.h

LoadGgufToGgufCheckpoint

func (api *Api) LoadGgufToGgufCheckpoint(path string, policyDevice StreamOrDevice, policySticky bool) (*GgufCheckpoint, error)

LoadGgufToGgufCheckpoint wraps api-table member `load_gguf_to_gguf_checkpoint`. ClikaRT::io::load_gguf <- ClikaRT/io/io.h

LoadImageBytes

func (api *Api) LoadImageBytes(bytes []byte, requestedChannels int32) (*Tensor, error)

LoadImageBytes wraps api-table member `load_image_bytes`. ClikaRT::io::load_image <- ClikaRT/io/io.h

LoadImagePath

func (api *Api) LoadImagePath(path string, requestedChannels int32) (*Tensor, error)

LoadImagePath wraps api-table member `load_image_path`. ClikaRT::io::load_image <- ClikaRT/io/io.h

LoadNpy

func (api *Api) LoadNpy(path string, device Device) (*Tensor, error)

LoadNpy wraps api-table member `load_npy`. ClikaRT::io::load_npy <- ClikaRT/io/io.h

LoadSafetensorsToTensorsContainer

func (api *Api) LoadSafetensorsToTensorsContainer(path string, policyDevice StreamOrDevice, policySticky bool) (*TensorsContainer, error)

LoadSafetensorsToTensorsContainer wraps api-table member `load_safetensors_to_tensors_container`. ClikaRT::io::load_safetensors <- ClikaRT/io/io.h

LoadTorchCheckpointToTensorsContainer

func (api *Api) LoadTorchCheckpointToTensorsContainer(path string, policyDevice StreamOrDevice, policySticky bool) (*TensorsContainer, error)

LoadTorchCheckpointToTensorsContainer wraps api-table member `load_torch_checkpoint_to_tensors_container`. ClikaRT::io::load_torch_checkpoint <- ClikaRT/io/io.h

MakeQuantized

func (api *Api) MakeQuantized(payload *Tensor, scheme string, logicalShape []int64, globalScale *Tensor) (*QTensor, error)

MakeQuantized wraps api-table member `make_quantized`. ClikaRT::make_quantized <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): globalScale.

MakeQuantizedAffine

func (api *Api) MakeQuantizedAffine(codes *Tensor, scales *Tensor, biases *Tensor, groupSize int64, bits int64, logicalShape []int64) (*QTensor, error)

MakeQuantizedAffine wraps api-table member `make_quantized_affine`. ClikaRT::make_quantized_affine <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

MakeQuantizedAwq

func (api *Api) MakeQuantizedAwq(qweight *Tensor, qzeros *Tensor, scales *Tensor, bits int64, groupSize int64) (*QTensor, error)

MakeQuantizedAwq wraps api-table member `make_quantized_awq`. ClikaRT::make_quantized_awq <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

MakeQuantizedBnb4

func (api *Api) MakeQuantizedBnb4(packed *Tensor, absmax *Tensor, nestedAbsmax *Tensor, nestedQuantMap *Tensor, offset *Tensor, quantMap *Tensor, quantType string, blocksize int64, nestedBlocksize int64, shape []int64) (*QTensor, error)

MakeQuantizedBnb4 wraps api-table member `make_quantized_bnb4`. ClikaRT::make_quantized_bnb4 <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): nestedAbsmax, nestedQuantMap, offset, quantMap.

MakeQuantizedCtPack

func (api *Api) MakeQuantizedCtPack(packed *Tensor, scales *Tensor, bits int64, groupSize int64) (*QTensor, error)

MakeQuantizedCtPack wraps api-table member `make_quantized_ct_pack`. ClikaRT::make_quantized_ct_pack <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

MakeQuantizedFp8

func (api *Api) MakeQuantizedFp8(codes *Tensor, scale *Tensor, logicalShape []int64) (*QTensor, error)

MakeQuantizedFp8 wraps api-table member `make_quantized_fp8`. ClikaRT::make_quantized_fp8 <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

MakeQuantizedFp8Blocked

func (api *Api) MakeQuantizedFp8Blocked(codes *Tensor, scale *Tensor, blockSize int64, logicalShape []int64) (*QTensor, error)

MakeQuantizedFp8Blocked wraps api-table member `make_quantized_fp8_blocked`. ClikaRT::make_quantized_fp8_blocked <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

MakeQuantizedGptq

func (api *Api) MakeQuantizedGptq(qweight *Tensor, qzeros *Tensor, scales *Tensor, gIdx *Tensor, bits int64, groupSize int64, zerosConvention ZerosConvention) (*QTensor, error)

MakeQuantizedGptq wraps api-table member `make_quantized_gptq`. ClikaRT::make_quantized_gptq <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): gIdx.

MakeQuantizedMxfp4

func (api *Api) MakeQuantizedMxfp4(blocks *Tensor, scales *Tensor, logicalShape []int64) (*QTensor, error)

MakeQuantizedMxfp4 wraps api-table member `make_quantized_mxfp4`. ClikaRT::make_quantized_mxfp4 <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

MakeQuantizedNvfp4

func (api *Api) MakeQuantizedNvfp4(codes *Tensor, subScales *Tensor, globalScale *Tensor, logicalShape []int64) (*QTensor, error)

MakeQuantizedNvfp4 wraps api-table member `make_quantized_nvfp4`. ClikaRT::make_quantized_nvfp4 <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): globalScale.

MemoryStats

func (api *Api) MemoryStats(device Device) (MemoryStats, error)

MemoryStats wraps api-table member `memory_stats`. ClikaRT::device::memory_stats <- ClikaRT/compute/memory_stats.h

ModelGraphFree

func (api *Api) ModelGraphFree(h *ModelGraph)

ModelGraphFree wraps api-table member `model_graph_free`.

ModelGraphInputNames

func (api *Api) ModelGraphInputNames(self *ModelGraph) *StringList

ModelGraphInputNames wraps api-table member `model_graph_input_names`. ClikaRT::graph::ModelGraph::input_names <- ClikaRT/graph/model_graph.h

ModelGraphOutputNames

func (api *Api) ModelGraphOutputNames(self *ModelGraph) *StringList

ModelGraphOutputNames wraps api-table member `model_graph_output_names`. ClikaRT::graph::ModelGraph::output_names <- ClikaRT/graph/model_graph.h

ModelGraphRunVector

func (api *Api) ModelGraphRunVector(self *ModelGraph, inputs []*Tensor) (*TensorList, error)

ModelGraphRunVector wraps api-table member `model_graph_run_vector`. ClikaRT::graph::ModelGraph::run <- ClikaRT/graph/model_graph.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

ModelGraphRunVectorBoundOutputs

func (api *Api) ModelGraphRunVectorBoundOutputs(self *ModelGraph, inputs []*Tensor, boundOutputs []*Tensor) (*TensorList, error)

ModelGraphRunVectorBoundOutputs wraps api-table member `model_graph_run_vector_bound_outputs`. ClikaRT::graph::ModelGraph::run <- ClikaRT/graph/model_graph.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OnnxModelAddInitializer

func (api *Api) OnnxModelAddInitializer(self *OnnxModel, value *Tensor) (*StringList, error)

OnnxModelAddInitializer wraps api-table member `onnx_model_add_initializer`. ClikaRT::io::OnnxModel::add_initializer <- ClikaRT/io/onnx_model.h

OnnxModelAddOpsetDomain

func (api *Api) OnnxModelAddOpsetDomain(self *OnnxModel, domain string, version int64) (error)

OnnxModelAddOpsetDomain wraps api-table member `onnx_model_add_opset_domain`. ClikaRT::io::OnnxModel::add_opset_domain <- ClikaRT/io/onnx_model.h

OnnxModelCompile

func (api *Api) OnnxModelCompile(self *OnnxModel) (*ModelGraph, error)

OnnxModelCompile wraps api-table member `onnx_model_compile`. ClikaRT::io::OnnxModel::compile <- ClikaRT/io/onnx_model.h

OnnxModelCreate

func (api *Api) OnnxModelCreate(graphName string, opsetVersion int64) (*OnnxModel, error)

OnnxModelCreate wraps api-table member `onnx_model_create`. ClikaRT::io::OnnxModel::create <- ClikaRT/io/onnx_model.h

OnnxModelFree

func (api *Api) OnnxModelFree(h *OnnxModel)

OnnxModelFree wraps api-table member `onnx_model_free`.

OnnxModelIrVersion

func (api *Api) OnnxModelIrVersion(self *OnnxModel) int64

OnnxModelIrVersion wraps api-table member `onnx_model_ir_version`. ClikaRT::io::OnnxModel::ir_version <- ClikaRT/io/onnx_model.h

OnnxModelNumInitializers

func (api *Api) OnnxModelNumInitializers(self *OnnxModel) uint

OnnxModelNumInitializers wraps api-table member `onnx_model_num_initializers`. ClikaRT::io::OnnxModel::num_initializers <- ClikaRT/io/onnx_model.h

OnnxModelNumNodes

func (api *Api) OnnxModelNumNodes(self *OnnxModel) uint

OnnxModelNumNodes wraps api-table member `onnx_model_num_nodes`. ClikaRT::io::OnnxModel::num_nodes <- ClikaRT/io/onnx_model.h

OnnxModelOpen

func (api *Api) OnnxModelOpen(path string) (*OnnxModel, error)

OnnxModelOpen wraps api-table member `onnx_model_open`. ClikaRT::io::OnnxModel::open <- ClikaRT/io/onnx_model.h

OnnxModelOpset

func (api *Api) OnnxModelOpset(self *OnnxModel) int64

OnnxModelOpset wraps api-table member `onnx_model_opset`. ClikaRT::io::OnnxModel::opset <- ClikaRT/io/onnx_model.h

OnnxModelOptimize

func (api *Api) OnnxModelOptimize(self *OnnxModel) (int32, error)

OnnxModelOptimize wraps api-table member `onnx_model_optimize`. ClikaRT::io::OnnxModel::optimize <- ClikaRT/io/onnx_model.h

OnnxModelRemoveNode

func (api *Api) OnnxModelRemoveNode(self *OnnxModel, name string) (error)

OnnxModelRemoveNode wraps api-table member `onnx_model_remove_node`. ClikaRT::io::OnnxModel::remove_node <- ClikaRT/io/onnx_model.h

OnnxModelSave

func (api *Api) OnnxModelSave(self *OnnxModel, path string) (error)

OnnxModelSave wraps api-table member `onnx_model_save`. ClikaRT::io::OnnxModel::save <- ClikaRT/io/onnx_model.h

OpAbs

func (api *Api) OpAbs(x *Tensor) (*Tensor, error)

OpAbs wraps api-table member `op_abs`. ClikaRT::ops::abs <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAbsInplace

func (api *Api) OpAbsInplace(self *Tensor) (error)

OpAbsInplace wraps api-table member `op_abs_inplace`. ClikaRT::ops::abs_ <- ClikaRT/compute/ops.h

OpAcos

func (api *Api) OpAcos(x *Tensor) (*Tensor, error)

OpAcos wraps api-table member `op_acos`. ClikaRT::ops::acos <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAcosInplace

func (api *Api) OpAcosInplace(self *Tensor) (error)

OpAcosInplace wraps api-table member `op_acos_inplace`. ClikaRT::ops::acos_ <- ClikaRT/compute/ops.h

OpAcosh

func (api *Api) OpAcosh(x *Tensor) (*Tensor, error)

OpAcosh wraps api-table member `op_acosh`. ClikaRT::ops::acosh <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAcoshInplace

func (api *Api) OpAcoshInplace(self *Tensor) (error)

OpAcoshInplace wraps api-table member `op_acosh_inplace`. ClikaRT::ops::acosh_ <- ClikaRT/compute/ops.h

OpAdaptiveAvgPool

func (api *Api) OpAdaptiveAvgPool(x *Tensor, outputSize []int64) (*Tensor, error)

OpAdaptiveAvgPool wraps api-table member `op_adaptive_avg_pool`. ClikaRT::ops::adaptive_avg_pool <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAdaptiveAvgPool1d

func (api *Api) OpAdaptiveAvgPool1d(x *Tensor, outputSize []int64) (*Tensor, error)

OpAdaptiveAvgPool1d wraps api-table member `op_adaptive_avg_pool1d`. ClikaRT::ops::adaptive_avg_pool1d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAdaptiveAvgPool2d

func (api *Api) OpAdaptiveAvgPool2d(x *Tensor, outputSize []int64) (*Tensor, error)

OpAdaptiveAvgPool2d wraps api-table member `op_adaptive_avg_pool2d`. ClikaRT::ops::adaptive_avg_pool2d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAdaptiveAvgPool3d

func (api *Api) OpAdaptiveAvgPool3d(x *Tensor, outputSize []int64) (*Tensor, error)

OpAdaptiveAvgPool3d wraps api-table member `op_adaptive_avg_pool3d`. ClikaRT::ops::adaptive_avg_pool3d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAdaptiveMaxPool

func (api *Api) OpAdaptiveMaxPool(x *Tensor, outputSize []int64) (*Tensor, error)

OpAdaptiveMaxPool wraps api-table member `op_adaptive_max_pool`. ClikaRT::ops::adaptive_max_pool <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAdaptiveMaxPool1d

func (api *Api) OpAdaptiveMaxPool1d(x *Tensor, outputSize []int64) (*Tensor, error)

OpAdaptiveMaxPool1d wraps api-table member `op_adaptive_max_pool1d`. ClikaRT::ops::adaptive_max_pool1d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAdaptiveMaxPool2d

func (api *Api) OpAdaptiveMaxPool2d(x *Tensor, outputSize []int64) (*Tensor, error)

OpAdaptiveMaxPool2d wraps api-table member `op_adaptive_max_pool2d`. ClikaRT::ops::adaptive_max_pool2d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAdaptiveMaxPool3d

func (api *Api) OpAdaptiveMaxPool3d(x *Tensor, outputSize []int64) (*Tensor, error)

OpAdaptiveMaxPool3d wraps api-table member `op_adaptive_max_pool3d`. ClikaRT::ops::adaptive_max_pool3d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAddInplace

func (api *Api) OpAddInplace(self *Tensor, other ScalarOrTensor, alpha float64, activation Activation) (error)

OpAddInplace wraps api-table member `op_add_inplace`. ClikaRT::ops::add_ <- ClikaRT/compute/ops.h

OpAddLayerNorm

func (api *Api) OpAddLayerNorm(x *Tensor, residual *Tensor, postResidual *Tensor, normalizedShape []int64, skipBias *Tensor, weight *Tensor, bias *Tensor, epsHas bool, eps float64, activationHas bool, activation Activation) (*Tensor, *Tensor, error)

OpAddLayerNorm wraps api-table member `op_add_layer_norm`. ClikaRT::ops::add_layer_norm <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): residual, postResidual, skipBias, weight, bias.

OpAddRmsNorm

func (api *Api) OpAddRmsNorm(x *Tensor, residual *Tensor, residual2 *Tensor, postResidual *Tensor, normalizedShape []int64, skipBias *Tensor, weight *Tensor, bias *Tensor, epsHas bool, eps float64, activationHas bool, activation Activation) (*Tensor, *Tensor, error)

OpAddRmsNorm wraps api-table member `op_add_rms_norm`. ClikaRT::ops::add_rms_norm <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): residual, residual2, postResidual, skipBias, weight, bias.

OpAddScalarLhs

func (api *Api) OpAddScalarLhs(a Scalar, b *Tensor, alpha float64, activation Activation) (*Tensor, error)

OpAddScalarLhs wraps api-table member `op_add_scalar_lhs`. ClikaRT::ops::add <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAddTensor

func (api *Api) OpAddTensor(a *Tensor, other ScalarOrTensor, alpha float64, activation Activation) (*Tensor, error)

OpAddTensor wraps api-table member `op_add_tensor`. ClikaRT::ops::add <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAll

func (api *Api) OpAll(x *Tensor, dims []int64, keepdim bool) (*Tensor, error)

OpAll wraps api-table member `op_all`. ClikaRT::ops::all <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAllclose

func (api *Api) OpAllclose(a *Tensor, b *Tensor, rtol float64, atol float64, equalNan bool) (*Tensor, error)

OpAllclose wraps api-table member `op_allclose`. ClikaRT::ops::allclose <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAmax

func (api *Api) OpAmax(x *Tensor, dims []int64, keepdim bool) (*Tensor, error)

OpAmax wraps api-table member `op_amax`. ClikaRT::ops::amax <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAmin

func (api *Api) OpAmin(x *Tensor, dims []int64, keepdim bool) (*Tensor, error)

OpAmin wraps api-table member `op_amin`. ClikaRT::ops::amin <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAminmax

func (api *Api) OpAminmax(x *Tensor, dimHas bool, dim int64, keepdim bool) (*Tensor, *Tensor, error)

OpAminmax wraps api-table member `op_aminmax`. ClikaRT::ops::aminmax <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAny

func (api *Api) OpAny(x *Tensor, dims []int64, keepdim bool) (*Tensor, error)

OpAny wraps api-table member `op_any`. ClikaRT::ops::any <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpArange

func (api *Api) OpArange(start ScalarOrTensor, end ScalarOrTensor, step ScalarOrTensor, dtype DataType, s StreamOrDevice) (*Tensor, error)

OpArange wraps api-table member `op_arange`. ClikaRT::ops::arange <- ClikaRT/compute/ops.h

OpArgmax

func (api *Api) OpArgmax(x *Tensor, dims []int64, keepdim bool, indexDtype DataType) (*Tensor, error)

OpArgmax wraps api-table member `op_argmax`. ClikaRT::ops::argmax <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpArgmin

func (api *Api) OpArgmin(x *Tensor, dims []int64, keepdim bool, indexDtype DataType) (*Tensor, error)

OpArgmin wraps api-table member `op_argmin`. ClikaRT::ops::argmin <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpArgsort

func (api *Api) OpArgsort(x *Tensor, dim int64, descending bool, stable bool) (*Tensor, error)

OpArgsort wraps api-table member `op_argsort`. ClikaRT::ops::argsort <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAsin

func (api *Api) OpAsin(x *Tensor) (*Tensor, error)

OpAsin wraps api-table member `op_asin`. ClikaRT::ops::asin <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAsinInplace

func (api *Api) OpAsinInplace(self *Tensor) (error)

OpAsinInplace wraps api-table member `op_asin_inplace`. ClikaRT::ops::asin_ <- ClikaRT/compute/ops.h

OpAsinh

func (api *Api) OpAsinh(x *Tensor) (*Tensor, error)

OpAsinh wraps api-table member `op_asinh`. ClikaRT::ops::asinh <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAsinhInplace

func (api *Api) OpAsinhInplace(self *Tensor) (error)

OpAsinhInplace wraps api-table member `op_asinh_inplace`. ClikaRT::ops::asinh_ <- ClikaRT/compute/ops.h

OpAtan

func (api *Api) OpAtan(x *Tensor) (*Tensor, error)

OpAtan wraps api-table member `op_atan`. ClikaRT::ops::atan <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAtan2

func (api *Api) OpAtan2(a *Tensor, b *Tensor) (*Tensor, error)

OpAtan2 wraps api-table member `op_atan2`. ClikaRT::ops::atan2 <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAtan2Inplace

func (api *Api) OpAtan2Inplace(self *Tensor, other *Tensor) (error)

OpAtan2Inplace wraps api-table member `op_atan2_inplace`. ClikaRT::ops::atan2_ <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAtanInplace

func (api *Api) OpAtanInplace(self *Tensor) (error)

OpAtanInplace wraps api-table member `op_atan_inplace`. ClikaRT::ops::atan_ <- ClikaRT/compute/ops.h

OpAtanh

func (api *Api) OpAtanh(x *Tensor) (*Tensor, error)

OpAtanh wraps api-table member `op_atanh`. ClikaRT::ops::atanh <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAtanhInplace

func (api *Api) OpAtanhInplace(self *Tensor) (error)

OpAtanhInplace wraps api-table member `op_atanh_inplace`. ClikaRT::ops::atanh_ <- ClikaRT/compute/ops.h

OpAtleast1d

func (api *Api) OpAtleast1d(x *Tensor) (*Tensor, error)

OpAtleast1d wraps api-table member `op_atleast_1d`. ClikaRT::ops::atleast_1d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAtleast2d

func (api *Api) OpAtleast2d(x *Tensor) (*Tensor, error)

OpAtleast2d wraps api-table member `op_atleast_2d`. ClikaRT::ops::atleast_2d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAtleast3d

func (api *Api) OpAtleast3d(x *Tensor) (*Tensor, error)

OpAtleast3d wraps api-table member `op_atleast_3d`. ClikaRT::ops::atleast_3d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAttention

func (api *Api) OpAttention(q *Tensor, k *Tensor, v *Tensor, attnMask *Tensor, headSink *Tensor, qScale ScalarOrTensor, kScale ScalarOrTensor, vScale ScalarOrTensor, opts *AttentionOptions) (*Tensor, error)

OpAttention wraps api-table member `op_attention`. ClikaRT::ops::attention <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): attnMask, headSink.

A nil `opts` means every option's default.

OpAttentionOverCache

func (api *Api) OpAttentionOverCache(q *Tensor, cacheKey *Tensor, cacheValue *Tensor, kvcacheStart *Tensor, cuSeqlensQ *Tensor, cuSeqlensK *Tensor, maxSeqlenQ ScalarOrTensor, maxSeqlenK ScalarOrTensor, ropeCos *Tensor, ropeSin *Tensor, positionIds *Tensor, attnMask *Tensor, qScale ScalarOrTensor, kScale ScalarOrTensor, vScale ScalarOrTensor, headSink *Tensor, qNormGain *Tensor, kNormGain *Tensor, slotIds *Tensor, opts *AttentionOverCacheOptions) (*Tensor, error)

OpAttentionOverCache wraps api-table member `op_attention_over_cache`. ClikaRT::ops::attention_over_cache <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): ropeCos, ropeSin, positionIds, attnMask, headSink, qNormGain, kNormGain, slotIds.

A nil `opts` means every option's default.

OpAttentionVarlen

func (api *Api) OpAttentionVarlen(q *Tensor, k *Tensor, v *Tensor, cuSeqlensQ *Tensor, cuSeqlensK *Tensor, maxSeqlenQ ScalarOrTensor, maxSeqlenK ScalarOrTensor, attnMask *Tensor, headSink *Tensor, qScale ScalarOrTensor, kScale ScalarOrTensor, vScale ScalarOrTensor, opts *AttentionVarlenOptions) (*Tensor, error)

OpAttentionVarlen wraps api-table member `op_attention_varlen`. ClikaRT::ops::attention_varlen <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): attnMask, headSink.

A nil `opts` means every option's default.

OpAvgPool

func (api *Api) OpAvgPool(x *Tensor, kernelSize []int64, stride []int64, padding []int64, ceilMode bool, countIncludePad bool, divisorOverrideHas bool, divisorOverride int64) (*Tensor, error)

OpAvgPool wraps api-table member `op_avg_pool`. ClikaRT::ops::avg_pool <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAvgPool1d

func (api *Api) OpAvgPool1d(x *Tensor, kernelSize []int64, stride []int64, padding []int64, ceilMode bool, countIncludePad bool) (*Tensor, error)

OpAvgPool1d wraps api-table member `op_avg_pool1d`. ClikaRT::ops::avg_pool1d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAvgPool2d

func (api *Api) OpAvgPool2d(x *Tensor, kernelSize []int64, stride []int64, padding []int64, ceilMode bool, countIncludePad bool, divisorOverrideHas bool, divisorOverride int64) (*Tensor, error)

OpAvgPool2d wraps api-table member `op_avg_pool2d`. ClikaRT::ops::avg_pool2d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpAvgPool3d

func (api *Api) OpAvgPool3d(x *Tensor, kernelSize []int64, stride []int64, padding []int64, ceilMode bool, countIncludePad bool, divisorOverrideHas bool, divisorOverride int64) (*Tensor, error)

OpAvgPool3d wraps api-table member `op_avg_pool3d`. ClikaRT::ops::avg_pool3d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpBatchNorm

func (api *Api) OpBatchNorm(x *Tensor, weight *Tensor, bias *Tensor, runningMean *Tensor, runningVar *Tensor, epsHas bool, eps float64, activationHas bool, activation Activation) (*Tensor, error)

OpBatchNorm wraps api-table member `op_batch_norm`. ClikaRT::ops::batch_norm <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): weight, bias, runningMean, runningVar.

OpBernoulli

func (api *Api) OpBernoulli(probabilities *Tensor, s StreamOrDevice) (*Tensor, error)

OpBernoulli wraps api-table member `op_bernoulli`. ClikaRT::ops::bernoulli <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpBernoulliInplace

func (api *Api) OpBernoulliInplace(self *Tensor, s StreamOrDevice) (error)

OpBernoulliInplace wraps api-table member `op_bernoulli_inplace`. ClikaRT::ops::bernoulli_ <- ClikaRT/compute/ops.h

OpBinaryCrossEntropy

func (api *Api) OpBinaryCrossEntropy(input *Tensor, target *Tensor, weight *Tensor, reduction Reduction) (*Tensor, error)

OpBinaryCrossEntropy wraps api-table member `op_binary_cross_entropy`. ClikaRT::ops::binary_cross_entropy <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): weight.

OpBinaryCrossEntropyWithLogits

func (api *Api) OpBinaryCrossEntropyWithLogits(input *Tensor, target *Tensor, weight *Tensor, reduction Reduction, posWeight *Tensor) (*Tensor, error)

OpBinaryCrossEntropyWithLogits wraps api-table member `op_binary_cross_entropy_with_logits`. ClikaRT::ops::binary_cross_entropy_with_logits <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): weight, posWeight.

OpBincount

func (api *Api) OpBincount(x *Tensor, weights *Tensor, minlength int64) (*Tensor, error)

OpBincount wraps api-table member `op_bincount`. ClikaRT::ops::bincount <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): weights.

OpBitwiseAnd

func (api *Api) OpBitwiseAnd(a *Tensor, other ScalarOrTensor) (*Tensor, error)

OpBitwiseAnd wraps api-table member `op_bitwise_and`. ClikaRT::ops::bitwise_and <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpBitwiseAndInplace

func (api *Api) OpBitwiseAndInplace(self *Tensor, other ScalarOrTensor) (error)

OpBitwiseAndInplace wraps api-table member `op_bitwise_and_inplace`. ClikaRT::ops::bitwise_and_ <- ClikaRT/compute/ops.h

OpBitwiseLeftShift

func (api *Api) OpBitwiseLeftShift(a *Tensor, other ScalarOrTensor) (*Tensor, error)

OpBitwiseLeftShift wraps api-table member `op_bitwise_left_shift`. ClikaRT::ops::bitwise_left_shift <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpBitwiseLeftShiftInplace

func (api *Api) OpBitwiseLeftShiftInplace(self *Tensor, other ScalarOrTensor) (error)

OpBitwiseLeftShiftInplace wraps api-table member `op_bitwise_left_shift_inplace`. ClikaRT::ops::bitwise_left_shift_ <- ClikaRT/compute/ops.h

OpBitwiseNot

func (api *Api) OpBitwiseNot(x *Tensor) (*Tensor, error)

OpBitwiseNot wraps api-table member `op_bitwise_not`. ClikaRT::ops::bitwise_not <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpBitwiseNotInplace

func (api *Api) OpBitwiseNotInplace(self *Tensor) (error)

OpBitwiseNotInplace wraps api-table member `op_bitwise_not_inplace`. ClikaRT::ops::bitwise_not_ <- ClikaRT/compute/ops.h

OpBitwiseOr

func (api *Api) OpBitwiseOr(a *Tensor, other ScalarOrTensor) (*Tensor, error)

OpBitwiseOr wraps api-table member `op_bitwise_or`. ClikaRT::ops::bitwise_or <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpBitwiseOrInplace

func (api *Api) OpBitwiseOrInplace(self *Tensor, other ScalarOrTensor) (error)

OpBitwiseOrInplace wraps api-table member `op_bitwise_or_inplace`. ClikaRT::ops::bitwise_or_ <- ClikaRT/compute/ops.h

OpBitwiseRightShift

func (api *Api) OpBitwiseRightShift(a *Tensor, other ScalarOrTensor) (*Tensor, error)

OpBitwiseRightShift wraps api-table member `op_bitwise_right_shift`. ClikaRT::ops::bitwise_right_shift <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpBitwiseRightShiftInplace

func (api *Api) OpBitwiseRightShiftInplace(self *Tensor, other ScalarOrTensor) (error)

OpBitwiseRightShiftInplace wraps api-table member `op_bitwise_right_shift_inplace`. ClikaRT::ops::bitwise_right_shift_ <- ClikaRT/compute/ops.h

OpBitwiseXor

func (api *Api) OpBitwiseXor(a *Tensor, other ScalarOrTensor) (*Tensor, error)

OpBitwiseXor wraps api-table member `op_bitwise_xor`. ClikaRT::ops::bitwise_xor <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpBitwiseXorInplace

func (api *Api) OpBitwiseXorInplace(self *Tensor, other ScalarOrTensor) (error)

OpBitwiseXorInplace wraps api-table member `op_bitwise_xor_inplace`. ClikaRT::ops::bitwise_xor_ <- ClikaRT/compute/ops.h

OpBmm

func (api *Api) OpBmm(a *Tensor, b *Tensor, bias *Tensor, activationHas bool, activation Activation) (*Tensor, error)

OpBmm wraps api-table member `op_bmm`. ClikaRT::ops::bmm <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpBroadcastTensors

func (api *Api) OpBroadcastTensors(tensors []*Tensor) (*TensorList, error)

OpBroadcastTensors wraps api-table member `op_broadcast_tensors`. ClikaRT::ops::broadcast_tensors <- ClikaRT/compute/ops.h

OpBroadcastTo

func (api *Api) OpBroadcastTo(x *Tensor, shape []ScalarOrTensor) (*Tensor, error)

OpBroadcastTo wraps api-table member `op_broadcast_to`. ClikaRT::ops::broadcast_to <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpBucketize

func (api *Api) OpBucketize(x *Tensor, boundaries *Tensor, outInt32 bool, right bool) (*Tensor, error)

OpBucketize wraps api-table member `op_bucketize`. ClikaRT::ops::bucketize <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpCast

func (api *Api) OpCast(x *Tensor, target DataType, forceCopy bool) (*Tensor, error)

OpCast wraps api-table member `op_cast`. ClikaRT::ops::cast <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpCastLike

func (api *Api) OpCastLike(x *Tensor, reference *Tensor) (*Tensor, error)

OpCastLike wraps api-table member `op_cast_like`. ClikaRT::ops::cast_like <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpCausalConvUpdate

func (api *Api) OpCausalConvUpdate(x *Tensor, weight *Tensor, bias *Tensor, state *Tensor, seqLens *Tensor, slotIds *Tensor, activationHas bool, activation Activation) (*Tensor, error)

OpCausalConvUpdate wraps api-table member `op_causal_conv_update`. ClikaRT::ops::causal_conv_update <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias, seqLens, slotIds.

OpCdist

func (api *Api) OpCdist(a *Tensor, b *Tensor, p Scalar) (*Tensor, error)

OpCdist wraps api-table member `op_cdist`. ClikaRT::ops::cdist <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpCeil

func (api *Api) OpCeil(x *Tensor) (*Tensor, error)

OpCeil wraps api-table member `op_ceil`. ClikaRT::ops::ceil <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpCeilInplace

func (api *Api) OpCeilInplace(self *Tensor) (error)

OpCeilInplace wraps api-table member `op_ceil_inplace`. ClikaRT::ops::ceil_ <- ClikaRT/compute/ops.h

OpCelu

func (api *Api) OpCelu(x *Tensor, alpha float64) (*Tensor, error)

OpCelu wraps api-table member `op_celu`. ClikaRT::ops::celu <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpCeluInplace

func (api *Api) OpCeluInplace(self *Tensor, alpha float64) (error)

OpCeluInplace wraps api-table member `op_celu_inplace`. ClikaRT::ops::celu_ <- ClikaRT/compute/ops.h

OpChunk

func (api *Api) OpChunk(x *Tensor, numChunks int64, dim int64) (*TensorList, error)

OpChunk wraps api-table member `op_chunk`. ClikaRT::ops::chunk <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpCircularPad

func (api *Api) OpCircularPad(x *Tensor, pad []ScalarOrTensor) (*Tensor, error)

OpCircularPad wraps api-table member `op_circular_pad`. ClikaRT::ops::circular_pad <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpClamp

func (api *Api) OpClamp(x *Tensor, min ScalarOrTensor, max ScalarOrTensor) (*Tensor, error)

OpClamp wraps api-table member `op_clamp`. ClikaRT::ops::clamp <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpClampInplace

func (api *Api) OpClampInplace(self *Tensor, min ScalarOrTensor, max ScalarOrTensor) (error)

OpClampInplace wraps api-table member `op_clamp_inplace`. ClikaRT::ops::clamp_ <- ClikaRT/compute/ops.h

OpClampMax

func (api *Api) OpClampMax(x *Tensor, max ScalarOrTensor) (*Tensor, error)

OpClampMax wraps api-table member `op_clamp_max`. ClikaRT::ops::clamp_max <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpClampMaxInplace

func (api *Api) OpClampMaxInplace(self *Tensor, max ScalarOrTensor) (error)

OpClampMaxInplace wraps api-table member `op_clamp_max_inplace`. ClikaRT::ops::clamp_max_ <- ClikaRT/compute/ops.h

OpClampMin

func (api *Api) OpClampMin(x *Tensor, min ScalarOrTensor) (*Tensor, error)

OpClampMin wraps api-table member `op_clamp_min`. ClikaRT::ops::clamp_min <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpClampMinInplace

func (api *Api) OpClampMinInplace(self *Tensor, min ScalarOrTensor) (error)

OpClampMinInplace wraps api-table member `op_clamp_min_inplace`. ClikaRT::ops::clamp_min_ <- ClikaRT/compute/ops.h

OpClone

func (api *Api) OpClone(src *Tensor) (*Tensor, error)

OpClone wraps api-table member `op_clone`. ClikaRT::ops::clone <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpConcat

func (api *Api) OpConcat(tensors []*Tensor, dim int64, activation Activation) (*Tensor, error)

OpConcat wraps api-table member `op_concat`. ClikaRT::ops::concat <- ClikaRT/compute/ops.h

OpConstantPad

func (api *Api) OpConstantPad(x *Tensor, pad []ScalarOrTensor, value ScalarOrTensor) (*Tensor, error)

OpConstantPad wraps api-table member `op_constant_pad`. ClikaRT::ops::constant_pad <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpContiguous

func (api *Api) OpContiguous(x *Tensor, forceCopy bool) (*Tensor, error)

OpContiguous wraps api-table member `op_contiguous`. ClikaRT::ops::contiguous <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpConv

func (api *Api) OpConv(x *Tensor, weight *Tensor, bias *Tensor, stride []int64, padding []int64, dilation []int64, groups int64, mode PadMode, valueHas bool, value float64, activation Activation) (*Tensor, error)

OpConv wraps api-table member `op_conv`. ClikaRT::ops::conv <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpConv1d

func (api *Api) OpConv1d(x *Tensor, weight *Tensor, bias *Tensor, stride []int64, padding []int64, dilation []int64, groups int64, activation Activation) (*Tensor, error)

OpConv1d wraps api-table member `op_conv1d`. ClikaRT::ops::conv1d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpConv2d

func (api *Api) OpConv2d(x *Tensor, weight *Tensor, bias *Tensor, stride []int64, padding []int64, dilation []int64, groups int64, activation Activation) (*Tensor, error)

OpConv2d wraps api-table member `op_conv2d`. ClikaRT::ops::conv2d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpConv3d

func (api *Api) OpConv3d(x *Tensor, weight *Tensor, bias *Tensor, stride []int64, padding []int64, dilation []int64, groups int64, activation Activation) (*Tensor, error)

OpConv3d wraps api-table member `op_conv3d`. ClikaRT::ops::conv3d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpConvTranspose

func (api *Api) OpConvTranspose(x *Tensor, weight *Tensor, bias *Tensor, stride []int64, padding []int64, outputPadding []int64, groups int64, dilation []int64, activation Activation) (*Tensor, error)

OpConvTranspose wraps api-table member `op_conv_transpose`. ClikaRT::ops::conv_transpose <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpConvTranspose1d

func (api *Api) OpConvTranspose1d(x *Tensor, weight *Tensor, bias *Tensor, opts *ConvTranspose1dOptions) (*Tensor, error)

OpConvTranspose1d wraps api-table member `op_conv_transpose1d`. ClikaRT::ops::conv_transpose1d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

A nil `opts` means every option's default.

OpConvTranspose2d

func (api *Api) OpConvTranspose2d(x *Tensor, weight *Tensor, bias *Tensor, opts *ConvTranspose2dOptions) (*Tensor, error)

OpConvTranspose2d wraps api-table member `op_conv_transpose2d`. ClikaRT::ops::conv_transpose2d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

A nil `opts` means every option's default.

OpConvTranspose3d

func (api *Api) OpConvTranspose3d(x *Tensor, weight *Tensor, bias *Tensor, opts *ConvTranspose3dOptions) (*Tensor, error)

OpConvTranspose3d wraps api-table member `op_conv_transpose3d`. ClikaRT::ops::conv_transpose3d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

A nil `opts` means every option's default.

OpCopy

func (api *Api) OpCopy(src *Tensor, target StreamOrDevice, forceCopy bool) (*Tensor, error)

OpCopy wraps api-table member `op_copy`. ClikaRT::ops::copy <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpCopyInplace

func (api *Api) OpCopyInplace(self *Tensor, src *Tensor, target StreamOrDevice) (error)

OpCopyInplace wraps api-table member `op_copy_inplace`. ClikaRT::ops::copy_ <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpCopyInto

func (api *Api) OpCopyInto(out *Tensor, src *Tensor, target StreamOrDevice) (error)

OpCopyInto wraps api-table member `op_copy_into`. ClikaRT::ops::copy_into <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpCopyToCpu

func (api *Api) OpCopyToCpu(src *Tensor) (*Tensor, error)

OpCopyToCpu wraps api-table member `op_copy_to_cpu`. ClikaRT::ops::copy_to_cpu <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpCopysign

func (api *Api) OpCopysign(a *Tensor, other ScalarOrTensor) (*Tensor, error)

OpCopysign wraps api-table member `op_copysign`. ClikaRT::ops::copysign <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpCopysignInplace

func (api *Api) OpCopysignInplace(self *Tensor, other ScalarOrTensor) (error)

OpCopysignInplace wraps api-table member `op_copysign_inplace`. ClikaRT::ops::copysign_ <- ClikaRT/compute/ops.h

OpCos

func (api *Api) OpCos(x *Tensor) (*Tensor, error)

OpCos wraps api-table member `op_cos`. ClikaRT::ops::cos <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpCosInplace

func (api *Api) OpCosInplace(self *Tensor) (error)

OpCosInplace wraps api-table member `op_cos_inplace`. ClikaRT::ops::cos_ <- ClikaRT/compute/ops.h

OpCosh

func (api *Api) OpCosh(x *Tensor) (*Tensor, error)

OpCosh wraps api-table member `op_cosh`. ClikaRT::ops::cosh <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpCoshInplace

func (api *Api) OpCoshInplace(self *Tensor) (error)

OpCoshInplace wraps api-table member `op_cosh_inplace`. ClikaRT::ops::cosh_ <- ClikaRT/compute/ops.h

OpCosineSimilarity

func (api *Api) OpCosineSimilarity(a *Tensor, b *Tensor, dim int64, epsHas bool, eps float64) (*Tensor, error)

OpCosineSimilarity wraps api-table member `op_cosine_similarity`. ClikaRT::ops::cosine_similarity <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpCountNonzero

func (api *Api) OpCountNonzero(x *Tensor, dims []int64) (*Tensor, error)

OpCountNonzero wraps api-table member `op_count_nonzero`. ClikaRT::ops::count_nonzero <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpCross

func (api *Api) OpCross(a *Tensor, b *Tensor, dimHas bool, dim int64) (*Tensor, error)

OpCross wraps api-table member `op_cross`. ClikaRT::ops::cross <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpCrossEntropy

func (api *Api) OpCrossEntropy(input *Tensor, target *Tensor, weight *Tensor, ignoreIndexHas bool, ignoreIndex int64, reduction Reduction) (*Tensor, error)

OpCrossEntropy wraps api-table member `op_cross_entropy`. ClikaRT::ops::cross_entropy <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): weight.

OpCummax

func (api *Api) OpCummax(x *Tensor, dim int64) (*Tensor, *Tensor, error)

OpCummax wraps api-table member `op_cummax`. ClikaRT::ops::cummax <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpCummin

func (api *Api) OpCummin(x *Tensor, dim int64) (*Tensor, *Tensor, error)

OpCummin wraps api-table member `op_cummin`. ClikaRT::ops::cummin <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpCumprod

func (api *Api) OpCumprod(x *Tensor, dim int64, dtype DataType) (*Tensor, error)

OpCumprod wraps api-table member `op_cumprod`. ClikaRT::ops::cumprod <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpCumprodInplace

func (api *Api) OpCumprodInplace(self *Tensor, dim int64, dtype DataType) (error)

OpCumprodInplace wraps api-table member `op_cumprod_inplace`. ClikaRT::ops::cumprod_ <- ClikaRT/compute/ops.h

OpCumsum

func (api *Api) OpCumsum(x *Tensor, dim int64, dtype DataType) (*Tensor, error)

OpCumsum wraps api-table member `op_cumsum`. ClikaRT::ops::cumsum <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpCumsumInplace

func (api *Api) OpCumsumInplace(self *Tensor, dim int64, dtype DataType) (error)

OpCumsumInplace wraps api-table member `op_cumsum_inplace`. ClikaRT::ops::cumsum_ <- ClikaRT/compute/ops.h

OpDeformConv

func (api *Api) OpDeformConv(x *Tensor, weight *Tensor, offset *Tensor, mask *Tensor, bias *Tensor, opts *DeformConvOptions) (*Tensor, error)

OpDeformConv wraps api-table member `op_deform_conv`. ClikaRT::ops::deform_conv <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): mask, bias.

A nil `opts` means every option's default.

OpDeg2rad

func (api *Api) OpDeg2rad(x *Tensor) (*Tensor, error)

OpDeg2rad wraps api-table member `op_deg2rad`. ClikaRT::ops::deg2rad <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpDeg2radInplace

func (api *Api) OpDeg2radInplace(self *Tensor) (error)

OpDeg2radInplace wraps api-table member `op_deg2rad_inplace`. ClikaRT::ops::deg2rad_ <- ClikaRT/compute/ops.h

OpDequantize

func (api *Api) OpDequantize(x *QTensor, targetDtype DataType) (*Tensor, error)

OpDequantize wraps api-table member `op_dequantize`. ClikaRT::ops::dequantize <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpDequantizeInplace

func (api *Api) OpDequantizeInplace(x *QTensor, out *Tensor) (error)

OpDequantizeInplace wraps api-table member `op_dequantize_inplace`. ClikaRT::ops::dequantize_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpDiag

func (api *Api) OpDiag(x *Tensor, diagonal int64) (*Tensor, error)

OpDiag wraps api-table member `op_diag`. ClikaRT::ops::diag <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpDiagEmbed

func (api *Api) OpDiagEmbed(x *Tensor, offset int64, dim1 int64, dim2 int64) (*Tensor, error)

OpDiagEmbed wraps api-table member `op_diag_embed`. ClikaRT::ops::diag_embed <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpDiagonal

func (api *Api) OpDiagonal(x *Tensor, offset int64, dim1 int64, dim2 int64) (*Tensor, error)

OpDiagonal wraps api-table member `op_diagonal`. ClikaRT::ops::diagonal <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpDiff

func (api *Api) OpDiff(x *Tensor, n int64, dim int64, prepend *Tensor, append *Tensor) (*Tensor, error)

OpDiff wraps api-table member `op_diff`. ClikaRT::ops::diff <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): prepend, append.

OpDivInplace

func (api *Api) OpDivInplace(self *Tensor, other ScalarOrTensor, roundingMode RoundingMode, activation Activation) (error)

OpDivInplace wraps api-table member `op_div_inplace`. ClikaRT::ops::div_ <- ClikaRT/compute/ops.h

OpDivScalarLhs

func (api *Api) OpDivScalarLhs(a Scalar, b *Tensor, roundingMode RoundingMode, activation Activation) (*Tensor, error)

OpDivScalarLhs wraps api-table member `op_div_scalar_lhs`. ClikaRT::ops::div <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpDivTensor

func (api *Api) OpDivTensor(a *Tensor, other ScalarOrTensor, roundingMode RoundingMode, activation Activation) (*Tensor, error)

OpDivTensor wraps api-table member `op_div_tensor`. ClikaRT::ops::div <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpDot

func (api *Api) OpDot(a *Tensor, b *Tensor) (*Tensor, error)

OpDot wraps api-table member `op_dot`. ClikaRT::ops::dot <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpDynamicQuantize

func (api *Api) OpDynamicQuantize(x *Tensor) (*Tensor, *Tensor, *Tensor, error)

OpDynamicQuantize wraps api-table member `op_dynamic_quantize`. ClikaRT::ops::dynamic_quantize <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpEinsum

func (api *Api) OpEinsum(equation string, operands []*Tensor) (*Tensor, error)

OpEinsum wraps api-table member `op_einsum`. ClikaRT::ops::einsum <- ClikaRT/compute/ops.h

OpElu

func (api *Api) OpElu(x *Tensor, alpha float64, scale float64, inputScale float64) (*Tensor, error)

OpElu wraps api-table member `op_elu`. ClikaRT::ops::elu <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpEluInplace

func (api *Api) OpEluInplace(self *Tensor, alpha float64, scale float64, inputScale float64) (error)

OpEluInplace wraps api-table member `op_elu_inplace`. ClikaRT::ops::elu_ <- ClikaRT/compute/ops.h

OpEmbedding

func (api *Api) OpEmbedding(indices *Tensor, weight *Tensor, bias *Tensor, activationHas bool, activation Activation) (*Tensor, error)

OpEmbedding wraps api-table member `op_embedding`. ClikaRT::ops::embedding <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpEmpty

func (api *Api) OpEmpty(shape []ScalarOrTensor, dtype DataType, s StreamOrDevice, pinnedFor StreamOrDevice) (*Tensor, error)

OpEmpty wraps api-table member `op_empty`. ClikaRT::ops::empty <- ClikaRT/compute/ops.h

OpEmptyLike

func (api *Api) OpEmptyLike(reference *Tensor, s StreamOrDevice) (*Tensor, error)

OpEmptyLike wraps api-table member `op_empty_like`. ClikaRT::ops::empty_like <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpEmptyStrided

func (api *Api) OpEmptyStrided(size []int64, stride []int64, dtype DataType, s StreamOrDevice) (*Tensor, error)

OpEmptyStrided wraps api-table member `op_empty_strided`. ClikaRT::ops::empty_strided <- ClikaRT/compute/ops.h

OpEq

func (api *Api) OpEq(a *Tensor, other ScalarOrTensor) (*Tensor, error)

OpEq wraps api-table member `op_eq`. ClikaRT::ops::eq <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpEqInplace

func (api *Api) OpEqInplace(self *Tensor, other ScalarOrTensor) (error)

OpEqInplace wraps api-table member `op_eq_inplace`. ClikaRT::ops::eq_ <- ClikaRT/compute/ops.h

OpErf

func (api *Api) OpErf(x *Tensor) (*Tensor, error)

OpErf wraps api-table member `op_erf`. ClikaRT::ops::erf <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpErfInplace

func (api *Api) OpErfInplace(self *Tensor) (error)

OpErfInplace wraps api-table member `op_erf_inplace`. ClikaRT::ops::erf_ <- ClikaRT/compute/ops.h

OpErfc

func (api *Api) OpErfc(x *Tensor) (*Tensor, error)

OpErfc wraps api-table member `op_erfc`. ClikaRT::ops::erfc <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpErfcInplace

func (api *Api) OpErfcInplace(self *Tensor) (error)

OpErfcInplace wraps api-table member `op_erfc_inplace`. ClikaRT::ops::erfc_ <- ClikaRT/compute/ops.h

OpErfinv

func (api *Api) OpErfinv(x *Tensor) (*Tensor, error)

OpErfinv wraps api-table member `op_erfinv`. ClikaRT::ops::erfinv <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpErfinvInplace

func (api *Api) OpErfinvInplace(self *Tensor) (error)

OpErfinvInplace wraps api-table member `op_erfinv_inplace`. ClikaRT::ops::erfinv_ <- ClikaRT/compute/ops.h

OpExp

func (api *Api) OpExp(x *Tensor) (*Tensor, error)

OpExp wraps api-table member `op_exp`. ClikaRT::ops::exp <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpExpInplace

func (api *Api) OpExpInplace(self *Tensor) (error)

OpExpInplace wraps api-table member `op_exp_inplace`. ClikaRT::ops::exp_ <- ClikaRT/compute/ops.h

OpExpand

func (api *Api) OpExpand(x *Tensor, shape []ScalarOrTensor, bidirectional bool) (*Tensor, error)

OpExpand wraps api-table member `op_expand`. ClikaRT::ops::expand <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpExpandAs

func (api *Api) OpExpandAs(x *Tensor, other *Tensor) (*Tensor, error)

OpExpandAs wraps api-table member `op_expand_as`. ClikaRT::ops::expand_as <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpExponentialInplace

func (api *Api) OpExponentialInplace(self *Tensor, lambd float64, s StreamOrDevice) (error)

OpExponentialInplace wraps api-table member `op_exponential_inplace`. ClikaRT::ops::exponential_ <- ClikaRT/compute/ops.h

OpEye

func (api *Api) OpEye(n ScalarOrTensor, m ScalarOrTensor, dtype DataType, s StreamOrDevice) (*Tensor, error)

OpEye wraps api-table member `op_eye`. ClikaRT::ops::eye <- ClikaRT/compute/ops.h

OpFastGelu

func (api *Api) OpFastGelu(x *Tensor) (*Tensor, error)

OpFastGelu wraps api-table member `op_fast_gelu`. ClikaRT::ops::fast_gelu <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpFill

func (api *Api) OpFill(x *Tensor, value ScalarOrTensor, s StreamOrDevice) (*Tensor, error)

OpFill wraps api-table member `op_fill`. ClikaRT::ops::fill <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpFillDiagonal

func (api *Api) OpFillDiagonal(x *Tensor, fillValue Scalar, wrap bool, s StreamOrDevice) (*Tensor, error)

OpFillDiagonal wraps api-table member `op_fill_diagonal`. ClikaRT::ops::fill_diagonal <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpFillDiagonalInplace

func (api *Api) OpFillDiagonalInplace(self *Tensor, fillValue Scalar, wrap bool, s StreamOrDevice) (error)

OpFillDiagonalInplace wraps api-table member `op_fill_diagonal_inplace`. ClikaRT::ops::fill_diagonal_ <- ClikaRT/compute/ops.h

OpFillInplace

func (api *Api) OpFillInplace(self *Tensor, value ScalarOrTensor, s StreamOrDevice) (error)

OpFillInplace wraps api-table member `op_fill_inplace`. ClikaRT::ops::fill_ <- ClikaRT/compute/ops.h

OpFlatten

func (api *Api) OpFlatten(x *Tensor, startDim int64, endDim int64) (*Tensor, error)

OpFlatten wraps api-table member `op_flatten`. ClikaRT::ops::flatten <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpFlip

func (api *Api) OpFlip(x *Tensor, dims []int64) (*Tensor, error)

OpFlip wraps api-table member `op_flip`. ClikaRT::ops::flip <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpFliplr

func (api *Api) OpFliplr(x *Tensor) (*Tensor, error)

OpFliplr wraps api-table member `op_fliplr`. ClikaRT::ops::fliplr <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpFlipud

func (api *Api) OpFlipud(x *Tensor) (*Tensor, error)

OpFlipud wraps api-table member `op_flipud`. ClikaRT::ops::flipud <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpFloor

func (api *Api) OpFloor(x *Tensor) (*Tensor, error)

OpFloor wraps api-table member `op_floor`. ClikaRT::ops::floor <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpFloorDivide

func (api *Api) OpFloorDivide(a *Tensor, other ScalarOrTensor) (*Tensor, error)

OpFloorDivide wraps api-table member `op_floor_divide`. ClikaRT::ops::floor_divide <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpFloorDivideInplace

func (api *Api) OpFloorDivideInplace(self *Tensor, other ScalarOrTensor) (error)

OpFloorDivideInplace wraps api-table member `op_floor_divide_inplace`. ClikaRT::ops::floor_divide_ <- ClikaRT/compute/ops.h

OpFloorInplace

func (api *Api) OpFloorInplace(self *Tensor) (error)

OpFloorInplace wraps api-table member `op_floor_inplace`. ClikaRT::ops::floor_ <- ClikaRT/compute/ops.h

OpFmax

func (api *Api) OpFmax(a *Tensor, b *Tensor) (*Tensor, error)

OpFmax wraps api-table member `op_fmax`. ClikaRT::ops::fmax <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpFmin

func (api *Api) OpFmin(a *Tensor, b *Tensor) (*Tensor, error)

OpFmin wraps api-table member `op_fmin`. ClikaRT::ops::fmin <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpFmod

func (api *Api) OpFmod(a *Tensor, other ScalarOrTensor) (*Tensor, error)

OpFmod wraps api-table member `op_fmod`. ClikaRT::ops::fmod <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpFmodInplace

func (api *Api) OpFmodInplace(self *Tensor, other ScalarOrTensor) (error)

OpFmodInplace wraps api-table member `op_fmod_inplace`. ClikaRT::ops::fmod_ <- ClikaRT/compute/ops.h

OpFold

func (api *Api) OpFold(x *Tensor, outputSize []int64, kernelSize []int64, dilation []int64, padding []int64, stride []int64, mode PadMode, valueHas bool, value float64) (*Tensor, error)

OpFold wraps api-table member `op_fold`. ClikaRT::ops::fold <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpFrac

func (api *Api) OpFrac(x *Tensor) (*Tensor, error)

OpFrac wraps api-table member `op_frac`. ClikaRT::ops::frac <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpFracInplace

func (api *Api) OpFracInplace(self *Tensor) (error)

OpFracInplace wraps api-table member `op_frac_inplace`. ClikaRT::ops::frac_ <- ClikaRT/compute/ops.h

OpFrexp

func (api *Api) OpFrexp(x *Tensor) (*Tensor, *Tensor, error)

OpFrexp wraps api-table member `op_frexp`. ClikaRT::ops::frexp <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpFromBlob

func (api *Api) OpFromBlob(data unsafe.Pointer, shape []int64, dtype DataType, s StreamOrDevice, strides []int64, deleter func(), pinnedFor StreamOrDevice) (*Tensor, error)

OpFromBlob wraps api-table member `op_from_blob`. ClikaRT::ops::from_blob <- ClikaRT/compute/ops.h

OpFull

func (api *Api) OpFull(shape []ScalarOrTensor, fillValue ScalarOrTensor, dtype DataType, s StreamOrDevice, pinnedFor StreamOrDevice) (*Tensor, error)

OpFull wraps api-table member `op_full`. ClikaRT::ops::full <- ClikaRT/compute/ops.h

OpFullLike

func (api *Api) OpFullLike(reference *Tensor, fillValue ScalarOrTensor, s StreamOrDevice) (*Tensor, error)

OpFullLike wraps api-table member `op_full_like`. ClikaRT::ops::full_like <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpGatedDeltaUpdate

func (api *Api) OpGatedDeltaUpdate(q *Tensor, k *Tensor, v *Tensor, beta *Tensor, g *Tensor, state *Tensor, seqLens *Tensor, slotIds *Tensor, scaleHas bool, scale float64, gateBias *Tensor, gateScale *Tensor) (*Tensor, error)

OpGatedDeltaUpdate wraps api-table member `op_gated_delta_update`. ClikaRT::ops::gated_delta_update <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): seqLens, slotIds, gateBias, gateScale.

OpGatedRmsNorm

func (api *Api) OpGatedRmsNorm(x *Tensor, z *Tensor, normalizedShape []int64, weight *Tensor, epsHas bool, eps float64) (*Tensor, error)

OpGatedRmsNorm wraps api-table member `op_gated_rms_norm`. ClikaRT::ops::gated_rms_norm <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): weight.

OpGather

func (api *Api) OpGather(x *Tensor, dim int64, index *Tensor) (*Tensor, error)

OpGather wraps api-table member `op_gather`. ClikaRT::ops::gather <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpGe

func (api *Api) OpGe(a *Tensor, other ScalarOrTensor) (*Tensor, error)

OpGe wraps api-table member `op_ge`. ClikaRT::ops::ge <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpGeInplace

func (api *Api) OpGeInplace(self *Tensor, other ScalarOrTensor) (error)

OpGeInplace wraps api-table member `op_ge_inplace`. ClikaRT::ops::ge_ <- ClikaRT/compute/ops.h

OpGeglu

func (api *Api) OpGeglu(x *Tensor, approximate GeluMode) (*Tensor, error)

OpGeglu wraps api-table member `op_geglu`. ClikaRT::ops::geglu <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpGelu

func (api *Api) OpGelu(x *Tensor, approximate GeluMode) (*Tensor, error)

OpGelu wraps api-table member `op_gelu`. ClikaRT::ops::gelu <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpGeluInplace

func (api *Api) OpGeluInplace(self *Tensor, approximate GeluMode) (error)

OpGeluInplace wraps api-table member `op_gelu_inplace`. ClikaRT::ops::gelu_ <- ClikaRT/compute/ops.h

OpGenerateRotaryCache

func (api *Api) OpGenerateRotaryCache(rotaryDim int64, maxPositions int64, freqFactors *Tensor, s StreamOrDevice, opts *GenerateRotaryCacheOptions) (*Tensor, *Tensor, error)

OpGenerateRotaryCache wraps api-table member `op_generate_rotary_cache`. ClikaRT::ops::generate_rotary_cache <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): freqFactors.

A nil `opts` means every option's default.

OpGlu

func (api *Api) OpGlu(x *Tensor, dim int64) (*Tensor, error)

OpGlu wraps api-table member `op_glu`. ClikaRT::ops::glu <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpGridSample

func (api *Api) OpGridSample(x *Tensor, grid *Tensor, mode GridSampleMode, paddingMode GridSamplePaddingMode, alignCorners bool) (*Tensor, error)

OpGridSample wraps api-table member `op_grid_sample`. ClikaRT::ops::grid_sample <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpGroupNorm

func (api *Api) OpGroupNorm(x *Tensor, numGroups int64, weight *Tensor, bias *Tensor, runningMean *Tensor, runningVar *Tensor, epsHas bool, eps float64, activationHas bool, activation Activation) (*Tensor, error)

OpGroupNorm wraps api-table member `op_group_norm`. ClikaRT::ops::group_norm <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): weight, bias, runningMean, runningVar.

OpGroupQueryAttention

func (api *Api) OpGroupQueryAttention(q *Tensor, k *Tensor, v *Tensor, pastKey *Tensor, pastValue *Tensor, kvcacheStart *Tensor, ropeCos *Tensor, ropeSin *Tensor, positionIds *Tensor, attnMask *Tensor, qScale ScalarOrTensor, outPresentKey *Tensor, outPresentValue *Tensor, kScale ScalarOrTensor, vScale ScalarOrTensor, headSink *Tensor, qNormGain *Tensor, kNormGain *Tensor, slotIds *Tensor, opts *GroupQueryAttentionOptions) (*Tensor, *Tensor, *Tensor, error)

OpGroupQueryAttention wraps api-table member `op_group_query_attention`. ClikaRT::ops::group_query_attention <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): pastKey, pastValue, kvcacheStart, ropeCos, ropeSin, positionIds, attnMask, outPresentKey, outPresentValue, headSink, qNormGain, kNormGain, slotIds.

A nil `opts` means every option's default.

OpGroupQueryAttentionVarlen

func (api *Api) OpGroupQueryAttentionVarlen(q *Tensor, k *Tensor, v *Tensor, cuSeqlensQ *Tensor, cuSeqlensK *Tensor, maxSeqlenQ ScalarOrTensor, maxSeqlenK ScalarOrTensor, pastKey *Tensor, pastValue *Tensor, kvcacheStart *Tensor, ropeCos *Tensor, ropeSin *Tensor, positionIds *Tensor, attnMask *Tensor, headSink *Tensor, qScale ScalarOrTensor, outPresentKey *Tensor, outPresentValue *Tensor, kScale ScalarOrTensor, vScale ScalarOrTensor, qNormGain *Tensor, kNormGain *Tensor, slotIds *Tensor, opts *GroupQueryAttentionVarlenOptions) (*Tensor, *Tensor, *Tensor, error)

OpGroupQueryAttentionVarlen wraps api-table member `op_group_query_attention_varlen`. ClikaRT::ops::group_query_attention_varlen <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): pastKey, pastValue, kvcacheStart, ropeCos, ropeSin, positionIds, attnMask, headSink, outPresentKey, outPresentValue, qNormGain, kNormGain, slotIds.

A nil `opts` means every option's default.

OpGt

func (api *Api) OpGt(a *Tensor, other ScalarOrTensor) (*Tensor, error)

OpGt wraps api-table member `op_gt`. ClikaRT::ops::gt <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpGtInplace

func (api *Api) OpGtInplace(self *Tensor, other ScalarOrTensor) (error)

OpGtInplace wraps api-table member `op_gt_inplace`. ClikaRT::ops::gt_ <- ClikaRT/compute/ops.h

OpHardshrink

func (api *Api) OpHardshrink(x *Tensor, lambd float64) (*Tensor, error)

OpHardshrink wraps api-table member `op_hardshrink`. ClikaRT::ops::hardshrink <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpHardshrinkInplace

func (api *Api) OpHardshrinkInplace(self *Tensor, lambd float64) (error)

OpHardshrinkInplace wraps api-table member `op_hardshrink_inplace`. ClikaRT::ops::hardshrink_ <- ClikaRT/compute/ops.h

OpHardsigmoid

func (api *Api) OpHardsigmoid(x *Tensor) (*Tensor, error)

OpHardsigmoid wraps api-table member `op_hardsigmoid`. ClikaRT::ops::hardsigmoid <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpHardsigmoidInplace

func (api *Api) OpHardsigmoidInplace(self *Tensor) (error)

OpHardsigmoidInplace wraps api-table member `op_hardsigmoid_inplace`. ClikaRT::ops::hardsigmoid_ <- ClikaRT/compute/ops.h

OpHardswish

func (api *Api) OpHardswish(x *Tensor) (*Tensor, error)

OpHardswish wraps api-table member `op_hardswish`. ClikaRT::ops::hardswish <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpHardswishInplace

func (api *Api) OpHardswishInplace(self *Tensor) (error)

OpHardswishInplace wraps api-table member `op_hardswish_inplace`. ClikaRT::ops::hardswish_ <- ClikaRT/compute/ops.h

OpHardtanh

func (api *Api) OpHardtanh(x *Tensor, minVal float64, maxVal float64) (*Tensor, error)

OpHardtanh wraps api-table member `op_hardtanh`. ClikaRT::ops::hardtanh <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpHardtanhInplace

func (api *Api) OpHardtanhInplace(self *Tensor, minVal float64, maxVal float64) (error)

OpHardtanhInplace wraps api-table member `op_hardtanh_inplace`. ClikaRT::ops::hardtanh_ <- ClikaRT/compute/ops.h

OpHash128

func (api *Api) OpHash128(x *Tensor, seed uint64) (*Tensor, error)

OpHash128 wraps api-table member `op_hash_128`. ClikaRT::ops::hash_128 <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpHash256

func (api *Api) OpHash256(x *Tensor, seed uint64) (*Tensor, error)

OpHash256 wraps api-table member `op_hash_256`. ClikaRT::ops::hash_256 <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpHash64

func (api *Api) OpHash64(x *Tensor, seed uint64) (*Tensor, error)

OpHash64 wraps api-table member `op_hash_64`. ClikaRT::ops::hash_64 <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpHashChain

func (api *Api) OpHashChain(rows *Tensor, parent *Tensor, seed uint64) (*Tensor, error)

OpHashChain wraps api-table member `op_hash_chain`. ClikaRT::ops::hash_chain <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpHashTensor

func (api *Api) OpHashTensor(x *Tensor, dims []int64, keepdim bool, mode HashTensorMode) (*Tensor, error)

OpHashTensor wraps api-table member `op_hash_tensor`. ClikaRT::ops::hash_tensor <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpHistogram

func (api *Api) OpHistogram(x *Tensor, bins int64, range_ *Tensor, weight *Tensor, density bool) (*Tensor, *Tensor, error)

OpHistogram wraps api-table member `op_histogram`. ClikaRT::ops::histogram <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): range_, weight.

OpHuberLoss

func (api *Api) OpHuberLoss(input *Tensor, target *Tensor, reduction Reduction, delta float64) (*Tensor, error)

OpHuberLoss wraps api-table member `op_huber_loss`. ClikaRT::ops::huber_loss <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpHypot

func (api *Api) OpHypot(a *Tensor, b *Tensor) (*Tensor, error)

OpHypot wraps api-table member `op_hypot`. ClikaRT::ops::hypot <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpHypotInplace

func (api *Api) OpHypotInplace(self *Tensor, other *Tensor) (error)

OpHypotInplace wraps api-table member `op_hypot_inplace`. ClikaRT::ops::hypot_ <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpIndex

func (api *Api) OpIndex(x *Tensor, indices []IndexEntry) (*Tensor, error)

OpIndex wraps api-table member `op_index`. ClikaRT::ops::index <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpIndexAdd

func (api *Api) OpIndexAdd(x *Tensor, dim int64, indices *Tensor, src *Tensor) (*Tensor, error)

OpIndexAdd wraps api-table member `op_index_add`. ClikaRT::ops::index_add <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpIndexAddInplace

func (api *Api) OpIndexAddInplace(self *Tensor, dim int64, indices *Tensor, src *Tensor) (error)

OpIndexAddInplace wraps api-table member `op_index_add_inplace`. ClikaRT::ops::index_add_ <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpIndexCopy

func (api *Api) OpIndexCopy(x *Tensor, dim int64, indices *Tensor, src *Tensor) (*Tensor, error)

OpIndexCopy wraps api-table member `op_index_copy`. ClikaRT::ops::index_copy <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpIndexCopyInplace

func (api *Api) OpIndexCopyInplace(self *Tensor, dim int64, indices *Tensor, src *Tensor) (error)

OpIndexCopyInplace wraps api-table member `op_index_copy_inplace`. ClikaRT::ops::index_copy_ <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpIndexFill

func (api *Api) OpIndexFill(x *Tensor, dim int64, indices *Tensor, value ScalarOrTensor) (*Tensor, error)

OpIndexFill wraps api-table member `op_index_fill`. ClikaRT::ops::index_fill <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpIndexFillInplace

func (api *Api) OpIndexFillInplace(self *Tensor, dim int64, indices *Tensor, value ScalarOrTensor) (error)

OpIndexFillInplace wraps api-table member `op_index_fill_inplace`. ClikaRT::ops::index_fill_ <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpIndexPut

func (api *Api) OpIndexPut(x *Tensor, indices []IndexEntry, value ScalarOrTensor, accumulate bool) (*Tensor, error)

OpIndexPut wraps api-table member `op_index_put`. ClikaRT::ops::index_put <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpIndexPutInplace

func (api *Api) OpIndexPutInplace(self *Tensor, indices []IndexEntry, value ScalarOrTensor, accumulate bool) (error)

OpIndexPutInplace wraps api-table member `op_index_put_inplace`. ClikaRT::ops::index_put_ <- ClikaRT/compute/ops.h

OpIndexSelect

func (api *Api) OpIndexSelect(x *Tensor, dim int64, index *Tensor) (*Tensor, error)

OpIndexSelect wraps api-table member `op_index_select`. ClikaRT::ops::index_select <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpInner

func (api *Api) OpInner(a *Tensor, b *Tensor) (*Tensor, error)

OpInner wraps api-table member `op_inner`. ClikaRT::ops::inner <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpInstanceNorm

func (api *Api) OpInstanceNorm(x *Tensor, weight *Tensor, bias *Tensor, runningMean *Tensor, runningVar *Tensor, epsHas bool, eps float64, activationHas bool, activation Activation) (*Tensor, error)

OpInstanceNorm wraps api-table member `op_instance_norm`. ClikaRT::ops::instance_norm <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): weight, bias, runningMean, runningVar.

OpInterpolate

func (api *Api) OpInterpolate(x *Tensor, sizes []ScalarOrTensor, scaleFactors []ScalarOrTensor, mode InterpMode, alignCornersHas bool, alignCorners bool, recomputeScaleFactor bool, antialias bool) (*Tensor, error)

OpInterpolate wraps api-table member `op_interpolate`. ClikaRT::ops::interpolate <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpIsclose

func (api *Api) OpIsclose(a *Tensor, b *Tensor, rtol float64, atol float64, equalNan bool) (*Tensor, error)

OpIsclose wraps api-table member `op_isclose`. ClikaRT::ops::isclose <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpIsfinite

func (api *Api) OpIsfinite(x *Tensor) (*Tensor, error)

OpIsfinite wraps api-table member `op_isfinite`. ClikaRT::ops::isfinite <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpIsinf

func (api *Api) OpIsinf(x *Tensor) (*Tensor, error)

OpIsinf wraps api-table member `op_isinf`. ClikaRT::ops::isinf <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpIsnan

func (api *Api) OpIsnan(x *Tensor) (*Tensor, error)

OpIsnan wraps api-table member `op_isnan`. ClikaRT::ops::isnan <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpIsneginf

func (api *Api) OpIsneginf(x *Tensor) (*Tensor, error)

OpIsneginf wraps api-table member `op_isneginf`. ClikaRT::ops::isneginf <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpIsposinf

func (api *Api) OpIsposinf(x *Tensor) (*Tensor, error)

OpIsposinf wraps api-table member `op_isposinf`. ClikaRT::ops::isposinf <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpKlDiv

func (api *Api) OpKlDiv(input *Tensor, target *Tensor, reduction Reduction, logTarget bool) (*Tensor, error)

OpKlDiv wraps api-table member `op_kl_div`. ClikaRT::ops::kl_div <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpKron

func (api *Api) OpKron(a *Tensor, b *Tensor) (*Tensor, error)

OpKron wraps api-table member `op_kron`. ClikaRT::ops::kron <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpKthvalue

func (api *Api) OpKthvalue(x *Tensor, k int64, dim int64, keepdim bool) (*Tensor, *Tensor, error)

OpKthvalue wraps api-table member `op_kthvalue`. ClikaRT::ops::kthvalue <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpL1Loss

func (api *Api) OpL1Loss(input *Tensor, target *Tensor, reduction Reduction) (*Tensor, error)

OpL1Loss wraps api-table member `op_l1_loss`. ClikaRT::ops::l1_loss <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpLayerNorm

func (api *Api) OpLayerNorm(x *Tensor, normalizedShape []int64, weight *Tensor, bias *Tensor, epsHas bool, eps float64, activationHas bool, activation Activation) (*Tensor, error)

OpLayerNorm wraps api-table member `op_layer_norm`. ClikaRT::ops::layer_norm <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): weight, bias.

OpLe

func (api *Api) OpLe(a *Tensor, other ScalarOrTensor) (*Tensor, error)

OpLe wraps api-table member `op_le`. ClikaRT::ops::le <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpLeInplace

func (api *Api) OpLeInplace(self *Tensor, other ScalarOrTensor) (error)

OpLeInplace wraps api-table member `op_le_inplace`. ClikaRT::ops::le_ <- ClikaRT/compute/ops.h

OpLeakyRelu

func (api *Api) OpLeakyRelu(x *Tensor, negativeSlope float64) (*Tensor, error)

OpLeakyRelu wraps api-table member `op_leaky_relu`. ClikaRT::ops::leaky_relu <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpLeakyReluInplace

func (api *Api) OpLeakyReluInplace(self *Tensor, negativeSlope float64) (error)

OpLeakyReluInplace wraps api-table member `op_leaky_relu_inplace`. ClikaRT::ops::leaky_relu_ <- ClikaRT/compute/ops.h

OpLinear

func (api *Api) OpLinear(x *Tensor, weight *Tensor, bias *Tensor, activationHas bool, activation Activation, situBeta float64, situLinearBeta float64) (*Tensor, error)

OpLinear wraps api-table member `op_linear`. ClikaRT::ops::linear <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpLinspace

func (api *Api) OpLinspace(start ScalarOrTensor, end ScalarOrTensor, steps ScalarOrTensor, dtype DataType, s StreamOrDevice) (*Tensor, error)

OpLinspace wraps api-table member `op_linspace`. ClikaRT::ops::linspace <- ClikaRT/compute/ops.h

OpLog

func (api *Api) OpLog(x *Tensor) (*Tensor, error)

OpLog wraps api-table member `op_log`. ClikaRT::ops::log <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpLog10

func (api *Api) OpLog10(x *Tensor) (*Tensor, error)

OpLog10 wraps api-table member `op_log10`. ClikaRT::ops::log10 <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpLog10Inplace

func (api *Api) OpLog10Inplace(self *Tensor) (error)

OpLog10Inplace wraps api-table member `op_log10_inplace`. ClikaRT::ops::log10_ <- ClikaRT/compute/ops.h

OpLog1p

func (api *Api) OpLog1p(x *Tensor) (*Tensor, error)

OpLog1p wraps api-table member `op_log1p`. ClikaRT::ops::log1p <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpLog1pInplace

func (api *Api) OpLog1pInplace(self *Tensor) (error)

OpLog1pInplace wraps api-table member `op_log1p_inplace`. ClikaRT::ops::log1p_ <- ClikaRT/compute/ops.h

OpLog2

func (api *Api) OpLog2(x *Tensor) (*Tensor, error)

OpLog2 wraps api-table member `op_log2`. ClikaRT::ops::log2 <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpLog2Inplace

func (api *Api) OpLog2Inplace(self *Tensor) (error)

OpLog2Inplace wraps api-table member `op_log2_inplace`. ClikaRT::ops::log2_ <- ClikaRT/compute/ops.h

OpLogInplace

func (api *Api) OpLogInplace(self *Tensor) (error)

OpLogInplace wraps api-table member `op_log_inplace`. ClikaRT::ops::log_ <- ClikaRT/compute/ops.h

OpLogSigmoid

func (api *Api) OpLogSigmoid(x *Tensor) (*Tensor, error)

OpLogSigmoid wraps api-table member `op_log_sigmoid`. ClikaRT::ops::log_sigmoid <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpLogSigmoidInplace

func (api *Api) OpLogSigmoidInplace(self *Tensor) (error)

OpLogSigmoidInplace wraps api-table member `op_log_sigmoid_inplace`. ClikaRT::ops::log_sigmoid_ <- ClikaRT/compute/ops.h

OpLogSoftmax

func (api *Api) OpLogSoftmax(x *Tensor, dim int64, dtype DataType) (*Tensor, error)

OpLogSoftmax wraps api-table member `op_log_softmax`. ClikaRT::ops::log_softmax <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpLogSoftmaxInplace

func (api *Api) OpLogSoftmaxInplace(self *Tensor, dim int64) (error)

OpLogSoftmaxInplace wraps api-table member `op_log_softmax_inplace`. ClikaRT::ops::log_softmax_ <- ClikaRT/compute/ops.h

OpLogaddexp

func (api *Api) OpLogaddexp(a *Tensor, b *Tensor) (*Tensor, error)

OpLogaddexp wraps api-table member `op_logaddexp`. ClikaRT::ops::logaddexp <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpLogaddexp2

func (api *Api) OpLogaddexp2(a *Tensor, b *Tensor) (*Tensor, error)

OpLogaddexp2 wraps api-table member `op_logaddexp2`. ClikaRT::ops::logaddexp2 <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpLogicalAnd

func (api *Api) OpLogicalAnd(a *Tensor, b *Tensor) (*Tensor, error)

OpLogicalAnd wraps api-table member `op_logical_and`. ClikaRT::ops::logical_and <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpLogicalAndInplace

func (api *Api) OpLogicalAndInplace(self *Tensor, other *Tensor) (error)

OpLogicalAndInplace wraps api-table member `op_logical_and_inplace`. ClikaRT::ops::logical_and_ <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpLogicalNot

func (api *Api) OpLogicalNot(x *Tensor) (*Tensor, error)

OpLogicalNot wraps api-table member `op_logical_not`. ClikaRT::ops::logical_not <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpLogicalNotInplace

func (api *Api) OpLogicalNotInplace(self *Tensor) (error)

OpLogicalNotInplace wraps api-table member `op_logical_not_inplace`. ClikaRT::ops::logical_not_ <- ClikaRT/compute/ops.h

OpLogicalOr

func (api *Api) OpLogicalOr(a *Tensor, b *Tensor) (*Tensor, error)

OpLogicalOr wraps api-table member `op_logical_or`. ClikaRT::ops::logical_or <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpLogicalOrInplace

func (api *Api) OpLogicalOrInplace(self *Tensor, other *Tensor) (error)

OpLogicalOrInplace wraps api-table member `op_logical_or_inplace`. ClikaRT::ops::logical_or_ <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpLogicalXor

func (api *Api) OpLogicalXor(a *Tensor, b *Tensor) (*Tensor, error)

OpLogicalXor wraps api-table member `op_logical_xor`. ClikaRT::ops::logical_xor <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpLogicalXorInplace

func (api *Api) OpLogicalXorInplace(self *Tensor, other *Tensor) (error)

OpLogicalXorInplace wraps api-table member `op_logical_xor_inplace`. ClikaRT::ops::logical_xor_ <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpLogit

func (api *Api) OpLogit(x *Tensor, epsHas bool, eps float64) (*Tensor, error)

OpLogit wraps api-table member `op_logit`. ClikaRT::ops::logit <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpLogitInplace

func (api *Api) OpLogitInplace(self *Tensor, epsHas bool, eps float64) (error)

OpLogitInplace wraps api-table member `op_logit_inplace`. ClikaRT::ops::logit_ <- ClikaRT/compute/ops.h

OpLogsumexp

func (api *Api) OpLogsumexp(x *Tensor, dims []int64, keepdim bool) (*Tensor, error)

OpLogsumexp wraps api-table member `op_logsumexp`. ClikaRT::ops::logsumexp <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpLt

func (api *Api) OpLt(a *Tensor, other ScalarOrTensor) (*Tensor, error)

OpLt wraps api-table member `op_lt`. ClikaRT::ops::lt <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpLtInplace

func (api *Api) OpLtInplace(self *Tensor, other ScalarOrTensor) (error)

OpLtInplace wraps api-table member `op_lt_inplace`. ClikaRT::ops::lt_ <- ClikaRT/compute/ops.h

OpMaskedFill

func (api *Api) OpMaskedFill(x *Tensor, mask *Tensor, value ScalarOrTensor) (*Tensor, error)

OpMaskedFill wraps api-table member `op_masked_fill`. ClikaRT::ops::masked_fill <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpMaskedFillInplace

func (api *Api) OpMaskedFillInplace(self *Tensor, mask *Tensor, value ScalarOrTensor) (error)

OpMaskedFillInplace wraps api-table member `op_masked_fill_inplace`. ClikaRT::ops::masked_fill_ <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpMaskedScatter

func (api *Api) OpMaskedScatter(x *Tensor, mask *Tensor, source *Tensor) (*Tensor, error)

OpMaskedScatter wraps api-table member `op_masked_scatter`. ClikaRT::ops::masked_scatter <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpMaskedScatterInplace

func (api *Api) OpMaskedScatterInplace(self *Tensor, mask *Tensor, source *Tensor) (error)

OpMaskedScatterInplace wraps api-table member `op_masked_scatter_inplace`. ClikaRT::ops::masked_scatter_ <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpMaskedSelect

func (api *Api) OpMaskedSelect(x *Tensor, mask *Tensor) (*Tensor, error)

OpMaskedSelect wraps api-table member `op_masked_select`. ClikaRT::ops::masked_select <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpMatmul

func (api *Api) OpMatmul(a *Tensor, b *Tensor, bias *Tensor, activationHas bool, activation Activation, transposeA bool, transposeB bool, situBeta float64, situLinearBeta float64) (*Tensor, error)

OpMatmul wraps api-table member `op_matmul`. ClikaRT::ops::matmul <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpMax

func (api *Api) OpMax(x *Tensor, dim int64, keepdim bool) (*Tensor, *Tensor, error)

OpMax wraps api-table member `op_max`. ClikaRT::ops::max <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpMaxPool

func (api *Api) OpMaxPool(x *Tensor, kernelSize []int64, stride []int64, padding []int64, dilation []int64, ceilMode bool) (*Tensor, error)

OpMaxPool wraps api-table member `op_max_pool`. ClikaRT::ops::max_pool <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpMaxPool1d

func (api *Api) OpMaxPool1d(x *Tensor, kernelSize []int64, stride []int64, padding []int64, dilation []int64, ceilMode bool) (*Tensor, error)

OpMaxPool1d wraps api-table member `op_max_pool1d`. ClikaRT::ops::max_pool1d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpMaxPool1dWithIndices

func (api *Api) OpMaxPool1dWithIndices(x *Tensor, kernelSize []int64, stride []int64, padding []int64, dilation []int64, ceilMode bool) (*Tensor, *Tensor, error)

OpMaxPool1dWithIndices wraps api-table member `op_max_pool1d_with_indices`. ClikaRT::ops::max_pool1d_with_indices <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpMaxPool2d

func (api *Api) OpMaxPool2d(x *Tensor, kernelSize []int64, stride []int64, padding []int64, dilation []int64, ceilMode bool) (*Tensor, error)

OpMaxPool2d wraps api-table member `op_max_pool2d`. ClikaRT::ops::max_pool2d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpMaxPool2dWithIndices

func (api *Api) OpMaxPool2dWithIndices(x *Tensor, kernelSize []int64, stride []int64, padding []int64, dilation []int64, ceilMode bool) (*Tensor, *Tensor, error)

OpMaxPool2dWithIndices wraps api-table member `op_max_pool2d_with_indices`. ClikaRT::ops::max_pool2d_with_indices <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpMaxPool3d

func (api *Api) OpMaxPool3d(x *Tensor, kernelSize []int64, stride []int64, padding []int64, dilation []int64, ceilMode bool) (*Tensor, error)

OpMaxPool3d wraps api-table member `op_max_pool3d`. ClikaRT::ops::max_pool3d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpMaxPool3dWithIndices

func (api *Api) OpMaxPool3dWithIndices(x *Tensor, kernelSize []int64, stride []int64, padding []int64, dilation []int64, ceilMode bool) (*Tensor, *Tensor, error)

OpMaxPool3dWithIndices wraps api-table member `op_max_pool3d_with_indices`. ClikaRT::ops::max_pool3d_with_indices <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpMaxPoolWithIndices

func (api *Api) OpMaxPoolWithIndices(x *Tensor, kernelSize []int64, stride []int64, padding []int64, dilation []int64, ceilMode bool) (*Tensor, *Tensor, error)

OpMaxPoolWithIndices wraps api-table member `op_max_pool_with_indices`. ClikaRT::ops::max_pool_with_indices <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpMaximum

func (api *Api) OpMaximum(a *Tensor, b *Tensor) (*Tensor, error)

OpMaximum wraps api-table member `op_maximum`. ClikaRT::ops::maximum <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpMaximumInplace

func (api *Api) OpMaximumInplace(self *Tensor, other *Tensor) (error)

OpMaximumInplace wraps api-table member `op_maximum_inplace`. ClikaRT::ops::maximum_ <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpMean

func (api *Api) OpMean(x *Tensor, dims []int64, keepdim bool, dtype DataType) (*Tensor, error)

OpMean wraps api-table member `op_mean`. ClikaRT::ops::mean <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpMedian

func (api *Api) OpMedian(x *Tensor, dimHas bool, dim int64, keepdim bool) (*Tensor, *Tensor, error)

OpMedian wraps api-table member `op_median`. ClikaRT::ops::median <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpMeshgrid

func (api *Api) OpMeshgrid(tensors []*Tensor, indexing MeshgridIndexing) (*TensorList, error)

OpMeshgrid wraps api-table member `op_meshgrid`. ClikaRT::ops::meshgrid <- ClikaRT/compute/ops.h

OpMin

func (api *Api) OpMin(x *Tensor, dim int64, keepdim bool) (*Tensor, *Tensor, error)

OpMin wraps api-table member `op_min`. ClikaRT::ops::min <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpMinimum

func (api *Api) OpMinimum(a *Tensor, b *Tensor) (*Tensor, error)

OpMinimum wraps api-table member `op_minimum`. ClikaRT::ops::minimum <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpMinimumInplace

func (api *Api) OpMinimumInplace(self *Tensor, other *Tensor) (error)

OpMinimumInplace wraps api-table member `op_minimum_inplace`. ClikaRT::ops::minimum_ <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpMish

func (api *Api) OpMish(x *Tensor) (*Tensor, error)

OpMish wraps api-table member `op_mish`. ClikaRT::ops::mish <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpMishInplace

func (api *Api) OpMishInplace(self *Tensor) (error)

OpMishInplace wraps api-table member `op_mish_inplace`. ClikaRT::ops::mish_ <- ClikaRT/compute/ops.h

OpMlaAttention

func (api *Api) OpMlaAttention(qNope *Tensor, qPe *Tensor, newCkv *Tensor, newKpe *Tensor, ckvCache *Tensor, kpeCache *Tensor, kvcacheStart *Tensor, cuSeqlensQ *Tensor, scale float64, slotIds *Tensor) (*Tensor, error)

OpMlaAttention wraps api-table member `op_mla_attention`. ClikaRT::ops::mla_attention <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): slotIds.

OpMm

func (api *Api) OpMm(a *Tensor, b *Tensor, bias *Tensor, activationHas bool, activation Activation) (*Tensor, error)

OpMm wraps api-table member `op_mm`. ClikaRT::ops::mm <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpMod

func (api *Api) OpMod(a *Tensor, other ScalarOrTensor, mode ModMode) (*Tensor, error)

OpMod wraps api-table member `op_mod`. ClikaRT::ops::mod <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpModInplace

func (api *Api) OpModInplace(self *Tensor, other ScalarOrTensor, mode ModMode) (error)

OpModInplace wraps api-table member `op_mod_inplace`. ClikaRT::ops::mod_ <- ClikaRT/compute/ops.h

OpMoe

func (api *Api) OpMoe(input *Tensor, routerLogits *Tensor, fc1Experts *Tensor, fc2Experts *Tensor, topK int64, fc1Bias *Tensor, fc2Bias *Tensor, fc3Experts *Tensor, fc3Bias *Tensor, eScoreCorrectionBias *Tensor, routerWeights *Tensor, sharedOutput *Tensor, opts *MoeOptions) (*Tensor, error)

OpMoe wraps api-table member `op_moe`. ClikaRT::ops::moe <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): fc1Bias, fc2Bias, fc3Experts, fc3Bias, eScoreCorrectionBias, routerWeights, sharedOutput.

A nil `opts` means every option's default.

OpMropeRotaryEmbedding

func (api *Api) OpMropeRotaryEmbedding(x0 *Tensor, positionIds *Tensor, mropeSections []int64, opts *MropeRotaryEmbeddingOptions) (*Tensor, error)

OpMropeRotaryEmbedding wraps api-table member `op_mrope_rotary_embedding`. ClikaRT::ops::mrope_rotary_embedding <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

A nil `opts` means every option's default.

OpMropeRotaryEmbeddingQkVarlen

func (api *Api) OpMropeRotaryEmbeddingQkVarlen(q *Tensor, k *Tensor, positionIds *Tensor, mropeSections []int64, opts *MropeRotaryEmbeddingQkVarlenOptions) (*Tensor, *Tensor, error)

OpMropeRotaryEmbeddingQkVarlen wraps api-table member `op_mrope_rotary_embedding_qk_varlen`. ClikaRT::ops::mrope_rotary_embedding_qk_varlen <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

A nil `opts` means every option's default.

OpMropeRotaryEmbeddingVarlen

func (api *Api) OpMropeRotaryEmbeddingVarlen(x0 *Tensor, positionIds *Tensor, mropeSections []int64, opts *MropeRotaryEmbeddingVarlenOptions) (*Tensor, error)

OpMropeRotaryEmbeddingVarlen wraps api-table member `op_mrope_rotary_embedding_varlen`. ClikaRT::ops::mrope_rotary_embedding_varlen <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

A nil `opts` means every option's default.

OpMsDeformAttention

func (api *Api) OpMsDeformAttention(value *Tensor, spatialShapes *Tensor, levelStartIndex *Tensor, samplingLocations *Tensor, attentionWeights *Tensor) (*Tensor, error)

OpMsDeformAttention wraps api-table member `op_ms_deform_attention`. ClikaRT::ops::ms_deform_attention <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpMseLoss

func (api *Api) OpMseLoss(input *Tensor, target *Tensor, reduction Reduction) (*Tensor, error)

OpMseLoss wraps api-table member `op_mse_loss`. ClikaRT::ops::mse_loss <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpMulInplace

func (api *Api) OpMulInplace(self *Tensor, other ScalarOrTensor, activation Activation) (error)

OpMulInplace wraps api-table member `op_mul_inplace`. ClikaRT::ops::mul_ <- ClikaRT/compute/ops.h

OpMulScalarLhs

func (api *Api) OpMulScalarLhs(a Scalar, b *Tensor, activation Activation) (*Tensor, error)

OpMulScalarLhs wraps api-table member `op_mul_scalar_lhs`. ClikaRT::ops::mul <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpMulTensor

func (api *Api) OpMulTensor(a *Tensor, other ScalarOrTensor, activation Activation) (*Tensor, error)

OpMulTensor wraps api-table member `op_mul_tensor`. ClikaRT::ops::mul <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpMultinomial

func (api *Api) OpMultinomial(probabilities *Tensor, numSamples int64, replacement bool, s StreamOrDevice) (*Tensor, error)

OpMultinomial wraps api-table member `op_multinomial`. ClikaRT::ops::multinomial <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpMv

func (api *Api) OpMv(a *Tensor, vec *Tensor, bias *Tensor, activationHas bool, activation Activation) (*Tensor, error)

OpMv wraps api-table member `op_mv`. ClikaRT::ops::mv <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpNanToNum

func (api *Api) OpNanToNum(x *Tensor, nanHas bool, nan float64, posinfHas bool, posinf float64, neginfHas bool, neginf float64) (*Tensor, error)

OpNanToNum wraps api-table member `op_nan_to_num`. ClikaRT::ops::nan_to_num <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpNanToNumInplace

func (api *Api) OpNanToNumInplace(self *Tensor, nanHas bool, nan float64, posinfHas bool, posinf float64, neginfHas bool, neginf float64) (error)

OpNanToNumInplace wraps api-table member `op_nan_to_num_inplace`. ClikaRT::ops::nan_to_num_ <- ClikaRT/compute/ops.h

OpNanmean

func (api *Api) OpNanmean(x *Tensor, dims []int64, keepdim bool) (*Tensor, error)

OpNanmean wraps api-table member `op_nanmean`. ClikaRT::ops::nanmean <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpNanmedian

func (api *Api) OpNanmedian(x *Tensor, dimHas bool, dim int64, keepdim bool) (*Tensor, *Tensor, error)

OpNanmedian wraps api-table member `op_nanmedian`. ClikaRT::ops::nanmedian <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpNanquantile

func (api *Api) OpNanquantile(x *Tensor, q ScalarOrTensor, dimHas bool, dim int64, keepdim bool, interpolation QuantileInterp) (*Tensor, error)

OpNanquantile wraps api-table member `op_nanquantile`. ClikaRT::ops::nanquantile <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpNansum

func (api *Api) OpNansum(x *Tensor, dims []int64, keepdim bool) (*Tensor, error)

OpNansum wraps api-table member `op_nansum`. ClikaRT::ops::nansum <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpNarrow

func (api *Api) OpNarrow(x *Tensor, dim int64, start IndexBound, length IndexBound) (*Tensor, error)

OpNarrow wraps api-table member `op_narrow`. ClikaRT::ops::narrow <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpNdim

func (api *Api) OpNdim(x *Tensor) (*Tensor, error)

OpNdim wraps api-table member `op_ndim`. ClikaRT::ops::ndim <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpNdimHost

func (api *Api) OpNdimHost(x *Tensor) (*Tensor, error)

OpNdimHost wraps api-table member `op_ndim_host`. ClikaRT::ops::ndim_host <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpNe

func (api *Api) OpNe(a *Tensor, other ScalarOrTensor) (*Tensor, error)

OpNe wraps api-table member `op_ne`. ClikaRT::ops::ne <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpNeInplace

func (api *Api) OpNeInplace(self *Tensor, other ScalarOrTensor) (error)

OpNeInplace wraps api-table member `op_ne_inplace`. ClikaRT::ops::ne_ <- ClikaRT/compute/ops.h

OpNeg

func (api *Api) OpNeg(x *Tensor) (*Tensor, error)

OpNeg wraps api-table member `op_neg`. ClikaRT::ops::neg <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpNegInplace

func (api *Api) OpNegInplace(self *Tensor) (error)

OpNegInplace wraps api-table member `op_neg_inplace`. ClikaRT::ops::neg_ <- ClikaRT/compute/ops.h

OpNllLoss

func (api *Api) OpNllLoss(input *Tensor, target *Tensor, weight *Tensor, ignoreIndexHas bool, ignoreIndex int64, reduction Reduction) (*Tensor, error)

OpNllLoss wraps api-table member `op_nll_loss`. ClikaRT::ops::nll_loss <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): weight.

OpNms

func (api *Api) OpNms(boxes *Tensor, scores *Tensor, maxOutputBoxesPerClass ScalarOrTensor, iouThreshold ScalarOrTensor, scoreThreshold ScalarOrTensor, centerPointBox bool) (*Tensor, error)

OpNms wraps api-table member `op_nms`. ClikaRT::ops::nms <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpNonzero

func (api *Api) OpNonzero(x *Tensor) (*Tensor, error)

OpNonzero wraps api-table member `op_nonzero`. ClikaRT::ops::nonzero <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpNorm

func (api *Api) OpNorm(x *Tensor, p Scalar, dims []int64, keepdim bool) (*Tensor, error)

OpNorm wraps api-table member `op_norm`. ClikaRT::ops::norm <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpNormal

func (api *Api) OpNormal(mean ScalarOrTensor, stddev ScalarOrTensor, shape []ScalarOrTensor, s StreamOrDevice) (*Tensor, error)

OpNormal wraps api-table member `op_normal`. ClikaRT::ops::normal <- ClikaRT/compute/ops.h

OpNormalInplace

func (api *Api) OpNormalInplace(self *Tensor, mean ScalarOrTensor, stddev ScalarOrTensor, s StreamOrDevice) (error)

OpNormalInplace wraps api-table member `op_normal_inplace`. ClikaRT::ops::normal_ <- ClikaRT/compute/ops.h

OpNormalize

func (api *Api) OpNormalize(x *Tensor, p Scalar, dim int64, epsHas bool, eps float64) (*Tensor, error)

OpNormalize wraps api-table member `op_normalize`. ClikaRT::ops::normalize <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpNormalizeInplace

func (api *Api) OpNormalizeInplace(self *Tensor, p Scalar, dim int64, epsHas bool, eps float64) (error)

OpNormalizeInplace wraps api-table member `op_normalize_inplace`. ClikaRT::ops::normalize_ <- ClikaRT/compute/ops.h

OpNumel

func (api *Api) OpNumel(x *Tensor) (*Tensor, error)

OpNumel wraps api-table member `op_numel`. ClikaRT::ops::numel <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpNumelHost

func (api *Api) OpNumelHost(x *Tensor) (*Tensor, error)

OpNumelHost wraps api-table member `op_numel_host`. ClikaRT::ops::numel_host <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpOneHot

func (api *Api) OpOneHot(indices *Tensor, numClasses int64) (*Tensor, error)

OpOneHot wraps api-table member `op_one_hot`. ClikaRT::ops::one_hot <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpOnes

func (api *Api) OpOnes(shape []ScalarOrTensor, dtype DataType, s StreamOrDevice, pinnedFor StreamOrDevice) (*Tensor, error)

OpOnes wraps api-table member `op_ones`. ClikaRT::ops::ones <- ClikaRT/compute/ops.h

OpOnesLike

func (api *Api) OpOnesLike(reference *Tensor, s StreamOrDevice) (*Tensor, error)

OpOnesLike wraps api-table member `op_ones_like`. ClikaRT::ops::ones_like <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpOuter

func (api *Api) OpOuter(a *Tensor, b *Tensor) (*Tensor, error)

OpOuter wraps api-table member `op_outer`. ClikaRT::ops::outer <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpPad

func (api *Api) OpPad(x *Tensor, pad []ScalarOrTensor, mode PadMode, value ScalarOrTensor) (*Tensor, error)

OpPad wraps api-table member `op_pad`. ClikaRT::ops::pad <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpPairwiseDistance

func (api *Api) OpPairwiseDistance(a *Tensor, b *Tensor, p Scalar, epsHas bool, eps float64, keepdim bool) (*Tensor, error)

OpPairwiseDistance wraps api-table member `op_pairwise_distance`. ClikaRT::ops::pairwise_distance <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpPdist

func (api *Api) OpPdist(a *Tensor, p Scalar) (*Tensor, error)

OpPdist wraps api-table member `op_pdist`. ClikaRT::ops::pdist <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpPermute

func (api *Api) OpPermute(x *Tensor, dims []int64) (*Tensor, error)

OpPermute wraps api-table member `op_permute`. ClikaRT::ops::permute <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpPixelShuffle

func (api *Api) OpPixelShuffle(x *Tensor, upscaleFactor int64, mode PixelShuffleMode) (*Tensor, error)

OpPixelShuffle wraps api-table member `op_pixel_shuffle`. ClikaRT::ops::pixel_shuffle <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpPixelUnshuffle

func (api *Api) OpPixelUnshuffle(x *Tensor, downscaleFactor int64, mode PixelShuffleMode) (*Tensor, error)

OpPixelUnshuffle wraps api-table member `op_pixel_unshuffle`. ClikaRT::ops::pixel_unshuffle <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpPoisson

func (api *Api) OpPoisson(rates *Tensor, s StreamOrDevice) (*Tensor, error)

OpPoisson wraps api-table member `op_poisson`. ClikaRT::ops::poisson <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpPow

func (api *Api) OpPow(a *Tensor, exponent ScalarOrTensor) (*Tensor, error)

OpPow wraps api-table member `op_pow`. ClikaRT::ops::pow <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpPowInplace

func (api *Api) OpPowInplace(self *Tensor, exponent ScalarOrTensor) (error)

OpPowInplace wraps api-table member `op_pow_inplace`. ClikaRT::ops::pow_ <- ClikaRT/compute/ops.h

OpPrelu

func (api *Api) OpPrelu(x *Tensor, weight *Tensor) (*Tensor, error)

OpPrelu wraps api-table member `op_prelu`. ClikaRT::ops::prelu <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): weight.

OpPreluInplace

func (api *Api) OpPreluInplace(self *Tensor, weight *Tensor) (error)

OpPreluInplace wraps api-table member `op_prelu_inplace`. ClikaRT::ops::prelu_ <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): weight.

OpProd

func (api *Api) OpProd(x *Tensor, dims []int64, keepdim bool, dtype DataType) (*Tensor, error)

OpProd wraps api-table member `op_prod`. ClikaRT::ops::prod <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpPut

func (api *Api) OpPut(x *Tensor, index *Tensor, source *Tensor, accumulate bool) (*Tensor, error)

OpPut wraps api-table member `op_put`. ClikaRT::ops::put <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpPutInplace

func (api *Api) OpPutInplace(self *Tensor, index *Tensor, source *Tensor, accumulate bool) (error)

OpPutInplace wraps api-table member `op_put_inplace`. ClikaRT::ops::put_ <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQEmbedding

func (api *Api) OpQEmbedding(indices *Tensor, weight *QTensor, bias *Tensor, activationHas bool, activation Activation, outDtype DataType) (*Tensor, error)

OpQEmbedding wraps api-table member `op_q_embedding`. ClikaRT::ops::q_embedding <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpQaddInplaceToDense

func (api *Api) OpQaddInplaceToDense(a *QTensor, b *QTensor, out *Tensor, activation Activation) (error)

OpQaddInplaceToDense wraps api-table member `op_qadd_inplace_to_dense`. ClikaRT::ops::qadd_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQaddInplaceToDenseOutScale

func (api *Api) OpQaddInplaceToDenseOutScale(a *QTensor, b *QTensor, out *Tensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, activation Activation) (error)

OpQaddInplaceToDenseOutScale wraps api-table member `op_qadd_inplace_to_dense_out_scale`. ClikaRT::ops::qadd_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQaddInplaceToQuantized

func (api *Api) OpQaddInplaceToQuantized(a *QTensor, b *QTensor, out *QTensor, activation Activation) (error)

OpQaddInplaceToQuantized wraps api-table member `op_qadd_inplace_to_quantized`. ClikaRT::ops::qadd_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQaddToDense

func (api *Api) OpQaddToDense(a *QTensor, b *QTensor, activation Activation) (*Tensor, error)

OpQaddToDense wraps api-table member `op_qadd_to_dense`. ClikaRT::ops::qadd <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQaddToQuantized

func (api *Api) OpQaddToQuantized(a *QTensor, b *QTensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, outDtype DataType, activation Activation) (*QTensor, error)

OpQaddToQuantized wraps api-table member `op_qadd_to_quantized`. ClikaRT::ops::qadd <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQconcatInplaceToDense

func (api *Api) OpQconcatInplaceToDense(tensors []*QTensor, dim int64, out *Tensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, activation Activation) (error)

OpQconcatInplaceToDense wraps api-table member `op_qconcat_inplace_to_dense`. ClikaRT::ops::qconcat_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQconcatInplaceToQuantized

func (api *Api) OpQconcatInplaceToQuantized(tensors []*QTensor, dim int64, out *QTensor, activation Activation) (error)

OpQconcatInplaceToQuantized wraps api-table member `op_qconcat_inplace_to_quantized`. ClikaRT::ops::qconcat_ <- ClikaRT/compute/q_tensor.h

OpQconcatToDense

func (api *Api) OpQconcatToDense(tensors []*QTensor, dim int64, activation Activation) (*Tensor, error)

OpQconcatToDense wraps api-table member `op_qconcat_to_dense`. ClikaRT::ops::qconcat <- ClikaRT/compute/q_tensor.h

OpQconcatToQuantized

func (api *Api) OpQconcatToQuantized(tensors []*QTensor, dim int64, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, outDtype DataType, activation Activation) (*QTensor, error)

OpQconcatToQuantized wraps api-table member `op_qconcat_to_quantized`. ClikaRT::ops::qconcat <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQconv1dToDense

func (api *Api) OpQconv1dToDense(a *QTensor, weight *QTensor, bias *Tensor, stride []int64, padding []int64, dilation []int64, groups int64, activation Activation) (*Tensor, error)

OpQconv1dToDense wraps api-table member `op_qconv1d_to_dense`. ClikaRT::ops::qconv1d <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpQconv1dToQuantized

func (api *Api) OpQconv1dToQuantized(a *QTensor, weight *QTensor, bias *Tensor, stride []int64, padding []int64, dilation []int64, groups int64, activation Activation, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, outDtype DataType) (*QTensor, error)

OpQconv1dToQuantized wraps api-table member `op_qconv1d_to_quantized`. ClikaRT::ops::qconv1d <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias, outZeroPoint.

OpQconv1dWoq

func (api *Api) OpQconv1dWoq(x *Tensor, weight *QTensor, bias *Tensor, stride []int64, padding []int64, dilation []int64, groups int64, activation Activation) (*Tensor, error)

OpQconv1dWoq wraps api-table member `op_qconv1d_woq`. ClikaRT::ops::qconv1d_woq <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpQconv2dToDense

func (api *Api) OpQconv2dToDense(a *QTensor, weight *QTensor, bias *Tensor, stride []int64, padding []int64, dilation []int64, groups int64, activation Activation) (*Tensor, error)

OpQconv2dToDense wraps api-table member `op_qconv2d_to_dense`. ClikaRT::ops::qconv2d <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpQconv2dToQuantized

func (api *Api) OpQconv2dToQuantized(a *QTensor, weight *QTensor, bias *Tensor, stride []int64, padding []int64, dilation []int64, groups int64, activation Activation, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, outDtype DataType) (*QTensor, error)

OpQconv2dToQuantized wraps api-table member `op_qconv2d_to_quantized`. ClikaRT::ops::qconv2d <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias, outZeroPoint.

OpQconv2dWoq

func (api *Api) OpQconv2dWoq(x *Tensor, weight *QTensor, bias *Tensor, stride []int64, padding []int64, dilation []int64, groups int64, activation Activation) (*Tensor, error)

OpQconv2dWoq wraps api-table member `op_qconv2d_woq`. ClikaRT::ops::qconv2d_woq <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpQconv3dToDense

func (api *Api) OpQconv3dToDense(a *QTensor, weight *QTensor, bias *Tensor, stride []int64, padding []int64, dilation []int64, groups int64, activation Activation) (*Tensor, error)

OpQconv3dToDense wraps api-table member `op_qconv3d_to_dense`. ClikaRT::ops::qconv3d <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpQconv3dToQuantized

func (api *Api) OpQconv3dToQuantized(a *QTensor, weight *QTensor, bias *Tensor, stride []int64, padding []int64, dilation []int64, groups int64, activation Activation, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, outDtype DataType) (*QTensor, error)

OpQconv3dToQuantized wraps api-table member `op_qconv3d_to_quantized`. ClikaRT::ops::qconv3d <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias, outZeroPoint.

OpQconv3dWoq

func (api *Api) OpQconv3dWoq(x *Tensor, weight *QTensor, bias *Tensor, stride []int64, padding []int64, dilation []int64, groups int64, activation Activation) (*Tensor, error)

OpQconv3dWoq wraps api-table member `op_qconv3d_woq`. ClikaRT::ops::qconv3d_woq <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpQconvInplaceToDense

func (api *Api) OpQconvInplaceToDense(a *QTensor, weight *QTensor, out *Tensor, bias *Tensor, opts *QconvInplaceToDenseOptions) (error)

OpQconvInplaceToDense wraps api-table member `op_qconv_inplace_to_dense`. ClikaRT::ops::qconv_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

A nil `opts` means every option's default.

OpQconvInplaceToDenseOutScale

func (api *Api) OpQconvInplaceToDenseOutScale(a *QTensor, weight *QTensor, out *Tensor, outScale *Tensor, outZeroPoint *Tensor, bias *Tensor, opts *QconvInplaceToDenseOutScaleOptions) (error)

OpQconvInplaceToDenseOutScale wraps api-table member `op_qconv_inplace_to_dense_out_scale`. ClikaRT::ops::qconv_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint, bias.

A nil `opts` means every option's default.

OpQconvInplaceToQuantized

func (api *Api) OpQconvInplaceToQuantized(a *QTensor, weight *QTensor, out *QTensor, bias *Tensor, opts *QconvInplaceToQuantizedOptions) (error)

OpQconvInplaceToQuantized wraps api-table member `op_qconv_inplace_to_quantized`. ClikaRT::ops::qconv_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

A nil `opts` means every option's default.

OpQconvToDense

func (api *Api) OpQconvToDense(a *QTensor, weight *QTensor, bias *Tensor, opts *QconvToDenseOptions) (*Tensor, error)

OpQconvToDense wraps api-table member `op_qconv_to_dense`. ClikaRT::ops::qconv <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

A nil `opts` means every option's default.

OpQconvToQuantized

func (api *Api) OpQconvToQuantized(a *QTensor, weight *QTensor, bias *Tensor, stride []int64, padding []int64, dilation []int64, groups int64, mode PadMode, valueHas bool, value float64, activation Activation, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, outDtype DataType) (*QTensor, error)

OpQconvToQuantized wraps api-table member `op_qconv_to_quantized`. ClikaRT::ops::qconv <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias, outZeroPoint.

OpQconvTranspose1dToDense

func (api *Api) OpQconvTranspose1dToDense(a *QTensor, weight *QTensor, bias *Tensor, opts *QconvTranspose1dToDenseOptions) (*Tensor, error)

OpQconvTranspose1dToDense wraps api-table member `op_qconv_transpose1d_to_dense`. ClikaRT::ops::qconv_transpose1d <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

A nil `opts` means every option's default.

OpQconvTranspose1dToQuantized

func (api *Api) OpQconvTranspose1dToQuantized(a *QTensor, weight *QTensor, bias *Tensor, stride []int64, padding []int64, outputPadding []int64, dilation []int64, groups int64, activation Activation, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, outDtype DataType) (*QTensor, error)

OpQconvTranspose1dToQuantized wraps api-table member `op_qconv_transpose1d_to_quantized`. ClikaRT::ops::qconv_transpose1d <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias, outZeroPoint.

OpQconvTranspose1dWoq

func (api *Api) OpQconvTranspose1dWoq(x *Tensor, weight *QTensor, bias *Tensor, opts *QconvTranspose1dWoqOptions) (*Tensor, error)

OpQconvTranspose1dWoq wraps api-table member `op_qconv_transpose1d_woq`. ClikaRT::ops::qconv_transpose1d_woq <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

A nil `opts` means every option's default.

OpQconvTranspose2dToDense

func (api *Api) OpQconvTranspose2dToDense(a *QTensor, weight *QTensor, bias *Tensor, opts *QconvTranspose2dToDenseOptions) (*Tensor, error)

OpQconvTranspose2dToDense wraps api-table member `op_qconv_transpose2d_to_dense`. ClikaRT::ops::qconv_transpose2d <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

A nil `opts` means every option's default.

OpQconvTranspose2dToQuantized

func (api *Api) OpQconvTranspose2dToQuantized(a *QTensor, weight *QTensor, bias *Tensor, stride []int64, padding []int64, outputPadding []int64, dilation []int64, groups int64, activation Activation, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, outDtype DataType) (*QTensor, error)

OpQconvTranspose2dToQuantized wraps api-table member `op_qconv_transpose2d_to_quantized`. ClikaRT::ops::qconv_transpose2d <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias, outZeroPoint.

OpQconvTranspose2dWoq

func (api *Api) OpQconvTranspose2dWoq(x *Tensor, weight *QTensor, bias *Tensor, opts *QconvTranspose2dWoqOptions) (*Tensor, error)

OpQconvTranspose2dWoq wraps api-table member `op_qconv_transpose2d_woq`. ClikaRT::ops::qconv_transpose2d_woq <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

A nil `opts` means every option's default.

OpQconvTranspose3dToDense

func (api *Api) OpQconvTranspose3dToDense(a *QTensor, weight *QTensor, bias *Tensor, opts *QconvTranspose3dToDenseOptions) (*Tensor, error)

OpQconvTranspose3dToDense wraps api-table member `op_qconv_transpose3d_to_dense`. ClikaRT::ops::qconv_transpose3d <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

A nil `opts` means every option's default.

OpQconvTranspose3dToQuantized

func (api *Api) OpQconvTranspose3dToQuantized(a *QTensor, weight *QTensor, bias *Tensor, stride []int64, padding []int64, outputPadding []int64, dilation []int64, groups int64, activation Activation, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, outDtype DataType) (*QTensor, error)

OpQconvTranspose3dToQuantized wraps api-table member `op_qconv_transpose3d_to_quantized`. ClikaRT::ops::qconv_transpose3d <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias, outZeroPoint.

OpQconvTranspose3dWoq

func (api *Api) OpQconvTranspose3dWoq(x *Tensor, weight *QTensor, bias *Tensor, opts *QconvTranspose3dWoqOptions) (*Tensor, error)

OpQconvTranspose3dWoq wraps api-table member `op_qconv_transpose3d_woq`. ClikaRT::ops::qconv_transpose3d_woq <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

A nil `opts` means every option's default.

OpQconvTransposeInplaceToDense

func (api *Api) OpQconvTransposeInplaceToDense(a *QTensor, weight *QTensor, out *Tensor, bias *Tensor, opts *QconvTransposeInplaceToDenseOptions) (error)

OpQconvTransposeInplaceToDense wraps api-table member `op_qconv_transpose_inplace_to_dense`. ClikaRT::ops::qconv_transpose_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

A nil `opts` means every option's default.

OpQconvTransposeInplaceToDenseOutScale

func (api *Api) OpQconvTransposeInplaceToDenseOutScale(a *QTensor, weight *QTensor, out *Tensor, outScale *Tensor, outZeroPoint *Tensor, bias *Tensor, opts *QconvTransposeInplaceToDenseOutScaleOptions) (error)

OpQconvTransposeInplaceToDenseOutScale wraps api-table member `op_qconv_transpose_inplace_to_dense_out_scale`. ClikaRT::ops::qconv_transpose_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint, bias.

A nil `opts` means every option's default.

OpQconvTransposeInplaceToQuantized

func (api *Api) OpQconvTransposeInplaceToQuantized(a *QTensor, weight *QTensor, out *QTensor, bias *Tensor, opts *QconvTransposeInplaceToQuantizedOptions) (error)

OpQconvTransposeInplaceToQuantized wraps api-table member `op_qconv_transpose_inplace_to_quantized`. ClikaRT::ops::qconv_transpose_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

A nil `opts` means every option's default.

OpQconvTransposeToDense

func (api *Api) OpQconvTransposeToDense(a *QTensor, weight *QTensor, bias *Tensor, opts *QconvTransposeToDenseOptions) (*Tensor, error)

OpQconvTransposeToDense wraps api-table member `op_qconv_transpose_to_dense`. ClikaRT::ops::qconv_transpose <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

A nil `opts` means every option's default.

OpQconvTransposeToQuantized

func (api *Api) OpQconvTransposeToQuantized(a *QTensor, weight *QTensor, bias *Tensor, stride []int64, padding []int64, outputPadding []int64, dilation []int64, groups int64, activation Activation, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, outDtype DataType) (*QTensor, error)

OpQconvTransposeToQuantized wraps api-table member `op_qconv_transpose_to_quantized`. ClikaRT::ops::qconv_transpose <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias, outZeroPoint.

OpQconvTransposeWoq

func (api *Api) OpQconvTransposeWoq(x *Tensor, weight *QTensor, bias *Tensor, opts *QconvTransposeWoqOptions) (*Tensor, error)

OpQconvTransposeWoq wraps api-table member `op_qconv_transpose_woq`. ClikaRT::ops::qconv_transpose_woq <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

A nil `opts` means every option's default.

OpQconvWoq

func (api *Api) OpQconvWoq(x *Tensor, weight *QTensor, bias *Tensor, opts *QconvWoqOptions) (*Tensor, error)

OpQconvWoq wraps api-table member `op_qconv_woq`. ClikaRT::ops::qconv_woq <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

A nil `opts` means every option's default.

OpQdeformConvToDense

func (api *Api) OpQdeformConvToDense(a *QTensor, weight *QTensor, offset *Tensor, mask *Tensor, bias *Tensor, opts *QdeformConvToDenseOptions) (*Tensor, error)

OpQdeformConvToDense wraps api-table member `op_qdeform_conv_to_dense`. ClikaRT::ops::qdeform_conv <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): mask, bias.

A nil `opts` means every option's default.

OpQdeformConvToQuantized

func (api *Api) OpQdeformConvToQuantized(a *QTensor, weight *QTensor, offset *Tensor, mask *Tensor, bias *Tensor, stride []int64, padding []int64, dilation []int64, groups int64, offsetGroups int64, activation Activation, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, outDtype DataType) (*QTensor, error)

OpQdeformConvToQuantized wraps api-table member `op_qdeform_conv_to_quantized`. ClikaRT::ops::qdeform_conv <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): mask, bias, outZeroPoint.

OpQdeformConvWoq

func (api *Api) OpQdeformConvWoq(x *Tensor, weight *QTensor, offset *Tensor, mask *Tensor, bias *Tensor, opts *QdeformConvWoqOptions) (*Tensor, error)

OpQdeformConvWoq wraps api-table member `op_qdeform_conv_woq`. ClikaRT::ops::qdeform_conv_woq <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): mask, bias.

A nil `opts` means every option's default.

OpQdivInplaceToDense

func (api *Api) OpQdivInplaceToDense(a *QTensor, b *QTensor, out *Tensor, activation Activation) (error)

OpQdivInplaceToDense wraps api-table member `op_qdiv_inplace_to_dense`. ClikaRT::ops::qdiv_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQdivInplaceToDenseOutScale

func (api *Api) OpQdivInplaceToDenseOutScale(a *QTensor, b *QTensor, out *Tensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, activation Activation) (error)

OpQdivInplaceToDenseOutScale wraps api-table member `op_qdiv_inplace_to_dense_out_scale`. ClikaRT::ops::qdiv_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQdivInplaceToQuantized

func (api *Api) OpQdivInplaceToQuantized(a *QTensor, b *QTensor, out *QTensor, activation Activation) (error)

OpQdivInplaceToQuantized wraps api-table member `op_qdiv_inplace_to_quantized`. ClikaRT::ops::qdiv_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQdivToDense

func (api *Api) OpQdivToDense(a *QTensor, b *QTensor, activation Activation) (*Tensor, error)

OpQdivToDense wraps api-table member `op_qdiv_to_dense`. ClikaRT::ops::qdiv <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQdivToQuantized

func (api *Api) OpQdivToQuantized(a *QTensor, b *QTensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, outDtype DataType, activation Activation) (*QTensor, error)

OpQdivToQuantized wraps api-table member `op_qdiv_to_quantized`. ClikaRT::ops::qdiv <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQfastGeluInplaceToDense

func (api *Api) OpQfastGeluInplaceToDense(a *QTensor, out *Tensor) (error)

OpQfastGeluInplaceToDense wraps api-table member `op_qfast_gelu_inplace_to_dense`. ClikaRT::ops::qfast_gelu_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQfastGeluInplaceToDenseOutScale

func (api *Api) OpQfastGeluInplaceToDenseOutScale(a *QTensor, out *Tensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64) (error)

OpQfastGeluInplaceToDenseOutScale wraps api-table member `op_qfast_gelu_inplace_to_dense_out_scale`. ClikaRT::ops::qfast_gelu_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQfastGeluInplaceToQuantized

func (api *Api) OpQfastGeluInplaceToQuantized(a *QTensor, out *QTensor) (error)

OpQfastGeluInplaceToQuantized wraps api-table member `op_qfast_gelu_inplace_to_quantized`. ClikaRT::ops::qfast_gelu_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQfastGeluToDense

func (api *Api) OpQfastGeluToDense(a *QTensor) (*Tensor, error)

OpQfastGeluToDense wraps api-table member `op_qfast_gelu_to_dense`. ClikaRT::ops::qfast_gelu <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQfastGeluToQuantized

func (api *Api) OpQfastGeluToQuantized(a *QTensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, outDtype DataType) (*QTensor, error)

OpQfastGeluToQuantized wraps api-table member `op_qfast_gelu_to_quantized`. ClikaRT::ops::qfast_gelu <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQgeluInplaceToDense

func (api *Api) OpQgeluInplaceToDense(a *QTensor, out *Tensor) (error)

OpQgeluInplaceToDense wraps api-table member `op_qgelu_inplace_to_dense`. ClikaRT::ops::qgelu_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQgeluInplaceToDenseOutScale

func (api *Api) OpQgeluInplaceToDenseOutScale(a *QTensor, out *Tensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64) (error)

OpQgeluInplaceToDenseOutScale wraps api-table member `op_qgelu_inplace_to_dense_out_scale`. ClikaRT::ops::qgelu_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQgeluInplaceToQuantized

func (api *Api) OpQgeluInplaceToQuantized(a *QTensor, out *QTensor) (error)

OpQgeluInplaceToQuantized wraps api-table member `op_qgelu_inplace_to_quantized`. ClikaRT::ops::qgelu_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQgeluToDense

func (api *Api) OpQgeluToDense(a *QTensor) (*Tensor, error)

OpQgeluToDense wraps api-table member `op_qgelu_to_dense`. ClikaRT::ops::qgelu <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQgeluToQuantized

func (api *Api) OpQgeluToQuantized(a *QTensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, outDtype DataType) (*QTensor, error)

OpQgeluToQuantized wraps api-table member `op_qgelu_to_quantized`. ClikaRT::ops::qgelu <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQhardswishInplaceToDense

func (api *Api) OpQhardswishInplaceToDense(a *QTensor, out *Tensor) (error)

OpQhardswishInplaceToDense wraps api-table member `op_qhardswish_inplace_to_dense`. ClikaRT::ops::qhardswish_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQhardswishInplaceToDenseOutScale

func (api *Api) OpQhardswishInplaceToDenseOutScale(a *QTensor, out *Tensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64) (error)

OpQhardswishInplaceToDenseOutScale wraps api-table member `op_qhardswish_inplace_to_dense_out_scale`. ClikaRT::ops::qhardswish_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQhardswishInplaceToQuantized

func (api *Api) OpQhardswishInplaceToQuantized(a *QTensor, out *QTensor) (error)

OpQhardswishInplaceToQuantized wraps api-table member `op_qhardswish_inplace_to_quantized`. ClikaRT::ops::qhardswish_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQhardswishToDense

func (api *Api) OpQhardswishToDense(a *QTensor) (*Tensor, error)

OpQhardswishToDense wraps api-table member `op_qhardswish_to_dense`. ClikaRT::ops::qhardswish <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQhardswishToQuantized

func (api *Api) OpQhardswishToQuantized(a *QTensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, outDtype DataType) (*QTensor, error)

OpQhardswishToQuantized wraps api-table member `op_qhardswish_to_quantized`. ClikaRT::ops::qhardswish <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQkLayerNorm

func (api *Api) OpQkLayerNorm(q *Tensor, k *Tensor, v *Tensor, wQ *Tensor, bQ *Tensor, wK *Tensor, bK *Tensor, headDim int64, epsHas bool, eps float64) (*Tensor, *Tensor, *Tensor, error)

OpQkLayerNorm wraps api-table member `op_qk_layer_norm`. ClikaRT::ops::qk_layer_norm <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): k, v, wQ, bQ, wK, bK.

OpQkLayerNormInplace

func (api *Api) OpQkLayerNormInplace(q *Tensor, k *Tensor, v *Tensor, wQ *Tensor, bQ *Tensor, wK *Tensor, bK *Tensor, headDim int64, epsHas bool, eps float64) (error)

OpQkLayerNormInplace wraps api-table member `op_qk_layer_norm_inplace`. ClikaRT::ops::qk_layer_norm_ <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): k, v, wQ, bQ, wK, bK.

OpQkRmsNorm

func (api *Api) OpQkRmsNorm(q *Tensor, k *Tensor, v *Tensor, wQ *Tensor, wK *Tensor, headDim int64, epsHas bool, eps float64) (*Tensor, *Tensor, *Tensor, error)

OpQkRmsNorm wraps api-table member `op_qk_rms_norm`. ClikaRT::ops::qk_rms_norm <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): k, v, wQ, wK.

OpQkRmsNormInplace

func (api *Api) OpQkRmsNormInplace(q *Tensor, k *Tensor, v *Tensor, wQ *Tensor, wK *Tensor, headDim int64, epsHas bool, eps float64) (error)

OpQkRmsNormInplace wraps api-table member `op_qk_rms_norm_inplace`. ClikaRT::ops::qk_rms_norm_ <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): k, v, wQ, wK.

OpQleakyReluInplaceToDense

func (api *Api) OpQleakyReluInplaceToDense(a *QTensor, negativeSlope float64, out *Tensor) (error)

OpQleakyReluInplaceToDense wraps api-table member `op_qleaky_relu_inplace_to_dense`. ClikaRT::ops::qleaky_relu_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQleakyReluInplaceToDenseOutScale

func (api *Api) OpQleakyReluInplaceToDenseOutScale(a *QTensor, negativeSlope float64, out *Tensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64) (error)

OpQleakyReluInplaceToDenseOutScale wraps api-table member `op_qleaky_relu_inplace_to_dense_out_scale`. ClikaRT::ops::qleaky_relu_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQleakyReluInplaceToQuantized

func (api *Api) OpQleakyReluInplaceToQuantized(a *QTensor, negativeSlope float64, out *QTensor) (error)

OpQleakyReluInplaceToQuantized wraps api-table member `op_qleaky_relu_inplace_to_quantized`. ClikaRT::ops::qleaky_relu_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQleakyReluToDense

func (api *Api) OpQleakyReluToDense(a *QTensor, negativeSlope float64) (*Tensor, error)

OpQleakyReluToDense wraps api-table member `op_qleaky_relu_to_dense`. ClikaRT::ops::qleaky_relu <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQleakyReluToQuantized

func (api *Api) OpQleakyReluToQuantized(a *QTensor, negativeSlope float64, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, outDtype DataType) (*QTensor, error)

OpQleakyReluToQuantized wraps api-table member `op_qleaky_relu_to_quantized`. ClikaRT::ops::qleaky_relu <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQlinearInplaceToDense

func (api *Api) OpQlinearInplaceToDense(x *QTensor, weight *QTensor, out *Tensor, bias *Tensor, activationHas bool, activation Activation) (error)

OpQlinearInplaceToDense wraps api-table member `op_qlinear_inplace_to_dense`. ClikaRT::ops::qlinear_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpQlinearInplaceToQuantized

func (api *Api) OpQlinearInplaceToQuantized(x *QTensor, weight *QTensor, out *QTensor, bias *Tensor, activationHas bool, activation Activation) (error)

OpQlinearInplaceToQuantized wraps api-table member `op_qlinear_inplace_to_quantized`. ClikaRT::ops::qlinear_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpQlinearToDense

func (api *Api) OpQlinearToDense(x *QTensor, weight *QTensor, bias *Tensor, activationHas bool, activation Activation) (*Tensor, error)

OpQlinearToDense wraps api-table member `op_qlinear_to_dense`. ClikaRT::ops::qlinear <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpQlinearToQuantized

func (api *Api) OpQlinearToQuantized(x *QTensor, weight *QTensor, bias *Tensor, activationHas bool, activation Activation, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, outDtype DataType) (*QTensor, error)

OpQlinearToQuantized wraps api-table member `op_qlinear_to_quantized`. ClikaRT::ops::qlinear <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias, outZeroPoint.

OpQlinearWoq

func (api *Api) OpQlinearWoq(x *Tensor, weight *QTensor, bias *Tensor, activationHas bool, activation Activation, computeMode QcomputeMode) (*Tensor, error)

OpQlinearWoq wraps api-table member `op_qlinear_woq`. ClikaRT::ops::qlinear_woq <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpQlinearWoqInplace

func (api *Api) OpQlinearWoqInplace(x *Tensor, weight *QTensor, out *Tensor, bias *Tensor, activationHas bool, activation Activation, computeMode QcomputeMode) (error)

OpQlinearWoqInplace wraps api-table member `op_qlinear_woq_inplace`. ClikaRT::ops::qlinear_woq_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpQmatmulInplaceToDense

func (api *Api) OpQmatmulInplaceToDense(a *QTensor, b *QTensor, out *Tensor, bias *Tensor, activationHas bool, activation Activation, transposeA bool, transposeB bool) (error)

OpQmatmulInplaceToDense wraps api-table member `op_qmatmul_inplace_to_dense`. ClikaRT::ops::qmatmul_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpQmatmulInplaceToDenseOutScale

func (api *Api) OpQmatmulInplaceToDenseOutScale(a *QTensor, b *QTensor, out *Tensor, outScale *Tensor, outZeroPoint *Tensor, bias *Tensor, opts *QmatmulInplaceToDenseOutScaleOptions) (error)

OpQmatmulInplaceToDenseOutScale wraps api-table member `op_qmatmul_inplace_to_dense_out_scale`. ClikaRT::ops::qmatmul_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint, bias.

A nil `opts` means every option's default.

OpQmatmulInplaceToQuantized

func (api *Api) OpQmatmulInplaceToQuantized(a *QTensor, b *QTensor, out *QTensor, bias *Tensor, activationHas bool, activation Activation, transposeA bool, transposeB bool) (error)

OpQmatmulInplaceToQuantized wraps api-table member `op_qmatmul_inplace_to_quantized`. ClikaRT::ops::qmatmul_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpQmatmulToDense

func (api *Api) OpQmatmulToDense(a *QTensor, b *QTensor, bias *Tensor, activationHas bool, activation Activation, transposeA bool, transposeB bool) (*Tensor, error)

OpQmatmulToDense wraps api-table member `op_qmatmul_to_dense`. ClikaRT::ops::qmatmul <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpQmatmulToQuantized

func (api *Api) OpQmatmulToQuantized(a *QTensor, b *QTensor, bias *Tensor, activationHas bool, activation Activation, transposeA bool, transposeB bool, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, outDtype DataType) (*QTensor, error)

OpQmatmulToQuantized wraps api-table member `op_qmatmul_to_quantized`. ClikaRT::ops::qmatmul <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias, outZeroPoint.

OpQmatmulWoq

func (api *Api) OpQmatmulWoq(a *Tensor, b *QTensor, bias *Tensor, activationHas bool, activation Activation, transposeA bool, transposeB bool, computeMode QcomputeMode) (*Tensor, error)

OpQmatmulWoq wraps api-table member `op_qmatmul_woq`. ClikaRT::ops::qmatmul_woq <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpQmatmulWoqInplace

func (api *Api) OpQmatmulWoqInplace(a *Tensor, b *QTensor, out *Tensor, bias *Tensor, activationHas bool, activation Activation, transposeA bool, transposeB bool, computeMode QcomputeMode) (error)

OpQmatmulWoqInplace wraps api-table member `op_qmatmul_woq_inplace`. ClikaRT::ops::qmatmul_woq_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): bias.

OpQmoeToDense

func (api *Api) OpQmoeToDense(input *QTensor, routerLogits *Tensor, fc1Experts *QTensor, fc2Experts *QTensor, topK int64, fc1Bias *Tensor, fc2Bias *Tensor, fc3Experts *QTensor, fc3Bias *Tensor, eScoreCorrectionBias *Tensor, routerWeights *Tensor, sharedOutput *Tensor, opts *QmoeToDenseOptions) (*Tensor, error)

OpQmoeToDense wraps api-table member `op_qmoe_to_dense`. ClikaRT::ops::qmoe <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): fc1Bias, fc2Bias, fc3Bias, eScoreCorrectionBias, routerWeights, sharedOutput.

A nil `opts` means every option's default.

OpQmoeToQuantized

func (api *Api) OpQmoeToQuantized(input *QTensor, routerLogits *Tensor, fc1Experts *QTensor, fc2Experts *QTensor, topK int64, fc1Bias *Tensor, fc2Bias *Tensor, fc3Experts *QTensor, fc3Bias *Tensor, eScoreCorrectionBias *Tensor, routerWeights *Tensor, routingModeHas bool, routingMode MoeRouting, renormalizeHas bool, renormalize bool, nGroupHas bool, nGroup int64, topkGroupHas bool, topkGroup int64, routedScalingFactorHas bool, routedScalingFactor float64, sparseMixerEpsHas bool, sparseMixerEps float64, applyRouterWeightOnInputHas bool, applyRouterWeightOnInput bool, activationHas bool, activation Activation, swigluFusionHas bool, swigluFusion SwigluFusion, swigluAlphaHas bool, swigluAlpha float64, swigluBetaHas bool, swigluBeta float64, swigluLimitHas bool, swigluLimit float64, geluModeHas bool, geluMode GeluMode, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, outDtype DataType, sharedOutput *Tensor) (*QTensor, error)

OpQmoeToQuantized wraps api-table member `op_qmoe_to_quantized`. ClikaRT::ops::qmoe <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): fc1Bias, fc2Bias, fc3Bias, eScoreCorrectionBias, routerWeights, outZeroPoint, sharedOutput.

OpQmoeWoq

func (api *Api) OpQmoeWoq(input *Tensor, routerLogits *Tensor, fc1Experts *QTensor, fc2Experts *QTensor, topK int64, fc1Bias *Tensor, fc2Bias *Tensor, fc3Experts *QTensor, fc3Bias *Tensor, eScoreCorrectionBias *Tensor, routerWeights *Tensor, sharedOutput *Tensor, opts *QmoeWoqOptions) (*Tensor, error)

OpQmoeWoq wraps api-table member `op_qmoe_woq`. ClikaRT::ops::qmoe_woq <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): fc1Bias, fc2Bias, fc3Bias, eScoreCorrectionBias, routerWeights, sharedOutput.

A nil `opts` means every option's default.

OpQmulInplaceToDense

func (api *Api) OpQmulInplaceToDense(a *QTensor, b *QTensor, out *Tensor, activation Activation) (error)

OpQmulInplaceToDense wraps api-table member `op_qmul_inplace_to_dense`. ClikaRT::ops::qmul_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQmulInplaceToDenseOutScale

func (api *Api) OpQmulInplaceToDenseOutScale(a *QTensor, b *QTensor, out *Tensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, activation Activation) (error)

OpQmulInplaceToDenseOutScale wraps api-table member `op_qmul_inplace_to_dense_out_scale`. ClikaRT::ops::qmul_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQmulInplaceToQuantized

func (api *Api) OpQmulInplaceToQuantized(a *QTensor, b *QTensor, out *QTensor, activation Activation) (error)

OpQmulInplaceToQuantized wraps api-table member `op_qmul_inplace_to_quantized`. ClikaRT::ops::qmul_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQmulToDense

func (api *Api) OpQmulToDense(a *QTensor, b *QTensor, activation Activation) (*Tensor, error)

OpQmulToDense wraps api-table member `op_qmul_to_dense`. ClikaRT::ops::qmul <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQmulToQuantized

func (api *Api) OpQmulToQuantized(a *QTensor, b *QTensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, outDtype DataType, activation Activation) (*QTensor, error)

OpQmulToQuantized wraps api-table member `op_qmul_to_quantized`. ClikaRT::ops::qmul <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQquickGeluInplaceToDense

func (api *Api) OpQquickGeluInplaceToDense(a *QTensor, out *Tensor) (error)

OpQquickGeluInplaceToDense wraps api-table member `op_qquick_gelu_inplace_to_dense`. ClikaRT::ops::qquick_gelu_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQquickGeluInplaceToDenseOutScale

func (api *Api) OpQquickGeluInplaceToDenseOutScale(a *QTensor, out *Tensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64) (error)

OpQquickGeluInplaceToDenseOutScale wraps api-table member `op_qquick_gelu_inplace_to_dense_out_scale`. ClikaRT::ops::qquick_gelu_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQquickGeluInplaceToQuantized

func (api *Api) OpQquickGeluInplaceToQuantized(a *QTensor, out *QTensor) (error)

OpQquickGeluInplaceToQuantized wraps api-table member `op_qquick_gelu_inplace_to_quantized`. ClikaRT::ops::qquick_gelu_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQquickGeluToDense

func (api *Api) OpQquickGeluToDense(a *QTensor) (*Tensor, error)

OpQquickGeluToDense wraps api-table member `op_qquick_gelu_to_dense`. ClikaRT::ops::qquick_gelu <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQquickGeluToQuantized

func (api *Api) OpQquickGeluToQuantized(a *QTensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, outDtype DataType) (*QTensor, error)

OpQquickGeluToQuantized wraps api-table member `op_qquick_gelu_to_quantized`. ClikaRT::ops::qquick_gelu <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQreluInplaceToDense

func (api *Api) OpQreluInplaceToDense(a *QTensor, out *Tensor) (error)

OpQreluInplaceToDense wraps api-table member `op_qrelu_inplace_to_dense`. ClikaRT::ops::qrelu_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQreluInplaceToDenseOutScale

func (api *Api) OpQreluInplaceToDenseOutScale(a *QTensor, out *Tensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64) (error)

OpQreluInplaceToDenseOutScale wraps api-table member `op_qrelu_inplace_to_dense_out_scale`. ClikaRT::ops::qrelu_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQreluInplaceToQuantized

func (api *Api) OpQreluInplaceToQuantized(a *QTensor, out *QTensor) (error)

OpQreluInplaceToQuantized wraps api-table member `op_qrelu_inplace_to_quantized`. ClikaRT::ops::qrelu_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQreluToDense

func (api *Api) OpQreluToDense(a *QTensor) (*Tensor, error)

OpQreluToDense wraps api-table member `op_qrelu_to_dense`. ClikaRT::ops::qrelu <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQreluToQuantized

func (api *Api) OpQreluToQuantized(a *QTensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, outDtype DataType) (*QTensor, error)

OpQreluToQuantized wraps api-table member `op_qrelu_to_quantized`. ClikaRT::ops::qrelu <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQsigmoidInplaceToDense

func (api *Api) OpQsigmoidInplaceToDense(a *QTensor, out *Tensor) (error)

OpQsigmoidInplaceToDense wraps api-table member `op_qsigmoid_inplace_to_dense`. ClikaRT::ops::qsigmoid_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQsigmoidInplaceToDenseOutScale

func (api *Api) OpQsigmoidInplaceToDenseOutScale(a *QTensor, out *Tensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64) (error)

OpQsigmoidInplaceToDenseOutScale wraps api-table member `op_qsigmoid_inplace_to_dense_out_scale`. ClikaRT::ops::qsigmoid_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQsigmoidInplaceToQuantized

func (api *Api) OpQsigmoidInplaceToQuantized(a *QTensor, out *QTensor) (error)

OpQsigmoidInplaceToQuantized wraps api-table member `op_qsigmoid_inplace_to_quantized`. ClikaRT::ops::qsigmoid_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQsigmoidToDense

func (api *Api) OpQsigmoidToDense(a *QTensor) (*Tensor, error)

OpQsigmoidToDense wraps api-table member `op_qsigmoid_to_dense`. ClikaRT::ops::qsigmoid <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQsigmoidToQuantized

func (api *Api) OpQsigmoidToQuantized(a *QTensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, outDtype DataType) (*QTensor, error)

OpQsigmoidToQuantized wraps api-table member `op_qsigmoid_to_quantized`. ClikaRT::ops::qsigmoid <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQsiluInplaceToDense

func (api *Api) OpQsiluInplaceToDense(a *QTensor, out *Tensor) (error)

OpQsiluInplaceToDense wraps api-table member `op_qsilu_inplace_to_dense`. ClikaRT::ops::qsilu_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQsiluInplaceToDenseOutScale

func (api *Api) OpQsiluInplaceToDenseOutScale(a *QTensor, out *Tensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64) (error)

OpQsiluInplaceToDenseOutScale wraps api-table member `op_qsilu_inplace_to_dense_out_scale`. ClikaRT::ops::qsilu_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQsiluInplaceToQuantized

func (api *Api) OpQsiluInplaceToQuantized(a *QTensor, out *QTensor) (error)

OpQsiluInplaceToQuantized wraps api-table member `op_qsilu_inplace_to_quantized`. ClikaRT::ops::qsilu_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQsiluToDense

func (api *Api) OpQsiluToDense(a *QTensor) (*Tensor, error)

OpQsiluToDense wraps api-table member `op_qsilu_to_dense`. ClikaRT::ops::qsilu <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQsiluToQuantized

func (api *Api) OpQsiluToQuantized(a *QTensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, outDtype DataType) (*QTensor, error)

OpQsiluToQuantized wraps api-table member `op_qsilu_to_quantized`. ClikaRT::ops::qsilu <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQsubInplaceToDense

func (api *Api) OpQsubInplaceToDense(a *QTensor, b *QTensor, out *Tensor, activation Activation) (error)

OpQsubInplaceToDense wraps api-table member `op_qsub_inplace_to_dense`. ClikaRT::ops::qsub_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQsubInplaceToDenseOutScale

func (api *Api) OpQsubInplaceToDenseOutScale(a *QTensor, b *QTensor, out *Tensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, activation Activation) (error)

OpQsubInplaceToDenseOutScale wraps api-table member `op_qsub_inplace_to_dense_out_scale`. ClikaRT::ops::qsub_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQsubInplaceToQuantized

func (api *Api) OpQsubInplaceToQuantized(a *QTensor, b *QTensor, out *QTensor, activation Activation) (error)

OpQsubInplaceToQuantized wraps api-table member `op_qsub_inplace_to_quantized`. ClikaRT::ops::qsub_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQsubToDense

func (api *Api) OpQsubToDense(a *QTensor, b *QTensor, activation Activation) (*Tensor, error)

OpQsubToDense wraps api-table member `op_qsub_to_dense`. ClikaRT::ops::qsub <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQsubToQuantized

func (api *Api) OpQsubToQuantized(a *QTensor, b *QTensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, outDtype DataType, activation Activation) (*QTensor, error)

OpQsubToQuantized wraps api-table member `op_qsub_to_quantized`. ClikaRT::ops::qsub <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQtanhInplaceToDense

func (api *Api) OpQtanhInplaceToDense(a *QTensor, out *Tensor) (error)

OpQtanhInplaceToDense wraps api-table member `op_qtanh_inplace_to_dense`. ClikaRT::ops::qtanh_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQtanhInplaceToDenseOutScale

func (api *Api) OpQtanhInplaceToDenseOutScale(a *QTensor, out *Tensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64) (error)

OpQtanhInplaceToDenseOutScale wraps api-table member `op_qtanh_inplace_to_dense_out_scale`. ClikaRT::ops::qtanh_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQtanhInplaceToQuantized

func (api *Api) OpQtanhInplaceToQuantized(a *QTensor, out *QTensor) (error)

OpQtanhInplaceToQuantized wraps api-table member `op_qtanh_inplace_to_quantized`. ClikaRT::ops::qtanh_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQtanhToDense

func (api *Api) OpQtanhToDense(a *QTensor) (*Tensor, error)

OpQtanhToDense wraps api-table member `op_qtanh_to_dense`. ClikaRT::ops::qtanh <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQtanhToQuantized

func (api *Api) OpQtanhToQuantized(a *QTensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, outDtype DataType) (*QTensor, error)

OpQtanhToQuantized wraps api-table member `op_qtanh_to_quantized`. ClikaRT::ops::qtanh <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpQuantile

func (api *Api) OpQuantile(x *Tensor, q ScalarOrTensor, dimHas bool, dim int64, keepdim bool, interpolation QuantileInterp) (*Tensor, error)

OpQuantile wraps api-table member `op_quantile`. ClikaRT::ops::quantile <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQuantize

func (api *Api) OpQuantize(x *Tensor, scale *Tensor, zeroPoint *Tensor, quantAxis int64, outDtype DataType, blockSize int64) (*QTensor, error)

OpQuantize wraps api-table member `op_quantize`. ClikaRT::ops::quantize <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): zeroPoint.

OpQuantizeDequantize

func (api *Api) OpQuantizeDequantize(x *Tensor, scale *Tensor, zeroPoint *Tensor, quantAxis int64, codeDtype DataType, outDtype DataType, blockSize int64) (*Tensor, error)

OpQuantizeDequantize wraps api-table member `op_quantize_dequantize`. ClikaRT::ops::quantize_dequantize <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): zeroPoint.

OpQuantizeInplaceToDense

func (api *Api) OpQuantizeInplaceToDense(x *Tensor, out *Tensor, scale *Tensor, zeroPoint *Tensor, quantAxis int64, blockSize int64) (error)

OpQuantizeInplaceToDense wraps api-table member `op_quantize_inplace_to_dense`. ClikaRT::ops::quantize_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): zeroPoint.

OpQuantizeInplaceToQuantized

func (api *Api) OpQuantizeInplaceToQuantized(x *Tensor, out *QTensor) (error)

OpQuantizeInplaceToQuantized wraps api-table member `op_quantize_inplace_to_quantized`. ClikaRT::ops::quantize_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpQuantizeToScheme

func (api *Api) OpQuantizeToScheme(x *Tensor, scheme string, scale *Tensor) (*QTensor, error)

OpQuantizeToScheme wraps api-table member `op_quantize_to_scheme`. ClikaRT::ops::quantize_to_scheme <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): scale.

OpQuickGelu

func (api *Api) OpQuickGelu(x *Tensor) (*Tensor, error)

OpQuickGelu wraps api-table member `op_quick_gelu`. ClikaRT::ops::quick_gelu <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpRad2deg

func (api *Api) OpRad2deg(x *Tensor) (*Tensor, error)

OpRad2deg wraps api-table member `op_rad2deg`. ClikaRT::ops::rad2deg <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpRad2degInplace

func (api *Api) OpRad2degInplace(self *Tensor) (error)

OpRad2degInplace wraps api-table member `op_rad2deg_inplace`. ClikaRT::ops::rad2deg_ <- ClikaRT/compute/ops.h

OpRand

func (api *Api) OpRand(shape []ScalarOrTensor, dtype DataType, s StreamOrDevice) (*Tensor, error)

OpRand wraps api-table member `op_rand`. ClikaRT::ops::rand <- ClikaRT/compute/ops.h

OpRandLike

func (api *Api) OpRandLike(reference *Tensor, s StreamOrDevice) (*Tensor, error)

OpRandLike wraps api-table member `op_rand_like`. ClikaRT::ops::rand_like <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpRandint

func (api *Api) OpRandint(low int64, high int64, shape []ScalarOrTensor, dtype DataType, s StreamOrDevice) (*Tensor, error)

OpRandint wraps api-table member `op_randint`. ClikaRT::ops::randint <- ClikaRT/compute/ops.h

OpRandintLike

func (api *Api) OpRandintLike(reference *Tensor, low int64, high int64, s StreamOrDevice) (*Tensor, error)

OpRandintLike wraps api-table member `op_randint_like`. ClikaRT::ops::randint_like <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpRandn

func (api *Api) OpRandn(shape []ScalarOrTensor, dtype DataType, s StreamOrDevice) (*Tensor, error)

OpRandn wraps api-table member `op_randn`. ClikaRT::ops::randn <- ClikaRT/compute/ops.h

OpRandnLike

func (api *Api) OpRandnLike(reference *Tensor, s StreamOrDevice) (*Tensor, error)

OpRandnLike wraps api-table member `op_randn_like`. ClikaRT::ops::randn_like <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpRandomInplace

func (api *Api) OpRandomInplace(self *Tensor, lowHas bool, low int64, highHas bool, high int64, s StreamOrDevice) (error)

OpRandomInplace wraps api-table member `op_random_inplace`. ClikaRT::ops::random_ <- ClikaRT/compute/ops.h

OpRandperm

func (api *Api) OpRandperm(n ScalarOrTensor, dtype DataType, s StreamOrDevice) (*Tensor, error)

OpRandperm wraps api-table member `op_randperm`. ClikaRT::ops::randperm <- ClikaRT/compute/ops.h

OpReciprocal

func (api *Api) OpReciprocal(x *Tensor) (*Tensor, error)

OpReciprocal wraps api-table member `op_reciprocal`. ClikaRT::ops::reciprocal <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpReciprocalInplace

func (api *Api) OpReciprocalInplace(self *Tensor) (error)

OpReciprocalInplace wraps api-table member `op_reciprocal_inplace`. ClikaRT::ops::reciprocal_ <- ClikaRT/compute/ops.h

OpReflectPad

func (api *Api) OpReflectPad(x *Tensor, pad []ScalarOrTensor) (*Tensor, error)

OpReflectPad wraps api-table member `op_reflect_pad`. ClikaRT::ops::reflect_pad <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpReglu

func (api *Api) OpReglu(x *Tensor) (*Tensor, error)

OpReglu wraps api-table member `op_reglu`. ClikaRT::ops::reglu <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpRelu

func (api *Api) OpRelu(x *Tensor) (*Tensor, error)

OpRelu wraps api-table member `op_relu`. ClikaRT::ops::relu <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpRelu6

func (api *Api) OpRelu6(x *Tensor) (*Tensor, error)

OpRelu6 wraps api-table member `op_relu6`. ClikaRT::ops::relu6 <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpRelu6Inplace

func (api *Api) OpRelu6Inplace(self *Tensor) (error)

OpRelu6Inplace wraps api-table member `op_relu6_inplace`. ClikaRT::ops::relu6_ <- ClikaRT/compute/ops.h

OpReluInplace

func (api *Api) OpReluInplace(self *Tensor) (error)

OpReluInplace wraps api-table member `op_relu_inplace`. ClikaRT::ops::relu_ <- ClikaRT/compute/ops.h

OpRemainder

func (api *Api) OpRemainder(a *Tensor, other ScalarOrTensor) (*Tensor, error)

OpRemainder wraps api-table member `op_remainder`. ClikaRT::ops::remainder <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpRemainderInplace

func (api *Api) OpRemainderInplace(self *Tensor, other ScalarOrTensor) (error)

OpRemainderInplace wraps api-table member `op_remainder_inplace`. ClikaRT::ops::remainder_ <- ClikaRT/compute/ops.h

OpRenorm

func (api *Api) OpRenorm(x *Tensor, p Scalar, dim int64, maxnorm Scalar, epsHas bool, eps float64) (*Tensor, error)

OpRenorm wraps api-table member `op_renorm`. ClikaRT::ops::renorm <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpRenormInplace

func (api *Api) OpRenormInplace(self *Tensor, p Scalar, dim int64, maxnorm Scalar, epsHas bool, eps float64) (error)

OpRenormInplace wraps api-table member `op_renorm_inplace`. ClikaRT::ops::renorm_ <- ClikaRT/compute/ops.h

OpRepeat

func (api *Api) OpRepeat(x *Tensor, sizes []ScalarOrTensor) (*Tensor, error)

OpRepeat wraps api-table member `op_repeat`. ClikaRT::ops::repeat <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpRepeatInterleave

func (api *Api) OpRepeatInterleave(x *Tensor, repeats ScalarOrTensor, dimHas bool, dim int64, outputSizeHas bool, outputSize int64) (*Tensor, error)

OpRepeatInterleave wraps api-table member `op_repeat_interleave`. ClikaRT::ops::repeat_interleave <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpReplicatePad

func (api *Api) OpReplicatePad(x *Tensor, pad []ScalarOrTensor) (*Tensor, error)

OpReplicatePad wraps api-table member `op_replicate_pad`. ClikaRT::ops::replicate_pad <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpRequantize

func (api *Api) OpRequantize(a *QTensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64, outDtype DataType) (*QTensor, error)

OpRequantize wraps api-table member `op_requantize`. ClikaRT::ops::requantize <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpRequantizeInplaceToDense

func (api *Api) OpRequantizeInplaceToDense(a *QTensor, out *Tensor, outScale *Tensor, outZeroPoint *Tensor, outQuantAxis int64) (error)

OpRequantizeInplaceToDense wraps api-table member `op_requantize_inplace_to_dense`. ClikaRT::ops::requantize_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): outZeroPoint.

OpRequantizeInplaceToQuantized

func (api *Api) OpRequantizeInplaceToQuantized(a *QTensor, out *QTensor) (error)

OpRequantizeInplaceToQuantized wraps api-table member `op_requantize_inplace_to_quantized`. ClikaRT::ops::requantize_ <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpResample

func (api *Api) OpResample(x *Tensor, origFreq int64, newFreq int64, lowpassFilterWidth int64, rolloff float64, betaHas bool, beta float64) (*Tensor, error)

OpResample wraps api-table member `op_resample`. ClikaRT::ops::resample <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpReshape

func (api *Api) OpReshape(x *Tensor, shape []IndexBound) (*Tensor, error)

OpReshape wraps api-table member `op_reshape`. ClikaRT::ops::reshape <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpReshapeAs

func (api *Api) OpReshapeAs(x *Tensor, other *Tensor) (*Tensor, error)

OpReshapeAs wraps api-table member `op_reshape_as`. ClikaRT::ops::reshape_as <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpRfft

func (api *Api) OpRfft(x *Tensor, nFftHas bool, nFft int64, normalized bool) (*Tensor, error)

OpRfft wraps api-table member `op_rfft`. ClikaRT::ops::rfft <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpRmsNorm

func (api *Api) OpRmsNorm(x *Tensor, normalizedShape []int64, weight *Tensor, bias *Tensor, epsHas bool, eps float64, activationHas bool, activation Activation) (*Tensor, error)

OpRmsNorm wraps api-table member `op_rms_norm`. ClikaRT::ops::rms_norm <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): weight, bias.

OpRoll

func (api *Api) OpRoll(x *Tensor, shifts []int64, dims []int64) (*Tensor, error)

OpRoll wraps api-table member `op_roll`. ClikaRT::ops::roll <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpRot90

func (api *Api) OpRot90(x *Tensor, k int64, dims []int64) (*Tensor, error)

OpRot90 wraps api-table member `op_rot90`. ClikaRT::ops::rot90 <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpRotaryEmbedding

func (api *Api) OpRotaryEmbedding(x0 *Tensor, positionIds *Tensor, cos *Tensor, sin *Tensor, freqFactors *Tensor, opts *RotaryEmbeddingOptions) (*Tensor, error)

OpRotaryEmbedding wraps api-table member `op_rotary_embedding`. ClikaRT::ops::rotary_embedding <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): positionIds, cos, sin, freqFactors.

A nil `opts` means every option's default.

OpRotaryEmbeddingQk

func (api *Api) OpRotaryEmbeddingQk(q *Tensor, k *Tensor, positionIds *Tensor, cos *Tensor, sin *Tensor, freqFactors *Tensor, opts *RotaryEmbeddingQkOptions) (*Tensor, *Tensor, error)

OpRotaryEmbeddingQk wraps api-table member `op_rotary_embedding_qk`. ClikaRT::ops::rotary_embedding_qk <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): positionIds, cos, sin, freqFactors.

A nil `opts` means every option's default.

OpRotaryEmbeddingQkVarlen

func (api *Api) OpRotaryEmbeddingQkVarlen(q *Tensor, k *Tensor, cuSeqlens *Tensor, seqlens *Tensor, positionIds *Tensor, cos *Tensor, sin *Tensor, freqFactors *Tensor, opts *RotaryEmbeddingQkVarlenOptions) (*Tensor, *Tensor, error)

OpRotaryEmbeddingQkVarlen wraps api-table member `op_rotary_embedding_qk_varlen`. ClikaRT::ops::rotary_embedding_qk_varlen <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): seqlens, positionIds, cos, sin, freqFactors.

A nil `opts` means every option's default.

OpRotaryEmbeddingVarlen

func (api *Api) OpRotaryEmbeddingVarlen(x0 *Tensor, cuSeqlens *Tensor, seqlens *Tensor, positionIds *Tensor, cos *Tensor, sin *Tensor, freqFactors *Tensor, opts *RotaryEmbeddingVarlenOptions) (*Tensor, error)

OpRotaryEmbeddingVarlen wraps api-table member `op_rotary_embedding_varlen`. ClikaRT::ops::rotary_embedding_varlen <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): seqlens, positionIds, cos, sin, freqFactors.

A nil `opts` means every option's default.

OpRound

func (api *Api) OpRound(x *Tensor, decimals int64) (*Tensor, error)

OpRound wraps api-table member `op_round`. ClikaRT::ops::round <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpRoundInplace

func (api *Api) OpRoundInplace(self *Tensor, decimals int64) (error)

OpRoundInplace wraps api-table member `op_round_inplace`. ClikaRT::ops::round_ <- ClikaRT/compute/ops.h

OpRsqrt

func (api *Api) OpRsqrt(x *Tensor) (*Tensor, error)

OpRsqrt wraps api-table member `op_rsqrt`. ClikaRT::ops::rsqrt <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpRsqrtInplace

func (api *Api) OpRsqrtInplace(self *Tensor) (error)

OpRsqrtInplace wraps api-table member `op_rsqrt_inplace`. ClikaRT::ops::rsqrt_ <- ClikaRT/compute/ops.h

OpScaledDotProductAttention

func (api *Api) OpScaledDotProductAttention(q *Tensor, k *Tensor, v *Tensor, attnMask *Tensor, isCausal bool, qScale ScalarOrTensor, kScale ScalarOrTensor, vScale ScalarOrTensor) (*Tensor, error)

OpScaledDotProductAttention wraps api-table member `op_scaled_dot_product_attention`. ClikaRT::ops::scaled_dot_product_attention <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): attnMask.

OpScaledDotProductAttentionVarlen

func (api *Api) OpScaledDotProductAttentionVarlen(q *Tensor, k *Tensor, v *Tensor, cuSeqlensQ *Tensor, cuSeqlensK *Tensor, maxSeqlenQ ScalarOrTensor, maxSeqlenK ScalarOrTensor, attnMask *Tensor, isCausal bool, qScale ScalarOrTensor, kScale ScalarOrTensor, vScale ScalarOrTensor) (*Tensor, error)

OpScaledDotProductAttentionVarlen wraps api-table member `op_scaled_dot_product_attention_varlen`. ClikaRT::ops::scaled_dot_product_attention_varlen <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): attnMask.

OpScatter

func (api *Api) OpScatter(x *Tensor, dim int64, index *Tensor, src ScalarOrTensor) (*Tensor, error)

OpScatter wraps api-table member `op_scatter`. ClikaRT::ops::scatter <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpScatterAdd

func (api *Api) OpScatterAdd(x *Tensor, dim int64, index *Tensor, src *Tensor, deterministic bool) (*Tensor, error)

OpScatterAdd wraps api-table member `op_scatter_add`. ClikaRT::ops::scatter_add <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpScatterAddInplace

func (api *Api) OpScatterAddInplace(self *Tensor, dim int64, index *Tensor, src *Tensor, deterministic bool) (error)

OpScatterAddInplace wraps api-table member `op_scatter_add_inplace`. ClikaRT::ops::scatter_add_ <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpScatterInplace

func (api *Api) OpScatterInplace(self *Tensor, dim int64, index *Tensor, src ScalarOrTensor) (error)

OpScatterInplace wraps api-table member `op_scatter_inplace`. ClikaRT::ops::scatter_ <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpScatterReduce

func (api *Api) OpScatterReduce(x *Tensor, dim int64, index *Tensor, src *Tensor, reduce ScatterReduceMode, includeSelf bool, deterministic bool) (*Tensor, error)

OpScatterReduce wraps api-table member `op_scatter_reduce`. ClikaRT::ops::scatter_reduce <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpScatterReduceInplace

func (api *Api) OpScatterReduceInplace(self *Tensor, dim int64, index *Tensor, src *Tensor, reduce ScatterReduceMode, includeSelf bool, deterministic bool) (error)

OpScatterReduceInplace wraps api-table member `op_scatter_reduce_inplace`. ClikaRT::ops::scatter_reduce_ <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSearchsorted

func (api *Api) OpSearchsorted(sortedSequence *Tensor, values *Tensor, outInt32 bool, right bool, sideHas bool, side bool, sorter *Tensor) (*Tensor, error)

OpSearchsorted wraps api-table member `op_searchsorted`. ClikaRT::ops::searchsorted <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): sorter.

OpSelect

func (api *Api) OpSelect(x *Tensor, dim int64, index IndexBound) (*Tensor, error)

OpSelect wraps api-table member `op_select`. ClikaRT::ops::select <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSelu

func (api *Api) OpSelu(x *Tensor) (*Tensor, error)

OpSelu wraps api-table member `op_selu`. ClikaRT::ops::selu <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSeluInplace

func (api *Api) OpSeluInplace(self *Tensor) (error)

OpSeluInplace wraps api-table member `op_selu_inplace`. ClikaRT::ops::selu_ <- ClikaRT/compute/ops.h

OpSgn

func (api *Api) OpSgn(x *Tensor) (*Tensor, error)

OpSgn wraps api-table member `op_sgn`. ClikaRT::ops::sgn <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSgnInplace

func (api *Api) OpSgnInplace(self *Tensor) (error)

OpSgnInplace wraps api-table member `op_sgn_inplace`. ClikaRT::ops::sgn_ <- ClikaRT/compute/ops.h

OpShapeDim

func (api *Api) OpShapeDim(x *Tensor, dimHas bool, dim int64) (*Tensor, error)

OpShapeDim wraps api-table member `op_shape_dim`. ClikaRT::ops::shape <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpShapeHostAll

func (api *Api) OpShapeHostAll(x *Tensor) (*Tensor, error)

OpShapeHostAll wraps api-table member `op_shape_host_all`. ClikaRT::ops::shape_host <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpShapeHostDim

func (api *Api) OpShapeHostDim(x *Tensor, dim int64) (*Tensor, error)

OpShapeHostDim wraps api-table member `op_shape_host_dim`. ClikaRT::ops::shape_host <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpShapeHostRange

func (api *Api) OpShapeHostRange(x *Tensor, startHas bool, start int64, endHas bool, end int64) (*Tensor, error)

OpShapeHostRange wraps api-table member `op_shape_host_range`. ClikaRT::ops::shape_host <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpShapeRange

func (api *Api) OpShapeRange(x *Tensor, startHas bool, start int64, endHas bool, end int64) (*Tensor, error)

OpShapeRange wraps api-table member `op_shape_range`. ClikaRT::ops::shape <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSigmoid

func (api *Api) OpSigmoid(x *Tensor) (*Tensor, error)

OpSigmoid wraps api-table member `op_sigmoid`. ClikaRT::ops::sigmoid <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSigmoidInplace

func (api *Api) OpSigmoidInplace(self *Tensor) (error)

OpSigmoidInplace wraps api-table member `op_sigmoid_inplace`. ClikaRT::ops::sigmoid_ <- ClikaRT/compute/ops.h

OpSign

func (api *Api) OpSign(x *Tensor) (*Tensor, error)

OpSign wraps api-table member `op_sign`. ClikaRT::ops::sign <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSignInplace

func (api *Api) OpSignInplace(self *Tensor) (error)

OpSignInplace wraps api-table member `op_sign_inplace`. ClikaRT::ops::sign_ <- ClikaRT/compute/ops.h

OpSilu

func (api *Api) OpSilu(x *Tensor) (*Tensor, error)

OpSilu wraps api-table member `op_silu`. ClikaRT::ops::silu <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSiluInplace

func (api *Api) OpSiluInplace(self *Tensor) (error)

OpSiluInplace wraps api-table member `op_silu_inplace`. ClikaRT::ops::silu_ <- ClikaRT/compute/ops.h

OpSin

func (api *Api) OpSin(x *Tensor) (*Tensor, error)

OpSin wraps api-table member `op_sin`. ClikaRT::ops::sin <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSinInplace

func (api *Api) OpSinInplace(self *Tensor) (error)

OpSinInplace wraps api-table member `op_sin_inplace`. ClikaRT::ops::sin_ <- ClikaRT/compute/ops.h

OpSinc

func (api *Api) OpSinc(x *Tensor) (*Tensor, error)

OpSinc wraps api-table member `op_sinc`. ClikaRT::ops::sinc <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSincInplace

func (api *Api) OpSincInplace(self *Tensor) (error)

OpSincInplace wraps api-table member `op_sinc_inplace`. ClikaRT::ops::sinc_ <- ClikaRT/compute/ops.h

OpSinh

func (api *Api) OpSinh(x *Tensor) (*Tensor, error)

OpSinh wraps api-table member `op_sinh`. ClikaRT::ops::sinh <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSinhInplace

func (api *Api) OpSinhInplace(self *Tensor) (error)

OpSinhInplace wraps api-table member `op_sinh_inplace`. ClikaRT::ops::sinh_ <- ClikaRT/compute/ops.h

OpSliceDim

func (api *Api) OpSliceDim(x *Tensor, dim int64, start IndexBound, end IndexBound, step IndexBound) (*Tensor, error)

OpSliceDim wraps api-table member `op_slice_dim`. ClikaRT::ops::slice <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSliceDims

func (api *Api) OpSliceDims(x *Tensor, dim []int64, start []IndexBound, end []IndexBound, step []IndexBound) (*Tensor, error)

OpSliceDims wraps api-table member `op_slice_dims`. ClikaRT::ops::slice <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSmoothL1Loss

func (api *Api) OpSmoothL1Loss(input *Tensor, target *Tensor, reduction Reduction, beta float64) (*Tensor, error)

OpSmoothL1Loss wraps api-table member `op_smooth_l1_loss`. ClikaRT::ops::smooth_l1_loss <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSnake

func (api *Api) OpSnake(x *Tensor, alpha *Tensor, beta *Tensor, eps float64) (*Tensor, error)

OpSnake wraps api-table member `op_snake`. ClikaRT::ops::snake <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): alpha, beta.

OpSnakeInplace

func (api *Api) OpSnakeInplace(self *Tensor, alpha *Tensor, beta *Tensor, eps float64) (error)

OpSnakeInplace wraps api-table member `op_snake_inplace`. ClikaRT::ops::snake_ <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): alpha, beta.

OpSoftcapLogits

func (api *Api) OpSoftcapLogits(x *Tensor, cap ScalarOrTensor) (*Tensor, error)

OpSoftcapLogits wraps api-table member `op_softcap_logits`. ClikaRT::ops::softcap_logits <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSoftcapLogitsInplace

func (api *Api) OpSoftcapLogitsInplace(self *Tensor, cap ScalarOrTensor) (error)

OpSoftcapLogitsInplace wraps api-table member `op_softcap_logits_inplace`. ClikaRT::ops::softcap_logits_ <- ClikaRT/compute/ops.h

OpSoftmax

func (api *Api) OpSoftmax(x *Tensor, dim int64, dtype DataType) (*Tensor, error)

OpSoftmax wraps api-table member `op_softmax`. ClikaRT::ops::softmax <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSoftmaxInplace

func (api *Api) OpSoftmaxInplace(self *Tensor, dim int64) (error)

OpSoftmaxInplace wraps api-table member `op_softmax_inplace`. ClikaRT::ops::softmax_ <- ClikaRT/compute/ops.h

OpSoftmin

func (api *Api) OpSoftmin(x *Tensor, dim int64, dtype DataType) (*Tensor, error)

OpSoftmin wraps api-table member `op_softmin`. ClikaRT::ops::softmin <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSoftminInplace

func (api *Api) OpSoftminInplace(self *Tensor, dim int64) (error)

OpSoftminInplace wraps api-table member `op_softmin_inplace`. ClikaRT::ops::softmin_ <- ClikaRT/compute/ops.h

OpSoftplus

func (api *Api) OpSoftplus(x *Tensor, beta float64, threshold float64) (*Tensor, error)

OpSoftplus wraps api-table member `op_softplus`. ClikaRT::ops::softplus <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSoftplusInplace

func (api *Api) OpSoftplusInplace(self *Tensor, beta float64, threshold float64) (error)

OpSoftplusInplace wraps api-table member `op_softplus_inplace`. ClikaRT::ops::softplus_ <- ClikaRT/compute/ops.h

OpSoftshrink

func (api *Api) OpSoftshrink(x *Tensor, lambd float64) (*Tensor, error)

OpSoftshrink wraps api-table member `op_softshrink`. ClikaRT::ops::softshrink <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSoftshrinkInplace

func (api *Api) OpSoftshrinkInplace(self *Tensor, lambd float64) (error)

OpSoftshrinkInplace wraps api-table member `op_softshrink_inplace`. ClikaRT::ops::softshrink_ <- ClikaRT/compute/ops.h

OpSoftsign

func (api *Api) OpSoftsign(x *Tensor) (*Tensor, error)

OpSoftsign wraps api-table member `op_softsign`. ClikaRT::ops::softsign <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSoftsignInplace

func (api *Api) OpSoftsignInplace(self *Tensor) (error)

OpSoftsignInplace wraps api-table member `op_softsign_inplace`. ClikaRT::ops::softsign_ <- ClikaRT/compute/ops.h

OpSort

func (api *Api) OpSort(x *Tensor, dim int64, descending bool, stable bool) (*Tensor, *Tensor, error)

OpSort wraps api-table member `op_sort`. ClikaRT::ops::sort <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSplitBySize

func (api *Api) OpSplitBySize(x *Tensor, chunkSize int64, dim int64) (*TensorList, error)

OpSplitBySize wraps api-table member `op_split_by_size`. ClikaRT::ops::split_by_size <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSplitWithSizes

func (api *Api) OpSplitWithSizes(x *Tensor, sizes []ScalarOrTensor, dim int64) (*TensorList, error)

OpSplitWithSizes wraps api-table member `op_split_with_sizes`. ClikaRT::ops::split_with_sizes <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSqrt

func (api *Api) OpSqrt(x *Tensor) (*Tensor, error)

OpSqrt wraps api-table member `op_sqrt`. ClikaRT::ops::sqrt <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSqrtInplace

func (api *Api) OpSqrtInplace(self *Tensor) (error)

OpSqrtInplace wraps api-table member `op_sqrt_inplace`. ClikaRT::ops::sqrt_ <- ClikaRT/compute/ops.h

OpSquare

func (api *Api) OpSquare(x *Tensor) (*Tensor, error)

OpSquare wraps api-table member `op_square`. ClikaRT::ops::square <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSquareInplace

func (api *Api) OpSquareInplace(self *Tensor) (error)

OpSquareInplace wraps api-table member `op_square_inplace`. ClikaRT::ops::square_ <- ClikaRT/compute/ops.h

OpSqueeze

func (api *Api) OpSqueeze(x *Tensor, dim []int64) (*Tensor, error)

OpSqueeze wraps api-table member `op_squeeze`. ClikaRT::ops::squeeze <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSqueezeInplace

func (api *Api) OpSqueezeInplace(self *Tensor, dim []int64) (error)

OpSqueezeInplace wraps api-table member `op_squeeze_inplace`. ClikaRT::ops::squeeze_ <- ClikaRT/compute/ops.h

OpSsdUpdate

func (api *Api) OpSsdUpdate(x *Tensor, dt *Tensor, aRate *Tensor, bMat *Tensor, cMat *Tensor, dSkip *Tensor, dtBias *Tensor, z *Tensor, state *Tensor, seqLens *Tensor, slotIds *Tensor, dtSoftplus bool) (*Tensor, error)

OpSsdUpdate wraps api-table member `op_ssd_update`. ClikaRT::ops::ssd_update <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): dSkip, dtBias, z, seqLens, slotIds.

OpStack

func (api *Api) OpStack(tensors []*Tensor, dim int64) (*Tensor, error)

OpStack wraps api-table member `op_stack`. ClikaRT::ops::stack <- ClikaRT/compute/ops.h

OpStd

func (api *Api) OpStd(x *Tensor, dims []int64, correction int64, keepdim bool) (*Tensor, error)

OpStd wraps api-table member `op_std`. ClikaRT::ops::std <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpStft

func (api *Api) OpStft(x *Tensor, nFft int64, window *Tensor, opts *StftOptions) (*Tensor, error)

OpStft wraps api-table member `op_stft`. ClikaRT::ops::stft <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

Optional (a nil handle passes NULL = absent): window.

A nil `opts` means every option's default.

OpSubInplace

func (api *Api) OpSubInplace(self *Tensor, other ScalarOrTensor, alpha float64, activation Activation) (error)

OpSubInplace wraps api-table member `op_sub_inplace`. ClikaRT::ops::sub_ <- ClikaRT/compute/ops.h

OpSubScalarLhs

func (api *Api) OpSubScalarLhs(a Scalar, b *Tensor, alpha float64, activation Activation) (*Tensor, error)

OpSubScalarLhs wraps api-table member `op_sub_scalar_lhs`. ClikaRT::ops::sub <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSubTensor

func (api *Api) OpSubTensor(a *Tensor, other ScalarOrTensor, alpha float64, activation Activation) (*Tensor, error)

OpSubTensor wraps api-table member `op_sub_tensor`. ClikaRT::ops::sub <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSum

func (api *Api) OpSum(x *Tensor, dims []int64, keepdim bool, dtype DataType) (*Tensor, error)

OpSum wraps api-table member `op_sum`. ClikaRT::ops::sum <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSwiglu

func (api *Api) OpSwiglu(x *Tensor, alpha float64, beta float64, limit float64) (*Tensor, error)

OpSwiglu wraps api-table member `op_swiglu`. ClikaRT::ops::swiglu <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpSynchronizeAll

func (api *Api) OpSynchronizeAll() (error)

OpSynchronizeAll wraps api-table member `op_synchronize_all`. ClikaRT::ops::synchronize_all <- ClikaRT/compute/ops.h

OpTake

func (api *Api) OpTake(self *Tensor, index *Tensor) (*Tensor, error)

OpTake wraps api-table member `op_take`. ClikaRT::ops::take <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpTakeAlongDim

func (api *Api) OpTakeAlongDim(x *Tensor, index *Tensor, dimHas bool, dim int64) (*Tensor, error)

OpTakeAlongDim wraps api-table member `op_take_along_dim`. ClikaRT::ops::take_along_dim <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpTan

func (api *Api) OpTan(x *Tensor) (*Tensor, error)

OpTan wraps api-table member `op_tan`. ClikaRT::ops::tan <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpTanInplace

func (api *Api) OpTanInplace(self *Tensor) (error)

OpTanInplace wraps api-table member `op_tan_inplace`. ClikaRT::ops::tan_ <- ClikaRT/compute/ops.h

OpTanh

func (api *Api) OpTanh(x *Tensor) (*Tensor, error)

OpTanh wraps api-table member `op_tanh`. ClikaRT::ops::tanh <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpTanhInplace

func (api *Api) OpTanhInplace(self *Tensor) (error)

OpTanhInplace wraps api-table member `op_tanh_inplace`. ClikaRT::ops::tanh_ <- ClikaRT/compute/ops.h

OpTensordot

func (api *Api) OpTensordot(a *Tensor, b *Tensor, dimsA []int64, dimsB []int64) (*Tensor, error)

OpTensordot wraps api-table member `op_tensordot`. ClikaRT::ops::tensordot <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpThreshold

func (api *Api) OpThreshold(x *Tensor, threshold float64, value float64) (*Tensor, error)

OpThreshold wraps api-table member `op_threshold`. ClikaRT::ops::threshold <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpThresholdInplace

func (api *Api) OpThresholdInplace(self *Tensor, threshold float64, value float64) (error)

OpThresholdInplace wraps api-table member `op_threshold_inplace`. ClikaRT::ops::threshold_ <- ClikaRT/compute/ops.h

OpTile

func (api *Api) OpTile(x *Tensor, dims []ScalarOrTensor) (*Tensor, error)

OpTile wraps api-table member `op_tile`. ClikaRT::ops::tile <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpToDeviceStr

func (api *Api) OpToDeviceStr(src *Tensor, deviceStr string) (*Tensor, error)

OpToDeviceStr wraps api-table member `op_to_device_str`. ClikaRT::ops::to <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpToMany

func (api *Api) OpToMany(tensors []*Tensor, target StreamOrDevice) (*TensorList, error)

OpToMany wraps api-table member `op_to_many`. ClikaRT::ops::to <- ClikaRT/compute/ops.h

OpToTensor

func (api *Api) OpToTensor(src *Tensor, target StreamOrDevice) (*Tensor, error)

OpToTensor wraps api-table member `op_to_tensor`. ClikaRT::ops::to <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpTopk

func (api *Api) OpTopk(x *Tensor, k int64, dim int64, largest bool, sorted bool) (*Tensor, *Tensor, error)

OpTopk wraps api-table member `op_topk`. ClikaRT::ops::topk <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpTrace

func (api *Api) OpTrace(x *Tensor) (*Tensor, error)

OpTrace wraps api-table member `op_trace`. ClikaRT::ops::trace <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpTranspose

func (api *Api) OpTranspose(x *Tensor, dim0 int64, dim1 int64) (*Tensor, error)

OpTranspose wraps api-table member `op_transpose`. ClikaRT::ops::transpose <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpTril

func (api *Api) OpTril(x *Tensor, diagonal int64) (*Tensor, error)

OpTril wraps api-table member `op_tril`. ClikaRT::ops::tril <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpTrilInplace

func (api *Api) OpTrilInplace(self *Tensor, diagonal int64) (error)

OpTrilInplace wraps api-table member `op_tril_inplace`. ClikaRT::ops::tril_ <- ClikaRT/compute/ops.h

OpTriu

func (api *Api) OpTriu(x *Tensor, diagonal int64) (*Tensor, error)

OpTriu wraps api-table member `op_triu`. ClikaRT::ops::triu <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpTriuInplace

func (api *Api) OpTriuInplace(self *Tensor, diagonal int64) (error)

OpTriuInplace wraps api-table member `op_triu_inplace`. ClikaRT::ops::triu_ <- ClikaRT/compute/ops.h

OpTrunc

func (api *Api) OpTrunc(x *Tensor) (*Tensor, error)

OpTrunc wraps api-table member `op_trunc`. ClikaRT::ops::trunc <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpTruncInplace

func (api *Api) OpTruncInplace(self *Tensor) (error)

OpTruncInplace wraps api-table member `op_trunc_inplace`. ClikaRT::ops::trunc_ <- ClikaRT/compute/ops.h

OpUnflatten

func (api *Api) OpUnflatten(x *Tensor, dim int64, sizes []int64) (*Tensor, error)

OpUnflatten wraps api-table member `op_unflatten`. ClikaRT::ops::unflatten <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpUnfold

func (api *Api) OpUnfold(x *Tensor, kernelSize []int64, dilation []int64, padding []int64, stride []int64, mode PadMode, valueHas bool, value float64) (*Tensor, error)

OpUnfold wraps api-table member `op_unfold`. ClikaRT::ops::unfold <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpUniformInplace

func (api *Api) OpUniformInplace(self *Tensor, low float64, high float64, s StreamOrDevice) (error)

OpUniformInplace wraps api-table member `op_uniform_inplace`. ClikaRT::ops::uniform_ <- ClikaRT/compute/ops.h

OpUnique

func (api *Api) OpUnique(x *Tensor, sorted bool, returnInverse bool, returnCounts bool, dimHas bool, dim int64) (*Tensor, *Tensor, *Tensor, error)

OpUnique wraps api-table member `op_unique`. ClikaRT::ops::unique <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpUniqueConsecutive

func (api *Api) OpUniqueConsecutive(x *Tensor, returnInverse bool, returnCounts bool, dimHas bool, dim int64) (*Tensor, *Tensor, *Tensor, error)

OpUniqueConsecutive wraps api-table member `op_unique_consecutive`. ClikaRT::ops::unique_consecutive <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpUnsqueeze

func (api *Api) OpUnsqueeze(x *Tensor, dim int64) (*Tensor, error)

OpUnsqueeze wraps api-table member `op_unsqueeze`. ClikaRT::ops::unsqueeze <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpUnsqueezeInplace

func (api *Api) OpUnsqueezeInplace(self *Tensor, dim int64) (error)

OpUnsqueezeInplace wraps api-table member `op_unsqueeze_inplace`. ClikaRT::ops::unsqueeze_ <- ClikaRT/compute/ops.h

OpUpsampleBicubic2d

func (api *Api) OpUpsampleBicubic2d(x *Tensor, sizes []ScalarOrTensor, scaleFactors []ScalarOrTensor, alignCorners bool) (*Tensor, error)

OpUpsampleBicubic2d wraps api-table member `op_upsample_bicubic2d`. ClikaRT::ops::upsample_bicubic2d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpUpsampleBilinear2d

func (api *Api) OpUpsampleBilinear2d(x *Tensor, sizes []ScalarOrTensor, scaleFactors []ScalarOrTensor, alignCorners bool) (*Tensor, error)

OpUpsampleBilinear2d wraps api-table member `op_upsample_bilinear2d`. ClikaRT::ops::upsample_bilinear2d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpUpsampleLinear1d

func (api *Api) OpUpsampleLinear1d(x *Tensor, sizes []ScalarOrTensor, scaleFactors []ScalarOrTensor, alignCorners bool) (*Tensor, error)

OpUpsampleLinear1d wraps api-table member `op_upsample_linear1d`. ClikaRT::ops::upsample_linear1d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpUpsampleNearest1d

func (api *Api) OpUpsampleNearest1d(x *Tensor, sizes []ScalarOrTensor, scaleFactors []ScalarOrTensor) (*Tensor, error)

OpUpsampleNearest1d wraps api-table member `op_upsample_nearest1d`. ClikaRT::ops::upsample_nearest1d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpUpsampleNearest2d

func (api *Api) OpUpsampleNearest2d(x *Tensor, sizes []ScalarOrTensor, scaleFactors []ScalarOrTensor) (*Tensor, error)

OpUpsampleNearest2d wraps api-table member `op_upsample_nearest2d`. ClikaRT::ops::upsample_nearest2d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpUpsampleNearest3d

func (api *Api) OpUpsampleNearest3d(x *Tensor, sizes []ScalarOrTensor, scaleFactors []ScalarOrTensor) (*Tensor, error)

OpUpsampleNearest3d wraps api-table member `op_upsample_nearest3d`. ClikaRT::ops::upsample_nearest3d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpUpsampleTrilinear3d

func (api *Api) OpUpsampleTrilinear3d(x *Tensor, sizes []ScalarOrTensor, scaleFactors []ScalarOrTensor, alignCorners bool) (*Tensor, error)

OpUpsampleTrilinear3d wraps api-table member `op_upsample_trilinear3d`. ClikaRT::ops::upsample_trilinear3d <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpValidateRotaryDim

func (api *Api) OpValidateRotaryDim(rotaryDim int64, headDim int64) (error)

OpValidateRotaryDim wraps api-table member `op_validate_rotary_dim`. ClikaRT::ops::validate_rotary_dim <- ClikaRT/compute/ops.h

OpVar

func (api *Api) OpVar(x *Tensor, dims []int64, correction int64, keepdim bool) (*Tensor, error)

OpVar wraps api-table member `op_var`. ClikaRT::ops::var <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpWhereNonzero

func (api *Api) OpWhereNonzero(condition *Tensor) (*Tensor, error)

OpWhereNonzero wraps api-table member `op_where_nonzero`. ClikaRT::ops::where <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpWhereSelect

func (api *Api) OpWhereSelect(condition *Tensor, x *Tensor, y *Tensor) (*Tensor, error)

OpWhereSelect wraps api-table member `op_where_select`. ClikaRT::ops::where <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpXlog1py

func (api *Api) OpXlog1py(a *Tensor, other ScalarOrTensor) (*Tensor, error)

OpXlog1py wraps api-table member `op_xlog1py`. ClikaRT::ops::xlog1py <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpXlogy

func (api *Api) OpXlogy(a *Tensor, other ScalarOrTensor) (*Tensor, error)

OpXlogy wraps api-table member `op_xlogy`. ClikaRT::ops::xlogy <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

OpXlogyInplace

func (api *Api) OpXlogyInplace(self *Tensor, other ScalarOrTensor) (error)

OpXlogyInplace wraps api-table member `op_xlogy_inplace`. ClikaRT::ops::xlogy_ <- ClikaRT/compute/ops.h

OpZeroInplace

func (api *Api) OpZeroInplace(self *Tensor, s StreamOrDevice) (error)

OpZeroInplace wraps api-table member `op_zero_inplace`. ClikaRT::ops::zero_ <- ClikaRT/compute/ops.h

OpZeros

func (api *Api) OpZeros(shape []ScalarOrTensor, dtype DataType, s StreamOrDevice, pinnedFor StreamOrDevice) (*Tensor, error)

OpZeros wraps api-table member `op_zeros`. ClikaRT::ops::zeros <- ClikaRT/compute/ops.h

OpZerosLike

func (api *Api) OpZerosLike(reference *Tensor, s StreamOrDevice) (*Tensor, error)

OpZerosLike wraps api-table member `op_zeros_like`. ClikaRT::ops::zeros_like <- ClikaRT/compute/ops.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

ParseQuantizationConfig

func (api *Api) ParseQuantizationConfig(jsonText string) (*QuantizationConfig, error)

ParseQuantizationConfig wraps api-table member `parse_quantization_config`. ClikaRT::quant::parse_quantization_config <- ClikaRT/compute/q_tensor.h

PeekAudioBytes

func (api *Api) PeekAudioBytes(bytes []byte, targetSampleRate int32, targetChannels int32) (AudioInfo, error)

PeekAudioBytes wraps api-table member `peek_audio_bytes`. ClikaRT::io::peek_audio <- ClikaRT/io/io.h

PeekAudioPath

func (api *Api) PeekAudioPath(path string, targetSampleRate int32, targetChannels int32) (AudioInfo, error)

PeekAudioPath wraps api-table member `peek_audio_path`. ClikaRT::io::peek_audio <- ClikaRT/io/io.h

PeekImageBytes

func (api *Api) PeekImageBytes(bytes []byte) (ImageInfo, error)

PeekImageBytes wraps api-table member `peek_image_bytes`. ClikaRT::io::peek_image <- ClikaRT/io/io.h

PeekImagePath

func (api *Api) PeekImagePath(path string) (ImageInfo, error)

PeekImagePath wraps api-table member `peek_image_path`. ClikaRT::io::peek_image <- ClikaRT/io/io.h

ProfileSessionChromeTraceJson

func (api *Api) ProfileSessionChromeTraceJson(self *ProfileSession) (string, error)

ProfileSessionChromeTraceJson wraps api-table member `profile_session_chrome_trace_json`. ClikaRT::ProfileSession::chrome_trace_json <- ClikaRT/profiler/profiler.h

ProfileSessionFree

func (api *Api) ProfileSessionFree(h *ProfileSession)

ProfileSessionFree wraps api-table member `profile_session_free`.

ProfileSessionNew

func (api *Api) ProfileSessionNew() (*ProfileSession, error)

ProfileSessionNew wraps api-table member `profile_session_new`. an empty profiling session; while a capture is alive, ops on the capturing thread (and the streams it drives) are timed automatically

ProfileSessionPerfettoTrace

func (api *Api) ProfileSessionPerfettoTrace(self *ProfileSession) ([]byte, error)

ProfileSessionPerfettoTrace wraps api-table member `profile_session_perfetto_trace`. ClikaRT::ProfileSession::perfetto_trace <- ClikaRT/profiler/profiler.h

ProfileSessionSave

func (api *Api) ProfileSessionSave(self *ProfileSession, dir string) (error)

ProfileSessionSave wraps api-table member `profile_session_save`. ClikaRT::ProfileSession::save <- ClikaRT/profiler/profiler.h

ProfileSessionSaveChromeTrace

func (api *Api) ProfileSessionSaveChromeTrace(self *ProfileSession, path string) (error)

ProfileSessionSaveChromeTrace wraps api-table member `profile_session_save_chrome_trace`. ClikaRT::ProfileSession::save_chrome_trace <- ClikaRT/profiler/profiler.h

ProfileSessionSaveMemoryStats

func (api *Api) ProfileSessionSaveMemoryStats(self *ProfileSession, path string) (error)

ProfileSessionSaveMemoryStats wraps api-table member `profile_session_save_memory_stats`. ClikaRT::ProfileSession::save_memory_stats <- ClikaRT/profiler/profiler.h

ProfileSessionSaveReportJson

func (api *Api) ProfileSessionSaveReportJson(self *ProfileSession, path string) (error)

ProfileSessionSaveReportJson wraps api-table member `profile_session_save_report_json`. ClikaRT::ProfileSession::save_report_json <- ClikaRT/profiler/profiler.h

ProfileSessionStartCapture

func (api *Api) ProfileSessionStartCapture(self *ProfileSession, tag string) *CaptureScope

ProfileSessionStartCapture wraps api-table member `profile_session_start_capture`. ClikaRT::ProfileSession::start_capture <- ClikaRT/profiler/profiler.h

ProfileSessionSummaryText

func (api *Api) ProfileSessionSummaryText(self *ProfileSession) (string, error)

ProfileSessionSummaryText wraps api-table member `profile_session_summary_text`. ClikaRT::ProfileSession::summary_text <- ClikaRT/profiler/profiler.h

QTensorRelease

func (api *Api) QTensorRelease(q *QTensor)

QTensorRelease wraps api-table member `qtensor_release`.

QTensorRetain

func (api *Api) QTensorRetain(q *QTensor)

QTensorRetain wraps api-table member `qtensor_retain`.

QuantizationConfigBits

func (api *Api) QuantizationConfigBits(cfg *QuantizationConfig) int64

QuantizationConfigBits wraps api-table member `quantization_config_bits`.

QuantizationConfigDescAct

func (api *Api) QuantizationConfigDescAct(cfg *QuantizationConfig) bool

QuantizationConfigDescAct wraps api-table member `quantization_config_desc_act`.

QuantizationConfigDoubleQuant

func (api *Api) QuantizationConfigDoubleQuant(cfg *QuantizationConfig) bool

QuantizationConfigDoubleQuant wraps api-table member `quantization_config_double_quant`.

QuantizationConfigFree

func (api *Api) QuantizationConfigFree(cfg *QuantizationConfig)

QuantizationConfigFree wraps api-table member `quantization_config_free`.

QuantizationConfigGroupSize

func (api *Api) QuantizationConfigGroupSize(cfg *QuantizationConfig) int64

QuantizationConfigGroupSize wraps api-table member `quantization_config_group_size`.

QuantizationConfigLmHeadQuantized

func (api *Api) QuantizationConfigLmHeadQuantized(cfg *QuantizationConfig) bool

QuantizationConfigLmHeadQuantized wraps api-table member `quantization_config_lm_head_quantized`.

QuantizationConfigMethod

func (api *Api) QuantizationConfigMethod(cfg *QuantizationConfig) QuantizedCheckpointMethod

QuantizationConfigMethod wraps api-table member `quantization_config_method`.

QuantizationConfigModulesToNotConvertCount

func (api *Api) QuantizationConfigModulesToNotConvertCount(cfg *QuantizationConfig) uint

QuantizationConfigModulesToNotConvertCount wraps api-table member `quantization_config_modules_to_not_convert_count`.

QuantizationConfigModulesToNotConvertGet

func (api *Api) QuantizationConfigModulesToNotConvertGet(cfg *QuantizationConfig, i uint) (string, error)

QuantizationConfigModulesToNotConvertGet wraps api-table member `quantization_config_modules_to_not_convert_get`.

QuantizationConfigQuantStorage

func (api *Api) QuantizationConfigQuantStorage(cfg *QuantizationConfig) (string, error)

QuantizationConfigQuantStorage wraps api-table member `quantization_config_quant_storage`.

QuantizationConfigQuantType

func (api *Api) QuantizationConfigQuantType(cfg *QuantizationConfig) (string, error)

QuantizationConfigQuantType wraps api-table member `quantization_config_quant_type`.

QuantizationConfigSym

func (api *Api) QuantizationConfigSym(cfg *QuantizationConfig) bool

QuantizationConfigSym wraps api-table member `quantization_config_sym`.

QuantizationConfigZerosConvention

func (api *Api) QuantizationConfigZerosConvention(cfg *QuantizationConfig) ZerosConvention

QuantizationConfigZerosConvention wraps api-table member `quantization_config_zeros_convention`.

QuantizedView

func (api *Api) QuantizedView(tensor *Tensor) (*QTensor, error)

QuantizedView wraps api-table member `quantized_view`. ClikaRT::quantized_view <- ClikaRT/compute/q_tensor.h

Non-consuming: the wrapper retains each donated operand before the call (retain-before-consuming-op), so the caller's handles stay live.

ReleaseCachedMemory

func (api *Api) ReleaseCachedMemory(device Device) (error)

ReleaseCachedMemory wraps api-table member `release_cached_memory`. ClikaRT::device::release_cached_memory <- ClikaRT/compute/memory_stats.h

SaveAudio

func (api *Api) SaveAudio(samples *Tensor, sampleRate int32, path string) (error)

SaveAudio wraps api-table member `save_audio`. ClikaRT::io::save_audio <- ClikaRT/io/io.h

SaveImage

func (api *Api) SaveImage(image *Tensor, path string) (error)

SaveImage wraps api-table member `save_image`. ClikaRT::io::save_image <- ClikaRT/io/io.h

SaveNpy

func (api *Api) SaveNpy(tensor *Tensor, path string) (error)

SaveNpy wraps api-table member `save_npy`. ClikaRT::io::save_npy <- ClikaRT/io/io.h

StreamAllocate

func (api *Api) StreamAllocate(self *Stream, shape []int64, dtype DataType) (*Tensor, error)

StreamAllocate wraps api-table member `stream_allocate`. ClikaRT::Stream::allocate <- ClikaRT/compute/stream.h

StreamCreate

func (api *Api) StreamCreate(device Device) (*Stream, error)

StreamCreate wraps api-table member `stream_create`. ClikaRT::Stream::create <- ClikaRT/compute/stream.h

StreamDefaultStream

func (api *Api) StreamDefaultStream(device Device) *Stream

StreamDefaultStream wraps api-table member `stream_default_stream`. ClikaRT::Stream::default_stream <- ClikaRT/compute/stream.h

StreamDevice

func (api *Api) StreamDevice(self *Stream) Device

StreamDevice wraps api-table member `stream_device`. ClikaRT::Stream::device <- ClikaRT/compute/stream.h

StreamIsDefault

func (api *Api) StreamIsDefault(self *Stream) bool

StreamIsDefault wraps api-table member `stream_is_default`. ClikaRT::Stream::is_default <- ClikaRT/compute/stream.h

StreamNativeHandle

func (api *Api) StreamNativeHandle(self *Stream) unsafe.Pointer

StreamNativeHandle wraps api-table member `stream_native_handle`. ClikaRT::Stream::native_handle <- ClikaRT/compute/stream.h

StreamQueryIdle

func (api *Api) StreamQueryIdle(self *Stream) bool

StreamQueryIdle wraps api-table member `stream_query_idle`. ClikaRT::Stream::query_idle <- ClikaRT/compute/stream.h

StreamRelease

func (api *Api) StreamRelease(s *Stream)

StreamRelease wraps api-table member `stream_release`.

StreamRetain

func (api *Api) StreamRetain(s *Stream)

StreamRetain wraps api-table member `stream_retain`.

StreamSynchronize

func (api *Api) StreamSynchronize(self *Stream) (error)

StreamSynchronize wraps api-table member `stream_synchronize`. ClikaRT::Stream::synchronize <- ClikaRT/compute/stream.h

StreamingDecoderFinish

func (api *Api) StreamingDecoderFinish(self *StreamingDecoder) (*StringList, error)

StreamingDecoderFinish wraps api-table member `streaming_decoder_finish`. ClikaRT::tokenizer::StreamingDecoder::finish <- ClikaRT/tokenizer/tokenizer.h

StreamingDecoderFree

func (api *Api) StreamingDecoderFree(h *StreamingDecoder)

StreamingDecoderFree wraps api-table member `streaming_decoder_free`.

StreamingDecoderPush

func (api *Api) StreamingDecoderPush(self *StreamingDecoder, id int32) (*StringList, error)

StreamingDecoderPush wraps api-table member `streaming_decoder_push`. ClikaRT::tokenizer::StreamingDecoder::push <- ClikaRT/tokenizer/tokenizer.h

StringListCount

func (api *Api) StringListCount(l *StringList) uint

StringListCount wraps api-table member `string_list_count`.

StringListFree

func (api *Api) StringListFree(l *StringList)

StringListFree wraps api-table member `string_list_free`.

StringListGetAt

func (api *Api) StringListGetAt(l *StringList, i uint) (string, error)

StringListGetAt wraps api-table member `string_list_get_at`. element i via the sized-string protocol

SynchronousStreamScopeClose

func (api *Api) SynchronousStreamScopeClose(scope *SynchronousStreamScope)

SynchronousStreamScopeClose wraps api-table member `synchronous_stream_scope_close`. exit: restores the mode this thread had at open, and frees the handle (NULL is a no-op)

SynchronousStreamScopeOpen

func (api *Api) SynchronousStreamScopeOpen(stream *Stream) (*SynchronousStreamScope, error)

SynchronousStreamScopeOpen wraps api-table member `synchronous_stream_scope_open`. enter: every op this thread dispatches on `stream` waits for completion before the dispatch returns, until close; open it only on a quiescent stream; close on the SAME thread

TempDirectoryPath

func (api *Api) TempDirectoryPath() (*StringList, error)

TempDirectoryPath wraps api-table member `temp_directory_path`. ClikaRT::io::temp_directory_path <- ClikaRT/io/io.h

TensorAbs

func (api *Api) TensorAbs(self *Tensor) (*Tensor, error)

TensorAbs wraps api-table member `tensor_abs`. ClikaRT::Tensor::abs <- ClikaRT/compute/tensor.h

TensorAbsInplace

func (api *Api) TensorAbsInplace(self *Tensor) (error)

TensorAbsInplace wraps api-table member `tensor_abs_inplace`. ClikaRT::Tensor::abs_ <- ClikaRT/compute/tensor.h

TensorAdd

func (api *Api) TensorAdd(self *Tensor, other ScalarOrTensor) (*Tensor, error)

TensorAdd wraps api-table member `tensor_add`. ClikaRT::Tensor::add <- ClikaRT/compute/tensor.h

TensorAddInplace

func (api *Api) TensorAddInplace(self *Tensor, other ScalarOrTensor) (error)

TensorAddInplace wraps api-table member `tensor_add_inplace`. ClikaRT::Tensor::add_ <- ClikaRT/compute/tensor.h

TensorConstDataPtr

func (api *Api) TensorConstDataPtr(self *Tensor) (unsafe.Pointer, error)

TensorConstDataPtr wraps api-table member `tensor_const_data_ptr`. ClikaRT::Tensor::const_data_ptr <- ClikaRT/compute/tensor.h

TensorContiguous

func (api *Api) TensorContiguous(self *Tensor) (*Tensor, error)

TensorContiguous wraps api-table member `tensor_contiguous`. ClikaRT::Tensor::contiguous <- ClikaRT/compute/tensor.h

TensorDefined

func (api *Api) TensorDefined(self *Tensor) bool

TensorDefined wraps api-table member `tensor_defined`. ClikaRT::Tensor::defined <- ClikaRT/compute/tensor.h

TensorDevice

func (api *Api) TensorDevice(self *Tensor) Device

TensorDevice wraps api-table member `tensor_device`. ClikaRT::Tensor::device <- ClikaRT/compute/tensor.h

TensorDeviceConstDataPtr

func (api *Api) TensorDeviceConstDataPtr(self *Tensor) (unsafe.Pointer, error)

TensorDeviceConstDataPtr wraps api-table member `tensor_device_const_data_ptr`. ClikaRT::Tensor::device_const_data_ptr <- ClikaRT/compute/tensor.h

TensorDeviceMutableDataPtr

func (api *Api) TensorDeviceMutableDataPtr(self *Tensor) (unsafe.Pointer, error)

TensorDeviceMutableDataPtr wraps api-table member `tensor_device_mutable_data_ptr`. ClikaRT::Tensor::device_mutable_data_ptr <- ClikaRT/compute/tensor.h

TensorDiv

func (api *Api) TensorDiv(self *Tensor, other ScalarOrTensor) (*Tensor, error)

TensorDiv wraps api-table member `tensor_div`. ClikaRT::Tensor::div <- ClikaRT/compute/tensor.h

TensorDivInplace

func (api *Api) TensorDivInplace(self *Tensor, other ScalarOrTensor) (error)

TensorDivInplace wraps api-table member `tensor_div_inplace`. ClikaRT::Tensor::div_ <- ClikaRT/compute/tensor.h

TensorDtype

func (api *Api) TensorDtype(self *Tensor) DataType

TensorDtype wraps api-table member `tensor_dtype`. ClikaRT::Tensor::dtype <- ClikaRT/compute/tensor.h

TensorEmpty

func (api *Api) TensorEmpty(shape []int64, dtype DataType, where StreamOrDevice, pinnedFor StreamOrDevice) (*Tensor, error)

TensorEmpty wraps api-table member `tensor_empty`. ClikaRT::Tensor::empty <- ClikaRT/compute/tensor.h

TensorEmptyReserved

func (api *Api) TensorEmptyReserved(shape []int64, dtype DataType, where StreamOrDevice) (*Tensor, error)

TensorEmptyReserved wraps api-table member `tensor_empty_reserved`. ClikaRT::Tensor::empty_reserved <- ClikaRT/compute/tensor.h

TensorFromBlob

func (a *Api) TensorFromBlob(data unsafe.Pointer, shape []int64,
	dtype DataType) (*Tensor, error)

TensorFromBlob wraps caller-owned memory as a tensor VIEW (no copy), shaped shape at dtype, on the default placement: the borrow form of from_blob. The view addresses data itself, so a write through the runtime lands in the caller's memory and a write to the memory shows through the view. The caller keeps ownership: the memory must outlive every handle over it, and Go memory must be pinned for that whole span (runtime.Pinner; the garbage collector may not move or free it while the runtime holds the address). The full-control form, with placement and a deleter, is Api.TensorFromBlobContiguous.

TensorFromBlobContiguous

func (api *Api) TensorFromBlobContiguous(data unsafe.Pointer, shape []int64, dtype DataType, where StreamOrDevice, deleter func(), pinnedFor StreamOrDevice) (*Tensor, error)

TensorFromBlobContiguous wraps api-table member `tensor_from_blob_contiguous`. ClikaRT::Tensor::from_blob <- ClikaRT/compute/tensor.h

TensorFromBlobOwned

func (a *Api) TensorFromBlobOwned(data unsafe.Pointer, shape []int64,
	dtype DataType, deleter func()) (*Tensor, error)

TensorFromBlobOwned wraps caller memory as a tensor (no copy) and hands the runtime its release: the adopt form of from_blob. deleter runs exactly once, when the last reference over the storage goes away (inside a consuming op, on a pool thread, or at the last Release), and is the place to free or unpin the memory. Until then the memory stays alive by construction: Go memory behind data is pinned here and unpinned after deleter returns, so the garbage collector neither moves nor frees it while the runtime holds the address (C memory needs no pin, and pinning it is a no-op). The registry holds deleter itself until the runtime releases the registration, so a closure the caller no longer references still fires.

TensorFromBlobStrided

func (a *Api) TensorFromBlobStrided(data unsafe.Pointer, shape []int64,
	strides []int64, dtype DataType) (*Tensor, error)

TensorFromBlobStrided wraps caller-owned memory as a strided tensor VIEW (no copy): shape names the extents and strides the element step per dimension (a region of a larger image keeps the image's row pitch as its row stride), at dtype, on the default placement. Borrowed exactly like Api.TensorFromBlob: the caller keeps ownership, the memory must outlive every handle over it, and Go memory stays pinned (runtime.Pinner) for that whole span. Every element the view addresses must lie inside the caller's allocation; the runtime does not see the allocation's bounds.

TensorFromData

func (api *Api) TensorFromData(data unsafe.Pointer, shape []int64, dtype DataType, where StreamOrDevice, pinnedFor StreamOrDevice) (*Tensor, error)

TensorFromData wraps api-table member `tensor_from_data`. ClikaRT::Tensor::from_data <- ClikaRT/compute/tensor.h

TensorFull

func (a *Api) TensorFull(shape []int64, value float64, dtype DataType) (*Tensor, error)

TensorFull builds a shape-extent tensor filled with value at dtype, on the default placement.

TensorIndex

func (api *Api) TensorIndex(self *Tensor, indices []IndexEntry) (*Tensor, error)

TensorIndex wraps api-table member `tensor_index`. ClikaRT::Tensor::index <- ClikaRT/compute/tensor.h

TensorIndexPut

func (api *Api) TensorIndexPut(self *Tensor, indices []IndexEntry, value ScalarOrTensor, accumulate bool) (*Tensor, error)

TensorIndexPut wraps api-table member `tensor_index_put`. ClikaRT::Tensor::index_put <- ClikaRT/compute/tensor.h

TensorIndexPutInplace

func (api *Api) TensorIndexPutInplace(self *Tensor, indices []IndexEntry, value ScalarOrTensor, accumulate bool) (error)

TensorIndexPutInplace wraps api-table member `tensor_index_put_inplace`. ClikaRT::Tensor::index_put_ <- ClikaRT/compute/tensor.h

TensorIsAliasOf

func (api *Api) TensorIsAliasOf(self *Tensor, other *Tensor) bool

TensorIsAliasOf wraps api-table member `tensor_is_alias_of`. ClikaRT::Tensor::is_alias_of <- ClikaRT/compute/tensor.h

TensorIsContiguous

func (api *Api) TensorIsContiguous(self *Tensor) bool

TensorIsContiguous wraps api-table member `tensor_is_contiguous`. ClikaRT::Tensor::is_contiguous <- ClikaRT/compute/tensor.h

TensorIsFake

func (api *Api) TensorIsFake(self *Tensor) bool

TensorIsFake wraps api-table member `tensor_is_fake`. ClikaRT::Tensor::is_fake <- ClikaRT/compute/tensor.h

TensorIsPinned

func (api *Api) TensorIsPinned(self *Tensor, peer StreamOrDevice) bool

TensorIsPinned wraps api-table member `tensor_is_pinned`. ClikaRT::Tensor::is_pinned <- ClikaRT/compute/tensor.h

TensorIsQuantized

func (api *Api) TensorIsQuantized(self *Tensor) bool

TensorIsQuantized wraps api-table member `tensor_is_quantized`. ClikaRT::Tensor::is_quantized <- ClikaRT/compute/tensor.h

TensorIsSame

func (api *Api) TensorIsSame(self *Tensor, other *Tensor) bool

TensorIsSame wraps api-table member `tensor_is_same`. ClikaRT::Tensor::is_same <- ClikaRT/compute/tensor.h

TensorItemF32

func (api *Api) TensorItemF32(self *Tensor) (float32, error)

TensorItemF32 wraps api-table member `tensor_item_f32`. the one element of a single-element tensor as float; a numel other than 1, or a tensor whose dtype is not this width, is refused

TensorItemF64

func (api *Api) TensorItemF64(self *Tensor) (float64, error)

TensorItemF64 wraps api-table member `tensor_item_f64`. the one element of a single-element tensor as double; a numel other than 1, or a tensor whose dtype is not this width, is refused

TensorItemI32

func (api *Api) TensorItemI32(self *Tensor) (int32, error)

TensorItemI32 wraps api-table member `tensor_item_i32`. the one element of a single-element tensor as int32_t; a numel other than 1, or a tensor whose dtype is not this width, is refused

TensorItemI64

func (api *Api) TensorItemI64(self *Tensor) (int64, error)

TensorItemI64 wraps api-table member `tensor_item_i64`. the one element of a single-element tensor as int64_t; a numel other than 1, or a tensor whose dtype is not this width, is refused

TensorItemU8

func (api *Api) TensorItemU8(self *Tensor) (bool, error)

TensorItemU8 wraps api-table member `tensor_item_u8`. the one element of a single-element tensor as uint8_t; a numel other than 1, or a tensor whose dtype is not this width, is refused

TensorListCount

func (api *Api) TensorListCount(l *TensorList) uint

TensorListCount wraps api-table member `tensor_list_count`.

TensorListFree

func (api *Api) TensorListFree(l *TensorList)

TensorListFree wraps api-table member `tensor_list_free`.

TensorListGetAt

func (api *Api) TensorListGetAt(l *TensorList, i uint) *Tensor

TensorListGetAt wraps api-table member `tensor_list_get_at`.

TensorMaxAll

func (api *Api) TensorMaxAll(self *Tensor) (*Tensor, error)

TensorMaxAll wraps api-table member `tensor_max_all`. ClikaRT::Tensor::max <- ClikaRT/compute/tensor.h

TensorMaxDims

func (api *Api) TensorMaxDims(self *Tensor, dims []int64, keepdim bool) (*Tensor, error)

TensorMaxDims wraps api-table member `tensor_max_dims`. ClikaRT::Tensor::max <- ClikaRT/compute/tensor.h

TensorMeanAll

func (api *Api) TensorMeanAll(self *Tensor) (*Tensor, error)

TensorMeanAll wraps api-table member `tensor_mean_all`. ClikaRT::Tensor::mean <- ClikaRT/compute/tensor.h

TensorMeanDims

func (api *Api) TensorMeanDims(self *Tensor, dims []int64, keepdim bool) (*Tensor, error)

TensorMeanDims wraps api-table member `tensor_mean_dims`. ClikaRT::Tensor::mean <- ClikaRT/compute/tensor.h

TensorMetadataNbytes

func (api *Api) TensorMetadataNbytes(self *Tensor) uint

TensorMetadataNbytes wraps api-table member `tensor_metadata_nbytes`. ClikaRT::Tensor::metadata_nbytes <- ClikaRT/compute/tensor.h

TensorMetadataNdim

func (api *Api) TensorMetadataNdim(self *Tensor) int64

TensorMetadataNdim wraps api-table member `tensor_metadata_ndim`. ClikaRT::Tensor::metadata_ndim <- ClikaRT/compute/tensor.h

TensorMetadataNumel

func (api *Api) TensorMetadataNumel(self *Tensor) int64

TensorMetadataNumel wraps api-table member `tensor_metadata_numel`. ClikaRT::Tensor::metadata_numel <- ClikaRT/compute/tensor.h

TensorMetadataShape

func (api *Api) TensorMetadataShape(self *Tensor) []int64

TensorMetadataShape wraps api-table member `tensor_metadata_shape`. ClikaRT::Tensor::metadata_shape <- ClikaRT/compute/tensor.h

TensorMetadataSizes

func (api *Api) TensorMetadataSizes(self *Tensor) []int64

TensorMetadataSizes wraps api-table member `tensor_metadata_sizes`. ClikaRT::Tensor::metadata_sizes <- ClikaRT/compute/tensor.h

TensorMetadataStrides

func (api *Api) TensorMetadataStrides(self *Tensor) []int64

TensorMetadataStrides wraps api-table member `tensor_metadata_strides`. ClikaRT::Tensor::metadata_strides <- ClikaRT/compute/tensor.h

TensorMinAll

func (api *Api) TensorMinAll(self *Tensor) (*Tensor, error)

TensorMinAll wraps api-table member `tensor_min_all`. ClikaRT::Tensor::min <- ClikaRT/compute/tensor.h

TensorMinDims

func (api *Api) TensorMinDims(self *Tensor, dims []int64, keepdim bool) (*Tensor, error)

TensorMinDims wraps api-table member `tensor_min_dims`. ClikaRT::Tensor::min <- ClikaRT/compute/tensor.h

TensorMul

func (api *Api) TensorMul(self *Tensor, other ScalarOrTensor) (*Tensor, error)

TensorMul wraps api-table member `tensor_mul`. ClikaRT::Tensor::mul <- ClikaRT/compute/tensor.h

TensorMulInplace

func (api *Api) TensorMulInplace(self *Tensor, other ScalarOrTensor) (error)

TensorMulInplace wraps api-table member `tensor_mul_inplace`. ClikaRT::Tensor::mul_ <- ClikaRT/compute/tensor.h

TensorMutableDataPtr

func (api *Api) TensorMutableDataPtr(self *Tensor) (unsafe.Pointer, error)

TensorMutableDataPtr wraps api-table member `tensor_mutable_data_ptr`. ClikaRT::Tensor::mutable_data_ptr <- ClikaRT/compute/tensor.h

TensorNbytes

func (api *Api) TensorNbytes(self *Tensor) (uint, error)

TensorNbytes wraps api-table member `tensor_nbytes`. ClikaRT::Tensor::nbytes <- ClikaRT/compute/tensor.h

TensorNdim

func (api *Api) TensorNdim(self *Tensor) int64

TensorNdim wraps api-table member `tensor_ndim`. ClikaRT::Tensor::ndim <- ClikaRT/compute/tensor.h

TensorNdimHost

func (api *Api) TensorNdimHost(self *Tensor) (*Tensor, error)

TensorNdimHost wraps api-table member `tensor_ndim_host`. ClikaRT::Tensor::ndim_host <- ClikaRT/compute/tensor.h

TensorNeg

func (api *Api) TensorNeg(self *Tensor) (*Tensor, error)

TensorNeg wraps api-table member `tensor_neg`. ClikaRT::Tensor::neg <- ClikaRT/compute/tensor.h

TensorNegInplace

func (api *Api) TensorNegInplace(self *Tensor) (error)

TensorNegInplace wraps api-table member `tensor_neg_inplace`. ClikaRT::Tensor::neg_ <- ClikaRT/compute/tensor.h

TensorNumel

func (api *Api) TensorNumel(self *Tensor) (int64, error)

TensorNumel wraps api-table member `tensor_numel`. ClikaRT::Tensor::numel <- ClikaRT/compute/tensor.h

TensorNumelHost

func (api *Api) TensorNumelHost(self *Tensor) (*Tensor, error)

TensorNumelHost wraps api-table member `tensor_numel_host`. ClikaRT::Tensor::numel_host <- ClikaRT/compute/tensor.h

TensorOnComplete

func (api *Api) TensorOnComplete(self *Tensor, callback func(*Tensor)) (error)

TensorOnComplete wraps api-table member `tensor_on_complete`. ClikaRT::Tensor::on_complete <- ClikaRT/compute/tensor.h

TensorOnes

func (api *Api) TensorOnes(shape []int64, dtype DataType, where StreamOrDevice, pinnedFor StreamOrDevice) (*Tensor, error)

TensorOnes wraps api-table member `tensor_ones`. ClikaRT::Tensor::ones <- ClikaRT/compute/tensor.h

TensorPinMemory

func (api *Api) TensorPinMemory(self *Tensor, peer StreamOrDevice) (*Tensor, error)

TensorPinMemory wraps api-table member `tensor_pin_memory`. ClikaRT::Tensor::pin_memory <- ClikaRT/compute/tensor.h

TensorPow

func (api *Api) TensorPow(self *Tensor, exponent ScalarOrTensor) (*Tensor, error)

TensorPow wraps api-table member `tensor_pow`. ClikaRT::Tensor::pow <- ClikaRT/compute/tensor.h

TensorRelease

func (api *Api) TensorRelease(t *Tensor)

TensorRelease wraps api-table member `tensor_release`.

TensorReshape

func (api *Api) TensorReshape(self *Tensor, shape []IndexBound) (*Tensor, error)

TensorReshape wraps api-table member `tensor_reshape`. ClikaRT::Tensor::reshape <- ClikaRT/compute/tensor.h

TensorRetain

func (api *Api) TensorRetain(t *Tensor)

TensorRetain wraps api-table member `tensor_retain`.

TensorShape

func (api *Api) TensorShape(self *Tensor) ([]int64, error)

TensorShape wraps api-table member `tensor_shape`. ClikaRT::Tensor::shape <- ClikaRT/compute/tensor.h

TensorShapeHostAll

func (api *Api) TensorShapeHostAll(self *Tensor) (*Tensor, error)

TensorShapeHostAll wraps api-table member `tensor_shape_host_all`. ClikaRT::Tensor::shape_host <- ClikaRT/compute/tensor.h

TensorShapeHostDim

func (api *Api) TensorShapeHostDim(self *Tensor, dim int64) (*Tensor, error)

TensorShapeHostDim wraps api-table member `tensor_shape_host_dim`. ClikaRT::Tensor::shape_host <- ClikaRT/compute/tensor.h

TensorSizes

func (api *Api) TensorSizes(self *Tensor) ([]int64, error)

TensorSizes wraps api-table member `tensor_sizes`. ClikaRT::Tensor::sizes <- ClikaRT/compute/tensor.h

TensorSoftmax

func (api *Api) TensorSoftmax(self *Tensor, dim int64) (*Tensor, error)

TensorSoftmax wraps api-table member `tensor_softmax`. ClikaRT::Tensor::softmax <- ClikaRT/compute/tensor.h

TensorStatus

func (api *Api) TensorStatus(self *Tensor) TensorStatus

TensorStatus wraps api-table member `tensor_status`. ClikaRT::Tensor::status <- ClikaRT/compute/tensor.h

TensorStream

func (api *Api) TensorStream(self *Tensor) *Stream

TensorStream wraps api-table member `tensor_stream`. ClikaRT::Tensor::stream <- ClikaRT/compute/tensor.h

TensorStrides

func (api *Api) TensorStrides(self *Tensor) ([]int64, error)

TensorStrides wraps api-table member `tensor_strides`. ClikaRT::Tensor::strides <- ClikaRT/compute/tensor.h

TensorSub

func (api *Api) TensorSub(self *Tensor, other ScalarOrTensor) (*Tensor, error)

TensorSub wraps api-table member `tensor_sub`. ClikaRT::Tensor::sub <- ClikaRT/compute/tensor.h

TensorSubInplace

func (api *Api) TensorSubInplace(self *Tensor, other ScalarOrTensor) (error)

TensorSubInplace wraps api-table member `tensor_sub_inplace`. ClikaRT::Tensor::sub_ <- ClikaRT/compute/tensor.h

TensorSumAll

func (api *Api) TensorSumAll(self *Tensor) (*Tensor, error)

TensorSumAll wraps api-table member `tensor_sum_all`. ClikaRT::Tensor::sum <- ClikaRT/compute/tensor.h

TensorSumDims

func (api *Api) TensorSumDims(self *Tensor, dims []int64, keepdim bool) (*Tensor, error)

TensorSumDims wraps api-table member `tensor_sum_dims`. ClikaRT::Tensor::sum <- ClikaRT/compute/tensor.h

TensorSynchronize

func (api *Api) TensorSynchronize(self *Tensor) (error)

TensorSynchronize wraps api-table member `tensor_synchronize`. ClikaRT::Tensor::synchronize <- ClikaRT/compute/tensor.h

TensorToDevice

func (api *Api) TensorToDevice(self *Tensor, device Device) (*Tensor, error)

TensorToDevice wraps api-table member `tensor_to_device`. ClikaRT::Tensor::to <- ClikaRT/compute/tensor.h

TensorToDeviceDtype

func (api *Api) TensorToDeviceDtype(self *Tensor, device Device, dtype DataType) (*Tensor, error)

TensorToDeviceDtype wraps api-table member `tensor_to_device_dtype`. ClikaRT::Tensor::to <- ClikaRT/compute/tensor.h

TensorToDtype

func (api *Api) TensorToDtype(self *Tensor, dtype DataType) (*Tensor, error)

TensorToDtype wraps api-table member `tensor_to_dtype`. ClikaRT::Tensor::to <- ClikaRT/compute/tensor.h

TensorToString

func (api *Api) TensorToString(self *Tensor) (string, error)

TensorToString wraps api-table member `tensor_to_string`. ClikaRT::Tensor::to_string <- ClikaRT/compute/tensor.h

TensorToVecF32

func (api *Api) TensorToVecF32(self *Tensor) ([]float32, error)

TensorToVecF32 wraps api-table member `tensor_to_vec_f32`. every element of a 0-D or 1-D contiguous tensor as float; two-call sizing: buf == NULL sizes; count carries capacity in, required count out (contract §8)

TensorToVecF64

func (api *Api) TensorToVecF64(self *Tensor) ([]float64, error)

TensorToVecF64 wraps api-table member `tensor_to_vec_f64`. every element of a 0-D or 1-D contiguous tensor as double; two-call sizing: buf == NULL sizes; count carries capacity in, required count out (contract §8)

TensorToVecI32

func (api *Api) TensorToVecI32(self *Tensor) ([]int32, error)

TensorToVecI32 wraps api-table member `tensor_to_vec_i32`. every element of a 0-D or 1-D contiguous tensor as int32_t; two-call sizing: buf == NULL sizes; count carries capacity in, required count out (contract §8)

TensorToVecI64

func (api *Api) TensorToVecI64(self *Tensor) ([]int64, error)

TensorToVecI64 wraps api-table member `tensor_to_vec_i64`. every element of a 0-D or 1-D contiguous tensor as int64_t; two-call sizing: buf == NULL sizes; count carries capacity in, required count out (contract §8)

TensorToVecU8

func (api *Api) TensorToVecU8(self *Tensor) ([]byte, error)

TensorToVecU8 wraps api-table member `tensor_to_vec_u8`. every element of a 0-D or 1-D contiguous tensor as uint8_t; two-call sizing: buf == NULL sizes; count carries capacity in, required count out (contract §8)

TensorZeros

func (api *Api) TensorZeros(shape []int64, dtype DataType, where StreamOrDevice, pinnedFor StreamOrDevice) (*Tensor, error)

TensorZeros wraps api-table member `tensor_zeros`. ClikaRT::Tensor::zeros <- ClikaRT/compute/tensor.h

TensorsContainerContains

func (api *Api) TensorsContainerContains(self *TensorsContainer, name string) bool

TensorsContainerContains wraps api-table member `tensors_container_contains`. ClikaRT::io::TensorsContainer::contains <- ClikaRT/io/tensors_container.h

TensorsContainerEntryBytes

func (api *Api) TensorsContainerEntryBytes(self *TensorsContainer, name string) uint64

TensorsContainerEntryBytes wraps api-table member `tensors_container_entry_bytes`. ClikaRT::io::TensorsContainer::entry_bytes <- ClikaRT/io/tensors_container.h

TensorsContainerEvict

func (api *Api) TensorsContainerEvict(self *TensorsContainer, name string) (error)

TensorsContainerEvict wraps api-table member `tensors_container_evict`. ClikaRT::io::TensorsContainer::evict <- ClikaRT/io/tensors_container.h

TensorsContainerEvictAll

func (api *Api) TensorsContainerEvictAll(self *TensorsContainer) (error)

TensorsContainerEvictAll wraps api-table member `tensors_container_evict_all`. ClikaRT::io::TensorsContainer::evict_all <- ClikaRT/io/tensors_container.h

TensorsContainerFree

func (api *Api) TensorsContainerFree(h *TensorsContainer)

TensorsContainerFree wraps api-table member `tensors_container_free`.

TensorsContainerGet

func (api *Api) TensorsContainerGet(self *TensorsContainer, name string) (*Tensor, error)

TensorsContainerGet wraps api-table member `tensors_container_get`. ClikaRT::io::TensorsContainer::get <- ClikaRT/io/tensors_container.h

TensorsContainerLoadInto

func (api *Api) TensorsContainerLoadInto(self *TensorsContainer, name string, dst *Tensor, where StreamOrDevice) (error)

TensorsContainerLoadInto wraps api-table member `tensors_container_load_into`. ClikaRT::io::TensorsContainer::load_into <- ClikaRT/io/tensors_container.h

TensorsContainerNames

func (api *Api) TensorsContainerNames(self *TensorsContainer) *StringList

TensorsContainerNames wraps api-table member `tensors_container_names`. ClikaRT::io::TensorsContainer::names <- ClikaRT/io/tensors_container.h

TensorsContainerPrefetch

func (api *Api) TensorsContainerPrefetch(self *TensorsContainer, names []string, where StreamOrDevice) (error)

TensorsContainerPrefetch wraps api-table member `tensors_container_prefetch`. ClikaRT::io::TensorsContainer::prefetch <- ClikaRT/io/tensors_container.h

TensorsContainerRelease

func (api *Api) TensorsContainerRelease(self *TensorsContainer, name string) (error)

TensorsContainerRelease wraps api-table member `tensors_container_release`. ClikaRT::io::TensorsContainer::release <- ClikaRT/io/tensors_container.h

TensorsContainerSize

func (api *Api) TensorsContainerSize(self *TensorsContainer) uint

TensorsContainerSize wraps api-table member `tensors_container_size`. ClikaRT::io::TensorsContainer::size <- ClikaRT/io/tensors_container.h

TensorsContainerTotalBytes

func (api *Api) TensorsContainerTotalBytes(self *TensorsContainer) uint

TensorsContainerTotalBytes wraps api-table member `tensors_container_total_bytes`. ClikaRT::io::TensorsContainer::total_bytes <- ClikaRT/io/tensors_container.h

ToString

func (a *Api) ToString(t *Tensor) (string, error)

ToString reads the tensor's human-readable summary (shape, dtype, first values).

TokenListBeginAt

func (api *Api) TokenListBeginAt(l *TokenList, i uint) uint

TokenListBeginAt wraps api-table member `token_list_begin_at`. byte span start in the source text

TokenListCount

func (api *Api) TokenListCount(l *TokenList) uint

TokenListCount wraps api-table member `token_list_count`.

TokenListEndAt

func (api *Api) TokenListEndAt(l *TokenList, i uint) uint

TokenListEndAt wraps api-table member `token_list_end_at`. byte span end (half-open)

TokenListFree

func (api *Api) TokenListFree(l *TokenList)

TokenListFree wraps api-table member `token_list_free`.

TokenListIdAt

func (api *Api) TokenListIdAt(l *TokenList, i uint) int32

TokenListIdAt wraps api-table member `token_list_id_at`. vocabulary id (0 when i is out of range)

TokenListSpecialAt

func (api *Api) TokenListSpecialAt(l *TokenList, i uint) bool

TokenListSpecialAt wraps api-table member `token_list_special_at`. 1 when the token was injected by the tokenizer (bos/eos/...)

TokenListTextAt

func (api *Api) TokenListTextAt(l *TokenList, i uint) (string, error)

TokenListTextAt wraps api-table member `token_list_text_at`. the surface piece (UTF-8), sized-string protocol

TokenizerApplyChatTemplateMessagesAddGenerationPrompt

func (api *Api) TokenizerApplyChatTemplateMessagesAddGenerationPrompt(self *Tokenizer, messagesJson string, addGenerationPrompt bool) (string, error)

TokenizerApplyChatTemplateMessagesAddGenerationPrompt wraps api-table member `tokenizer_apply_chat_template_messages_add_generation_prompt`. ClikaRT::tokenizer::Tokenizer::apply_chat_template <- ClikaRT/tokenizer/tokenizer.h

TokenizerBosId

func (api *Api) TokenizerBosId(self *Tokenizer) int64

TokenizerBosId wraps api-table member `tokenizer_bos_id`. ClikaRT::tokenizer::Tokenizer::bos_id <- ClikaRT/tokenizer/tokenizer.h

TokenizerDecode

func (api *Api) TokenizerDecode(self *Tokenizer, ids []int32, skipSpecialTokens bool) (string, error)

TokenizerDecode wraps api-table member `tokenizer_decode`. ClikaRT::tokenizer::Tokenizer::decode <- ClikaRT/tokenizer/tokenizer.h

TokenizerDecodeBatchEncodedSkipSpecialTokens

func (api *Api) TokenizerDecodeBatchEncodedSkipSpecialTokens(self *Tokenizer, encoded *Encoded, skipSpecialTokens bool) (*StringList, error)

TokenizerDecodeBatchEncodedSkipSpecialTokens wraps api-table member `tokenizer_decode_batch_encoded_skip_special_tokens`. ClikaRT::tokenizer::Tokenizer::decode_batch <- ClikaRT/tokenizer/tokenizer.h

TokenizerDecodeBatchIdsCuSeqlens

func (api *Api) TokenizerDecodeBatchIdsCuSeqlens(self *Tokenizer, ids *Tensor, cuSeqlens *Tensor, skipSpecialTokens bool) (*StringList, error)

TokenizerDecodeBatchIdsCuSeqlens wraps api-table member `tokenizer_decode_batch_ids_cu_seqlens`. ClikaRT::tokenizer::Tokenizer::decode_batch <- ClikaRT/tokenizer/tokenizer.h

TokenizerDecodeBatchIdsSkipSpecialTokens

func (api *Api) TokenizerDecodeBatchIdsSkipSpecialTokens(self *Tokenizer, ids *Tensor, skipSpecialTokens bool) (*StringList, error)

TokenizerDecodeBatchIdsSkipSpecialTokens wraps api-table member `tokenizer_decode_batch_ids_skip_special_tokens`. ClikaRT::tokenizer::Tokenizer::decode_batch <- ClikaRT/tokenizer/tokenizer.h

TokenizerEncode

func (api *Api) TokenizerEncode(self *Tokenizer, text string, addSpecialTokens bool) ([]int32, error)

TokenizerEncode wraps api-table member `tokenizer_encode`. ClikaRT::tokenizer::Tokenizer::encode <- ClikaRT/tokenizer/tokenizer.h

TokenizerEncodeBatch

func (api *Api) TokenizerEncodeBatch(self *Tokenizer, texts []string, options *EncodeOptions) (*Encoded, error)

TokenizerEncodeBatch wraps api-table member `tokenizer_encode_batch`. ClikaRT::tokenizer::Tokenizer::encode_batch <- ClikaRT/tokenizer/tokenizer.h

TokenizerEncodeChatMessages

func (api *Api) TokenizerEncodeChatMessages(self *Tokenizer, messagesJson string, addGenerationPrompt bool, addSpecialTokens bool) ([]int32, error)

TokenizerEncodeChatMessages wraps api-table member `tokenizer_encode_chat_messages`. ClikaRT::tokenizer::Tokenizer::encode_chat <- ClikaRT/tokenizer/tokenizer.h

TokenizerEncodeText

func (api *Api) TokenizerEncodeText(self *Tokenizer, text string, options *EncodeOptions) (*Encoded, error)

TokenizerEncodeText wraps api-table member `tokenizer_encode_text`. ClikaRT::tokenizer::Tokenizer::encode_text <- ClikaRT/tokenizer/tokenizer.h

TokenizerEosId

func (api *Api) TokenizerEosId(self *Tokenizer) int64

TokenizerEosId wraps api-table member `tokenizer_eos_id`. ClikaRT::tokenizer::Tokenizer::eos_id <- ClikaRT/tokenizer/tokenizer.h

TokenizerFree

func (api *Api) TokenizerFree(h *Tokenizer)

TokenizerFree wraps api-table member `tokenizer_free`.

TokenizerFromBertVocab

func (api *Api) TokenizerFromBertVocab(dir string) (*Tokenizer, error)

TokenizerFromBertVocab wraps api-table member `tokenizer_from_bert_vocab`. ClikaRT::tokenizer::Tokenizer::from_bert_vocab <- ClikaRT/tokenizer/tokenizer.h

TokenizerFromFile

func (api *Api) TokenizerFromFile(path string) (*Tokenizer, error)

TokenizerFromFile wraps api-table member `tokenizer_from_file`. ClikaRT::tokenizer::Tokenizer::from_file <- ClikaRT/tokenizer/tokenizer.h

TokenizerFromGpt2

func (api *Api) TokenizerFromGpt2(dir string) (*Tokenizer, error)

TokenizerFromGpt2 wraps api-table member `tokenizer_from_gpt2`. ClikaRT::tokenizer::Tokenizer::from_gpt2 <- ClikaRT/tokenizer/tokenizer.h

TokenizerFromHuggingface

func (api *Api) TokenizerFromHuggingface(path string) (*Tokenizer, error)

TokenizerFromHuggingface wraps api-table member `tokenizer_from_huggingface`. ClikaRT::tokenizer::Tokenizer::from_huggingface <- ClikaRT/tokenizer/tokenizer.h

TokenizerFromSentencepiece

func (api *Api) TokenizerFromSentencepiece(path string) (*Tokenizer, error)

TokenizerFromSentencepiece wraps api-table member `tokenizer_from_sentencepiece`. ClikaRT::tokenizer::Tokenizer::from_sentencepiece <- ClikaRT/tokenizer/tokenizer.h

TokenizerFromTekken

func (api *Api) TokenizerFromTekken(path string) (*Tokenizer, error)

TokenizerFromTekken wraps api-table member `tokenizer_from_tekken`. ClikaRT::tokenizer::Tokenizer::from_tekken <- ClikaRT/tokenizer/tokenizer.h

TokenizerFromTiktoken

func (api *Api) TokenizerFromTiktoken(path string) (*Tokenizer, error)

TokenizerFromTiktoken wraps api-table member `tokenizer_from_tiktoken`. ClikaRT::tokenizer::Tokenizer::from_tiktoken <- ClikaRT/tokenizer/tokenizer.h

TokenizerHasChatTemplate

func (api *Api) TokenizerHasChatTemplate(self *Tokenizer) bool

TokenizerHasChatTemplate wraps api-table member `tokenizer_has_chat_template`. ClikaRT::tokenizer::Tokenizer::has_chat_template <- ClikaRT/tokenizer/tokenizer.h

TokenizerIdToToken

func (api *Api) TokenizerIdToToken(self *Tokenizer, id int32) (string, error)

TokenizerIdToToken wraps api-table member `tokenizer_id_to_token`. ClikaRT::tokenizer::Tokenizer::id_to_token <- ClikaRT/tokenizer/tokenizer.h

TokenizerPadId

func (api *Api) TokenizerPadId(self *Tokenizer) int64

TokenizerPadId wraps api-table member `tokenizer_pad_id`. ClikaRT::tokenizer::Tokenizer::pad_id <- ClikaRT/tokenizer/tokenizer.h

TokenizerStreamingDecoder

func (api *Api) TokenizerStreamingDecoder(self *Tokenizer, skipSpecialTokens bool) *StreamingDecoder

TokenizerStreamingDecoder wraps api-table member `tokenizer_streaming_decoder`. ClikaRT::tokenizer::Tokenizer::streaming_decoder <- ClikaRT/tokenizer/tokenizer.h

TokenizerTokenToId

func (api *Api) TokenizerTokenToId(self *Tokenizer, token string) (int32, error)

TokenizerTokenToId wraps api-table member `tokenizer_token_to_id`. ClikaRT::tokenizer::Tokenizer::token_to_id <- ClikaRT/tokenizer/tokenizer.h

TokenizerTokenize

func (api *Api) TokenizerTokenize(self *Tokenizer, text string, addSpecialTokens bool) (*TokenList, error)

TokenizerTokenize wraps api-table member `tokenizer_tokenize`. ClikaRT::tokenizer::Tokenizer::tokenize <- ClikaRT/tokenizer/tokenizer.h

TokenizerVocabSize

func (api *Api) TokenizerVocabSize(self *Tokenizer) int64

TokenizerVocabSize wraps api-table member `tokenizer_vocab_size`. ClikaRT::tokenizer::Tokenizer::vocab_size <- ClikaRT/tokenizer/tokenizer.h

TracingScopeClose

func (api *Api) TracingScopeClose(scope *TracingScope)

TracingScopeClose wraps api-table member `tracing_scope_close`. exit: restores the mode this thread had at open, and frees the handle (NULL is a no-op)

TracingScopeOpen

func (api *Api) TracingScopeOpen() (*TracingScope, error)

TracingScopeOpen wraps api-table member `tracing_scope_open`. enter: this thread records ops symbolically and runs no kernel until close; the ops return unscheduled placeholders that tensor_synchronize materializes; close on the SAME thread

Version

func (a *Api) Version() (string, error)

Version reports the runtime's version string (e.g. "0.1.0").

VersionString

func (api *Api) VersionString() (string, error)

VersionString wraps api-table member `version_string`.

VideoCapability

func (api *Api) VideoCapability() bool

VideoCapability wraps api-table member `video_capability`. ClikaRT::io::video_capability <- ClikaRT/io/io.h