Struct Tensor 

pub struct Tensor { /* private fields */ }

An n-dimensional, immutable tensor backed by shared Storage.

The layout follows DLPack conventions: C-order shape, element-unit strides (None means C-contiguous), and a byte offset into the backing storage. Constructors validate that every addressable element falls inside the storage, so accessors never fail.

Equality is logical: two tensors are equal when dtype, shape, and element bytes (in C order) match, regardless of how they are laid out in storage.

Implementations

impl Tensor

pub fn from_vec( data: Vec<u8>, shape: Vec<i64>, dtype: DType, ) -> Result<Self, TensorError>

Adopt data as a C-contiguous tensor without copying.

data.len() must equal exactly numel * dtype_size. The buffer keeps its original allocation, so no alignment is guaranteed.

pub fn from_slice( data: &[u8], shape: &[i64], dtype: DType, ) -> Result<Self, TensorError>

Copy data into a fresh 64-byte-aligned C-contiguous tensor.

data.len() must equal exactly numel * dtype_size.

pub fn zeros(shape: &[i64], dtype: DType) -> Result<Self, TensorError>

A zero-filled, 64-byte-aligned C-contiguous tensor.

pub fn from_storage( storage: Storage, dtype: DType, shape: Vec<i64>, strides: Option<Vec<i64>>, byte_offset: usize, ) -> Result<Self, TensorError>

A tensor view over storage with full layout control.

strides are in element units; None means C-contiguous. Dims and strides must be non-negative and every addressable element must fall inside the storage.

pub fn dtype(&self) -> DType

Element data type.

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

Dimension sizes in C order.

pub fn strides(&self) -> Option<&[i64]>

Explicit element-unit strides, or None when C-contiguous.

pub fn effective_strides(&self) -> Cow<'_, [i64]>

Element-unit strides, materializing the C-contiguous default.

pub fn byte_offset(&self) -> usize

Offset in bytes from the start of the storage to the first element.

pub fn device(&self) -> Device

Device the storage lives on. Always Device::Cpu today.

pub fn storage(&self) -> &Storage

The shared backing storage.

pub fn numel(&self) -> usize

Number of elements.

pub fn nbytes(&self) -> usize

Logical size of the element data in bytes (numel * dtype_size).

pub fn is_contiguous(&self) -> bool

Whether elements are laid out C-contiguously.

pub fn reshape(&self, shape: &[i64]) -> Result<Self, TensorError>

A tensor with the same elements and a new shape.

At most one dimension may be -1, which is inferred from the element count. Returns a zero-copy view sharing this tensor’s storage when the layout is contiguous, and a contiguous copy otherwise.

pub fn to_contiguous_bytes(&self) -> Cow<'_, [u8]>

The element bytes in C order.

Borrows from storage when the layout is contiguous; gathers into a fresh buffer otherwise.

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

Stack tensors of identical dtype and shape along a new leading axis.

The result is a fresh 64-byte-aligned contiguous tensor of shape [tensors.len(), ..shape].

pub fn unstack(&self) -> Result<Vec<Tensor>, TensorError>

Split along axis 0 into zero-copy views sharing this storage.

Trait Implementations

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

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.