Struct Host 

pub struct Host<E = f32, I = i32> { /* private fields */ }

The Host backend, a fast, portable CPU backend for Ruda.

The E and I type parameters exist purely to match the shape of other Ruda backends (e.g. NdArray<E, I, Q>) so Host slots into ruda-dispatch’s generic dispatch macros. The body of Host uses runtime DType dispatch, so both parameters are phantom and unused at runtime.

Limitations of the phantom generics

The Backend impl is provided only for the default instantiation Host<f32, i32>. Writing Host (with no arguments) resolves to the default and works exactly as before. Writing Host<f64, i64> or any other non-default combination is a valid Rust type but will not satisfy trait bounds requiring Backend, producing errors like:

the trait bound `Host<f64, i64>: Backend` is not satisfied

This is a deliberate compromise for the initial migration: making Host generic over element types at the trait-impl level is a follow-up that would require rewriting all impl FooOps<Host> for Host blocks plus internal Host::method() calls (tracked in #4762). Until then, treat the generic parameters as opaque shape placeholders; real element-type selection happens at runtime via DType.

The bound is locked in by a compile-fail doctest so that if someone later makes the Backend impl generic over E/I, this documentation gets flagged as out of date:

use ruda_tensor::Backend;
use ruda_tensor_host::Host;
fn requires_backend<B: Backend>() {}
requires_backend::<Host<f64, i64>>();

Trait Implementations

impl ActivationOps<Host> for Host

fn relu(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Applies the ReLU activation function.

fn relu_backward( output: FloatTensor<Host>, grad: FloatTensor<Host>, ) -> FloatTensor<Host>

Applies the ReLU activation function backward.

fn leaky_relu( tensor: FloatTensor<Host>, negative_slope: Scalar, ) -> FloatTensor<Host>

Applies the LeakyReLU activation function.

fn prelu( tensor: FloatTensor<Host>, alpha: FloatTensor<Host>, ) -> FloatTensor<Host>

Applies the PReLu activation function.

fn gelu(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Applies the Gelu activation function.

fn gelu_backward( x: FloatTensor<Host>, grad: FloatTensor<Host>, ) -> FloatTensor<Host>

Applies the Gelu activation function backward.

fn sigmoid(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Applies the Sigmoid activation function.

fn sigmoid_backward( output: FloatTensor<Host>, grad: FloatTensor<Host>, ) -> FloatTensor<Host>

Applies the Sigmoid activation function backward.

fn hard_sigmoid( tensor: FloatTensor<Host>, alpha: Scalar, beta: Scalar, ) -> FloatTensor<Host>

Applies the hard Sigmoid activation function.

fn log_sigmoid(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Applies the LogSigmoid activation function.

fn log_sigmoid_backward( x: FloatTensor<Host>, grad: FloatTensor<Host>, ) -> FloatTensor<Host>

Applies the LogSigmoid activation function backward.

fn softmax(tensor: FloatTensor<Host>, dim: usize) -> FloatTensor<Host>

Applies the softmax function along the given dimension.

fn silu( tensor: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Applies SiLU element-wise. Backends may fuse its arithmetic and rounding.

fn log_softmax( tensor: <B as BackendTypes>::FloatTensorPrimitive, dim: usize, ) -> <B as BackendTypes>::FloatTensorPrimitive

Applies the log-softmax function along the given dimension.

fn softmin( tensor: <B as BackendTypes>::FloatTensorPrimitive, dim: usize, ) -> <B as BackendTypes>::FloatTensorPrimitive

Applies the softmin function along the given dimension.

impl Backend for Host

fn flush(_device: &Self::Device) -> Result<(), ExecutionError>

Submit the current stream’s buffered work without waiting for device completion. Eager backends may return immediately; deferred backends must dispatch their queue.

fn name(_device: &Self::Device) -> String

Name of the backend.

fn seed(_device: &Self::Device, seed: u64)

Seeds the backend on the specified device.

fn rng_state(_device: &Self::Device) -> Result<Vec<u8>, ExecutionError>

fn restore_rng_state( _device: &Self::Device, state: &[u8], ) -> Result<(), ExecutionError>

fn device_count(_type_id: u16) -> usize

Returns the number of devices available on this backend. device is a reference device used to determine the underlying backend that should be queried. A CUDA device will return all devices available to CUDA, a Vulkan device will return all devices available to Vulkan, etc.

fn dtype_usage(_device: &Self::Device, dtype: DType) -> DTypeUsageSet

Returns the DTypeUsageSet for the given DType on the specified device.

fn ad_enabled(_device: &Self::Device) -> bool

If autodiff is enabled.

fn autodiff_creation_context(device: &Self::Device) -> AutodiffContext

Runtime association for new tensors on this device in the current synchronous scope.

fn with_autodiff_creation_context<R>( device: &Self::Device, context: AutodiffContext, func: impl FnOnce() -> R, ) -> R

Run synchronous tensor creation with an explicit association, restoring it on unwind.

fn memory_persistent_allocations<Output, Input, Func>( device: &Self::Device, input: Input, func: Func, ) -> Output

where Output: Send, Input: Send, Func: Fn(Input) -> Output + Send,

Sets the current allocation mode to persistent.

fn memory_cleanup(device: &Self::Device)

Manually triggers a memory cleanup on the given device.

fn sync(_device: &Self::Device) -> Result<(), ExecutionError>

Sync the backend, ensure that all computation are finished.

fn profile<O>( device: &Self::Device, _options: ProfileOptions, func: impl FnOnce() -> O + Send, ) -> Result<(O, ProfileDuration), ExecutionError>

where O: Send + 'static,

Measure a closure, preserving the timing method reported by this backend.

fn profile_start( _device: &Self::Device, ) -> Result<Option<ProfileToken>, ExecutionError>

Open an independent profiling window, or return None for system-only timing.

fn profile_end( _device: &Self::Device, _token: ProfileToken, _options: ProfileOptions, ) -> Result<ProfileDuration, ExecutionError>

Close a window on the stream where it opened, optionally flushing deferred work.

fn profile_abandon(device: &Self::Device, token: ProfileToken)

Release an abandoned window, including when a profiled closure unwinds.

fn graph_prepare(_device: &Self::Device) -> Result<(), ExecutionError>

Prepare memory and metadata for graph-capture warmup.

fn graph_start_capture(_device: &Self::Device) -> Result<(), ExecutionError>

Begin recording a warmed computation.

fn graph_stop_capture( _device: &Self::Device, ) -> Result<BackendGraph, ExecutionError>

End recording, resetting capture state on failure as well as success.

fn graph_abort_capture(_device: &Self::Device)

Close an abandoned recording.

unsafe fn graph_replay( _device: &Self::Device, graph: &BackendGraph, ) -> Result<(), ExecutionError>

Replay a recorded computation on its capture stream.

fn staging<'a, Iter>(_data: Iter, _device: &Self::Device)

where Iter: Iterator<Item = &'a mut TensorData>,

Marks the given data as being used as a staging buffer for transfer between CPU and accelerators like GPUs.

fn supports_dtype(device: &Self::Device, dtype: DType) -> bool

Whether the type is fully supported by the specified device for general operations.

impl BackendIr for Host

type Handle = HandleKind<Host>

The type that can be used to point to a tensor of any kind.

fn float_tensor(handle: TensorHandle<Self::Handle>) -> HostTensor

Convert a handle to a float tensor.

fn int_tensor(handle: TensorHandle<Self::Handle>) -> HostTensor

Convert a handle to an int tensor.

fn bool_tensor(handle: TensorHandle<Self::Handle>) -> HostTensor

Convert a handle to a bool tensor.

fn quantized_tensor(handle: TensorHandle<Self::Handle>) -> HostQTensor

Convert a handle to a quantized tensor.

fn float_tensor_handle(tensor: HostTensor) -> Self::Handle

Convert a float tensor to a handle.

fn int_tensor_handle(tensor: HostTensor) -> Self::Handle

Convert an int tensor to a handle.

fn bool_tensor_handle(tensor: HostTensor) -> Self::Handle

Convert a bool tensor to a handle.

fn quantized_tensor_handle(tensor: HostQTensor) -> Self::Handle

Convert a quantized tensor to a handle.

impl BackendTypes for Host

type FloatElem = f32

Default float element type. Determines the dtype for .float() conversions and Tensor::from_data when no explicit dtype is provided. Prefer explicit dtypes via (&device, DType::F32).

type IntElem = i32

Default int element type. Determines the dtype for .int() conversions and Tensor::from_data when no explicit dtype is provided. Set to i32 to match ruda’s ecosystem default (test suite, record settings, ruda-tensor-remote). Prefer explicit dtypes via (&device, DType::I32).

type Device = HostDevice

Device type.

type FloatTensorPrimitive = HostTensor

Tensor primitive to be used for all float operations.

type IntTensorPrimitive = HostTensor

Tensor primitive to be used for all int operations.

type BoolTensorPrimitive = HostTensor

Tensor primitive to be used for all bool operations.

type BoolElem = bool

Tensor primitive to be used for all bool operations.

type QuantizedTensorPrimitive = HostQTensor

Tensor primitive to be used for all quantized operations.

impl BoolTensorOps<Host> for Host

fn bool_from_data(data: TensorData, _device: &Device<Host>) -> BoolTensor<Host>

Creates a tensor from the data structure.

async fn bool_into_data( tensor: BoolTensor<Host>, ) -> Result<TensorData, ExecutionError>

Converts the tensor to a data structure.

fn bool_device(_tensor: &BoolTensor<Host>) -> Device<Host>

Gets the device of the tensor.

fn bool_to_device( tensor: BoolTensor<Host>, _device: &Device<Host>, ) -> BoolTensor<Host>

Moves the tensor to the device.

fn bool_cat(tensors: Vec<BoolTensor<Host>>, dim: usize) -> BoolTensor<Host>

Concatenates the tensors along the given dimension.

fn bool_reshape(tensor: BoolTensor<Host>, shape: Shape) -> BoolTensor<Host>

Reshapes the tensor.

fn bool_slice(tensor: BoolTensor<Host>, slices: &[Slice]) -> BoolTensor<Host>

Gets the values from the tensor for the given ranges.

fn bool_empty( shape: Shape, _device: &Device<Host>, dtype: BoolDType, ) -> BoolTensor<Host>

Creates a new bool tensor.

fn bool_slice_assign( tensor: BoolTensor<Host>, slices: &[Slice], value: BoolTensor<Host>, ) -> BoolTensor<Host>

Sets the values in the tensor for the given ranges.

fn bool_into_int( tensor: BoolTensor<Host>, out_dtype: IntDType, ) -> IntTensor<Host>

Converts bool tensor to int tensor.

fn bool_into_float( tensor: BoolTensor<Host>, out_dtype: FloatDType, ) -> FloatTensor<Host>

Converts bool tensor to float tensor.

fn bool_swap_dims( tensor: BoolTensor<Host>, dim1: usize, dim2: usize, ) -> BoolTensor<Host>

Swaps two dimensions of a bool tensor.

fn bool_permute(tensor: BoolTensor<Host>, axes: &[usize]) -> BoolTensor<Host>

Permutes the dimensions of a tensor.

fn bool_flip(tensor: BoolTensor<Host>, axes: &[usize]) -> BoolTensor<Host>

Reverse the order of elements in a tensor along the given axes.

fn bool_equal(lhs: BoolTensor<Host>, rhs: BoolTensor<Host>) -> BoolTensor<Host>

Equates the two tensors.

fn bool_not(tensor: BoolTensor<Host>) -> BoolTensor<Host>

Inverses boolean values.

fn bool_and(lhs: BoolTensor<Host>, rhs: BoolTensor<Host>) -> BoolTensor<Host>

Executes the logical and (&&) operation on two boolean tensors.

fn bool_or(lhs: BoolTensor<Host>, rhs: BoolTensor<Host>) -> BoolTensor<Host>

Executes the logical or (||) operation on two boolean tensors.

fn bool_xor(lhs: BoolTensor<Host>, rhs: BoolTensor<Host>) -> BoolTensor<Host>

Element-wise exclusive or.

fn bool_expand(tensor: BoolTensor<Host>, shape: Shape) -> BoolTensor<Host>

Broadcasts the bool tensor to the given shape.

fn bool_zeros( shape: Shape, device: &Device<Host>, dtype: BoolDType, ) -> BoolTensor<Host>

Creates a new bool tensor filled false.

fn bool_ones( shape: Shape, _device: &Device<Host>, dtype: BoolDType, ) -> BoolTensor<Host>

Creates a new bool tensor filled true.

fn bool_mask_where( tensor: BoolTensor<Host>, mask: BoolTensor<Host>, value: BoolTensor<Host>, ) -> BoolTensor<Host>

Fills the tensor with values from the value tensor if the mask is true at the given indices.

fn bool_mask_fill( tensor: BoolTensor<Host>, mask: BoolTensor<Host>, value: Scalar, ) -> BoolTensor<Host>

Fills the tensor with the given value if the mask is true at the given indices.

fn bool_gather( dim: usize, tensor: BoolTensor<Host>, indices: IntTensor<Host>, ) -> BoolTensor<Host>

Gather elements from the tensor at the given indices.

fn bool_scatter_or( dim: usize, tensor: BoolTensor<Host>, indices: IntTensor<Host>, value: BoolTensor<Host>, ) -> BoolTensor<Host>

Scatter a given value to the tensor at the given indices using boolean or reduction.

fn bool_equal_elem(lhs: BoolTensor<Host>, rhs: Scalar) -> BoolTensor<Host>

Element-wise equality comparison with a scalar.

fn bool_unfold( tensor: BoolTensor<Host>, dim: usize, size: usize, step: usize, ) -> BoolTensor<Host>

Unfold windows along a dimension.

fn bool_not_equal( lhs: BoolTensor<Host>, rhs: BoolTensor<Host>, ) -> BoolTensor<Host>

Element-wise non-equality comparison.

fn bool_not_equal_elem(lhs: BoolTensor<Host>, rhs: Scalar) -> BoolTensor<Host>

Element-wise non-equality comparison with a scalar.

fn bool_any(tensor: BoolTensor<Host>) -> BoolTensor<Host>

Tests if any element in the boolean tensor evaluates to True.

fn bool_any_dim(tensor: BoolTensor<Host>, dim: usize) -> BoolTensor<Host>

Tests if any element in the boolean tensor evaluates to True along a given dimension dim.

fn bool_all(tensor: BoolTensor<Host>) -> BoolTensor<Host>

Tests if all elements in the boolean tensor evaluate to True.

fn bool_all_dim(tensor: BoolTensor<Host>, dim: usize) -> BoolTensor<Host>

Tests if all elements in the boolean tensor evaluate to True along a given dimension dim.

fn bool_select( tensor: BoolTensor<Host>, dim: usize, indices: IntTensor<Host>, ) -> BoolTensor<Host>

Select tensor elements along the given dimension corresponding to the given indices.

fn bool_select_or( tensor: BoolTensor<Host>, dim: usize, indices: IntTensor<Host>, value: BoolTensor<Host>, ) -> BoolTensor<Host>

Assign the selected elements along the given dimension corresponding to the given indices to the given value using sum reduction.

fn bool_transpose(tensor: BoolTensor<Host>) -> BoolTensor<Host>

Transposes a bool tensor.

fn bool_repeat_dim( tensor: BoolTensor<Host>, dim: usize, times: usize, ) -> BoolTensor<Host>

Repeats one dimension of the tensor a given number of times along that dimension.

async fn bool_argwhere( tensor: BoolTensor<Host>, out_dtype: IntDType, ) -> IntTensor<Host>

Compute the indices of the elements that are non-zero, grouped by element.

fn bool_autodiff_context( tensor: &<B as BackendTypes>::BoolTensorPrimitive, ) -> AutodiffContext

Runtime association used when combining masks and floating-point values.

fn bool_with_autodiff_context( tensor: <B as BackendTypes>::BoolTensorPrimitive, context: AutodiffContext, ) -> <B as BackendTypes>::BoolTensorPrimitive

Change the runtime association without changing boolean storage.

impl<E: Clone, I: Clone> Clone for Host<E, I>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<E: Copy, I: Copy> Copy for Host<E, I>

impl<E: Debug, I: Debug> Debug for Host<E, I>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<E: Default, I: Default> Default for Host<E, I>

fn default() -> Self

Returns the “default value” for a type.

impl FloatTensorOps<Host> for Host

fn float_from_data( data: TensorData, _device: &Device<Host>, ) -> FloatTensor<Host>

Creates a new tensor from the data structure.

fn float_random( shape: Shape, distribution: Distribution, _device: &Device<Host>, dtype: FloatDType, ) -> FloatTensor<Host>

Creates a new tensor with random values.

async fn float_into_data( tensor: FloatTensor<Host>, ) -> Result<TensorData, ExecutionError>

Converts the tensor to a data structure.

fn float_device(_tensor: &FloatTensor<Host>) -> Device<Host>

Gets the device of the tensor.

fn float_to_device( tensor: FloatTensor<Host>, _device: &Device<Host>, ) -> FloatTensor<Host>

Moves the tensor to the given device.

fn float_detach(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Detaches a tensor from the computation graph.

fn float_into_int( tensor: FloatTensor<Host>, out_dtype: IntDType, ) -> IntTensor<Host>

Converts float tensor to int tensor.

fn float_empty( shape: Shape, _device: &Device<Host>, dtype: FloatDType, ) -> FloatTensor<Host>

Creates an empty tensor with the given shape.

fn float_add( lhs: FloatTensor<Host>, rhs: FloatTensor<Host>, ) -> FloatTensor<Host>

Adds two tensors together.

fn float_add_scalar(lhs: FloatTensor<Host>, rhs: Scalar) -> FloatTensor<Host>

Adds a scalar to a tensor.

fn float_sub( lhs: FloatTensor<Host>, rhs: FloatTensor<Host>, ) -> FloatTensor<Host>

Subtracts two tensors.

fn float_sub_scalar(lhs: FloatTensor<Host>, rhs: Scalar) -> FloatTensor<Host>

Subtracts a scalar from a tensor.

fn float_mul( lhs: FloatTensor<Host>, rhs: FloatTensor<Host>, ) -> FloatTensor<Host>

Multiplies two tensors together element-wise.

fn float_mul_scalar(lhs: FloatTensor<Host>, rhs: Scalar) -> FloatTensor<Host>

Multiplies a tensor by a scalar.

fn float_div( lhs: FloatTensor<Host>, rhs: FloatTensor<Host>, ) -> FloatTensor<Host>

Divides two tensors element-wise.

fn float_div_scalar(lhs: FloatTensor<Host>, rhs: Scalar) -> FloatTensor<Host>

Divides a tensor by a scalar.

fn float_remainder( lhs: FloatTensor<Host>, rhs: FloatTensor<Host>, ) -> FloatTensor<Host>

Computes the remainder of division between two tensors element-wise.

fn float_remainder_scalar( lhs: FloatTensor<Host>, rhs: Scalar, ) -> FloatTensor<Host>

Computes the modulus of a tensor given a scalar.

fn float_matmul( lhs: FloatTensor<Host>, rhs: FloatTensor<Host>, ) -> FloatTensor<Host>

Multiplies two tensors together using matrix multiplication.

fn float_cross( lhs: FloatTensor<Host>, rhs: FloatTensor<Host>, dim: usize, ) -> FloatTensor<Host>

Computes the cross product of two tensors along a given dimension.

fn float_recip(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Calculates the reciprocals element-wise

fn float_swap_dims( tensor: FloatTensor<Host>, dim1: usize, dim2: usize, ) -> FloatTensor<Host>

Swaps two dimensions of a tensor.

fn float_permute(tensor: FloatTensor<Host>, axes: &[usize]) -> FloatTensor<Host>

Permutes the dimensions of a tensor.

fn float_flip(tensor: FloatTensor<Host>, axes: &[usize]) -> FloatTensor<Host>

Reverse the order of elements in a tensor along the given axes.

fn float_cat(tensors: Vec<FloatTensor<Host>>, dim: usize) -> FloatTensor<Host>

Concatenates tensors along a dimension.

fn float_reshape(tensor: FloatTensor<Host>, shape: Shape) -> FloatTensor<Host>

Reshapes a tensor.

fn float_gather( dim: usize, tensor: FloatTensor<Host>, indices: IntTensor<Host>, ) -> FloatTensor<Host>

Gather elements from a tensor.

fn float_scatter_add( dim: usize, tensor: FloatTensor<Host>, indices: IntTensor<Host>, value: FloatTensor<Host>, ) -> FloatTensor<Host>

Scatter elements into a tensor using sum reduction.

fn float_scatter_nd( data: FloatTensor<Host>, indices: IntTensor<Host>, values: FloatTensor<Host>, reduction: IndexingUpdateOp, ) -> FloatTensor<Host>

Multi-dimensional scatter: update data at locations specified by indices with values.

fn float_gather_nd( data: FloatTensor<Host>, indices: IntTensor<Host>, ) -> FloatTensor<Host>

Multi-dimensional gather: collect slices from data at locations specified by indices.

fn float_select( tensor: FloatTensor<Host>, dim: usize, indices: IntTensor<Host>, ) -> FloatTensor<Host>

Select tensor elements along the given dimension corresponding for the given indices.

fn float_select_add( tensor: FloatTensor<Host>, dim: usize, indices: IntTensor<Host>, value: FloatTensor<Host>, ) -> FloatTensor<Host>

Assign the selected elements along the given dimension corresponding for the given indices to the given value using sum reduction.

fn float_slice(tensor: FloatTensor<Host>, slices: &[Slice]) -> FloatTensor<Host>

Select tensor elements corresponding to the given slices.

fn float_slice_assign( tensor: FloatTensor<Host>, slices: &[Slice], value: FloatTensor<Host>, ) -> FloatTensor<Host>

Assign the selected elements corresponding to the given slices to the given value.

fn float_mask_where( tensor: FloatTensor<Host>, mask: BoolTensor<Host>, value: FloatTensor<Host>, ) -> FloatTensor<Host>

Update the given tensor with the value tensor where the mask is true.

fn float_mask_fill( tensor: FloatTensor<Host>, mask: BoolTensor<Host>, value: Scalar, ) -> FloatTensor<Host>

Update the given tensor with the value where the mask is true.

fn float_equal( lhs: FloatTensor<Host>, rhs: FloatTensor<Host>, out_dtype: BoolDType, ) -> BoolTensor<Host>

Equal comparison of two tensors.

fn float_equal_elem( lhs: FloatTensor<Host>, rhs: Scalar, out_dtype: BoolDType, ) -> BoolTensor<Host>

Equal comparison of a tensor and a scalar.

fn float_greater( lhs: FloatTensor<Host>, rhs: FloatTensor<Host>, out_dtype: BoolDType, ) -> BoolTensor<Host>

Greater than comparison of two tensors.

fn float_greater_elem( lhs: FloatTensor<Host>, rhs: Scalar, out_dtype: BoolDType, ) -> BoolTensor<Host>

Greater than comparison of a tensor and a scalar.

fn float_greater_equal( lhs: FloatTensor<Host>, rhs: FloatTensor<Host>, out_dtype: BoolDType, ) -> BoolTensor<Host>

Greater than or equal comparison of two tensors.

fn float_greater_equal_elem( lhs: FloatTensor<Host>, rhs: Scalar, out_dtype: BoolDType, ) -> BoolTensor<Host>

Greater than or equal comparison of a tensor and a scalar.

fn float_lower( lhs: FloatTensor<Host>, rhs: FloatTensor<Host>, out_dtype: BoolDType, ) -> BoolTensor<Host>

Less than comparison of two tensors.

fn float_lower_elem( lhs: FloatTensor<Host>, rhs: Scalar, out_dtype: BoolDType, ) -> BoolTensor<Host>

Less than comparison of a tensor and a scalar.

fn float_lower_equal( lhs: FloatTensor<Host>, rhs: FloatTensor<Host>, out_dtype: BoolDType, ) -> BoolTensor<Host>

Less than or equal comparison of two tensors.

fn float_lower_equal_elem( lhs: FloatTensor<Host>, rhs: Scalar, out_dtype: BoolDType, ) -> BoolTensor<Host>

Less than or equal comparison of a tensor and a scalar.

fn float_not_equal( lhs: FloatTensor<Host>, rhs: FloatTensor<Host>, out_dtype: BoolDType, ) -> BoolTensor<Host>

Element-wise non-equality comparison.

fn float_not_equal_elem( lhs: FloatTensor<Host>, rhs: Scalar, out_dtype: BoolDType, ) -> BoolTensor<Host>

Element-wise non-equality comparison with a scalar.

fn float_neg(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Negates a tensor element-wise.

fn float_clamp( tensor: FloatTensor<Host>, min: Scalar, max: Scalar, ) -> FloatTensor<Host>

Clamps a tensor between a minimum and maximum value.

fn float_clamp_min(tensor: FloatTensor<Host>, min: Scalar) -> FloatTensor<Host>

Clamps a tensor under a minimum value.

fn float_clamp_max(tensor: FloatTensor<Host>, max: Scalar) -> FloatTensor<Host>

Clamps a tensor over a maximum value.

fn float_sign(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Returns the signs of the float tensor.

fn float_mean(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Mean of all elements in a tensor.

fn float_max(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Gets the maximum element of a tensor.

fn float_max_dim(tensor: FloatTensor<Host>, dim: usize) -> FloatTensor<Host>

Gets the maximum elements of a tensor along an axis.

fn float_min(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Gets the minimum element of a tensor.

fn float_min_dim(tensor: FloatTensor<Host>, dim: usize) -> FloatTensor<Host>

Gets the minimum elements of a tensor along an axis.

fn float_max_dim_with_indices( tensor: FloatTensor<Host>, dim: usize, indices_dtype: IntDType, ) -> (FloatTensor<Host>, IntTensor<Host>)

Gets the maximum elements of a tensor along an axis and their indices.

fn float_min_dim_with_indices( tensor: FloatTensor<Host>, dim: usize, indices_dtype: IntDType, ) -> (FloatTensor<Host>, IntTensor<Host>)

Gets the minimum elements of a tensor along an axis and their indices.

fn float_any( tensor: FloatTensor<Host>, out_dtype: BoolDType, ) -> BoolTensor<Host>

Tests if any element in the float tensor evaluates to True.

fn float_any_dim( tensor: FloatTensor<Host>, dim: usize, out_dtype: BoolDType, ) -> BoolTensor<Host>

Tests if any element in the float tensor evaluates to True along a given dimension dim.

fn float_all( tensor: FloatTensor<Host>, out_dtype: BoolDType, ) -> BoolTensor<Host>

Tests if all elements in the float tensor evaluate to True.

fn float_all_dim( tensor: FloatTensor<Host>, dim: usize, out_dtype: BoolDType, ) -> BoolTensor<Host>

Tests if all elements in the float tensor evaluate to True along a given dimension dim.

fn float_sum(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Sum of all elements in a tensor.

fn float_sum_dim(tensor: FloatTensor<Host>, dim: usize) -> FloatTensor<Host>

Sum of all elements in a tensor along a dimension.

fn float_mean_dim(tensor: FloatTensor<Host>, dim: usize) -> FloatTensor<Host>

Mean of all elements in a tensor along a dimension.

fn float_prod(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Product of all elements in a tensor.

fn float_prod_dim(tensor: FloatTensor<Host>, dim: usize) -> FloatTensor<Host>

Product of all elements in a tensor along a dimension.

fn float_cumsum(tensor: FloatTensor<Host>, dim: usize) -> FloatTensor<Host>

Computes the cumulative sum of elements along a dimension.

fn float_cumprod(tensor: FloatTensor<Host>, dim: usize) -> FloatTensor<Host>

Computes the cumulative product of elements along a dimension.

fn float_cummin(tensor: FloatTensor<Host>, dim: usize) -> FloatTensor<Host>

Computes the cumulative minimum of elements along a dimension.

fn float_cummax(tensor: FloatTensor<Host>, dim: usize) -> FloatTensor<Host>

Computes the cumulative maximum of elements along a dimension.

fn float_cast(tensor: FloatTensor<Host>, dtype: FloatDType) -> FloatTensor<Host>

Converts a tensor to another floating point data type.

fn float_exp(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Returns a new tensor with exponential values.

fn float_log(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Returns a new tensor with natural logarithm values.

fn float_log1p(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Returns a new tensor with logarithm values of (1 + Xi).

fn float_powf( lhs: FloatTensor<Host>, rhs: FloatTensor<Host>, ) -> FloatTensor<Host>

Element-wise power with a FloatTensor.

fn float_powf_scalar_impl( tensor: FloatTensor<Host>, value: Scalar, ) -> FloatTensor<Host>

Returns a new tensor with values raised to the power of float value.

fn float_sqrt(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Returns a new tensor with square root values.

fn float_abs(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Returns a new tensor with absolute values.

fn float_cos(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Returns a new tensor with cosine values.

fn float_sin(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Returns a new tensor with sine values.

fn float_tan(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Returns a new tensor with tangent values.

fn float_cosh(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Returns a new tensor with hyperbolic cosine values.

fn float_sinh(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Returns a new tensor with hyperbolic sine values.

fn float_tanh(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Returns a new tensor with hyperbolic tangent values.

fn float_acos(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Returns a new tensor with inverse cosine values.

fn float_acosh(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Returns a new tensor with inverse hyperbolic cosine values.

fn float_asin(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Returns a new tensor with inverse sine values.

fn float_asinh(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Returns a new tensor with inverse hyperbolic sine values.

fn float_atan(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Returns a new tensor with the inverse tangent values.

fn float_atanh(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Returns a new tensor with the inverse hyperbolic tangent values.

fn float_atan2( lhs: FloatTensor<Host>, rhs: FloatTensor<Host>, ) -> FloatTensor<Host>

Returns a tensor with the four-quadrant inverse tangent values of y and x.

fn float_hypot( lhs: FloatTensor<Host>, rhs: FloatTensor<Host>, ) -> FloatTensor<Host>

Computes the element-wise hypotenuse without intermediate squaring overflow.

fn float_round(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Returns a new tensor with rounded values.

fn float_floor(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Returns a new tensor with floored values.

fn float_ceil(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Returns a new tensor with ceiled values.

fn float_trunc(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Returns a new tensor with truncated values.

fn float_erf(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Returns a new tensor with the error function values.

fn float_argmax( tensor: FloatTensor<Host>, dim: usize, out_dtype: IntDType, ) -> IntTensor<Host>

Gets the indices of the maximum elements of a tensor along an axis.

fn float_argtopk( tensor: FloatTensor<Host>, dim: usize, k: usize, out_dtype: IntDType, ) -> IntTensor<Host>

Gets the indices of the k maximum elements of a tensor along an axis. if two elements are equals, it will be ordered by lowest indices

fn float_argmin( tensor: FloatTensor<Host>, dim: usize, out_dtype: IntDType, ) -> IntTensor<Host>

Gets the indices of the minimum elements of a tensor along an axis.

fn float_expand(tensor: FloatTensor<Host>, shape: Shape) -> FloatTensor<Host>

Broadcasts the float tensor to the given shape.

fn float_unfold( tensor: FloatTensor<Host>, dim: usize, size: usize, step: usize, ) -> FloatTensor<Host>

Unfold windows along a dimension.

fn float_grid_sample_2d( tensor: FloatTensor<Host>, grid: FloatTensor<Host>, options: GridSampleOptions, ) -> FloatTensor<Host>

Samples tensor as a two-dimensional spatial grid of (possibly multi-channel) values, using the given locations in [-1, 1].

fn float_zeros( shape: Shape, _device: &Device<Host>, dtype: FloatDType, ) -> FloatTensor<Host>

Creates a new tensor with zeros.

fn float_ones( shape: Shape, _device: &Device<Host>, dtype: FloatDType, ) -> FloatTensor<Host>

Creates a new tensor with ones.

fn float_full( shape: Shape, fill_value: Scalar, _device: &Device<Host>, dtype: FloatDType, ) -> FloatTensor<Host>

Creates a tensor filled with given value.

fn float_transpose(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Transposes a tensor.

fn float_repeat_dim( tensor: FloatTensor<Host>, dim: usize, times: usize, ) -> FloatTensor<Host>

Repeat the tensor along the given dimension.

fn float_sort( tensor: FloatTensor<Host>, dim: usize, descending: bool, ) -> FloatTensor<Host>

Sort the elements of the input tensor by value in along a given dimension.

fn float_sort_with_indices( tensor: FloatTensor<Host>, dim: usize, descending: bool, indices_dtype: IntDType, ) -> (FloatTensor<Host>, IntTensor<Host>)

Sort the elements of the input tensor by value in along a given dimension.

fn float_argsort( tensor: FloatTensor<Host>, dim: usize, descending: bool, out_dtype: IntDType, ) -> IntTensor<Host>

Returns the indices that sort the elements of the input tensor by value along a given dimension.

fn float_powi(lhs: FloatTensor<Host>, rhs: IntTensor<Host>) -> FloatTensor<Host>

Element-wise power with an IntTensor.

fn float_powi_scalar(lhs: FloatTensor<Host>, rhs: Scalar) -> FloatTensor<Host>

Raises a tensor to the power of an int scalar.

fn float_powi_scalar_impl( lhs: FloatTensor<Host>, rhs: Scalar, ) -> FloatTensor<Host>

Raises a tensor to the power of an int scalar.

fn float_powf_scalar( tensor: FloatTensor<Host>, value: Scalar, ) -> FloatTensor<Host>

Returns a new tensor with values raised to the power of float value.

fn float_max_abs(tensor: FloatTensor<Host>) -> FloatTensor<Host>

Gets the maximum absolute element of a tensor.

fn float_max_abs_dim(tensor: FloatTensor<Host>, dim: usize) -> FloatTensor<Host>

Gets the maximum absolute elements of a tensor along an axis.

fn float_is_nan( tensor: FloatTensor<Host>, out_dtype: BoolDType, ) -> BoolTensor<Host>

Returns a new tensor with boolean elements indicating whether each element of the input is NaN.

fn float_is_inf( tensor: FloatTensor<Host>, out_dtype: BoolDType, ) -> BoolTensor<Host>

Returns a new tensor with boolean elements indicating whether each element of the input is infinite (either +INF or -INF).

fn float_scatter( dim: usize, tensor: <B as BackendTypes>::FloatTensorPrimitive, indices: <B as BackendTypes>::IntTensorPrimitive, value: <B as BackendTypes>::FloatTensorPrimitive, update: IndexingUpdateOp, ) -> <B as BackendTypes>::FloatTensorPrimitive

Scatter with the specified update operation.

fn float_select_assign( tensor: <B as BackendTypes>::FloatTensorPrimitive, dim: usize, indices: <B as BackendTypes>::IntTensorPrimitive, value: <B as BackendTypes>::FloatTensorPrimitive, update: IndexingUpdateOp, ) -> <B as BackendTypes>::FloatTensorPrimitive

Update selected slices using the specified operation.

fn float_set_require_grad( tensor: <B as BackendTypes>::FloatTensorPrimitive, _require_grad: bool, ) -> <B as BackendTypes>::FloatTensorPrimitive

Sets the require_grad flag of a tensor.

fn float_is_require_grad( _tensor: &<B as BackendTypes>::FloatTensorPrimitive, ) -> bool

Returns the require_grad flag of a tensor.

fn float_is_tracked(tensor: &<B as BackendTypes>::FloatTensorPrimitive) -> bool

Whether the tensor belongs to a recorded graph, independently of gradient retention.

fn float_gradient_checkpointing_strategy( _tensor: &<B as BackendTypes>::FloatTensorPrimitive, ) -> Option<GradientCheckpointingStrategy>

The tensor’s checkpointing policy, or None without autodiff.

fn float_autodiff_context( tensor: &<B as BackendTypes>::FloatTensorPrimitive, ) -> AutodiffContext

Runtime autodiff association of a floating tensor.

fn float_with_autodiff_context( tensor: <B as BackendTypes>::FloatTensorPrimitive, context: AutodiffContext, ) -> <B as BackendTypes>::FloatTensorPrimitive

Change runtime association on a backend supporting dynamic autodiff.

fn float_with_gradient_checkpointing_strategy( _tensor: <B as BackendTypes>::FloatTensorPrimitive, _strategy: GradientCheckpointingStrategy, ) -> <B as BackendTypes>::FloatTensorPrimitive

Override the tensor’s policy without detaching it from its current graph.

fn float_rsqrt( tensor: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Returns element-wise reciprocal square roots. Backends may provide a native instruction.

fn float_topk( tensor: <B as BackendTypes>::FloatTensorPrimitive, dim: usize, k: usize, ) -> <B as BackendTypes>::FloatTensorPrimitive

Gets the values of the k maximum elements of a tensor along an axis.

impl IntTensorOps<Host> for Host

fn int_gather( dim: usize, tensor: IntTensor<Host>, indices: IntTensor<Host>, ) -> IntTensor<Host>

Gather ints along dim at the given indices.

The tensor dispatches on its own int dtype (I8/I16/I32/I64 signed or U8/U16/U32/U64 unsigned). The indices tensor may be any of those widths too - it’s normalised to isize by the shared read_indices helper in ops::gather_scatter before the kernel runs, so callers are not required to pre-convert to I64.

fn int_scatter_add( dim: usize, tensor: IntTensor<Host>, indices: IntTensor<Host>, value: IntTensor<Host>, ) -> IntTensor<Host>

Scatter-add int values at the given indices along dim.

tensor and value must share the same int dtype; indices may be any supported int width. See int_gather for the full index-width policy.

fn int_select( tensor: IntTensor<Host>, dim: usize, indices: IntTensor<Host>, ) -> IntTensor<Host>

Select ints along dim by a 1D index tensor.

The indices tensor may be any supported int width. See int_gather for the full index-width policy.

fn int_select_add( tensor: IntTensor<Host>, dim: usize, indices: IntTensor<Host>, value: IntTensor<Host>, ) -> IntTensor<Host>

Select-add int values at a 1D index tensor along dim.

tensor and value must share the same int dtype; indices may be any supported int width. See int_gather for the full index-width policy.

fn int_from_data(data: TensorData, _device: &Device<Host>) -> IntTensor<Host>

Creates a tensor from the data structure.

async fn int_into_data( tensor: IntTensor<Host>, ) -> Result<TensorData, ExecutionError>

Converts the tensor to a data structure.

fn int_device(_tensor: &IntTensor<Host>) -> Device<Host>

Gets the device of the tensor.

fn int_to_device( tensor: IntTensor<Host>, _device: &Device<Host>, ) -> IntTensor<Host>

Moves the tensor to the given device.

fn int_cat(tensors: Vec<IntTensor<Host>>, dim: usize) -> IntTensor<Host>

Concatenates the given tensors along the given dimension.

fn int_reshape(tensor: IntTensor<Host>, shape: Shape) -> IntTensor<Host>

Reshapes the tensor.

fn int_slice(tensor: IntTensor<Host>, slices: &[Slice]) -> IntTensor<Host>

Gets the element at the given indices.

fn int_empty( shape: Shape, _device: &Device<Host>, dtype: IntDType, ) -> IntTensor<Host>

Creates a new int tensor.

fn int_mask_where( tensor: IntTensor<Host>, mask: BoolTensor<Host>, value: IntTensor<Host>, ) -> IntTensor<Host>

Fills the tensor with values from the value tensor if the mask is true at the given indices.

fn int_mask_fill( tensor: IntTensor<Host>, mask: BoolTensor<Host>, value: Scalar, ) -> IntTensor<Host>

Fills the tensor with the given value if the mask is true at the given indices.

fn int_slice_assign( tensor: IntTensor<Host>, slices: &[Slice], value: IntTensor<Host>, ) -> IntTensor<Host>

Sets the values in the tensor for the given ranges.

fn int_scatter_nd( data: IntTensor<Host>, indices: IntTensor<Host>, values: IntTensor<Host>, reduction: IndexingUpdateOp, ) -> IntTensor<Host>

Multi-dimensional scatter for int tensors.

fn int_gather_nd( data: IntTensor<Host>, indices: IntTensor<Host>, ) -> IntTensor<Host>

Multi-dimensional gather for int tensors.

fn int_equal( lhs: IntTensor<Host>, rhs: IntTensor<Host>, out_dtype: BoolDType, ) -> BoolTensor<Host>

Element-wise equality comparison.

fn int_equal_elem( lhs: IntTensor<Host>, rhs: Scalar, out_dtype: BoolDType, ) -> BoolTensor<Host>

Element-wise equality comparison with a scalar.

fn int_greater( lhs: IntTensor<Host>, rhs: IntTensor<Host>, out_dtype: BoolDType, ) -> BoolTensor<Host>

Element-wise greater than comparison.

fn int_greater_elem( lhs: IntTensor<Host>, rhs: Scalar, out_dtype: BoolDType, ) -> BoolTensor<Host>

Element-wise greater than comparison with a scalar.

fn int_greater_equal( lhs: IntTensor<Host>, rhs: IntTensor<Host>, out_dtype: BoolDType, ) -> BoolTensor<Host>

Element-wise greater than or equal comparison.

fn int_greater_equal_elem( lhs: IntTensor<Host>, rhs: Scalar, out_dtype: BoolDType, ) -> BoolTensor<Host>

Element-wise greater than or equal comparison with a scalar.

fn int_lower( lhs: IntTensor<Host>, rhs: IntTensor<Host>, out_dtype: BoolDType, ) -> BoolTensor<Host>

Element-wise less than comparison.

fn int_lower_elem( lhs: IntTensor<Host>, rhs: Scalar, out_dtype: BoolDType, ) -> BoolTensor<Host>

Element-wise less than comparison with a scalar.

fn int_lower_equal( lhs: IntTensor<Host>, rhs: IntTensor<Host>, out_dtype: BoolDType, ) -> BoolTensor<Host>

Element-wise less than or equal comparison.

fn int_lower_equal_elem( lhs: IntTensor<Host>, rhs: Scalar, out_dtype: BoolDType, ) -> BoolTensor<Host>

Element-wise less than or equal comparison with a scalar.

fn int_add(lhs: IntTensor<Host>, rhs: IntTensor<Host>) -> IntTensor<Host>

Element-wise addition.

fn int_add_scalar(lhs: IntTensor<Host>, rhs: Scalar) -> IntTensor<Host>

Element-wise addition with a scalar.

fn int_sub(lhs: IntTensor<Host>, rhs: IntTensor<Host>) -> IntTensor<Host>

Element-wise subtraction.

fn int_sub_scalar(lhs: IntTensor<Host>, rhs: Scalar) -> IntTensor<Host>

Element-wise subtraction with a scalar.

fn int_mul(lhs: IntTensor<Host>, rhs: IntTensor<Host>) -> IntTensor<Host>

Element-wise multiplication.

fn int_mul_scalar(lhs: IntTensor<Host>, rhs: Scalar) -> IntTensor<Host>

Element-wise multiplication with a scalar.

fn int_div(lhs: IntTensor<Host>, rhs: IntTensor<Host>) -> IntTensor<Host>

Element-wise division.

fn int_div_scalar(lhs: IntTensor<Host>, rhs: Scalar) -> IntTensor<Host>

Element-wise division with a scalar.

fn int_remainder(lhs: IntTensor<Host>, rhs: IntTensor<Host>) -> IntTensor<Host>

Element-wise modulus.

fn int_remainder_scalar(lhs: IntTensor<Host>, rhs: Scalar) -> IntTensor<Host>

Element-wise modulus with a scalar.

fn int_into_float( tensor: IntTensor<Host>, out_dtype: FloatDType, ) -> FloatTensor<Host>

Converts int tensor to float tensor.

fn int_swap_dims( tensor: IntTensor<Host>, dim1: usize, dim2: usize, ) -> IntTensor<Host>

Swaps two dimensions of an int tensor.

fn int_permute(tensor: IntTensor<Host>, axes: &[usize]) -> IntTensor<Host>

Permutes the dimensions of a tensor.

fn int_flip(tensor: IntTensor<Host>, axes: &[usize]) -> IntTensor<Host>

Reverse the order of elements in a tensor along the given axes.

fn int_random( shape: Shape, distribution: Distribution, _device: &Device<Host>, dtype: IntDType, ) -> IntTensor<Host>

Creates a new int tensor with random values.

fn int_expand(tensor: IntTensor<Host>, shape: Shape) -> IntTensor<Host>

Broadcasts the int tensor to the given shape.

fn int_matmul(lhs: IntTensor<Host>, rhs: IntTensor<Host>) -> IntTensor<Host>

Multiplies two tensors together using matrix multiplication.

fn int_sum(tensor: IntTensor<Host>) -> IntTensor<Host>

Sums all elements in the tensor.

fn int_sum_dim(tensor: IntTensor<Host>, dim: usize) -> IntTensor<Host>

Sums all elements in the tensor along a dimension.

fn int_prod(tensor: IntTensor<Host>) -> IntTensor<Host>

Computes the product of all elements in the tensor.

fn int_prod_dim(tensor: IntTensor<Host>, dim: usize) -> IntTensor<Host>

Computes the product of all elements in the tensor along a dimension.

fn int_mean_dim(tensor: IntTensor<Host>, dim: usize) -> IntTensor<Host>

Computes the mean of all elements in the tensor along a dimension.

fn int_cumsum(tensor: IntTensor<Host>, dim: usize) -> IntTensor<Host>

Computes the cumulative sum of elements along a dimension.

fn int_cumprod(tensor: IntTensor<Host>, dim: usize) -> IntTensor<Host>

Computes the cumulative product of elements along a dimension.

fn int_cummin(tensor: IntTensor<Host>, dim: usize) -> IntTensor<Host>

Computes the cumulative minimum of elements along a dimension.

fn int_cummax(tensor: IntTensor<Host>, dim: usize) -> IntTensor<Host>

Computes the cumulative maximum of elements along a dimension.

fn int_argmax(tensor: IntTensor<Host>, dim: usize) -> IntTensor<Host>

Gets the indices of the maximum elements along a dimension.

fn int_argtopk(tensor: IntTensor<Host>, dim: usize, k: usize) -> IntTensor<Host>

Gets the indices of the k maximum elements along a dimension. If two elements share the same value, it will be ordered by the lowest coordinate

fn int_argmin(tensor: IntTensor<Host>, dim: usize) -> IntTensor<Host>

Gets the indices of the minimum elements along a dimension.

fn int_abs(tensor: IntTensor<Host>) -> IntTensor<Host>

Returns a new tensor with absolute values.

fn bitwise_and(lhs: IntTensor<Host>, rhs: IntTensor<Host>) -> IntTensor<Host>

Bitwise AND operation for Int Tensors

fn bitwise_and_scalar(lhs: IntTensor<Host>, rhs: Scalar) -> IntTensor<Host>

Bitwise AND operation for Int Tensors with a scalar

fn bitwise_or(lhs: IntTensor<Host>, rhs: IntTensor<Host>) -> IntTensor<Host>

Bitwise OR operation for Int Tensors

fn bitwise_or_scalar(lhs: IntTensor<Host>, rhs: Scalar) -> IntTensor<Host>

Bitwise OR operation for Int Tensors with a scalar

fn bitwise_xor(lhs: IntTensor<Host>, rhs: IntTensor<Host>) -> IntTensor<Host>

Bitwise XOR operation for Int Tensors

fn bitwise_xor_scalar(lhs: IntTensor<Host>, rhs: Scalar) -> IntTensor<Host>

Bitwise XOR operation for Int Tensors with a scalar

fn bitwise_not(tensor: IntTensor<Host>) -> IntTensor<Host>

Bitwise NOT operation for Int Tensors

fn bitwise_left_shift( lhs: IntTensor<Host>, rhs: IntTensor<Host>, ) -> IntTensor<Host>

Bitwise left shift operation for Int Tensors

fn bitwise_left_shift_scalar( lhs: IntTensor<Host>, rhs: Scalar, ) -> IntTensor<Host>

Bitwise left shift operation for Int Tensors with a scalar

fn bitwise_right_shift( lhs: IntTensor<Host>, rhs: IntTensor<Host>, ) -> IntTensor<Host>

Bitwise right shift operation for Int Tensors

fn bitwise_right_shift_scalar( lhs: IntTensor<Host>, rhs: Scalar, ) -> IntTensor<Host>

Bitwise right shift operation for Int Tensors with a scalar

fn int_cast(tensor: IntTensor<Host>, dtype: IntDType) -> IntTensor<Host>

Converts a tensor to another integer data type.

fn int_unfold( tensor: IntTensor<Host>, dim: usize, size: usize, step: usize, ) -> IntTensor<Host>

Unfold windows along a dimension.

fn int_neg(tensor: IntTensor<Host>) -> IntTensor<Host>

Element-wise negation.

fn int_clamp( tensor: IntTensor<Host>, min: Scalar, max: Scalar, ) -> IntTensor<Host>

Clamps a tensor between a minimum and maximum value.

fn int_clamp_min(tensor: IntTensor<Host>, min: Scalar) -> IntTensor<Host>

Clamps a tensor under a minimum value.

fn int_clamp_max(tensor: IntTensor<Host>, max: Scalar) -> IntTensor<Host>

Clamps a tensor over a maximum value.

fn int_sign(tensor: IntTensor<Host>) -> IntTensor<Host>

Returns the signs of the int tensor.

fn int_mean(tensor: IntTensor<Host>) -> IntTensor<Host>

Computes the mean of all elements in the tensor.

fn int_max(tensor: IntTensor<Host>) -> IntTensor<Host>

Gets the maximum element in the tensor.

fn int_max_dim(tensor: IntTensor<Host>, dim: usize) -> IntTensor<Host>

Gets the maximum element in the tensor along a dimension.

fn int_min(tensor: IntTensor<Host>) -> IntTensor<Host>

Gets the minimum element in the tensor.

fn int_min_dim(tensor: IntTensor<Host>, dim: usize) -> IntTensor<Host>

Gets the minimum elements in the tensor along a dimension.

fn int_max_dim_with_indices( tensor: IntTensor<Host>, dim: usize, ) -> (IntTensor<Host>, IntTensor<Host>)

Gets the maximum elements and corresponding indices along a dimension.

fn int_min_dim_with_indices( tensor: IntTensor<Host>, dim: usize, ) -> (IntTensor<Host>, IntTensor<Host>)

Gets the minimum elements and corresponding indices along a dimension.

fn int_any(tensor: IntTensor<Host>, out_dtype: BoolDType) -> BoolTensor<Host>

Tests if any element in the int tensor evaluates to True.

fn int_any_dim( tensor: IntTensor<Host>, dim: usize, out_dtype: BoolDType, ) -> BoolTensor<Host>

Tests if any element in the int tensor evaluates to True along a given dimension dim.

fn int_all(tensor: IntTensor<Host>, out_dtype: BoolDType) -> BoolTensor<Host>

Tests if all elements in the int tensor evaluate to True.

fn int_all_dim( tensor: IntTensor<Host>, dim: usize, out_dtype: BoolDType, ) -> BoolTensor<Host>

Tests if all elements in the int tensor evaluate to True along a given dimension dim.

fn int_powi(lhs: IntTensor<Host>, rhs: IntTensor<Host>) -> IntTensor<Host>

Element-wise power with a IntTensor.

fn int_zeros( shape: Shape, _device: &Device<Host>, dtype: IntDType, ) -> IntTensor<Host>

Creates a tensor of zeros.

fn int_ones( shape: Shape, _device: &Device<Host>, dtype: IntDType, ) -> IntTensor<Host>

Creates a tensor of ones.

fn int_full( shape: Shape, fill_value: Scalar, _device: &Device<Host>, dtype: IntDType, ) -> IntTensor<Host>

Creates a tensor filled with given value.

fn int_transpose(tensor: IntTensor<Host>) -> IntTensor<Host>

Transposes an int tensor.

fn int_repeat_dim( tensor: IntTensor<Host>, dim: usize, times: usize, ) -> IntTensor<Host>

Repeats the tensor along the given dimension the given number of times.

fn int_not_equal( lhs: IntTensor<Host>, rhs: IntTensor<Host>, out_dtype: BoolDType, ) -> BoolTensor<Host>

Element-wise non-equality comparison.

fn int_not_equal_elem( lhs: IntTensor<Host>, rhs: Scalar, out_dtype: BoolDType, ) -> BoolTensor<Host>

Element-wise non-equality comparison with a scalar.

fn int_sort( tensor: IntTensor<Host>, dim: usize, descending: bool, ) -> IntTensor<Host>

Sort the elements of the input tensor by value along a given dimension.

fn int_sort_with_indices( tensor: IntTensor<Host>, dim: usize, descending: bool, ) -> (IntTensor<Host>, IntTensor<Host>)

Sort the elements of the input tensor by value along a given dimension.

fn int_argsort( tensor: IntTensor<Host>, dim: usize, descending: bool, ) -> IntTensor<Host>

Returns the indices that sort the elements of the input tensor by value along a given dimension.

fn int_powi_scalar(lhs: IntTensor<Host>, rhs: Scalar) -> IntTensor<Host>

Element-wise power with a scalar.

fn int_powi_scalar_impl(lhs: IntTensor<Host>, rhs: Scalar) -> IntTensor<Host>

Element-wise power with a scalar.

fn int_max_abs(tensor: IntTensor<Host>) -> IntTensor<Host>

Gets the maximum absolute element in the tensor.

fn int_max_abs_dim(tensor: IntTensor<Host>, dim: usize) -> IntTensor<Host>

Gets the maximum absolute element in the tensor along a dimension.

fn int_arange( range: Range<i64>, _device: &Device<Host>, dtype: IntDType, ) -> IntTensor<Host>

Creates a new tensor with values from the given range.

fn int_arange_step( range: Range<i64>, step: usize, _device: &Device<Host>, dtype: IntDType, ) -> IntTensor<Host>

Creates a new tensor with values from the given range with the given step size.

fn int_autodiff_context( tensor: &<B as BackendTypes>::IntTensorPrimitive, ) -> AutodiffContext

Runtime association used when combining integer and floating-point values.

fn int_with_autodiff_context( tensor: <B as BackendTypes>::IntTensorPrimitive, context: AutodiffContext, ) -> <B as BackendTypes>::IntTensorPrimitive

Change the runtime association without changing integer storage.

fn int_scatter( dim: usize, tensor: <B as BackendTypes>::IntTensorPrimitive, indices: <B as BackendTypes>::IntTensorPrimitive, value: <B as BackendTypes>::IntTensorPrimitive, update: IndexingUpdateOp, ) -> <B as BackendTypes>::IntTensorPrimitive

Scatter with the specified update operation.

fn int_select_assign( tensor: <B as BackendTypes>::IntTensorPrimitive, dim: usize, indices: <B as BackendTypes>::IntTensorPrimitive, value: <B as BackendTypes>::IntTensorPrimitive, update: IndexingUpdateOp, ) -> <B as BackendTypes>::IntTensorPrimitive

Update selected slices using the specified operation.

fn int_topk( tensor: <B as BackendTypes>::IntTensorPrimitive, dim: usize, k: usize, ) -> <B as BackendTypes>::IntTensorPrimitive

Gets the values of the k maximum elements along a dimension.

impl ModuleOps<Host> for Host

fn conv1d( x: FloatTensor<Host>, weight: FloatTensor<Host>, bias: Option<FloatTensor<Host>>, options: ConvOptions<1>, ) -> FloatTensor<Host>

One dimensional convolution.

fn conv2d( x: FloatTensor<Host>, weight: FloatTensor<Host>, bias: Option<FloatTensor<Host>>, options: ConvOptions<2>, ) -> FloatTensor<Host>

Two dimensional convolution.

fn deform_conv2d( x: FloatTensor<Host>, offset: FloatTensor<Host>, weight: FloatTensor<Host>, mask: Option<FloatTensor<Host>>, bias: Option<FloatTensor<Host>>, options: DeformConvOptions<2>, ) -> FloatTensor<Host>

Two dimensional deformable convolution.

fn deform_conv2d_backward( x: FloatTensor<Host>, offset: FloatTensor<Host>, weight: FloatTensor<Host>, mask: Option<FloatTensor<Host>>, bias: Option<FloatTensor<Host>>, output_grad: FloatTensor<Host>, options: DeformConvOptions<2>, ) -> DeformConv2dBackward<Host>

Backward pass for the deform_conv2d operation.

fn conv3d( x: FloatTensor<Host>, weight: FloatTensor<Host>, bias: Option<FloatTensor<Host>>, options: ConvOptions<3>, ) -> FloatTensor<Host>

Three dimensional convolution.

fn conv_transpose1d( x: FloatTensor<Host>, weight: FloatTensor<Host>, bias: Option<FloatTensor<Host>>, options: ConvTransposeOptions<1>, ) -> FloatTensor<Host>

One dimensional transposed convolution.

fn conv_transpose2d( x: FloatTensor<Host>, weight: FloatTensor<Host>, bias: Option<FloatTensor<Host>>, options: ConvTransposeOptions<2>, ) -> FloatTensor<Host>

Two dimensional transposed convolution.

fn conv_transpose3d( x: FloatTensor<Host>, weight: FloatTensor<Host>, bias: Option<FloatTensor<Host>>, options: ConvTransposeOptions<3>, ) -> FloatTensor<Host>

Three dimensional transposed convolution.

fn avg_pool2d( x: FloatTensor<Host>, kernel_size: [usize; 2], stride: [usize; 2], padding: [usize; 2], count_include_pad: bool, ceil_mode: bool, ) -> FloatTensor<Host>

Two dimensional avg pooling.

fn avg_pool2d_backward( x: FloatTensor<Host>, grad: FloatTensor<Host>, kernel_size: [usize; 2], stride: [usize; 2], padding: [usize; 2], count_include_pad: bool, _divisor_override: bool, ) -> FloatTensor<Host>

Backward pass for the avg pooling 2d operation.

fn adaptive_avg_pool2d( x: FloatTensor<Host>, output_size: [usize; 2], ) -> FloatTensor<Host>

Two dimensional adaptive avg pooling.

fn adaptive_avg_pool2d_backward( x: FloatTensor<Host>, grad: FloatTensor<Host>, ) -> FloatTensor<Host>

Backward pass for the adaptive avg pooling 2d operation.

fn max_pool2d( x: FloatTensor<Host>, kernel_size: [usize; 2], stride: [usize; 2], padding: [usize; 2], dilation: [usize; 2], ceil_mode: bool, ) -> FloatTensor<Host>

Two dimensional max pooling.

fn max_pool2d_with_indices( x: FloatTensor<Host>, kernel_size: [usize; 2], stride: [usize; 2], padding: [usize; 2], dilation: [usize; 2], ceil_mode: bool, ) -> MaxPool2dWithIndices<Host>

Two dimensional max pooling with indices.

fn max_pool2d_with_indices_backward( x: FloatTensor<Host>, _kernel_size: [usize; 2], _stride: [usize; 2], _padding: [usize; 2], _dilation: [usize; 2], _ceil_mode: bool, output_grad: FloatTensor<Host>, indices: IntTensor<Host>, ) -> MaxPool2dBackward<Host>

Backward pass for the max pooling 2d operation.

fn interpolate( x: FloatTensor<Host>, output_size: [usize; 2], options: InterpolateOptions, ) -> FloatTensor<Host>

Down/up samples the input.

fn interpolate_backward( x: FloatTensor<Host>, grad: FloatTensor<Host>, output_size: [usize; 2], options: InterpolateOptions, ) -> FloatTensor<Host>

Backward pass for the interpolate operation.

fn attention( query: FloatTensor<Host>, key: FloatTensor<Host>, value: FloatTensor<Host>, mask: Option<BoolTensor<Host>>, attn_bias: Option<FloatTensor<Host>>, options: AttentionModuleOptions, ) -> FloatTensor<Host>

Computes scaled dot-product attention: softmax(QKᵗ * scale) · V, where scale defaults to 1/sqrt(head_dim). Optionally applies masking, additive bias, causal masking, and softcap to the attention scores.

fn rfft( signal: FloatTensor<Host>, dim: usize, n: Option<usize>, ) -> (FloatTensor<Host>, FloatTensor<Host>)

Real-valued FFT with optional size parameter.

fn irfft( spectrum_re: FloatTensor<Host>, spectrum_im: FloatTensor<Host>, dim: usize, n: Option<usize>, ) -> FloatTensor<Host>

Inverse real-valued FFT with optional output size.

fn embedding( weights: FloatTensor<Host>, indices: IntTensor<Host>, ) -> FloatTensor<Host>

Embedding operation.

fn layer_norm( tensor: FloatTensor<Host>, gamma: FloatTensor<Host>, beta: Option<FloatTensor<Host>>, epsilon: f64, ) -> FloatTensor<Host>

Applies Layer Normalization over the last dimension of the input tensor.

fn embedding_backward( weights: FloatTensor<Host>, output_grad: FloatTensor<Host>, indices: IntTensor<Host>, ) -> FloatTensor<Host>

Embedding backward operation.

fn batch_norm( x: <B as BackendTypes>::FloatTensorPrimitive, gamma: <B as BackendTypes>::FloatTensorPrimitive, beta: <B as BackendTypes>::FloatTensorPrimitive, mean: <B as BackendTypes>::FloatTensorPrimitive, variance: <B as BackendTypes>::FloatTensorPrimitive, epsilon: f64, ) -> <B as BackendTypes>::FloatTensorPrimitive

Normalize [batch, channels, ...] using supplied [channels] statistics.

fn batch_norm_train( x: <B as BackendTypes>::FloatTensorPrimitive, gamma: <B as BackendTypes>::FloatTensorPrimitive, beta: <B as BackendTypes>::FloatTensorPrimitive, epsilon: f64, ) -> BatchNormTrain<B>

Normalize using batch statistics, returning the mean and biased variance. Autodiff differentiates the output as one operation and detaches the statistics.

fn batch_norm_train_backward( x: <B as BackendTypes>::FloatTensorPrimitive, gamma: <B as BackendTypes>::FloatTensorPrimitive, mean: <B as BackendTypes>::FloatTensorPrimitive, variance: <B as BackendTypes>::FloatTensorPrimitive, epsilon: f64, output_grad: <B as BackendTypes>::FloatTensorPrimitive, ) -> BatchNormTrainBackward<B>

Differentiate the normalized output using its saved batch mean and variance.

fn exponential_relu_native( tensor: <B as BackendTypes>::FloatTensorPrimitive, alpha: f64, continuous: bool, ) -> <B as BackendTypes>::FloatTensorPrimitive

Working-storage ELU, or CELU when continuous is true, using the original alpha.

fn exponential_relu_native_backward( tensor: <B as BackendTypes>::FloatTensorPrimitive, grad: <B as BackendTypes>::FloatTensorPrimitive, alpha: f64, continuous: bool, ) -> <B as BackendTypes>::FloatTensorPrimitive

Original selected ELU/CELU mode’s independent first-order input derivative.

fn leaky_relu_native( tensor: <B as BackendTypes>::FloatTensorPrimitive, negative_slope: f64, ) -> <B as BackendTypes>::FloatTensorPrimitive

Working-storage LeakyReLU using the actual scalar negative slope.

fn leaky_relu_native_backward( tensor: <B as BackendTypes>::FloatTensorPrimitive, grad: <B as BackendTypes>::FloatTensorPrimitive, negative_slope: f64, ) -> <B as BackendTypes>::FloatTensorPrimitive

Independent first-order VJP, using the original primal to select the branch.

fn prelu_native( tensor: <B as BackendTypes>::FloatTensorPrimitive, alpha: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Working-storage PReLU with the original shared or per-channel slope vector.

fn prelu_native_backward_select( tensor: <B as BackendTypes>::FloatTensorPrimitive, alpha: <B as BackendTypes>::FloatTensorPrimitive, grad: <B as BackendTypes>::FloatTensorPrimitive, mask: [bool; 2], ) -> [Option<<B as BackendTypes>::FloatTensorPrimitive>; 2]

Independently requested original-input and slope derivatives.

fn group_norm( tensor: <B as BackendTypes>::FloatTensorPrimitive, gamma: Option<<B as BackendTypes>::FloatTensorPrimitive>, beta: Option<<B as BackendTypes>::FloatTensorPrimitive>, groups: usize, epsilon: f64, ) -> <B as BackendTypes>::FloatTensorPrimitive

Native GroupNorm on actual channel groups with independently optional affine leaves.

fn group_norm_with_stats( tensor: <B as BackendTypes>::FloatTensorPrimitive, gamma: Option<<B as BackendTypes>::FloatTensorPrimitive>, beta: Option<<B as BackendTypes>::FloatTensorPrimitive>, groups: usize, epsilon: f64, ) -> LayerNormOutput<B>

GroupNorm output and FP32/FP64 saved [batch, groups] mean/reciprocal deviation.

fn group_norm_backward_select( tensor: <B as BackendTypes>::FloatTensorPrimitive, gamma: Option<<B as BackendTypes>::FloatTensorPrimitive>, grad: <B as BackendTypes>::FloatTensorPrimitive, mean: <B as BackendTypes>::FloatTensorPrimitive, rstd: <B as BackendTypes>::FloatTensorPrimitive, groups: usize, mask: [bool; 3], ) -> [Option<<B as BackendTypes>::FloatTensorPrimitive>; 3]

Only requested original input, actual weight and bias derivatives, in that order.

fn gelu_native( tensor: <B as BackendTypes>::FloatTensorPrimitive, approximate: bool, ) -> <B as BackendTypes>::FloatTensorPrimitive

Explicit native GELU preserving the caller’s original erf/tanh approximation choice.

fn gelu_native_backward( input: <B as BackendTypes>::FloatTensorPrimitive, grad: <B as BackendTypes>::FloatTensorPrimitive, approximate: bool, ) -> <B as BackendTypes>::FloatTensorPrimitive

Independent first-order GELU VJP in the same selected erf/tanh mode.

fn silu_native( tensor: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Explicit native SiLU training path, using FP32 for half activation arithmetic.

fn silu_native_backward( input: <B as BackendTypes>::FloatTensorPrimitive, grad: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Independent first-order SiLU VJP, retaining the original input storage.

fn softmax_native( tensor: <B as BackendTypes>::FloatTensorPrimitive, dim: usize, logarithmic: bool, ) -> <B as BackendTypes>::FloatTensorPrimitive

Explicit saved-working-output softmax path; existing activation defaults are unchanged.

fn softmax_with_stats( tensor: <B as BackendTypes>::FloatTensorPrimitive, dim: usize, logarithmic: bool, ) -> SoftmaxOutput<B>

Softmax/log-softmax retaining its working output, with FP32 low-precision arithmetic.

fn softmax_native_backward( working: <B as BackendTypes>::FloatTensorPrimitive, grad: <B as BackendTypes>::FloatTensorPrimitive, dim: usize, logarithmic: bool, ) -> <B as BackendTypes>::FloatTensorPrimitive

VJP from the saved working output, retaining FP64 if either argument uses FP64.

fn linear( x: <B as BackendTypes>::FloatTensorPrimitive, weight: <B as BackendTypes>::FloatTensorPrimitive, bias: Option<<B as BackendTypes>::FloatTensorPrimitive>, ) -> <B as BackendTypes>::FloatTensorPrimitive

Linear transformation.

fn linear_x_backward( weight: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for linear, returning the gradient for x.

fn linear_weight_backward( x: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for linear, returning the gradient for weight.

fn linear_bias_backward( output_grad: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for linear, returning the gradient for bias.

fn conv1d_x_backward( x: <B as BackendTypes>::FloatTensorPrimitive, weight: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, options: ConvOptions<1>, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv1d operation, returning the gradient for x.

fn conv1d_weight_backward( x: <B as BackendTypes>::FloatTensorPrimitive, weight: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, options: ConvOptions<1>, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv1d operation, returning the gradient for weight.

fn conv1d_bias_backward( x: <B as BackendTypes>::FloatTensorPrimitive, bias: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv1d operation, returning the gradient for bias.

fn conv2d_x_backward( x: <B as BackendTypes>::FloatTensorPrimitive, weight: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, options: ConvOptions<2>, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv2d operation, returning the gradient for x.

fn conv2d_weight_backward( x: <B as BackendTypes>::FloatTensorPrimitive, weight: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, options: ConvOptions<2>, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv2d operation, returning the gradient for weight.

fn conv2d_bias_backward( x: <B as BackendTypes>::FloatTensorPrimitive, bias: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv2d operation, returning the gradient for bias.

fn conv3d_x_backward( x: <B as BackendTypes>::FloatTensorPrimitive, weight: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, options: ConvOptions<3>, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv3d operation, returning the gradient for x.

fn conv3d_weight_backward( x: <B as BackendTypes>::FloatTensorPrimitive, weight: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, options: ConvOptions<3>, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv3d operation, returning the gradient for weight.

fn conv3d_bias_backward( x: <B as BackendTypes>::FloatTensorPrimitive, bias: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv3d operation, returning the gradient for bias.

fn conv_transpose1d_x_backward( weight: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, options: ConvTransposeOptions<1>, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv transpose 1d operation, returning the gradient for x.

fn conv_transpose1d_weight_backward( x: <B as BackendTypes>::FloatTensorPrimitive, weight: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, options: ConvTransposeOptions<1>, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv transpose 1d operation, returning the gradient for weight.

fn conv_transpose1d_bias_backward( x: <B as BackendTypes>::FloatTensorPrimitive, bias: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv transpose 1d operation, returning the gradient for bias.

fn conv_transpose2d_x_backward( weight: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, options: ConvTransposeOptions<2>, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv transpose 2d operation, returning the gradient for x.

fn conv_transpose2d_weight_backward( x: <B as BackendTypes>::FloatTensorPrimitive, weight: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, options: ConvTransposeOptions<2>, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv transpose 2d operation, returning the gradient for weight.

fn conv_transpose2d_bias_backward( x: <B as BackendTypes>::FloatTensorPrimitive, bias: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv transpose 2d operation, returning the gradient for bias.

fn conv_transpose3d_x_backward( weight: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, options: ConvTransposeOptions<3>, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv transpose 3d operation, returning the gradient for x.

fn conv_transpose3d_weight_backward( x: <B as BackendTypes>::FloatTensorPrimitive, weight: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, options: ConvTransposeOptions<3>, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv transpose 3d operation, returning the gradient for weight.

fn conv_transpose3d_bias_backward( x: <B as BackendTypes>::FloatTensorPrimitive, bias: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv transpose 3d operation, returning the gradient for bias.

fn unfold4d( x: <B as BackendTypes>::FloatTensorPrimitive, kernel_size: [usize; 2], options: UnfoldOptions, ) -> <B as BackendTypes>::FloatTensorPrimitive

Four-dimensional unfolding.

fn fold4d( x: <B as BackendTypes>::FloatTensorPrimitive, output_size: [usize; 2], kernel_size: [usize; 2], options: UnfoldOptions, ) -> <B as BackendTypes>::FloatTensorPrimitive

Fold [batch, channels * kernel_area, blocks] into NCHW, summing overlaps. The grouped one-hot transposed convolution is the adjoint of Self::unfold4d.

fn avg_pool1d( x: <B as BackendTypes>::FloatTensorPrimitive, kernel_size: usize, stride: usize, padding: usize, count_include_pad: bool, ceil_mode: bool, ) -> <B as BackendTypes>::FloatTensorPrimitive

One dimensional avg pooling.

fn avg_pool1d_backward( x: <B as BackendTypes>::FloatTensorPrimitive, grad: <B as BackendTypes>::FloatTensorPrimitive, kernel_size: usize, stride: usize, padding: usize, count_include_pad: bool, ceil_mode: bool, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the avg pooling 1d operation.

fn avg_pool3d( x: <B as BackendTypes>::FloatTensorPrimitive, kernel_size: [usize; 3], stride: [usize; 3], padding: [usize; 3], count_include_pad: bool, ceil_mode: bool, ) -> <B as BackendTypes>::FloatTensorPrimitive

Three dimensional average pooling of [batch, channels, depth, height, width].

fn avg_pool3d_native_output_size( _input: [usize; 3], _kernel: [usize; 3], _stride: [usize; 3], _padding: [usize; 3], _ceil: bool, ) -> Option<[usize; 3]>

Native volume output geometry, or None to retain the backend’s composed operations.

fn avg_pool3d_backward( x: <B as BackendTypes>::FloatTensorPrimitive, grad: <B as BackendTypes>::FloatTensorPrimitive, kernel_size: [usize; 3], stride: [usize; 3], padding: [usize; 3], count_include_pad: bool, ceil_mode: bool, ) -> <B as BackendTypes>::FloatTensorPrimitive

Input gradients for three dimensional average pooling.

fn adaptive_avg_pool3d( x: <B as BackendTypes>::FloatTensorPrimitive, output_size: [usize; 3], ) -> <B as BackendTypes>::FloatTensorPrimitive

Three dimensional adaptive average pooling of [batch, channels, depth, height, width].

fn adaptive_avg_pool3d_backward( x: <B as BackendTypes>::FloatTensorPrimitive, grad: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Input gradients for native three dimensional adaptive average pooling.

fn max_pool3d( x: <B as BackendTypes>::FloatTensorPrimitive, kernel: [usize; 3], stride: [usize; 3], padding: [usize; 3], dilation: [usize; 3], ceil: bool, ) -> <B as BackendTypes>::FloatTensorPrimitive

Three dimensional maximum pooling with native padding, stride and dilation.

fn max_pool3d_with_indices( x: <B as BackendTypes>::FloatTensorPrimitive, kernel: [usize; 3], stride: [usize; 3], padding: [usize; 3], dilation: [usize; 3], ceil: bool, ) -> MaxPool3dWithIndices<B>

Volume maxima and original input positions.

fn max_pool3d_with_indices_backward( x: <B as BackendTypes>::FloatTensorPrimitive, grad: <B as BackendTypes>::FloatTensorPrimitive, indices: <B as BackendTypes>::IntTensorPrimitive, _kernel: [usize; 3], _stride: [usize; 3], _padding: [usize; 3], _dilation: [usize; 3], _ceil: bool, ) -> MaxPool3dBackward<B>

Accumulate volume gradients through the saved maximum positions.

fn adaptive_avg_pool1d( x: <B as BackendTypes>::FloatTensorPrimitive, output_size: usize, ) -> <B as BackendTypes>::FloatTensorPrimitive

One dimensional adaptive avg pooling.

fn adaptive_avg_pool1d_backward( x: <B as BackendTypes>::FloatTensorPrimitive, grad: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the adaptive avg pooling 1d operation.

fn max_pool1d( x: <B as BackendTypes>::FloatTensorPrimitive, kernel_size: usize, stride: usize, padding: usize, dilation: usize, ceil_mode: bool, ) -> <B as BackendTypes>::FloatTensorPrimitive

One dimensional max pooling.

fn max_pool1d_with_indices( x: <B as BackendTypes>::FloatTensorPrimitive, kernel_size: usize, stride: usize, padding: usize, dilation: usize, ceil_mode: bool, ) -> MaxPool1dWithIndices<B>

One dimensional max pooling with indices.

fn max_pool1d_with_indices_backward( x: <B as BackendTypes>::FloatTensorPrimitive, kernel_size: usize, stride: usize, padding: usize, dilation: usize, ceil_mode: bool, output_grad: <B as BackendTypes>::FloatTensorPrimitive, indices: <B as BackendTypes>::IntTensorPrimitive, ) -> MaxPool1dBackward<B>

Backward pass for the max pooling 1d operation.

fn interpolate1d( x: <B as BackendTypes>::FloatTensorPrimitive, size: usize, options: InterpolateOptions, ) -> <B as BackendTypes>::FloatTensorPrimitive

Resize native [batch, channels, width] lines with the original filter.

fn interpolate1d_backward( x: <B as BackendTypes>::FloatTensorPrimitive, grad: <B as BackendTypes>::FloatTensorPrimitive, size: usize, options: InterpolateOptions, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward line resizing in the original input geometry and storage.

fn interpolate3d( x: <B as BackendTypes>::FloatTensorPrimitive, size: [usize; 3], options: InterpolateOptions, ) -> <B as BackendTypes>::FloatTensorPrimitive

Resize native volumes using the existing spatial-then-depth filter sequence.

fn interpolate3d_backward( x: <B as BackendTypes>::FloatTensorPrimitive, grad: <B as BackendTypes>::FloatTensorPrimitive, size: [usize; 3], options: InterpolateOptions, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward volume resizing through the original spatial and depth filters.

fn has_layer_norm_backward() -> bool

Whether native forward statistics and complete first-order backward are available.

fn has_rms_norm_backward() -> bool

Whether saved RMSNorm statistics and complete first-order backward are available.

fn rms_norm( tensor: <B as BackendTypes>::FloatTensorPrimitive, gamma: <B as BackendTypes>::FloatTensorPrimitive, epsilon: f64, ) -> <B as BackendTypes>::FloatTensorPrimitive

Last-axis RMSNorm with working arithmetic and one final output-storage cast.

fn rms_norm_with_stats( tensor: <B as BackendTypes>::FloatTensorPrimitive, gamma: <B as BackendTypes>::FloatTensorPrimitive, epsilon: f64, ) -> RmsNormOutput<B>

RMSNorm forward retaining reciprocal row norms for backward.

fn rms_norm_backward( tensor: <B as BackendTypes>::FloatTensorPrimitive, gamma: <B as BackendTypes>::FloatTensorPrimitive, grad: <B as BackendTypes>::FloatTensorPrimitive, rstd: <B as BackendTypes>::FloatTensorPrimitive, ) -> RmsNormBackward<B>

RMSNorm derivatives from saved reciprocal row norms, without repeating forward.

fn rms_norm_backward_select( tensor: <B as BackendTypes>::FloatTensorPrimitive, gamma: <B as BackendTypes>::FloatTensorPrimitive, grad: <B as BackendTypes>::FloatTensorPrimitive, rstd: <B as BackendTypes>::FloatTensorPrimitive, mask: [bool; 2], ) -> [Option<<B as BackendTypes>::FloatTensorPrimitive>; 2]

RMSNorm input and weight gradients selected by the two corresponding mask entries.

fn layer_norm_with_stats( tensor: <B as BackendTypes>::FloatTensorPrimitive, gamma: <B as BackendTypes>::FloatTensorPrimitive, beta: Option<<B as BackendTypes>::FloatTensorPrimitive>, epsilon: f64, ) -> LayerNormOutput<B>

Native forward with statistics retained for backward.

fn layer_norm_backward( tensor: <B as BackendTypes>::FloatTensorPrimitive, gamma: <B as BackendTypes>::FloatTensorPrimitive, grad: <B as BackendTypes>::FloatTensorPrimitive, mean: <B as BackendTypes>::FloatTensorPrimitive, rstd: <B as BackendTypes>::FloatTensorPrimitive, ) -> LayerNormBackward<B>

Native backward using the exact statistics returned by forward.

fn layer_norm_backward_select( tensor: <B as BackendTypes>::FloatTensorPrimitive, gamma: <B as BackendTypes>::FloatTensorPrimitive, grad: <B as BackendTypes>::FloatTensorPrimitive, mean: <B as BackendTypes>::FloatTensorPrimitive, rstd: <B as BackendTypes>::FloatTensorPrimitive, mask: [bool; 3], ) -> [Option<<B as BackendTypes>::FloatTensorPrimitive>; 3]

LayerNorm input, weight and bias gradients selected in that order.

fn layer_norm_default( tensor: <B as BackendTypes>::FloatTensorPrimitive, gamma: <B as BackendTypes>::FloatTensorPrimitive, beta: Option<<B as BackendTypes>::FloatTensorPrimitive>, epsilon: f64, ) -> <B as BackendTypes>::FloatTensorPrimitive

Differentiable primitive composition for backends without native LayerNorm backward.

fn ctc_loss( log_probs: <B as BackendTypes>::FloatTensorPrimitive, targets: <B as BackendTypes>::IntTensorPrimitive, input_lengths: <B as BackendTypes>::IntTensorPrimitive, target_lengths: <B as BackendTypes>::IntTensorPrimitive, blank: usize, ) -> <B as BackendTypes>::FloatTensorPrimitive

Computes the Connectionist Temporal Classification (CTC) loss.

fn has_ctc_loss_backward() -> bool

Returns true if this backend implements ctc_loss_backward natively.

fn ctc_loss_backward( _log_probs: <B as BackendTypes>::FloatTensorPrimitive, _targets: <B as BackendTypes>::IntTensorPrimitive, _input_lengths: <B as BackendTypes>::IntTensorPrimitive, _target_lengths: <B as BackendTypes>::IntTensorPrimitive, _grad_loss: <B as BackendTypes>::FloatTensorPrimitive, _blank: usize, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for ctc_loss: gradient w.r.t. log_probs.

impl QTensorOps<Host> for Host

fn q_from_data( data: TensorData, _device: &Device<Host>, ) -> QuantizedTensor<Host>

Creates a new tensor from the data structure.

fn quantize_dynamic( tensor: FloatTensor<Host>, scheme: &QuantScheme, ) -> QuantizedTensor<Host>

Dynamically convert the tensor to a lower precision data type based on the quantization scheme.

fn quantize( tensor: FloatTensor<Host>, scheme: &QuantScheme, qparams: QuantizationParametersPrimitive<Host>, ) -> QuantizedTensor<Host>

Convert the tensor to a lower precision data type based on the quantization scheme and parameters.

fn dequantize( tensor: QuantizedTensor<Host>, dtype: FloatDType, ) -> FloatTensor<Host>

Convert the tensor back to a higher precision data type.

fn q_device(_tensor: &QuantizedTensor<Host>) -> Device<Host>

Gets the device of the tensor.

fn q_to_device( tensor: QuantizedTensor<Host>, _device: &Device<Host>, ) -> QuantizedTensor<Host>

Moves the tensor to the given device.

fn q_reshape( tensor: QuantizedTensor<Host>, shape: Shape, ) -> QuantizedTensor<Host>

Reshapes a tensor.

async fn q_into_data( tensor: QuantizedTensor<Host>, ) -> Result<TensorData, ExecutionError>

Converts the tensor to a data structure.

fn q_swap_dims( tensor: QuantizedTensor<Host>, dim1: usize, dim2: usize, ) -> QuantizedTensor<Host>

Swaps two dimensions of a tensor.

fn q_permute( tensor: QuantizedTensor<Host>, axes: &[usize], ) -> QuantizedTensor<Host>

Permutes the dimensions of a tensor.

fn q_flip( tensor: QuantizedTensor<Host>, axes: &[usize], ) -> QuantizedTensor<Host>

Reverse the order of elements in a tensor along the given axes.

fn q_expand( tensor: QuantizedTensor<Host>, shape: Shape, ) -> QuantizedTensor<Host>

Broadcasts the tensor to the given shape.

fn q_select( tensor: QuantizedTensor<Host>, dim: usize, indices: IntTensor<Host>, ) -> QuantizedTensor<Host>

Select tensor elements along the given dimension corresponding for the given indices.

fn q_slice( tensor: QuantizedTensor<Host>, slices: &[Slice], ) -> QuantizedTensor<Host>

Select tensor elements corresponding to the given slices.

fn q_gather( dim: usize, tensor: QuantizedTensor<Host>, indices: IntTensor<Host>, ) -> QuantizedTensor<Host>

Gather elements from a tensor.

fn quantize_dynamic_with_precision( tensor: <B as BackendTypes>::FloatTensorPrimitive, scheme: &QuantScheme, calibration_dtype: FloatDType, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Explicit calibration arithmetic independent of the original input and packed parameter storage. Quantizes the original input rather than its calibration copy, retaining the selected scheme.

fn q_detach( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Detaches a tensor from the computation graph.

fn q_set_require_grad( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, _require_grad: bool, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Sets the require_grad flag of a tensor.

fn q_is_require_grad( _tensor: &<B as BackendTypes>::QuantizedTensorPrimitive, ) -> bool

Returns the require_grad flag of a tensor.

fn q_is_tracked(tensor: &<B as BackendTypes>::QuantizedTensorPrimitive) -> bool

Graph participation of a differentiable quantized surrogate, if supported.

fn q_gradient_checkpointing_strategy( _tensor: &<B as BackendTypes>::QuantizedTensorPrimitive, ) -> Option<GradientCheckpointingStrategy>

The checkpointing policy attached to this quantized tensor.

fn q_autodiff_context( tensor: &<B as BackendTypes>::QuantizedTensorPrimitive, ) -> AutodiffContext

Runtime autodiff association of quantized storage and its optional surrogate.

fn q_with_autodiff_context( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, context: AutodiffContext, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Change runtime association without converting the quantized payload.

fn q_with_gradient_checkpointing_strategy( _tensor: <B as BackendTypes>::QuantizedTensorPrimitive, _strategy: GradientCheckpointingStrategy, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Override checkpointing without changing quantized storage or surrogate history.

fn q_transpose( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Transposes a tensor.

fn q_repeat_dim( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, times: usize, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Repeat the tensor along the given dimension.

fn q_add( lhs: <B as BackendTypes>::QuantizedTensorPrimitive, rhs: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Adds two tensors together.

fn q_add_scalar( lhs: <B as BackendTypes>::QuantizedTensorPrimitive, rhs: Scalar, ) -> TensorPrimitive<B>

Adds a scalar to a tensor.

fn q_clamp_min( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, min: Scalar, ) -> TensorPrimitive<B>

Clamps a tensor under a minimum value.

fn q_clamp_max( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, max: Scalar, ) -> TensorPrimitive<B>

Clamps a tensor over a maximum value.

fn q_clamp( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, min: Scalar, max: Scalar, ) -> TensorPrimitive<B>

Clamps a tensor between a minimum and maximum value.

fn q_sub( lhs: <B as BackendTypes>::QuantizedTensorPrimitive, rhs: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Subtracts two tensors.

fn q_sub_scalar( lhs: <B as BackendTypes>::QuantizedTensorPrimitive, rhs: Scalar, ) -> TensorPrimitive<B>

Subtracts a scalar from a tensor.

fn q_mul( lhs: <B as BackendTypes>::QuantizedTensorPrimitive, rhs: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Multiplies two tensors together element-wise.

fn q_mul_scalar( lhs: <B as BackendTypes>::QuantizedTensorPrimitive, rhs: Scalar, ) -> TensorPrimitive<B>

Multiplies a tensor by a scalar.

fn q_div( lhs: <B as BackendTypes>::QuantizedTensorPrimitive, rhs: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Divides two tensors element-wise.

fn q_div_scalar( lhs: <B as BackendTypes>::QuantizedTensorPrimitive, rhs: Scalar, ) -> TensorPrimitive<B>

Divides a tensor by a scalar.

fn q_matmul( lhs: TensorPrimitive<B>, rhs: TensorPrimitive<B>, ) -> TensorPrimitive<B>

Multiplies two tensors together using matrix multiplication.

fn q_matmul_default( lhs: TensorPrimitive<B>, rhs: TensorPrimitive<B>, ) -> TensorPrimitive<B>

Existing dequantized arithmetic and propagation contract for unsupported native combinations.

fn q_neg( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Negates a tensor element-wise.

fn q_recip( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Calculates the reciprocals element-wise

fn q_sum( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Sum of all elements in a tensor.

fn q_sum_dim( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, ) -> TensorPrimitive<B>

Sum of all elements in a tensor along a dimension.

fn q_prod( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Product of all elements in a tensor.

fn q_prod_dim( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, ) -> TensorPrimitive<B>

Product of all elements in a tensor along a dimension.

fn q_mean( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Mean of all elements in a tensor.

fn q_mean_dim( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, ) -> TensorPrimitive<B>

Mean of all elements in a tensor along a dimension.

fn q_cumsum( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, ) -> TensorPrimitive<B>

Computes the cumulative sum of elements along a dimension.

fn q_cumprod( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, ) -> TensorPrimitive<B>

Computes the cumulative product of elements along a dimension.

fn q_cummin( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, ) -> TensorPrimitive<B>

Computes the cumulative minimum of elements along a dimension.

fn q_cummax( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, ) -> TensorPrimitive<B>

Computes the cumulative maximum of elements along a dimension.

fn q_exp( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Returns a new tensor with exponential values.

fn q_log( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Returns a new tensor with natural logarithm values.

fn q_log1p( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Returns a new tensor with logarithm values of (1 + Xi).

fn q_powf( lhs: <B as BackendTypes>::QuantizedTensorPrimitive, rhs: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Element-wise power with another tensor.

fn q_powi( lhs: <B as BackendTypes>::QuantizedTensorPrimitive, rhs: <B as BackendTypes>::IntTensorPrimitive, ) -> TensorPrimitive<B>

Element-wise power with an IntTensor.

fn q_powi_scalar( lhs: <B as BackendTypes>::QuantizedTensorPrimitive, rhs: Scalar, ) -> TensorPrimitive<B>

Element-wise power with an int scalar.

fn q_powf_scalar( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, value: Scalar, ) -> TensorPrimitive<B>

Element-wise power with a float scalar.

fn q_sqrt( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Returns a new tensor with square root values.

fn q_abs( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Returns a new tensor with absolute values.

fn q_cos( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Returns a new tensor with cosine values.

fn q_sin( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Returns a new tensor with sine values.

fn q_tan( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Returns a new tensor with tangent values.

fn q_cosh( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Returns a new tensor with hyperbolic cosine values.

fn q_sinh( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Returns a new tensor with hyperbolic sine values.

fn q_tanh( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Returns a new tensor with hyperbolic tangent values.

fn q_erf( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Returns a new tensor with the error function values.

fn q_cat( tensors: Vec<<B as BackendTypes>::QuantizedTensorPrimitive>, dim: usize, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Concatenates tensors along a dimension.

fn q_argmax( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, out_dtype: IntDType, ) -> <B as BackendTypes>::IntTensorPrimitive

Gets the indices of the maximum elements of a tensor along an axis.

fn q_argtopk( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, k: usize, out_dtype: IntDType, ) -> <B as BackendTypes>::IntTensorPrimitive

Gets the indices of the k maximum elements of a tensor along an axis. If two elements are equals, order them by the lowest indices

fn q_topk( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, k: usize, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Gets the values of the k maximum elements of a tensor along an axis.

fn q_argmin( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, out_dtype: IntDType, ) -> <B as BackendTypes>::IntTensorPrimitive

Gets the indices of the minimum elements of a tensor along an axis.

fn q_max( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Gets the maximum element of a tensor.

fn q_max_dim( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Gets the maximum elements of a tensor along an axis.

fn q_max_dim_with_indices( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, out_dtype: IntDType, ) -> (<B as BackendTypes>::QuantizedTensorPrimitive, <B as BackendTypes>::IntTensorPrimitive)

Gets the maximum elements of a tensor along an axis and their indices.

fn q_min( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Gets the minimum element of a tensor.

fn q_min_dim( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Gets the minimum elements of a tensor along an axis.

fn q_min_dim_with_indices( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, out_dtype: IntDType, ) -> (<B as BackendTypes>::QuantizedTensorPrimitive, <B as BackendTypes>::IntTensorPrimitive)

Gets the minimum elements of a tensor along an axis and their indices.

fn q_max_abs( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Gets the maximum element of a tensor.

fn q_max_abs_dim( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Gets the maximum elements of a tensor along an axis.

fn q_any( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Tests if any element in the tensor evaluates to True.

fn q_any_dim( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Tests if any element in the float tensor evaluates to True along a given dimension dim.

fn q_all( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Tests if all elements in the tensor evaluate to True.

fn q_all_dim( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Tests if all elements in the tensor evaluate to True along a given dimension dim.

fn q_sort( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, descending: bool, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Sort the elements of the input tensor by value in along a given dimension.

fn q_sort_with_indices( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, descending: bool, out_dtype: IntDType, ) -> (<B as BackendTypes>::QuantizedTensorPrimitive, <B as BackendTypes>::IntTensorPrimitive)

Sort the elements of the input tensor by value in along a given dimension.

fn q_argsort( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, descending: bool, out_dtype: IntDType, ) -> <B as BackendTypes>::IntTensorPrimitive

Returns the indices that sort the elements of the input tensor by value along a given dimension.

impl TransactionOps<Host> for Host

fn tr_execute( transaction: TransactionPrimitive<B>, ) -> impl Future<Output = Result<TransactionData, ExecutionError>> + Send

Executes a transaction and return its data.