Struct Tensor 

pub struct Tensor { /* private fields */ }

Enhanced Tensor implementation with Candle backend.

Implementations

impl Tensor

Convenience functions for arithmetic operations.

pub fn clamp(&self, min: f32, max: f32) -> Result<Tensor>

Clamp tensor values between min and max.

pub fn relu(&self) -> Result<Tensor>

Apply ReLU activation function.

pub fn sigmoid(&self) -> Result<Tensor>

Apply Sigmoid activation function.

pub fn tanh(&self) -> Result<Tensor>

Apply Tanh activation function.

pub fn gelu(&self) -> Result<Tensor>

Apply GELU activation function.

impl Tensor

Additional matrix operations as methods on Tensor.

pub fn trace(&self) -> Result<Tensor>

Compute the trace (sum of diagonal elements) of a 2D tensor.

pub fn diagonal(&self) -> Result<Tensor>

Get the diagonal elements of a 2D tensor.

pub fn eye(size: usize, dtype: DataType, layout: TensorLayout) -> Result<Tensor>

Create an identity matrix of given size.

pub fn det(&self) -> Result<Tensor>

Compute the determinant of a 2D square tensor.

pub fn inverse(&self) -> Result<Tensor>

Compute matrix inverse (for 2x2 matrices only in this implementation).

pub fn frobenius_norm(&self) -> Result<Tensor>

Compute the Frobenius norm of the tensor.

pub fn diag_embed(&self) -> Result<Tensor>

Create a tensor with ones on the diagonal and zeros elsewhere.

impl Tensor

Additional reduction methods for convenience.

pub fn sum_dim(&self, dim: usize, keep_dim: bool) -> Result<Tensor>

Sum along a single dimension.

pub fn mean_dim(&self, dim: usize, keep_dim: bool) -> Result<Tensor>

Mean along a single dimension.

pub fn max_dim(&self, dim: usize, keep_dim: bool) -> Result<Tensor>

Maximum along a single dimension.

pub fn min_dim(&self, dim: usize, keep_dim: bool) -> Result<Tensor>

Minimum along a single dimension.

pub fn argmax(&self, dim: usize, keep_dim: bool) -> Result<Tensor>

Find indices of maximum values along a dimension.

pub fn argmin(&self, dim: usize, keep_dim: bool) -> Result<Tensor>

Find indices of minimum values along a dimension.

pub fn count_nonzero(&self) -> Result<usize>

Count non-zero elements.

pub fn count_nonzero_dim(&self, dim: usize) -> Result<Tensor>

Count elements along a dimension.

pub fn cumsum(&self, dim: usize) -> Result<Tensor>

Cumulative sum along a dimension.

pub fn cumprod(&self, dim: usize) -> Result<Tensor>

Cumulative product along a dimension.

pub fn softmax(&self, dim: usize) -> Result<Tensor>

Softmax operation along a dimension.

pub fn log_softmax(&self, dim: usize) -> Result<Tensor>

Log softmax operation along a dimension.

impl Tensor

Additional shape manipulation methods.

pub fn chunk(&self, chunks: usize, dim: usize) -> Result<Vec<Tensor>>

Split the tensor into chunks along a specific dimension.

pub fn slice(&self, dim: usize, start: usize, end: usize) -> Result<Tensor>

Slice the tensor along a specific dimension.

pub fn concat(tensors: &[&Tensor], dim: usize) -> Result<Tensor>

Concatenate tensors along a specific dimension.

pub fn repeat(&self, repeats: &[usize]) -> Result<Tensor>

Repeat the tensor along specified dimensions.

pub fn tile(&self, multiples: &[usize]) -> Result<Tensor>

Tile the tensor with the given multiples.

pub fn pad_zeros(&self, padding: &[(usize, usize)]) -> Result<Tensor>

Pad the tensor with zeros.

impl Tensor

pub fn from_data( data: Vec<f32>, shape: Vec<usize>, dtype: DataType, layout: TensorLayout, ) -> Result<Self>

Create a new tensor from raw data.

Arguments

• data - Raw tensor data
• shape - Tensor dimensions
• dtype - Data type specification
• layout - Memory layout preference

Example

use ronn_core::tensor::Tensor;
use ronn_core::types::{DataType, TensorLayout};

let data = vec![1.0, 2.0, 3.0, 4.0];
let tensor = Tensor::from_data(data, vec![2, 2], DataType::F32, TensorLayout::RowMajor)?;

pub fn zeros( shape: Vec<usize>, dtype: DataType, layout: TensorLayout, ) -> Result<Self>

Create a tensor filled with zeros.

Arguments

• shape - Tensor dimensions
• dtype - Data type specification
• layout - Memory layout preference

pub fn ones( shape: Vec<usize>, dtype: DataType, layout: TensorLayout, ) -> Result<Self>

Create a tensor filled with ones.

Arguments

• shape - Tensor dimensions
• dtype - Data type specification
• layout - Memory layout preference

pub fn rand( shape: Vec<usize>, dtype: DataType, layout: TensorLayout, ) -> Result<Self>

Create a tensor with random values from a uniform distribution.

pub fn shape(&self) -> Vec<usize>

Get the shape of the tensor.

pub fn dtype(&self) -> DataType

Get the data type of the tensor.

pub fn layout(&self) -> TensorLayout

Get the memory layout of the tensor.

pub fn ndim(&self) -> usize

Get the number of dimensions.

pub fn numel(&self) -> usize

Get the total number of elements.

pub fn device(&self) -> &Device

Get the device where the tensor is stored.

pub fn to_cpu(&self) -> Result<Self>

Convert tensor to CPU device.

pub fn to_vec(&self) -> Result<Vec<f32>>

Extract data as a vector of f32 values.

pub fn candle_tensor(&self) -> &CandleTensor

Get the underlying Candle tensor for advanced operations.

pub fn from_candle( candle_tensor: CandleTensor, dtype: DataType, layout: TensorLayout, ) -> Self

Create a Tensor from a Candle tensor.

pub fn is_broadcastable_with(&self, other: &Tensor) -> bool

Check if tensor shapes are broadcastable.

pub fn broadcast_shape(shape1: &[usize], shape2: &[usize]) -> Result<Vec<usize>>

Compute broadcast shape for two tensors.

pub fn conv2d( &self, weight: &Tensor, bias: Option<&Tensor>, strides: &[usize], pads: &[usize], dilations: &[usize], groups: usize, ) -> Result<Tensor>

Convolution 2D operation (placeholder - uses Candle’s conv2d).

pub fn max_pool2d( &self, kernel_shape: &[usize], strides: &[usize], pads: &[usize], ) -> Result<Tensor>

Max pooling 2D operation.

pub fn avg_pool2d( &self, kernel_shape: &[usize], strides: &[usize], pads: &[usize], ) -> Result<Tensor>

Average pooling 2D operation.

pub fn batch_norm( &self, scale: &Tensor, bias: &Tensor, mean: &Tensor, var: &Tensor, epsilon: f32, ) -> Result<Tensor>

Batch normalization operation.

pub fn rank(&self) -> usize

Get rank (number of dimensions).

pub fn to_vec1<T: WithDType>(&self) -> Result<Vec<T>>

Convert to 1D vector (alias for to_vec).

pub fn stack(tensors: &[&Tensor], dim: usize) -> Result<Self>

Stack tensors along a new dimension.

Arguments

• tensors - Slice of tensors to stack
• dim - Dimension along which to stack

Example

use ronn_core::tensor::Tensor;
use ronn_core::types::{DataType, TensorLayout};

let t1 = Tensor::from_data(vec![1.0, 2.0], vec![2], DataType::F32, TensorLayout::RowMajor)?;
let t2 = Tensor::from_data(vec![3.0, 4.0], vec![2], DataType::F32, TensorLayout::RowMajor)?;
let stacked = Tensor::stack(&[&t1, &t2], 0)?;
assert_eq!(stacked.shape(), vec![2, 2]);

pub fn split(&self, num_chunks: usize, dim: usize) -> Result<Vec<Tensor>>

Split tensor into chunks along an axis.

Arguments

• num_chunks - Number of chunks to split into
• dim - Dimension along which to split

Example

use ronn_core::tensor::Tensor;
use ronn_core::types::{DataType, TensorLayout};

let t = Tensor::from_data(
    vec![1.0, 2.0, 3.0, 4.0],
    vec![2, 2],
    DataType::F32,
    TensorLayout::RowMajor
)?;
let chunks = t.split(2, 0)?;
assert_eq!(chunks.len(), 2);

pub fn gather(&self, indices: &Tensor, dim: usize) -> Result<Tensor>

Gather elements along an axis.

pub fn transpose(&self, perm: &[usize]) -> Result<Tensor>

Transpose with specific permutation.

pub fn layer_norm( &self, scale: Option<&Tensor>, bias: Option<&Tensor>, epsilon: f32, axis: i32, ) -> Result<Self>

Layer normalization (critical for transformers).

Normalizes the input across the specified axis.

Arguments

• scale - Optional scale parameter (gamma)
• bias - Optional bias parameter (beta)
• epsilon - Small constant for numerical stability
• axis - Axis to normalize over (default: -1 for last dimension)

Example

use ronn_core::tensor::Tensor;
use ronn_core::types::{DataType, TensorLayout};

let input = Tensor::from_data(
    vec![1.0, 2.0, 3.0, 4.0],
    vec![2, 2],
    DataType::F32,
    TensorLayout::RowMajor
)?;
let normalized = input.layer_norm(None, None, 1e-5, 1)?;  // Use positive axis

pub fn attention( &self, key: &Tensor, value: &Tensor, num_heads: usize, mask: Option<&Tensor>, ) -> Result<Self>

Multi-head attention mechanism (critical for transformers).

Computes scaled dot-product attention: softmax(Q·K^T / sqrt(d_k))·V

Arguments

• key - Key tensor
• value - Value tensor
• num_heads - Number of attention heads
• mask - Optional attention mask

Example

use ronn_core::tensor::Tensor;
use ronn_core::types::{DataType, TensorLayout};

let query = Tensor::from_data(
    vec![1.0; 64],
    vec![1, 8, 8],  // (batch, seq_len, d_model)
    DataType::F32,
    TensorLayout::RowMajor
)?;
let key = query.clone();
let value = query.clone();

let output = query.attention(&key, &value, 2, None)?;

pub fn clip(&self, min: f32, max: f32) -> Result<Self>

Clip values to a range [min, max]

pub fn pow_tensor(&self, exponent: &Tensor) -> Result<Self>

Element-wise power operation with tensor exponent. For scalar exponents, use the ArithmeticOps::pow trait method instead.

pub fn sqrt(&self) -> Result<Self>

Element-wise square root

pub fn exp(&self) -> Result<Self>

Element-wise exponential (e^x)

pub fn log(&self) -> Result<Self>

Element-wise natural logarithm

pub fn neg(&self) -> Result<Self>

Element-wise negation

pub fn abs(&self) -> Result<Self>

Element-wise absolute value

pub fn leaky_relu(&self, alpha: f32) -> Result<Self>

LeakyReLU activation: max(alpha * x, x)

pub fn elu(&self, alpha: f32) -> Result<Self>

ELU activation: x if x > 0 else alpha * (exp(x) - 1)

pub fn swish(&self) -> Result<Self>

Swish/SiLU activation: x * sigmoid(x)

pub fn squeeze(&self, axes: Option<Vec<usize>>) -> Result<Self>

Remove dimensions of size 1

pub fn unsqueeze(&self, axes: &[usize]) -> Result<Self>

Add dimensions of size 1

pub fn reduce_mean(&self, axes: &[usize], keepdims: bool) -> Result<Self>

Reduce mean along axes

pub fn reduce_sum(&self, axes: &[usize], keepdims: bool) -> Result<Self>

Reduce sum along axes

pub fn cast(&self, to: DataType) -> Result<Self>

Cast tensor to a different data type

pub fn to_scalar_f32(&self) -> Result<f32>

Convert tensor to a scalar f32 value

Trait Implementations

impl ArithmeticOps for Tensor

fn add(&self, other: &Tensor) -> Result<Tensor>

Element-wise addition with broadcasting.

fn sub(&self, other: &Tensor) -> Result<Tensor>

Element-wise subtraction with broadcasting.

fn mul(&self, other: &Tensor) -> Result<Tensor>

Element-wise multiplication with broadcasting.

fn div(&self, other: &Tensor) -> Result<Tensor>

Element-wise division with broadcasting.

fn add_scalar(&self, scalar: f32) -> Result<Tensor>

Add a scalar to all elements.

fn sub_scalar(&self, scalar: f32) -> Result<Tensor>

Subtract a scalar from all elements.

fn mul_scalar(&self, scalar: f32) -> Result<Tensor>

Multiply all elements by a scalar.

fn div_scalar(&self, scalar: f32) -> Result<Tensor>

Divide all elements by a scalar.

fn neg(&self) -> Result<Tensor>

Element-wise negation.

fn abs(&self) -> Result<Tensor>

Element-wise absolute value.

fn pow(&self, exponent: f32) -> Result<Tensor>

Element-wise power operation.

fn sqrt(&self) -> Result<Tensor>

Element-wise square root.

fn exp(&self) -> Result<Tensor>

Element-wise exponential.

fn log(&self) -> Result<Tensor>

Element-wise natural logarithm.

impl Clone for Tensor

fn clone(&self) -> Tensor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Tensor

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

Formats the value using the given formatter.

impl From<Tensor> for Tensor

Convert legacy RonnTensor to new Tensor implementation.

fn from(legacy: RonnTensor) -> Self

Converts to this type from the input type.

impl From<Tensor> for Tensor

Convert new Tensor to legacy RonnTensor for compatibility.

fn from(tensor: Tensor) -> Self

Converts to this type from the input type.

impl MatrixOps for Tensor

fn matmul(&self, other: &Tensor) -> Result<Tensor>

Matrix multiplication.

fn transpose(&self) -> Result<Tensor>

Transpose the tensor (swap last two dimensions).

fn transpose_dims(&self, dim1: usize, dim2: usize) -> Result<Tensor>

Transpose with specific dimension indices.

fn batch_matmul(&self, other: &Tensor) -> Result<Tensor>

Batch matrix multiplication.

impl ReductionOps for Tensor

fn sum_all(&self) -> Result<Tensor>

Sum all elements in the tensor.

fn sum_dims(&self, dims: &[usize], keep_dim: bool) -> Result<Tensor>

Sum along specified dimensions.

fn mean_all(&self) -> Result<Tensor>

Mean of all elements in the tensor.

fn mean_dims(&self, dims: &[usize], keep_dim: bool) -> Result<Tensor>

Mean along specified dimensions.

fn max_all(&self) -> Result<Tensor>

Maximum value in the tensor.

fn max_dims(&self, dims: &[usize], keep_dim: bool) -> Result<Tensor>

Maximum along specified dimensions.

fn min_all(&self) -> Result<Tensor>

Minimum value in the tensor.

fn min_dims(&self, dims: &[usize], keep_dim: bool) -> Result<Tensor>

Minimum along specified dimensions.

fn prod_all(&self) -> Result<Tensor>

Product of all elements.

fn std_all(&self) -> Result<Tensor>

Standard deviation of all elements.

fn var_all(&self) -> Result<Tensor>

Variance of all elements.

fn norm(&self) -> Result<Tensor>

L2 norm (Euclidean norm) of the tensor.

fn norm_p(&self, p: f32) -> Result<Tensor>

Lp norm of the tensor.

impl ShapeOps for Tensor

fn reshape(&self, new_shape: &[usize]) -> Result<Tensor>

Reshape the tensor to a new shape.

fn flatten(&self) -> Result<Tensor>

Flatten the tensor to 1D.

fn flatten_from(&self, start_dim: usize) -> Result<Tensor>

Flatten starting from a specific dimension.

fn squeeze(&self) -> Result<Tensor>

Remove dimensions of size 1.

fn squeeze_dim(&self, dim: usize) -> Result<Tensor>

Remove a specific dimension of size 1.

fn unsqueeze(&self, dim: usize) -> Result<Tensor>

Add a dimension of size 1.

fn permute(&self, dims: &[usize]) -> Result<Tensor>

Permute the dimensions of the tensor.

fn expand(&self, new_shape: &[usize]) -> Result<Tensor>

Expand the tensor to a new shape (broadcasting).

fn view(&self, new_shape: &[usize]) -> Result<Tensor>

View the tensor with a new shape (no data copy).