Struct NdArray

pub struct NdArray<E = f32, I = i64, Q = i8> { /* private fields */ }

Tensor backend that uses the ndarray crate for executing tensor operations.

This backend is compatible with CPUs and can be compiled for almost any platform, including wasm, arm, and x86.

Trait Implementations

impl<E: FloatNdArrayElement, I: IntNdArrayElement, Q: QuantElement> ActivationOps<NdArray<E, I, Q>> for NdArray<E, I, Q>

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

Applies the ReLU activation function.

fn leaky_relu( tensor: <B as Backend>::FloatTensorPrimitive, negative_slope: <B as Backend>::FloatElem, ) -> <B as Backend>::FloatTensorPrimitive

Applies the LeakyReLU activation function.

fn relu_backward( output: <B as Backend>::FloatTensorPrimitive, grad: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Applies the ReLU activation function backward.

fn gelu( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Applies the Gelu activation function.

fn prelu( tensor: <B as Backend>::FloatTensorPrimitive, alpha: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Applies the PReLu activation function.

fn gelu_backward( x: <B as Backend>::FloatTensorPrimitive, grad: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Applies the Gelu activation function backward.

fn sigmoid( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Applies the Sigmoid activation function.

fn sigmoid_backward( output: <B as Backend>::FloatTensorPrimitive, grad: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Applies the Sigmoid activation function backward.

fn hard_sigmoid( tensor: <B as Backend>::FloatTensorPrimitive, alpha: <B as Backend>::FloatElem, beta: <B as Backend>::FloatElem, ) -> <B as Backend>::FloatTensorPrimitive

Applies the hard Sigmoid activation function.

fn log_sigmoid( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Applies the LogSigmoid activation function.

fn log_sigmoid_backward( x: <B as Backend>::FloatTensorPrimitive, grad: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Applies the LogSigmoid activation function backward.

impl<E: FloatNdArrayElement, I: IntNdArrayElement, Q: QuantElement> Backend for NdArray<E, I, Q>

type Device = NdArrayDevice

Device type.

type FloatTensorPrimitive = NdArrayTensorFloat

Tensor primitive to be used for all float operations.

type FloatElem = E

Default float element type.

type IntTensorPrimitive = NdArrayTensor<I>

Tensor primitive to be used for all int operations.

type IntElem = I

Int element type.

type BoolTensorPrimitive = NdArrayTensor<bool>

Tensor primitive to be used for all bool operations.

type BoolElem = bool

Tensor primitive to be used for all bool operations.

type QuantizedTensorPrimitive = NdArrayQTensor<Q>

Tensor primitive to be used for all quantized operations.

type QuantizedEncoding = Q

Quantized tensor encoding type.

fn ad_enabled() -> bool

If autodiff is enabled.

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

Name of the backend.

fn seed(seed: u64)

Seed the backend.

fn sync(_device: &Self::Device)

Sync the backend, ensure that all computation are finished.

impl<E: FloatNdArrayElement, I: IntNdArrayElement, Q: QuantElement> BackendIr for NdArray<E, I, Q>

type Handle = HandleKind<NdArray<E, I, Q>>

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

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

Convert a handle to a float tensor.

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

Convert a handle to an int tensor.

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

Convert a handle to a bool tensor.

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

Convert a handle to a quantized tensor.

fn float_tensor_handle(tensor: FloatTensor<Self>) -> Self::Handle

Convert a float tensor to a handle.

fn int_tensor_handle(tensor: IntTensor<Self>) -> Self::Handle

Convert an int tensor to a handle.

fn bool_tensor_handle(tensor: BoolTensor<Self>) -> Self::Handle

Convert a bool tensor to a handle.

fn quantized_tensor_handle(tensor: QuantizedTensor<Self>) -> Self::Handle

Convert a quantized tensor to a handle.

impl<E: FloatNdArrayElement, I: IntNdArrayElement, Q: QuantElement> BoolTensorOps<NdArray<E, I, Q>> for NdArray<E, I, Q>

fn bool_from_data( data: TensorData, _device: &NdArrayDevice, ) -> NdArrayTensor<bool>

Creates a tensor from the data structure.

async fn bool_into_data(tensor: NdArrayTensor<bool>) -> TensorData

Converts the tensor to a data structure.

fn bool_to_device( tensor: NdArrayTensor<bool>, _device: &NdArrayDevice, ) -> NdArrayTensor<bool>

Moves the tensor to the device.

fn bool_reshape( tensor: NdArrayTensor<bool>, shape: Shape, ) -> NdArrayTensor<bool>

Reshapes the tensor.

fn bool_slice( tensor: NdArrayTensor<bool>, ranges: &[Range<usize>], ) -> NdArrayTensor<bool>

Gets the values from the tensor for the given ranges.

fn bool_into_int(tensor: NdArrayTensor<bool>) -> NdArrayTensor<I>

Converts bool tensor to int tensor.

fn bool_device(_tensor: &NdArrayTensor<bool>) -> <NdArray<E> as Backend>::Device

Gets the device of the tensor.

fn bool_empty( shape: Shape, _device: &<NdArray<E> as Backend>::Device, ) -> NdArrayTensor<bool>

Creates a new bool tensor.

fn bool_slice_assign( tensor: NdArrayTensor<bool>, ranges: &[Range<usize>], value: NdArrayTensor<bool>, ) -> NdArrayTensor<bool>

Sets the values in the tensor for the given ranges.

fn bool_cat( tensors: Vec<NdArrayTensor<bool>>, dim: usize, ) -> NdArrayTensor<bool>

Concatenates the tensors along the given dimension.

fn bool_equal( lhs: NdArrayTensor<bool>, rhs: NdArrayTensor<bool>, ) -> NdArrayTensor<bool>

Equates the two tensors.

fn bool_not(tensor: NdArrayTensor<bool>) -> NdArrayTensor<bool>

Inverses boolean values.

fn bool_and( lhs: NdArrayTensor<bool>, rhs: NdArrayTensor<bool>, ) -> NdArrayTensor<bool>

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

fn bool_or( lhs: NdArrayTensor<bool>, rhs: NdArrayTensor<bool>, ) -> NdArrayTensor<bool>

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

fn bool_into_float(tensor: NdArrayTensor<bool>) -> FloatTensor<Self>

Converts bool tensor to float tensor.

fn bool_swap_dims( tensor: NdArrayTensor<bool>, dim1: usize, dim2: usize, ) -> NdArrayTensor<bool>

Swaps two dimensions of a bool tensor.

fn bool_permute( tensor: NdArrayTensor<bool>, axes: &[usize], ) -> NdArrayTensor<bool>

Permutes the dimensions of a tensor.

fn bool_expand(tensor: NdArrayTensor<bool>, shape: Shape) -> NdArrayTensor<bool>

Broadcasts the bool tensor to the given shape.

fn bool_flip(tensor: NdArrayTensor<bool>, axes: &[usize]) -> NdArrayTensor<bool>

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

fn bool_repeat_dim( tensor: <B as Backend>::BoolTensorPrimitive, dim: usize, times: usize, ) -> <B as Backend>::BoolTensorPrimitive

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

fn bool_not_equal( lhs: <B as Backend>::BoolTensorPrimitive, rhs: <B as Backend>::BoolTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

Element-wise non-equality comparison.

fn bool_transpose( tensor: <B as Backend>::BoolTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

Transposes a bool tensor.

fn bool_narrow( tensor: <B as Backend>::BoolTensorPrimitive, dim: usize, start: usize, length: usize, ) -> <B as Backend>::BoolTensorPrimitive

Returns a new tensor with the given dimension narrowed to the given range.

fn bool_chunk( tensor: <B as Backend>::BoolTensorPrimitive, chunks: usize, dim: usize, ) -> Vec<<B as Backend>::BoolTensorPrimitive>

Split the tensor along the given dimension into chunks.

fn bool_split( tensor: <B as Backend>::BoolTensorPrimitive, split_size: usize, dim: usize, ) -> Vec<<B as Backend>::BoolTensorPrimitive>

Split the tensor along the given dimension into chunks of split_size.

fn bool_split_with_sizes( tensor: <B as Backend>::BoolTensorPrimitive, split_sizes: Vec<usize>, dim: usize, ) -> Vec<<B as Backend>::BoolTensorPrimitive>

Split the tensor along the given dimension into chunks with sizes in dim according to split_sizes.

fn bool_any( tensor: <B as Backend>::BoolTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

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

fn bool_any_dim( tensor: <B as Backend>::BoolTensorPrimitive, dim: usize, ) -> <B as Backend>::BoolTensorPrimitive

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

fn bool_all( tensor: <B as Backend>::BoolTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

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

fn bool_all_dim( tensor: <B as Backend>::BoolTensorPrimitive, dim: usize, ) -> <B as Backend>::BoolTensorPrimitive

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

fn bool_argwhere( tensor: <B as Backend>::BoolTensorPrimitive, ) -> impl Future<Output = <B as Backend>::IntTensorPrimitive> + Send + 'static

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

fn bool_nonzero( tensor: <B as Backend>::BoolTensorPrimitive, ) -> impl Future<Output = Vec<<B as Backend>::IntTensorPrimitive>> + Send + 'static

Compute the indices of the elements that are non-zero.

impl<E: Clone, I: Clone, Q: Clone> Clone for NdArray<E, I, Q>

fn clone(&self) -> NdArray<E, I, Q>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: Debug, I: Debug, Q: Debug> Debug for NdArray<E, I, Q>

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

Formats the value using the given formatter.

impl<E: Default, I: Default, Q: Default> Default for NdArray<E, I, Q>

fn default() -> NdArray<E, I, Q>

Returns the “default value” for a type.

impl<E: FloatNdArrayElement, I: IntNdArrayElement, Q: QuantElement> FloatTensorOps<NdArray<E, I, Q>> for NdArray<E, I, Q>

fn float_from_data( data: TensorData, _device: &NdArrayDevice, ) -> FloatTensor<Self>

Creates a new tensor from the data structure.

fn float_random( shape: Shape, distribution: Distribution, device: &NdArrayDevice, ) -> FloatTensor<Self>

Creates a new tensor with random values.

async fn float_into_data(tensor: FloatTensor<Self>) -> TensorData

Converts the tensor to a data structure.

fn float_device(_tensor: &FloatTensor<Self>) -> NdArrayDevice

Gets the device of the tensor.

fn float_to_device( tensor: FloatTensor<Self>, _device: &NdArrayDevice, ) -> FloatTensor<Self>

Moves the tensor to the given device.

fn float_empty( shape: Shape, device: &<NdArray<E> as Backend>::Device, ) -> FloatTensor<Self>

Creates an empty tensor with the given shape.

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

Adds two tensors together.

fn float_add_scalar(lhs: FloatTensor<Self>, rhs: E) -> FloatTensor<Self>

Adds a scalar to a tensor.

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

Subtracts two tensors.

fn float_sub_scalar(lhs: FloatTensor<Self>, rhs: E) -> FloatTensor<Self>

Subtracts a scalar from a tensor.

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

Multiplies two tensors together element-wise.

fn float_mul_scalar(lhs: FloatTensor<Self>, rhs: E) -> FloatTensor<Self>

Multiplies a tensor by a scalar.

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

Divides two tensors element-wise.

fn float_div_scalar(lhs: FloatTensor<Self>, rhs: E) -> FloatTensor<Self>

Divides a tensor by a scalar.

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

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

fn float_remainder_scalar(lhs: FloatTensor<Self>, rhs: E) -> FloatTensor<Self>

Computes the modulus of a tensor given a scalar.

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

Multiplies two tensors together using matrix multiplication.

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

Negates a tensor element-wise.

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

Calculates the reciprocals element-wise

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

Swaps two dimensions of a tensor.

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

Reshapes a tensor.

fn float_gather( dim: usize, tensor: FloatTensor<Self>, indices: NdArrayTensor<I>, ) -> FloatTensor<Self>

Gather elements from a tensor.

fn float_scatter( dim: usize, tensor: FloatTensor<Self>, indices: NdArrayTensor<I>, value: FloatTensor<Self>, ) -> FloatTensor<Self>

Scatter elements into a tensor.

fn float_select( tensor: FloatTensor<Self>, dim: usize, indices: NdArrayTensor<I>, ) -> FloatTensor<Self>

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

fn float_select_assign( tensor: FloatTensor<Self>, dim: usize, indices: NdArrayTensor<I>, value: FloatTensor<Self>, ) -> FloatTensor<Self>

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

fn float_slice( tensor: FloatTensor<Self>, ranges: &[Range<usize>], ) -> FloatTensor<Self>

Select tensor elements corresponding for the given ranges.

fn float_slice_assign( tensor: FloatTensor<Self>, ranges: &[Range<usize>], value: FloatTensor<Self>, ) -> FloatTensor<Self>

Assign the selected elements corresponding for the given ranges to the given value.

fn float_mask_where( tensor: FloatTensor<Self>, mask: NdArrayTensor<bool>, value: FloatTensor<Self>, ) -> FloatTensor<Self>

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

fn float_mask_fill( tensor: FloatTensor<Self>, mask: NdArrayTensor<bool>, value: E, ) -> FloatTensor<Self>

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

fn float_equal( lhs: FloatTensor<Self>, rhs: FloatTensor<Self>, ) -> NdArrayTensor<bool>

Equal comparison of two tensors.

fn float_equal_elem(lhs: FloatTensor<Self>, rhs: E) -> NdArrayTensor<bool>

Equal comparison of a tensor and a scalar.

fn float_greater( lhs: FloatTensor<Self>, rhs: FloatTensor<Self>, ) -> NdArrayTensor<bool>

Greater than comparison of two tensors.

fn float_greater_elem(lhs: FloatTensor<Self>, rhs: E) -> NdArrayTensor<bool>

Greater than comparison of a tensor and a scalar.

fn float_greater_equal( lhs: FloatTensor<Self>, rhs: FloatTensor<Self>, ) -> NdArrayTensor<bool>

Greater than or equal comparison of two tensors.

fn float_greater_equal_elem( lhs: FloatTensor<Self>, rhs: E, ) -> NdArrayTensor<bool>

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

fn float_lower( lhs: FloatTensor<Self>, rhs: FloatTensor<Self>, ) -> NdArrayTensor<bool>

Less than comparison of two tensors.

fn float_lower_elem(lhs: FloatTensor<Self>, rhs: E) -> NdArrayTensor<bool>

Less than comparison of a tensor and a scalar.

fn float_lower_equal( lhs: FloatTensor<Self>, rhs: FloatTensor<Self>, ) -> NdArrayTensor<bool>

Less than or equal comparison of two tensors.

fn float_lower_equal_elem(lhs: FloatTensor<Self>, rhs: E) -> NdArrayTensor<bool>

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

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

Detaches a tensor from the computation graph.

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

Mean of all elements in a tensor.

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

Sum of all elements in a tensor.

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

Mean of all elements in a tensor along a dimension.

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

Sum of all elements in a tensor along a dimension.

fn float_argmax(tensor: FloatTensor<Self>, dim: usize) -> NdArrayTensor<I>

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

fn float_argmin(tensor: FloatTensor<Self>, dim: usize) -> NdArrayTensor<I>

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

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

Returns a new tensor with exponential values.

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

Returns a new tensor with natural logarithm values.

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

Product of all elements in a tensor.

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

Product of all elements in a tensor along a dimension.

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

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

fn float_powf_scalar(tensor: FloatTensor<Self>, value: f32) -> FloatTensor<Self>

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

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

Returns a new tensor with square root values.

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

Returns a new tensor with absolute values.

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

Returns a new tensor with cosine values.

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

Returns a new tensor with sine values.

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

Returns a new tensor with hyperbolic tangent values.

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

Returns a new tensor with rounded values.

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

Returns a new tensor with floored values.

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

Returns a new tensor with ceiled values.

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

Returns a new tensor with the error function values.

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

Concatenates tensors along a dimension.

fn float_clamp_min(tensor: FloatTensor<Self>, min: E) -> FloatTensor<Self>

Clamps a tensor under a minimum value.

fn float_clamp_max(tensor: FloatTensor<Self>, max: E) -> FloatTensor<Self>

Clamps a tensor over a maximum value.

fn float_clamp(tensor: FloatTensor<Self>, min: E, max: E) -> FloatTensor<Self>

Clamps a tensor between a minimum and maximum value.

fn float_into_int(tensor: FloatTensor<Self>) -> NdArrayTensor<I>

Converts float tensor to int tensor.

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

Element-wise power with a FloatTensor.

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

Permutes the dimensions of a tensor.

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

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

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

Returns the signs of the float tensor.

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

Broadcasts the float tensor to the given shape.

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

Converts a tensor to another floating point data type.

fn float_zeros( shape: Shape, device: &<B as Backend>::Device, ) -> <B as Backend>::FloatTensorPrimitive

Creates a new tensor with zeros.

fn float_ones( shape: Shape, device: &<B as Backend>::Device, ) -> <B as Backend>::FloatTensorPrimitive

Creates a new tensor with ones.

fn float_full( shape: Shape, fill_value: <B as Backend>::FloatElem, device: &<B as Backend>::Device, ) -> <B as Backend>::FloatTensorPrimitive

Creates a tensor filled with given value.

fn float_repeat_dim( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, times: usize, ) -> <B as Backend>::FloatTensorPrimitive

Repeat the tensor along the given dimension.

fn float_transpose( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Transposes a tensor.

fn float_not_equal( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

Element-wise non-equality comparison.

fn float_not_equal_elem( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::BoolTensorPrimitive

Element-wise non-equality comparison with a scalar.

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

Sets the require_grad flag of a tensor.

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

Returns the require_grad flag of a tensor.

fn float_powi( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::IntTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Element-wise power with an IntTensor.

fn float_powi_scalar( lhs: <B as Backend>::FloatTensorPrimitive, rhs: <B as Backend>::IntElem, ) -> <B as Backend>::FloatTensorPrimitive

raises a tensor to the power of an int scalar.

fn float_tan( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Returns a new tensor with tangent values.

fn float_cosh( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Returns a new tensor with hyperbolic cosine values.

fn float_sinh( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Returns a new tensor with hyperbolic sine values.

fn float_max( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Gets the maximum element of a tensor.

fn float_max_dim( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, ) -> <B as Backend>::FloatTensorPrimitive

Gets the maximum elements of a tensor along an axis.

fn float_max_dim_with_indices( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, ) -> (<B as Backend>::FloatTensorPrimitive, <B as Backend>::IntTensorPrimitive)

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

fn float_min( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Gets the minimum element of a tensor.

fn float_min_dim( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, ) -> <B as Backend>::FloatTensorPrimitive

Gets the minimum elements of a tensor along an axis.

fn float_min_dim_with_indices( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, ) -> (<B as Backend>::FloatTensorPrimitive, <B as Backend>::IntTensorPrimitive)

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

fn float_max_abs( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Gets the maximum absolute element of a tensor.

fn float_max_abs_dim( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, ) -> <B as Backend>::FloatTensorPrimitive

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

fn float_narrow( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, start: usize, length: usize, ) -> <B as Backend>::FloatTensorPrimitive

Returns a new tensor with the given dimension narrowed to the given range.

fn float_chunk( tensor: <B as Backend>::FloatTensorPrimitive, chunks: usize, dim: usize, ) -> Vec<<B as Backend>::FloatTensorPrimitive>

Split the tensor along the given dimension into chunks.

fn float_split( tensor: <B as Backend>::FloatTensorPrimitive, split_size: usize, dim: usize, ) -> Vec<<B as Backend>::FloatTensorPrimitive>

Split the tensor along the given dimension into chunks of split_size.

fn float_split_with_sizes( tensor: <B as Backend>::FloatTensorPrimitive, split_sizes: Vec<usize>, dim: usize, ) -> Vec<<B as Backend>::FloatTensorPrimitive>

Split the tensor along the given dimension into chunks with sizes in dim according to split_sizes.

fn float_any( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

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

fn float_any_dim( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, ) -> <B as Backend>::BoolTensorPrimitive

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

fn float_all( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

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

fn float_all_dim( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, ) -> <B as Backend>::BoolTensorPrimitive

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

fn float_sort( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, descending: bool, ) -> <B as Backend>::FloatTensorPrimitive

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

fn float_sort_with_indices( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, descending: bool, ) -> (<B as Backend>::FloatTensorPrimitive, <B as Backend>::IntTensorPrimitive)

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

fn float_argsort( tensor: <B as Backend>::FloatTensorPrimitive, dim: usize, descending: bool, ) -> <B as Backend>::IntTensorPrimitive

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

impl<E: FloatNdArrayElement, I: IntNdArrayElement, Q: QuantElement> IntTensorOps<NdArray<E, I, Q>> for NdArray<E, I, Q>

fn int_from_data(data: TensorData, _device: &NdArrayDevice) -> NdArrayTensor<I>

Creates a tensor from the data structure.

async fn int_into_data(tensor: NdArrayTensor<I>) -> TensorData

Converts the tensor to a data structure.

fn int_to_device( tensor: NdArrayTensor<I>, _device: &NdArrayDevice, ) -> NdArrayTensor<I>

Moves the tensor to the given device.

fn int_reshape(tensor: NdArrayTensor<I>, shape: Shape) -> NdArrayTensor<I>

Reshapes the tensor.

fn int_slice( tensor: NdArrayTensor<I>, ranges: &[Range<usize>], ) -> NdArrayTensor<I>

Gets the element at the given indices.

fn int_device(_tensor: &NdArrayTensor<I>) -> <NdArray<E> as Backend>::Device

Gets the device of the tensor.

fn int_empty( shape: Shape, device: &<NdArray<E> as Backend>::Device, ) -> NdArrayTensor<I>

Creates a new int tensor.

fn int_mask_where( tensor: NdArrayTensor<I>, mask: NdArrayTensor<bool>, source: NdArrayTensor<I>, ) -> NdArrayTensor<I>

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

fn int_mask_fill( tensor: NdArrayTensor<I>, mask: NdArrayTensor<bool>, value: I, ) -> NdArrayTensor<I>

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

fn int_slice_assign( tensor: NdArrayTensor<I>, ranges: &[Range<usize>], value: NdArrayTensor<I>, ) -> NdArrayTensor<I>

Sets the element at the given indices.

fn int_cat(tensors: Vec<NdArrayTensor<I>>, dim: usize) -> NdArrayTensor<I>

Concatenates the given tensors along the given dimension.

fn int_equal( lhs: NdArrayTensor<I>, rhs: NdArrayTensor<I>, ) -> NdArrayTensor<bool>

Element-wise equality comparison.

fn int_equal_elem(lhs: NdArrayTensor<I>, rhs: I) -> NdArrayTensor<bool>

Element-wise equality comparison with a scalar.

fn int_greater( lhs: NdArrayTensor<I>, rhs: NdArrayTensor<I>, ) -> NdArrayTensor<bool>

Element-wise greater than comparison.

fn int_greater_elem(lhs: NdArrayTensor<I>, rhs: I) -> NdArrayTensor<bool>

Element-wise greater than comparison with a scalar.

fn int_greater_equal( lhs: NdArrayTensor<I>, rhs: NdArrayTensor<I>, ) -> NdArrayTensor<bool>

Element-wise greater than or equal comparison.

fn int_greater_equal_elem(lhs: NdArrayTensor<I>, rhs: I) -> NdArrayTensor<bool>

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

fn int_lower( lhs: NdArrayTensor<I>, rhs: NdArrayTensor<I>, ) -> NdArrayTensor<bool>

Element-wise less than comparison.

fn int_lower_elem(lhs: NdArrayTensor<I>, rhs: I) -> NdArrayTensor<bool>

Element-wise less than comparison with a scalar.

fn int_lower_equal( lhs: NdArrayTensor<I>, rhs: NdArrayTensor<I>, ) -> NdArrayTensor<bool>

Element-wise less than or equal comparison.

fn int_lower_equal_elem(lhs: NdArrayTensor<I>, rhs: I) -> NdArrayTensor<bool>

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

fn int_add(lhs: NdArrayTensor<I>, rhs: NdArrayTensor<I>) -> NdArrayTensor<I>

Element-wise addition.

fn int_add_scalar(lhs: NdArrayTensor<I>, rhs: I) -> NdArrayTensor<I>

Element-wise addition with a scalar.

fn int_sub(lhs: NdArrayTensor<I>, rhs: NdArrayTensor<I>) -> NdArrayTensor<I>

Element-wise subtraction.

fn int_sub_scalar(lhs: NdArrayTensor<I>, rhs: I) -> NdArrayTensor<I>

Element-wise subtraction with a scalar.

fn int_mul(lhs: NdArrayTensor<I>, rhs: NdArrayTensor<I>) -> NdArrayTensor<I>

Element-wise multiplication.

fn int_mul_scalar(lhs: NdArrayTensor<I>, rhs: I) -> NdArrayTensor<I>

Element-wise multiplication with a scalar.

fn int_div(lhs: NdArrayTensor<I>, rhs: NdArrayTensor<I>) -> NdArrayTensor<I>

Element-wise division.

fn int_div_scalar(lhs: NdArrayTensor<I>, rhs: I) -> NdArrayTensor<I>

Element-wise division with a scalar.

fn int_remainder( lhs: NdArrayTensor<I>, rhs: NdArrayTensor<I>, ) -> NdArrayTensor<I>

Element-wise modulus.

fn int_remainder_scalar(lhs: NdArrayTensor<I>, rhs: I) -> NdArrayTensor<I>

Element-wise modulus with a scalar.

fn int_neg(tensor: NdArrayTensor<I>) -> NdArrayTensor<I>

Element-wise negation.

fn int_zeros( shape: Shape, device: &<NdArray<E> as Backend>::Device, ) -> NdArrayTensor<I>

Creates a tensor of zeros.

fn int_ones( shape: Shape, device: &<NdArray<E> as Backend>::Device, ) -> NdArrayTensor<I>

Creates a tensor of ones.

fn int_full( shape: Shape, fill_value: I, device: &<NdArray<E> as Backend>::Device, ) -> NdArrayTensor<I>

Creates a tensor filled with given value.

fn int_sum(tensor: NdArrayTensor<I>) -> NdArrayTensor<I>

Sums all elements in the tensor.

fn int_sum_dim(tensor: NdArrayTensor<I>, dim: usize) -> NdArrayTensor<I>

Sums all elements in the tensor along a dimension.

fn int_prod(tensor: NdArrayTensor<I>) -> NdArrayTensor<I>

Computes the product of all elements in the tensor.

fn int_prod_dim(tensor: NdArrayTensor<I>, dim: usize) -> NdArrayTensor<I>

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

fn int_mean(tensor: NdArrayTensor<I>) -> NdArrayTensor<I>

Computes the mean of all elements in the tensor.

fn int_mean_dim(tensor: NdArrayTensor<I>, dim: usize) -> NdArrayTensor<I>

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

fn int_gather( dim: usize, tensor: NdArrayTensor<I>, indices: NdArrayTensor<I>, ) -> NdArrayTensor<I>

Gather elements from the tensor at the given indices.

fn int_scatter( dim: usize, tensor: NdArrayTensor<I>, indices: NdArrayTensor<I>, value: NdArrayTensor<I>, ) -> NdArrayTensor<I>

Scatter a given value to the tensor at the given indices.

fn int_select( tensor: NdArrayTensor<I>, dim: usize, indices: NdArrayTensor<I>, ) -> NdArrayTensor<I>

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

fn int_select_assign( tensor: NdArrayTensor<I>, dim: usize, indices: NdArrayTensor<I>, value: NdArrayTensor<I>, ) -> NdArrayTensor<I>

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

fn int_argmax(tensor: NdArrayTensor<I>, dim: usize) -> NdArrayTensor<I>

Gets the indices of the maximum elements along a dimension.

fn int_argmin(tensor: NdArrayTensor<I>, dim: usize) -> NdArrayTensor<I>

Gets the indices of the minimum elements along a dimension.

fn int_clamp_min(tensor: NdArrayTensor<I>, min: I) -> NdArrayTensor<I>

Clamps a tensor under a minimum value.

fn int_clamp_max(tensor: NdArrayTensor<I>, max: I) -> NdArrayTensor<I>

Clamps a tensor over a maximum value.

fn int_clamp(tensor: NdArrayTensor<I>, min: I, max: I) -> NdArrayTensor<I>

Clamps a tensor between a minimum and maximum value.

fn int_abs(tensor: NdArrayTensor<I>) -> NdArrayTensor<I>

Returns a new tensor with absolute values.

fn int_into_float(tensor: NdArrayTensor<I>) -> FloatTensor<Self>

Converts int tensor to float tensor.

fn int_swap_dims( tensor: NdArrayTensor<I>, dim1: usize, dim2: usize, ) -> NdArrayTensor<I>

Swaps two dimensions of an int tensor.

fn int_random( shape: Shape, distribution: Distribution, device: &NdArrayDevice, ) -> NdArrayTensor<I>

Creates a new int tensor with random values.

fn int_powi(lhs: NdArrayTensor<I>, rhs: NdArrayTensor<I>) -> NdArrayTensor<I>

Element-wise power with a IntTensor.

fn int_powf(lhs: NdArrayTensor<I>, rhs: FloatTensor<Self>) -> NdArrayTensor<I>

Element-wise power with a floatTensor.

fn int_powf_scalar(lhs: NdArrayTensor<I>, rhs: f32) -> NdArrayTensor<I>

Element-wise power with a floatTensor.

fn int_permute(tensor: NdArrayTensor<I>, axes: &[usize]) -> NdArrayTensor<I>

Permutes the dimensions of a tensor.

fn int_flip(tensor: NdArrayTensor<I>, axes: &[usize]) -> NdArrayTensor<I>

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

fn int_sign(tensor: NdArrayTensor<I>) -> NdArrayTensor<I>

Returns the signs of the int tensor.

fn int_expand(tensor: NdArrayTensor<I>, shape: Shape) -> NdArrayTensor<I>

Broadcasts the int tensor to the given shape.

fn bitwise_and(lhs: NdArrayTensor<I>, rhs: NdArrayTensor<I>) -> NdArrayTensor<I>

Bitwise AND operation for Int Tensors

fn bitwise_and_scalar(lhs: NdArrayTensor<I>, rhs: I) -> NdArrayTensor<I>

Bitwise AND operation for Int Tensors with a scalar

fn bitwise_or(lhs: NdArrayTensor<I>, rhs: NdArrayTensor<I>) -> NdArrayTensor<I>

Bitwise OR operation for Int Tensors

fn bitwise_or_scalar(lhs: NdArrayTensor<I>, rhs: I) -> NdArrayTensor<I>

Bitwise OR operation for Int Tensors with a scalar

fn bitwise_xor(lhs: NdArrayTensor<I>, rhs: NdArrayTensor<I>) -> NdArrayTensor<I>

Bitwise XOR operation for Int Tensors

fn bitwise_xor_scalar(lhs: NdArrayTensor<I>, rhs: I) -> NdArrayTensor<I>

Bitwise XOR operation for Int Tensors with a scalar

fn bitwise_not(tensor: NdArrayTensor<I>) -> NdArrayTensor<I>

Bitwise NOT operation for Int Tensors

fn bitwise_left_shift( lhs: NdArrayTensor<I>, rhs: NdArrayTensor<I>, ) -> NdArrayTensor<I>

Bitwise left shift operation for Int Tensors

fn bitwise_left_shift_scalar(lhs: NdArrayTensor<I>, rhs: I) -> NdArrayTensor<I>

Bitwise left shift operation for Int Tensors with a scalar

fn bitwise_right_shift( lhs: NdArrayTensor<I>, rhs: NdArrayTensor<I>, ) -> NdArrayTensor<I>

Bitwise right shift operation for Int Tensors

fn bitwise_right_shift_scalar(lhs: NdArrayTensor<I>, rhs: I) -> NdArrayTensor<I>

Bitwise right shift operation for Int Tensors with a scalar

fn int_repeat_dim( tensor: <B as Backend>::IntTensorPrimitive, dim: usize, times: usize, ) -> <B as Backend>::IntTensorPrimitive

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

fn int_not_equal( lhs: <B as Backend>::IntTensorPrimitive, rhs: <B as Backend>::IntTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

Element-wise non-equality comparison.

fn int_not_equal_elem( lhs: <B as Backend>::IntTensorPrimitive, rhs: <B as Backend>::IntElem, ) -> <B as Backend>::BoolTensorPrimitive

Element-wise non-equality comparison with a scalar.

fn int_powi_scalar( lhs: <B as Backend>::IntTensorPrimitive, rhs: <B as Backend>::IntElem, ) -> <B as Backend>::IntTensorPrimitive

Element-wise power with a scalar.

fn int_max( tensor: <B as Backend>::IntTensorPrimitive, ) -> <B as Backend>::IntTensorPrimitive

Gets the maximum element in the tensor.

fn int_max_dim( tensor: <B as Backend>::IntTensorPrimitive, dim: usize, ) -> <B as Backend>::IntTensorPrimitive

Gets the maximum element in the tensor along a dimension.

fn int_max_dim_with_indices( tensor: <B as Backend>::IntTensorPrimitive, dim: usize, ) -> (<B as Backend>::IntTensorPrimitive, <B as Backend>::IntTensorPrimitive)

Gets the maximum elements and corresponding indices along a dimension.

fn int_max_abs( tensor: <B as Backend>::IntTensorPrimitive, ) -> <B as Backend>::IntTensorPrimitive

Gets the maximum absolute element in the tensor.

fn int_max_abs_dim( tensor: <B as Backend>::IntTensorPrimitive, dim: usize, ) -> <B as Backend>::IntTensorPrimitive

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

fn int_min( tensor: <B as Backend>::IntTensorPrimitive, ) -> <B as Backend>::IntTensorPrimitive

Gets the minimum element in the tensor.

fn int_min_dim( tensor: <B as Backend>::IntTensorPrimitive, dim: usize, ) -> <B as Backend>::IntTensorPrimitive

Gets the minimum elements in the tensor along a dimension.

fn int_min_dim_with_indices( tensor: <B as Backend>::IntTensorPrimitive, dim: usize, ) -> (<B as Backend>::IntTensorPrimitive, <B as Backend>::IntTensorPrimitive)

Gets the minimum elements and corresponding indices along a dimension.

fn int_transpose( tensor: <B as Backend>::IntTensorPrimitive, ) -> <B as Backend>::IntTensorPrimitive

Transposes an int tensor.

fn int_narrow( tensor: <B as Backend>::IntTensorPrimitive, dim: usize, start: usize, length: usize, ) -> <B as Backend>::IntTensorPrimitive

Returns a new tensor with the given dimension narrowed to the given range.

fn int_chunk( tensor: <B as Backend>::IntTensorPrimitive, chunks: usize, dim: usize, ) -> Vec<<B as Backend>::IntTensorPrimitive>

Split the tensor along the given dimension into chunks.

fn int_split( tensor: <B as Backend>::IntTensorPrimitive, split_size: usize, dim: usize, ) -> Vec<<B as Backend>::IntTensorPrimitive>

Split the tensor along the given dimension into chunks of split_size.

fn int_split_with_sizes( tensor: <B as Backend>::IntTensorPrimitive, split_sizes: Vec<usize>, dim: usize, ) -> Vec<<B as Backend>::IntTensorPrimitive>

Split the tensor along the given dimension into chunks with sizes in dim according to split_sizes.

fn int_arange_step( range: Range<i64>, step: usize, device: &<B as Backend>::Device, ) -> <B as Backend>::IntTensorPrimitive

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

fn int_arange( range: Range<i64>, device: &<B as Backend>::Device, ) -> <B as Backend>::IntTensorPrimitive

Creates a new tensor with values from the given range.

fn int_any( tensor: <B as Backend>::IntTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

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

fn int_any_dim( tensor: <B as Backend>::IntTensorPrimitive, dim: usize, ) -> <B as Backend>::BoolTensorPrimitive

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

fn int_all( tensor: <B as Backend>::IntTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

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

fn int_all_dim( tensor: <B as Backend>::IntTensorPrimitive, dim: usize, ) -> <B as Backend>::BoolTensorPrimitive

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

fn int_sort( tensor: <B as Backend>::IntTensorPrimitive, dim: usize, descending: bool, ) -> <B as Backend>::IntTensorPrimitive

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

fn int_sort_with_indices( tensor: <B as Backend>::IntTensorPrimitive, dim: usize, descending: bool, ) -> (<B as Backend>::IntTensorPrimitive, <B as Backend>::IntTensorPrimitive)

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

fn int_argsort( tensor: <B as Backend>::IntTensorPrimitive, dim: usize, descending: bool, ) -> <B as Backend>::IntTensorPrimitive

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

impl<E: FloatNdArrayElement, I: IntNdArrayElement, Q: QuantElement> ModuleOps<NdArray<E, I, Q>> for NdArray<E, I, Q>

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

Two dimensional convolution.

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

Two dimensional deformable convolution.

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

Backward pass for the deform_conv2d operation.

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

Two dimensional transposed convolution.

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

Two dimensional avg pooling.

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

Backward pass for the avg pooling 2d operation.

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

Two dimensional max pooling.

fn max_pool2d_with_indices( x: FloatTensor<Self>, kernel_size: [usize; 2], stride: [usize; 2], padding: [usize; 2], dilation: [usize; 2], ) -> MaxPool2dWithIndices<NdArray<E, I, Q>>

Two dimensional max pooling with indices.

fn max_pool2d_with_indices_backward( x: FloatTensor<Self>, kernel_size: [usize; 2], stride: [usize; 2], padding: [usize; 2], dilation: [usize; 2], output_grad: FloatTensor<Self>, indices: NdArrayTensor<I>, ) -> MaxPool2dBackward<NdArray<E, I, Q>>

Backward pass for the max pooling 2d operation.

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

Two dimensional adaptive avg pooling.

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

Backward pass for the adaptive avg pooling 2d operation.

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

Down/up samples the input.

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

Backward pass for the interpolate operation.

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

Three dimensional convolution.

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

Three dimensional transposed convolution.

fn embedding( weights: <B as Backend>::FloatTensorPrimitive, indices: <B as Backend>::IntTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Embedding operation.

fn embedding_backward( weights: <B as Backend>::FloatTensorPrimitive, output_grad: <B as Backend>::FloatTensorPrimitive, indices: <B as Backend>::IntTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Embedding backward operation.

fn conv1d( x: <B as Backend>::FloatTensorPrimitive, weight: <B as Backend>::FloatTensorPrimitive, bias: Option<<B as Backend>::FloatTensorPrimitive>, options: ConvOptions<1>, ) -> <B as Backend>::FloatTensorPrimitive

One dimensional convolution.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn conv_transpose1d( x: <B as Backend>::FloatTensorPrimitive, weight: <B as Backend>::FloatTensorPrimitive, bias: Option<<B as Backend>::FloatTensorPrimitive>, options: ConvTransposeOptions<1>, ) -> <B as Backend>::FloatTensorPrimitive

One dimensional transposed convolution.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Four-dimensional unfolding.

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

One dimensional avg pooling.

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

Backward pass for the avg pooling 1d operation.

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

One dimensional adaptive avg pooling.

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

Backward pass for the adaptive avg pooling 1d operation.

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

One dimensional max pooling.

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

One dimensional max pooling with indices.

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

Backward pass for the max pooling 1d operation.

impl<E: FloatNdArrayElement, I: IntNdArrayElement, Q: QuantElement> QTensorOps<NdArray<E, I, Q>> for NdArray<E, I, Q>

fn q_from_data( data: TensorData, _device: &NdArrayDevice, ) -> QuantizedTensor<Self>

Creates a new tensor from the data structure.

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

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

fn dequantize(tensor: QuantizedTensor<Self>) -> FloatTensor<Self>

Convert the tensor back to a higher precision data type.

fn q_device(_tensor: &QuantizedTensor<Self>) -> NdArrayDevice

Gets the device of the tensor.

fn q_to_device( tensor: QuantizedTensor<Self>, _device: &NdArrayDevice, ) -> QuantizedTensor<Self>

Moves the tensor to the given device.

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

Reshapes a tensor.

async fn q_into_data(tensor: QuantizedTensor<Self>) -> TensorData

Converts the tensor to a data structure.

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

Swaps two dimensions of a tensor.

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

Permutes the dimensions of a tensor.

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

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

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

Gather elements from a tensor.

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

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

fn q_slice( tensor: QuantizedTensor<Self>, ranges: &[Range<usize>], ) -> QuantizedTensor<Self>

Select tensor elements corresponding for the given ranges.

fn q_argmax(tensor: QuantizedTensor<Self>, dim: usize) -> IntTensor<Self>

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

fn q_argmin(tensor: QuantizedTensor<Self>, dim: usize) -> IntTensor<Self>

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

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

Broadcasts the tensor to the given shape.

fn quantize_dynamic( tensor: <B as Backend>::FloatTensorPrimitive, scheme: &QuantizationScheme, ) -> <B as Backend>::QuantizedTensorPrimitive

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

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

Detaches a tensor from the computation graph.

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

Sets the require_grad flag of a tensor.

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

Returns the require_grad flag of a tensor.

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

Repeat the tensor along the given dimension.

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

Adds two tensors together.

fn q_add_scalar( lhs: <B as Backend>::QuantizedTensorPrimitive, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::QuantizedTensorPrimitive

Adds a scalar to a tensor.

fn q_clamp_min( tensor: <B as Backend>::QuantizedTensorPrimitive, min: <B as Backend>::FloatElem, ) -> <B as Backend>::QuantizedTensorPrimitive

Clamps a tensor under a minimum value.

fn q_clamp_max( tensor: <B as Backend>::QuantizedTensorPrimitive, max: <B as Backend>::FloatElem, ) -> <B as Backend>::QuantizedTensorPrimitive

Clamps a tensor over a maximum value.

fn q_clamp( tensor: <B as Backend>::QuantizedTensorPrimitive, min: <B as Backend>::FloatElem, max: <B as Backend>::FloatElem, ) -> <B as Backend>::QuantizedTensorPrimitive

Clamps a tensor between a minimum and maximum value.

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

Subtracts two tensors.

fn q_sub_scalar( lhs: <B as Backend>::QuantizedTensorPrimitive, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::QuantizedTensorPrimitive

Subtracts a scalar from a tensor.

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

Multiplies two tensors together element-wise.

fn q_mul_scalar( lhs: <B as Backend>::QuantizedTensorPrimitive, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::QuantizedTensorPrimitive

Multiplies a tensor by a scalar.

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

Divides two tensors element-wise.

fn q_div_scalar( lhs: <B as Backend>::QuantizedTensorPrimitive, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::QuantizedTensorPrimitive

Divides a tensor by a scalar.

fn q_remainder( lhs: <B as Backend>::QuantizedTensorPrimitive, rhs: <B as Backend>::QuantizedTensorPrimitive, ) -> <B as Backend>::QuantizedTensorPrimitive

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

fn q_remainder_scalar( lhs: <B as Backend>::QuantizedTensorPrimitive, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::QuantizedTensorPrimitive

Computes the modulus of a tensor given a scalar.

fn q_matmul( lhs: <B as Backend>::QuantizedTensorPrimitive, rhs: <B as Backend>::QuantizedTensorPrimitive, ) -> <B as Backend>::QuantizedTensorPrimitive

Multiplies two tensors together using matrix multiplication.

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

Negates a tensor element-wise.

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

Calculates the reciprocals element-wise

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

Transposes a tensor.

fn q_scatter( dim: usize, tensor: <B as Backend>::QuantizedTensorPrimitive, indices: <B as Backend>::IntTensorPrimitive, value: <B as Backend>::QuantizedTensorPrimitive, ) -> <B as Backend>::QuantizedTensorPrimitive

Scatter elements into a tensor.

fn q_select_assign( tensor: <B as Backend>::QuantizedTensorPrimitive, dim: usize, indices: <B as Backend>::IntTensorPrimitive, value: <B as Backend>::QuantizedTensorPrimitive, ) -> <B as Backend>::QuantizedTensorPrimitive

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

fn q_slice_assign( tensor: <B as Backend>::QuantizedTensorPrimitive, ranges: &[Range<usize>], value: <B as Backend>::QuantizedTensorPrimitive, ) -> <B as Backend>::QuantizedTensorPrimitive

Assign the selected elements corresponding for the given ranges to the given value.

fn q_mask_where( tensor: <B as Backend>::QuantizedTensorPrimitive, mask: <B as Backend>::BoolTensorPrimitive, value: <B as Backend>::QuantizedTensorPrimitive, ) -> <B as Backend>::QuantizedTensorPrimitive

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

fn q_mask_fill( tensor: <B as Backend>::QuantizedTensorPrimitive, mask: <B as Backend>::BoolTensorPrimitive, value: <B as Backend>::FloatElem, ) -> <B as Backend>::QuantizedTensorPrimitive

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

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

Sum of all elements in a tensor.

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

Sum of all elements in a tensor along a dimension.

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

Product of all elements in a tensor.

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

Product of all elements in a tensor along a dimension.

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

Mean of all elements in a tensor.

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

Mean of all elements in a tensor along a dimension.

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

Returns a new tensor with exponential values.

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

Returns a new tensor with natural logarithm values.

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

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

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

Element-wise power with another tensor.

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

Element-wise power with an IntTensor.

fn q_powi_scalar( lhs: <B as Backend>::QuantizedTensorPrimitive, rhs: <B as Backend>::IntElem, ) -> <B as Backend>::QuantizedTensorPrimitive

Element-wise power with an int scalar.

fn q_powf_scalar( tensor: <B as Backend>::QuantizedTensorPrimitive, value: f32, ) -> <B as Backend>::QuantizedTensorPrimitive

Element-wise power with a float scalar.

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

Returns a new tensor with square root values.

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

Returns a new tensor with absolute values.

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

Returns a new tensor with cosine values.

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

Returns a new tensor with sine values.

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

Returns a new tensor with tangent values.

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

Returns a new tensor with hyperbolic cosine values.

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

Returns a new tensor with hyperbolic sine values.

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

Returns a new tensor with hyperbolic tangent values.

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

Returns a new tensor with the error function values.

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

Concatenates tensors along a dimension.

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

Gets the maximum element of a tensor.

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

Gets the maximum elements of a tensor along an axis.

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

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

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

Gets the minimum element of a tensor.

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

Gets the minimum elements of a tensor along an axis.

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

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

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

Gets the maximum element of a tensor.

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

Gets the maximum elements of a tensor along an axis.

fn q_narrow( tensor: <B as Backend>::QuantizedTensorPrimitive, dim: usize, start: usize, length: usize, ) -> <B as Backend>::QuantizedTensorPrimitive

Returns a new tensor with the given dimension narrowed to the given range.

fn q_chunk( tensor: <B as Backend>::QuantizedTensorPrimitive, chunks: usize, dim: usize, ) -> Vec<<B as Backend>::QuantizedTensorPrimitive>

Split the tensor along the given dimension into chunks.

fn q_split( tensor: <B as Backend>::QuantizedTensorPrimitive, split_size: usize, dim: usize, ) -> Vec<<B as Backend>::QuantizedTensorPrimitive>

Split the tensor along the given dimension into chunks of split_size.

fn q_split_with_sizes( tensor: <B as Backend>::QuantizedTensorPrimitive, split_sizes: Vec<usize>, dim: usize, ) -> Vec<<B as Backend>::QuantizedTensorPrimitive>

Split the tensor along the given dimension into chunks with sizes in dim according to split_sizes.

fn q_any( tensor: <B as Backend>::QuantizedTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

Tests if any element in the tensor evaluates to True.

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

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

fn q_all( tensor: <B as Backend>::QuantizedTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

Tests if all elements in the tensor evaluate to True.

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

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

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

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

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

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

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

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

impl<E: FloatNdArrayElement, I: IntNdArrayElement, Q: QuantElement> TransactionOps<NdArray<E, I, Q>> for NdArray<E, I, Q>

fn tr_execute( transaction: TransactionPrimitive<B>, ) -> impl Future<Output = TransactionPrimitiveResult> + Send + 'static

Executes a transaction and return its result.

impl<E: Copy, I: Copy, Q: Copy> Copy for NdArray<E, I, Q>