Struct Tensor 

pub struct Tensor { /* private fields */ }

The core Tensor type

Tensors are multi-dimensional arrays with:

• Shared storage (enables zero-copy views)
• Shape and strides (enables non-contiguous layouts)
• Optional gradient tracking for autograd

Implementations

impl Tensor

pub fn from_slice<T: TensorElement>(data: &[T], shape: &[usize]) -> Result<Self>

Create a new tensor from a flat slice and shape

pub fn zeros(shape: &[usize]) -> Self

Create a tensor filled with zeros

pub fn ones(shape: &[usize]) -> Self

Create a tensor filled with ones

pub fn full<T: TensorElement>(shape: &[usize], value: T) -> Self

Create a tensor filled with a constant value

pub fn rand(shape: &[usize]) -> Self

Create a tensor with random values from uniform distribution [0, 1)

pub fn randn(shape: &[usize]) -> Self

Create a tensor with random values from standard normal distribution

pub fn eye(n: usize) -> Self

Create an identity matrix

pub fn arange(start: f32, end: f32, step: f32) -> Self

Create a 1D tensor with evenly spaced values

pub fn linspace(start: f32, end: f32, n: usize) -> Self

Create a 1D tensor with n evenly spaced values between start and end

pub fn shape(&self) -> &Shape

Get the shape of the tensor

pub fn dims(&self) -> &[usize]

Get dimensions as slice

pub fn ndim(&self) -> usize

Number of dimensions

pub fn numel(&self) -> usize

Total number of elements

pub fn dtype(&self) -> DType

Get the data type

pub fn strides(&self) -> &Strides

Get strides

pub fn is_contiguous(&self) -> bool

Check if tensor is contiguous in memory

pub fn requires_grad(&self) -> bool

Check if gradient tracking is enabled

pub fn set_requires_grad(&mut self, requires_grad: bool)

Enable gradient tracking

pub fn grad(&self) -> Option<Tensor>

Get gradient if available

pub fn storage(&self) -> &Storage

Get reference to underlying storage

pub fn set_grad(&mut self, grad: Tensor)

Set gradient

pub fn zero_grad(&mut self)

Zero out gradient

pub fn data_f32(&self) -> Vec<f32>

Get data as f32 slice (for f32 tensors)

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

Reshape tensor to new shape (must have same numel)

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

Flatten tensor to 1D

pub fn transpose(&self, dim0: usize, dim1: usize) -> Result<Tensor>

Transpose dimensions

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

Transpose for 2D tensors (matrix transpose)

pub fn squeeze(&self) -> Tensor

Squeeze: remove dimensions of size 1

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

Unsqueeze: add dimension of size 1 at position

pub fn deep_clone(&self) -> Self

Deep clone (copies data)

impl Tensor

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

Element-wise addition

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

Element-wise subtraction

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

Element-wise multiplication

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

Element-wise division

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

Add scalar

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

Subtract scalar

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

Multiply by scalar

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

Divide by scalar

pub fn neg(&self) -> Tensor

Negation

pub fn abs(&self) -> Tensor

Absolute value

pub fn pow(&self, exp: f32) -> Tensor

Power

pub fn sqrt(&self) -> Tensor

Square root

pub fn exp(&self) -> Tensor

Exponential

pub fn log(&self) -> Tensor

Natural logarithm

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

Clamp values to range

impl Tensor

pub fn sum(&self) -> Tensor

Sum all elements

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

Sum along dimension

pub fn mean(&self) -> Tensor

Mean of all elements

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

Mean along dimension

pub fn max(&self) -> Tensor

Maximum element

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

Maximum along dimension

pub fn min(&self) -> Tensor

Minimum element

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

Minimum along dimension

pub fn prod(&self) -> Tensor

Product of all elements

pub fn var(&self, unbiased: bool) -> Tensor

Variance of all elements

pub fn std(&self, unbiased: bool) -> Tensor

Standard deviation

pub fn argmax(&self) -> Tensor

Argmax - index of maximum element

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

Argmax along dimension

pub fn argmin(&self) -> Tensor

Argmin - index of minimum element

pub fn norm(&self) -> Tensor

L2 norm

pub fn norm_l1(&self) -> Tensor

L1 norm

impl Tensor

pub fn relu(&self) -> Tensor

ReLU activation: max(0, x)

pub fn leaky_relu(&self, alpha: f32) -> Tensor

Leaky ReLU: max(alpha * x, x)

pub fn elu(&self, alpha: f32) -> Tensor

ELU activation

pub fn selu(&self) -> Tensor

SELU activation (self-normalizing)

pub fn sigmoid(&self) -> Tensor

Sigmoid activation: 1 / (1 + exp(-x))

pub fn tanh(&self) -> Tensor

Tanh activation

pub fn gelu(&self) -> Tensor

GELU activation (Gaussian Error Linear Unit)

pub fn silu(&self) -> Tensor

SiLU / Swish activation: x * sigmoid(x)

pub fn mish(&self) -> Tensor

Mish activation: x * tanh(softplus(x))

pub fn softplus(&self) -> Tensor

Softplus: log(1 + exp(x))

pub fn softsign(&self) -> Tensor

Softsign: x / (1 + |x|)

pub fn softmax(&self, dim: i32) -> Tensor

Softmax along last dimension

pub fn log_softmax(&self, dim: i32) -> Tensor

Log softmax (numerically stable)

pub fn hardtanh(&self, min_val: f32, max_val: f32) -> Tensor

Hardtanh: clamp(x, min, max)

pub fn hardsigmoid(&self) -> Tensor

Hard sigmoid: clamp((x + 3) / 6, 0, 1)

pub fn hardswish(&self) -> Tensor

Hard swish: x * hardsigmoid(x)

impl Tensor

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

Matrix multiplication Supports:

• 2D x 2D: standard matmul
• Batched: broadcast batch dimensions

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

Vector dot product

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

Outer product of two vectors

pub fn mv(&self, vec: &Tensor) -> Result<Tensor>

Matrix-vector multiplication

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

Batch matrix-matrix multiplication (bmm)

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

Compute trace of a matrix

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

Compute diagonal of a matrix

impl Tensor

Tensor operations with NEON acceleration

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

Add two tensors using NEON

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

Multiply two tensors using NEON

pub fn relu_neon(&self) -> Tensor

ReLU activation using NEON

Trait Implementations

impl Add for &Tensor

type Output = Tensor

The resulting type after applying the + operator.

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

Performs the + operation.

impl Clone for Tensor

fn clone(&self) -> Self

Shallow clone (shares storage)

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 Display for Tensor

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

Formats the value using the given formatter.

impl Div for &Tensor

type Output = Tensor

The resulting type after applying the / operator.

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

Performs the / operation.

impl HardwareOps for Tensor

fn matmul_hw(&self, other: &Tensor, device: &HardwareDevice) -> Result<Tensor>

Matrix multiplication on hardware

fn conv2d_hw(&self, kernel: &Tensor, device: &HardwareDevice) -> Result<Tensor>

Convolution on hardware

fn elementwise_hw( &self, op: ElementwiseOp, device: &HardwareDevice, ) -> Result<Tensor>

Element-wise operations on hardware

impl Mul for &Tensor

type Output = Tensor

The resulting type after applying the * operator.

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

Performs the * operation.

impl Neg for &Tensor

type Output = Tensor

The resulting type after applying the - operator.

fn neg(self) -> Tensor

Performs the unary - operation.

impl Sub for &Tensor

type Output = Tensor

The resulting type after applying the - operator.

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

Performs the - operation.