Enum Tensor 

pub enum Tensor {
    F32(TypedTensor<f32>),
    F64(TypedTensor<f64>),
    I32(TypedTensor<i32>),
    I64(TypedTensor<i64>),
    Bool(TypedTensor<bool>),
    C32(TypedTensor<Complex<f32>>),
    C64(TypedTensor<Complex<f64>>),
}

Dynamic tensor enum over the supported scalar types.

The enum keeps dtype dynamic and rank dynamic. Use TypedTensor<T, R> directly when the scalar type or rank should be represented in Rust’s type system.

Examples

use tenferro_tensor::{Tensor, TypedTensor};

let t = Tensor::F64(TypedTensor::from_vec_col_major(vec![2], vec![1.0, 2.0]).unwrap());
assert_eq!(t.shape(), &[2]);

let erased = Tensor::from_vec_col_major(vec![1, 2], vec![1.0_f64, 2.0]).unwrap();
assert_eq!(erased.shape().len(), 2);

Variants

F32(TypedTensor<f32>)

F64(TypedTensor<f64>)

I32(TypedTensor<i32>)

I64(TypedTensor<i64>)

Bool(TypedTensor<bool>)

C32(TypedTensor<Complex<f32>>)

C64(TypedTensor<Complex<f64>>)

Implementations

impl Tensor

pub fn linear_offset(&self, indices: &[usize]) -> Result<usize, Error>

Compute the linear physical-buffer offset for a logical index.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2, 3], vec![0.0_f64; 6]).unwrap();
assert_eq!(t.linear_offset(&[1, 2])?, 5);

pub fn linear_offset2(&self, i: usize, j: usize) -> Result<usize, Error>

Compute the linear physical-buffer offset for a rank-2 logical index.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2, 3], vec![0.0_f64; 6]).unwrap();
assert_eq!(t.linear_offset2(1, 2)?, 5);

pub fn linear_offset3( &self, i: usize, j: usize, k: usize, ) -> Result<usize, Error>

Compute the linear physical-buffer offset for a rank-3 logical index.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2, 3, 2], vec![0.0_f64; 12]).unwrap();
assert_eq!(t.linear_offset3(1, 2, 1)?, 11);

pub fn get<T>(&self, indices: &[usize]) -> Result<&T, Error>

where T: TensorScalar,

Borrow a single typed element by multi-index.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0]).unwrap();
assert_eq!(t.get::<f64>(&[1])?, &2.0);
assert!(t.get::<f32>(&[1]).is_err());

pub fn get_mut<T>(&mut self, indices: &[usize]) -> Result<&mut T, Error>

where T: TensorScalar,

Mutably borrow a single typed element by multi-index.

Examples

use tenferro_tensor::Tensor;

let mut t = Tensor::from_vec_col_major(vec![1], vec![1.0_f64]).unwrap();
*t.get_mut::<f64>(&[0])? = 2.0;
assert_eq!(t.as_slice::<f64>()?, &[2.0]);

pub unsafe fn get_unchecked<T>(&self, indices: &[usize]) -> Result<&T, Error>

where T: TensorScalar,

Try to borrow a single typed element by multi-index without release-mode bounds checks.

Debug builds still validate the rank and bounds. Dtype and backend host-access failures are still reported as errors.

Safety

indices must have the same rank as this tensor and every index must be in bounds.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0]).unwrap();
assert_eq!(unsafe { *t.get_unchecked::<f64>(&[1])? }, 2.0);

pub unsafe fn get_unchecked_mut<T>( &mut self, indices: &[usize], ) -> Result<&mut T, Error>

where T: TensorScalar,

Try to mutably borrow a single typed element by multi-index without release-mode bounds checks.

Debug builds still validate the rank and bounds. Dtype and backend host-access failures are still reported as errors.

Safety

indices must have the same rank as this tensor and every index must be in bounds.

Examples

use tenferro_tensor::Tensor;

let mut t = Tensor::from_vec_col_major(vec![1], vec![1.0_f64]).unwrap();
unsafe {
    *t.get_unchecked_mut::<f64>(&[0])? = 2.0;
}
assert_eq!(t.as_slice::<f64>()?, &[2.0]);

pub fn as_slice_mut<T>(&mut self) -> Result<&mut [T], Error>

where T: TensorScalar,

Mutably borrow the host data as a typed slice.

Examples

use tenferro_tensor::Tensor;

let mut t = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0]).unwrap();
t.as_slice_mut::<f64>()?[0] = 3.0;
assert_eq!(t.as_slice::<f64>()?, &[3.0, 2.0]);
assert!(t.as_slice_mut::<f32>().is_err());

pub fn iter<T>(&self) -> Result<Iter<'_, T>, Error>

where T: TensorScalar,

Iterate over the contiguous host buffer in physical memory order.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0]).unwrap();
let sum: f64 = t.iter::<f64>()?.copied().sum();
assert_eq!(sum, 3.0);
assert!(t.iter::<f32>().is_err());

pub fn iter_mut<T>(&mut self) -> Result<IterMut<'_, T>, Error>

where T: TensorScalar,

Mutably iterate over the contiguous host buffer in physical memory order.

Examples

use tenferro_tensor::Tensor;

let mut t = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0]).unwrap();
for value in t.iter_mut::<f64>()? {
    *value += 1.0;
}
assert_eq!(t.as_slice::<f64>()?, &[2.0, 3.0]);
assert!(t.iter_mut::<f32>().is_err());

impl Tensor

pub fn index_select( &self, axis: isize, positions: &[usize], ctx: &mut impl TensorBackend, ) -> Result<Tensor, Error>

Select entries from one axis using host-known positions.

Examples

use tenferro_tensor::{Tensor, TensorBackend};

fn select_last_axis<B: TensorBackend>(
    backend: &mut B,
    x: &Tensor,
) -> tenferro_tensor::Result<Tensor> {
    x.index_select(-1, &[2, 0], backend)
}

pub fn stack( tensors: &[&Tensor], dim: isize, ctx: &mut impl TensorBackend, ) -> Result<Tensor, Error>

Stack tensors along a newly inserted axis.

Examples

use tenferro_tensor::{Tensor, TensorBackend};

fn stack_scalars<B: TensorBackend>(
    backend: &mut B,
    a: &Tensor,
    b: &Tensor,
) -> tenferro_tensor::Result<Tensor> {
    Tensor::stack(&[a, b], -1, backend)
}

impl Tensor

pub fn from_vec_col_major<T>( shape: Vec<usize>, data: Vec<T>, ) -> Result<Tensor, Error>

where T: TensorScalar,

Create a tensor from a shape and column-major flat data.

This is the Tensor-level equivalent of TypedTensor::<T>::from_vec_col_major.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2, 2], vec![1.0_f64, 3.0, 2.0, 4.0]).unwrap();
assert_eq!(t.shape(), &[2, 2]);
assert_eq!(t.as_slice::<f64>().unwrap(), &[1.0, 3.0, 2.0, 4.0]);

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

Tensor shape.

Examples

use tenferro_tensor::{Tensor, TypedTensor};

let t = Tensor::F64(TypedTensor::from_vec_col_major(vec![2], vec![1.0, 2.0]).unwrap());
assert_eq!(t.shape(), &[2]);

pub fn dtype(&self) -> DType

Tensor dtype tag.

Examples

use tenferro_tensor::{DType, Tensor, TypedTensor};

let t = Tensor::F64(TypedTensor::from_vec_col_major(vec![], vec![1.0]).unwrap());
assert_eq!(t.dtype(), DType::F64);

pub fn placement(&self) -> &Placement

Return placement metadata for this dtype-erased tensor.

Examples

use tenferro_tensor::{MemoryKind, Tensor};

let t = Tensor::from_vec_col_major(vec![1], vec![1.0_f64]).unwrap();
assert_eq!(t.placement().memory_kind, MemoryKind::UnpinnedHost);

pub fn is_backend_buffer(&self) -> bool

Return whether this tensor is backed by backend-native storage.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![1], vec![1.0_f64]).unwrap();
assert!(!t.is_backend_buffer());

pub fn as_slice<T>(&self) -> Result<&[T], Error>

where T: TensorScalar,

Try to borrow the host data as a typed slice.

Returns an error if the tensor dtype does not match T.

Examples

use tenferro_tensor::{Tensor, TypedTensor};

let t = Tensor::F64(TypedTensor::from_vec_col_major(vec![3], vec![1.0, 2.0, 3.0]).unwrap());
assert_eq!(t.as_slice::<f64>().unwrap(), [1.0, 2.0, 3.0].as_slice());
assert!(t.as_slice::<f32>().is_err());

pub fn into_vec_col_major<T>(self) -> Result<(Vec<usize>, Vec<T>), Error>

where T: TensorScalar,

Consume this tensor and return its owned column-major buffer when the dtype matches.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![1], vec![2.0_f64]).unwrap();
assert_eq!(t.into_vec_col_major::<f64>().unwrap().1, vec![2.0]);

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<(), Error>

Formats the value using the given formatter.

impl From<TypedTensor<Complex<f32>>> for Tensor

Wrap a Complex32 TypedTensor into the corresponding Tensor variant.

Examples

use num_complex::Complex32;
use tenferro_tensor::{Tensor, TypedTensor};

let typed = TypedTensor::from_vec_col_major(
    vec![1],
    vec![Complex32::new(1.0, 2.0)],
).unwrap();
let tensor: Tensor = typed.into();
assert_eq!(tensor.shape(), &[1]);

fn from(t: TypedTensor<Complex<f32>>) -> Tensor

Converts to this type from the input type.

impl From<TypedTensor<Complex<f64>>> for Tensor

Wrap a Complex64 TypedTensor into the corresponding Tensor variant.

Examples

use num_complex::Complex64;
use tenferro_tensor::{Tensor, TypedTensor};

let typed = TypedTensor::from_vec_col_major(
    vec![1],
    vec![Complex64::new(1.0, 2.0)],
).unwrap();
let tensor: Tensor = typed.into();
assert_eq!(tensor.shape(), &[1]);

fn from(t: TypedTensor<Complex<f64>>) -> Tensor

Converts to this type from the input type.

impl From<TypedTensor<bool>> for Tensor

Wrap a bool TypedTensor into the corresponding Tensor variant.

Examples

use tenferro_tensor::{DType, Tensor, TypedTensor};

let typed = TypedTensor::from_vec_col_major(vec![2], vec![true, false]).unwrap();
let tensor: Tensor = typed.into();
assert_eq!(tensor.dtype(), DType::Bool);
assert_eq!(tensor.shape(), &[2]);

fn from(t: TypedTensor<bool>) -> Tensor

Converts to this type from the input type.

impl From<TypedTensor<f32>> for Tensor

Wrap an f32 TypedTensor into the corresponding Tensor variant.

Examples

use tenferro_tensor::{Tensor, TypedTensor};

let typed = TypedTensor::from_vec_col_major(vec![2], vec![1.0_f32, 2.0]).unwrap();
let tensor: Tensor = typed.into();
assert_eq!(tensor.shape(), &[2]);

fn from(t: TypedTensor<f32>) -> Tensor

Converts to this type from the input type.

impl From<TypedTensor<f64>> for Tensor

Wrap an f64 TypedTensor into the corresponding Tensor variant.

Examples

use tenferro_tensor::{Tensor, TypedTensor};

let typed = TypedTensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0]).unwrap();
let tensor: Tensor = typed.into();
assert_eq!(tensor.shape(), &[2]);

fn from(t: TypedTensor<f64>) -> Tensor

Converts to this type from the input type.

impl From<TypedTensor<i32>> for Tensor

Wrap an i32 TypedTensor into the corresponding Tensor variant.

Examples

use tenferro_tensor::{DType, Tensor, TypedTensor};

let typed = TypedTensor::from_vec_col_major(vec![2], vec![1_i32, 2]).unwrap();
let tensor: Tensor = typed.into();
assert_eq!(tensor.dtype(), DType::I32);
assert_eq!(tensor.shape(), &[2]);

fn from(t: TypedTensor<i32>) -> Tensor

Converts to this type from the input type.

impl From<TypedTensor<i64>> for Tensor

Wrap an i64 TypedTensor into the corresponding Tensor variant.

Examples

use tenferro_tensor::{DType, Tensor, TypedTensor};

let typed = TypedTensor::from_vec_col_major(vec![2], vec![1_i64, 2]).unwrap();
let tensor: Tensor = typed.into();
assert_eq!(tensor.dtype(), DType::I64);
assert_eq!(tensor.shape(), &[2]);

fn from(t: TypedTensor<i64>) -> Tensor

Converts to this type from the input type.

impl TensorOpsExt for Tensor

fn convert<B: TensorBackend>( &self, to: DType, backend: &mut B, ) -> Result<Tensor>

Convert to a different dtype using the checked conversion lattice.

fn cast<B: TensorBackend>(&self, to: DType, backend: &mut B) -> Result<Tensor>

Cast to a different dtype using explicit lossy projection.

fn add<B: TensorBackend>(&self, rhs: &Tensor, backend: &mut B) -> Result<Tensor>

Elementwise addition with NumPy-style broadcasting.

fn sub<B: TensorBackend>(&self, rhs: &Tensor, backend: &mut B) -> Result<Tensor>

Elementwise subtraction with NumPy-style broadcasting.

fn mul<B: TensorBackend>(&self, rhs: &Tensor, backend: &mut B) -> Result<Tensor>

Elementwise multiplication with NumPy-style broadcasting.

fn div<B: TensorBackend>(&self, rhs: &Tensor, backend: &mut B) -> Result<Tensor>

Elementwise division with NumPy-style broadcasting.

fn pow<B: TensorBackend>(&self, rhs: &Tensor, backend: &mut B) -> Result<Tensor>

Elementwise power with NumPy-style broadcasting.

fn maximum<B: TensorBackend>( &self, rhs: &Tensor, backend: &mut B, ) -> Result<Tensor>

Elementwise maximum with NumPy-style broadcasting.

fn minimum<B: TensorBackend>( &self, rhs: &Tensor, backend: &mut B, ) -> Result<Tensor>

Elementwise minimum with NumPy-style broadcasting.

fn neg<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>

Elementwise negation.

fn abs<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>

Elementwise absolute value.

fn sign<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>

Elementwise sign.

fn conj<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>

Elementwise complex conjugate.

fn exp<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>

Elementwise exponential.

fn log<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>

Elementwise natural logarithm.

fn sin<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>

Elementwise sine.

fn cos<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>

Elementwise cosine.

fn tanh<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>

Elementwise hyperbolic tangent.

fn sqrt<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>

Elementwise square root.

fn rsqrt<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>

Elementwise reciprocal square root.

fn expm1<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>

Elementwise exp(x) - 1.

fn log1p<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>

Elementwise log(1 + x).

fn compare<B: TensorBackend>( &self, rhs: &Tensor, dir: CompareDir, backend: &mut B, ) -> Result<Tensor>

Elementwise comparison with NumPy-style broadcasting.

fn where_select<B: TensorBackend>( &self, on_true: &Tensor, on_false: &Tensor, backend: &mut B, ) -> Result<Tensor>

Select values from on_true or on_false using this tensor as condition.

fn clamp<B: TensorBackend>( &self, lower: &Tensor, upper: &Tensor, backend: &mut B, ) -> Result<Tensor>

Clamp values elementwise between lower and upper bounds.

fn matmul<B: TensorBackend>( &self, rhs: &Tensor, backend: &mut B, ) -> Result<Tensor>

Rank-2 matrix multiplication.

fn reshape<B: TensorBackend>( &self, shape: &[usize], backend: &mut B, ) -> Result<Tensor>

Reshape without changing element order.

fn transpose<B: TensorBackend>( &self, perm: &[usize], backend: &mut B, ) -> Result<Tensor>

Permute axes.

fn reduce_sum<B: TensorBackend>( &self, axes: &[usize], backend: &mut B, ) -> Result<Tensor>

Sum over one or more axes.