Struct Tensor 

pub struct Tensor<T: Scalar, B: Backend> { /* private fields */ }

A multi-dimensional tensor with stride-based layout.

Tensors support zero-copy view operations (permute, reshape) and automatically make data contiguous when needed for operations like GEMM.

Type Parameters

• T - The scalar element type (f32, f64, etc.)
• B - The backend type (Cpu, Cuda)

Example

use omeinsum::{Tensor, Cpu};

let a = Tensor::<f32, Cpu>::from_data(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], &[2, 3]);
let b = a.permute(&[1, 0]);  // Zero-copy transpose
let c = b.contiguous();      // Make contiguous copy

Implementations

impl<T: Scalar, B: Backend> Tensor<T, B>

pub fn contract_binary<A: Algebra<Scalar = T, Index = u32>>( &self, other: &Self, ia: &[usize], ib: &[usize], iy: &[usize], ) -> Self

where T: BackendScalar<B>,

Binary tensor contraction using reshape-to-GEMM strategy.

Arguments

• other - The other tensor to contract with
• ia - Index labels for self
• ib - Index labels for other
• iy - Output index labels

Example

use omeinsum::{Tensor, Cpu};
use omeinsum::algebra::MaxPlus;

// A[i,j,k] × B[j,k,l] → C[i,l]
let a = Tensor::<f32, Cpu>::from_data(&(0..24).map(|x| x as f32).collect::<Vec<_>>(), &[2, 3, 4]);
let b = Tensor::<f32, Cpu>::from_data(&(0..60).map(|x| x as f32).collect::<Vec<_>>(), &[3, 4, 5]);
let c = a.contract_binary::<MaxPlus<f32>>(&b, &[0, 1, 2], &[1, 2, 3], &[0, 3]);
assert_eq!(c.shape(), &[2, 5]);

pub fn contract_binary_with_argmax<A: Algebra<Scalar = T, Index = u32>>( &self, other: &Self, ia: &[usize], ib: &[usize], iy: &[usize], ) -> (Self, Tensor<u32, B>)

where T: BackendScalar<B>,

Binary contraction with argmax tracking.

impl<T: Scalar, B: Backend> Tensor<T, B>

pub fn from_data(data: &[T], shape: &[usize]) -> Self

where B: Default,

Create a tensor from data with the given shape.

Data is assumed to be in column-major (Fortran) order.

pub fn from_data_with_backend(data: &[T], shape: &[usize], backend: B) -> Self

Create a tensor from data with explicit backend.

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

where B: Default,

Create a zero-filled tensor.

pub fn zeros_with_backend(shape: &[usize], backend: B) -> Self

Create a zero-filled tensor with explicit backend.

pub fn from_storage(storage: B::Storage<T>, shape: &[usize], backend: B) -> Self

Create a tensor from storage with given shape.

The storage must be contiguous and have exactly shape.iter().product() elements.

pub fn storage(&self) -> Option<&B::Storage<T>>

Get a reference to the underlying storage.

Returns Some(&storage) only if the tensor is contiguous and has no offset. For non-contiguous tensors, call contiguous() first.

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

Get the shape of the tensor.

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

Get the strides 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 backend(&self) -> &B

Get the backend.

pub fn is_contiguous(&self) -> bool

Check if the tensor is contiguous in memory (row-major).

pub fn to_vec(&self) -> Vec<T>

Copy all data to a Vec.

pub fn as_slice(&self) -> Option<&[T]>

where B::Storage<T>: AsRef<[T]>,

Get underlying storage (only if contiguous).

pub fn get(&self, index: usize) -> T

Get element at linear index (column-major).

This is an O(ndim) operation that directly accesses storage without allocating memory. The linear index is interpreted in column-major order.

Arguments

• index - Linear index into the flattened tensor (column-major order)

Panics

Panics if index is out of bounds.

Example

use omeinsum::{Tensor, Cpu};

let t = Tensor::<f32, Cpu>::from_data(&[1.0, 2.0, 3.0, 4.0], &[2, 2]);
assert_eq!(t.get(0), 1.0);
assert_eq!(t.get(3), 4.0);

pub fn permute(&self, axes: &[usize]) -> Self

Permute dimensions (zero-copy).

Example

use omeinsum::{Tensor, Cpu};

let data: Vec<f32> = (0..24).map(|x| x as f32).collect();
let a = Tensor::<f32, Cpu>::from_data(&data, &[2, 3, 4]);
let b = a.permute(&[2, 0, 1]);  // Shape becomes [4, 2, 3]
assert_eq!(b.shape(), &[4, 2, 3]);

pub fn t(&self) -> Self

Transpose (2D shorthand for permute).

pub fn reshape(&self, new_shape: &[usize]) -> Self

Reshape to a new shape (zero-copy if contiguous).

Example

use omeinsum::{Tensor, Cpu};

let a = Tensor::<f32, Cpu>::from_data(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], &[2, 3]);
let b = a.reshape(&[6]);      // Flatten
let c = a.reshape(&[3, 2]);   // Different shape, same data
assert_eq!(b.shape(), &[6]);
assert_eq!(c.shape(), &[3, 2]);

pub fn contiguous(&self) -> Self

Make tensor contiguous in memory.

If already contiguous, returns a clone (shared storage). Otherwise, copies data to a new contiguous buffer.

pub fn sum<A: Algebra<Scalar = T>>(&self) -> T

Sum all elements using the algebra’s addition.

Type Parameters

• A - The algebra to use for summation

Example

use omeinsum::{Tensor, Cpu, Standard};

let t = Tensor::<f32, Cpu>::from_data(&[1.0, 2.0, 3.0, 4.0], &[2, 2]);
let sum = t.sum::<Standard<f32>>();
assert_eq!(sum, 10.0);

pub fn sum_axis<A: Algebra<Scalar = T>>(&self, axis: usize) -> Self

where B: Default,

Sum along a specific axis using the algebra’s addition.

The result has one fewer dimension than the input.

Arguments

• axis - The axis to sum over

Panics

Panics if axis is out of bounds.

Example

use omeinsum::{Tensor, Cpu, Standard};

// Column-major: data [1, 2, 3, 4] with shape [2, 2] represents:
// [[1, 3],
//  [2, 4]]
let t = Tensor::<f32, Cpu>::from_data(&[1.0, 2.0, 3.0, 4.0], &[2, 2]);
// Sum over axis 1 (columns): [1+3, 2+4] = [4, 6]
let result = t.sum_axis::<Standard<f32>>(1);
assert_eq!(result.to_vec(), vec![4.0, 6.0]);

pub fn diagonal(&self) -> Self

where B: Default,

Extract diagonal elements from a 2D tensor.

Panics

Panics if the tensor is not 2D or not square.

Example

use omeinsum::{Tensor, Cpu};

let t = Tensor::<f32, Cpu>::from_data(&[1.0, 2.0, 3.0, 4.0], &[2, 2]);
let diag = t.diagonal();
assert_eq!(diag.to_vec(), vec![1.0, 4.0]);

Trait Implementations

impl<T: Clone + Scalar, B: Clone + Backend> Clone for Tensor<T, B>

where B::Storage<T>: Clone,

fn clone(&self) -> Tensor<T, B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Scalar, B: Backend> Debug for Tensor<T, B>

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

Formats the value using the given formatter.

impl<'a, T: Scalar, B: Backend> From<&'a Tensor<T, B>> for TensorView<'a, T, B>

fn from(tensor: &'a Tensor<T, B>) -> Self

Converts to this type from the input type.