Struct TypedTensor 

pub struct TypedTensor<T> {
    pub buffer: Buffer<T>,
    pub shape: Vec<usize>,
    pub placement: Placement,
}

Contiguous column-major typed tensor storage.

Examples

use tenferro_tensor::TypedTensor;

let t = TypedTensor::<f64>::from_vec(vec![2, 2], vec![1.0, 2.0, 3.0, 4.0]);
assert_eq!(t.shape, vec![2, 2]);

Fields

buffer: Buffer<T>

shape: Vec<usize>

placement: Placement

Implementations

impl<T: TensorScalar> TypedTensor<T>

pub fn svd( &self, ctx: &mut impl TensorBackend, ) -> Result<(Self, TypedTensor<T::Real>, Self)>

Singular value decomposition: A = U diag(S) Vt.

Returns (U, S, Vt) using the thin/economy SVD.

For complex inputs, this wrapper expects the backend to return the singular values as TypedTensor<T::Real>. If the backend still returns a complex tensor for S, this method returns Error::DTypeMismatch.

Examples

use tenferro_tensor::{cpu::CpuBackend, TensorBackend, TypedTensor};

let mut ctx = CpuBackend::new();
let a = TypedTensor::<f64>::from_vec(vec![2, 2], vec![1.0, 0.0, 0.0, 2.0]);
let (u, s, vt) = a.svd(&mut ctx).unwrap();

assert_eq!(u.shape, vec![2, 2]);
assert_eq!(s.shape, vec![2]);
assert_eq!(vt.shape, vec![2, 2]);

pub fn qr(&self, ctx: &mut impl TensorBackend) -> Result<(Self, Self)>

QR decomposition: A = Q R.

Returns (Q, R) using the thin/economy QR decomposition.

Examples

use tenferro_tensor::{cpu::CpuBackend, TensorBackend, TypedTensor};

let mut ctx = CpuBackend::new();
let a = TypedTensor::<f64>::from_vec(vec![2, 2], vec![1.0, 2.0, 3.0, 4.0]);
let (q, r) = a.qr(&mut ctx).unwrap();

assert_eq!(q.shape, vec![2, 2]);
assert_eq!(r.shape, vec![2, 2]);

pub fn cholesky(&self, ctx: &mut impl TensorBackend) -> Result<Self>

Cholesky factorization: A = L L^T or A = L L^H.

Returns the lower-triangular factor L.

Examples

use tenferro_tensor::{cpu::CpuBackend, TensorBackend, TypedTensor};

let mut ctx = CpuBackend::new();
let a = TypedTensor::<f64>::from_vec(vec![2, 2], vec![4.0, 1.0, 1.0, 3.0]);
let l = a.cholesky(&mut ctx).unwrap();

assert_eq!(l.shape, vec![2, 2]);

pub fn eigh( &self, ctx: &mut impl TensorBackend, ) -> Result<(TypedTensor<T::Real>, Self)>

Symmetric or Hermitian eigendecomposition: A = V diag(W) V^T.

Returns (eigenvalues, eigenvectors).

For complex inputs, this wrapper expects the backend to return the eigenvalues as TypedTensor<T::Real>. If the backend still returns a complex tensor for W, this method returns Error::DTypeMismatch.

Examples

use tenferro_tensor::{cpu::CpuBackend, TensorBackend, TypedTensor};

let mut ctx = CpuBackend::new();
let a = TypedTensor::<f64>::from_vec(vec![2, 2], vec![4.0, 1.0, 1.0, 3.0]);
let (w, v) = a.eigh(&mut ctx).unwrap();

assert_eq!(w.shape, vec![2]);
assert_eq!(v.shape, vec![2, 2]);

impl<T: Clone + Zero> TypedTensor<T>

pub fn zeros(shape: Vec<usize>) -> Self

Allocate a zero-filled tensor.

Examples

use tenferro_tensor::TypedTensor;

let t = TypedTensor::<f64>::zeros(vec![2, 3]);
assert_eq!(t.n_elements(), 6);

impl<T: Clone + One + Zero> TypedTensor<T>

pub fn ones(shape: Vec<usize>) -> Self

Allocate a one-filled tensor.

Examples

use tenferro_tensor::TypedTensor;

let t = TypedTensor::<f64>::ones(vec![2]);
assert_eq!(t.host_data(), &[1.0, 1.0]);

impl<T: Clone> TypedTensor<T>

pub fn from_vec(shape: Vec<usize>, data: Vec<T>) -> Self

Create a tensor from a column-major buffer.

Examples

use tenferro_tensor::TypedTensor;

let t = TypedTensor::<f64>::from_vec(vec![2, 2], vec![1.0, 2.0, 3.0, 4.0]);
assert_eq!(t.get(&[1, 0]), &2.0);

pub fn n_elements(&self) -> usize

Number of elements in the tensor.

Examples

use tenferro_tensor::TypedTensor;

let t = TypedTensor::<f64>::from_vec(vec![2, 3], vec![0.0; 6]);
assert_eq!(t.n_elements(), 6);

pub fn host_data(&self) -> &[T]

Borrow the host buffer.

Examples

use tenferro_tensor::TypedTensor;

let t = TypedTensor::<f64>::from_vec(vec![2], vec![1.0, 2.0]);
assert_eq!(t.host_data(), &[1.0, 2.0]);

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

View the tensor data as a flat slice.

This is an alias for host_data() for API consistency with Tensor::as_slice.

Examples

use tenferro_tensor::TypedTensor;

let t = TypedTensor::<f64>::from_vec(vec![2], vec![1.0, 2.0]);
assert_eq!(t.as_slice(), &[1.0, 2.0]);

pub fn host_data_mut(&mut self) -> &mut [T]

Mutably borrow the host buffer.

Examples

use tenferro_tensor::TypedTensor;

let mut t = TypedTensor::<f64>::zeros(vec![2]);
t.host_data_mut()[0] = 3.0;
assert_eq!(t.host_data(), &[3.0, 0.0]);

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

Compute the linear column-major offset for an index.

Examples

use tenferro_tensor::TypedTensor;

let t = TypedTensor::<f64>::zeros(vec![2, 3]);
assert_eq!(t.linear_offset(&[1, 2]), 5);

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

Borrow a single element by multi-index.

Examples

use tenferro_tensor::TypedTensor;

let t = TypedTensor::<f64>::from_vec(vec![2], vec![1.0, 2.0]);
assert_eq!(t.get(&[1]), &2.0);

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

Mutably borrow a single element by multi-index.

Examples

use tenferro_tensor::TypedTensor;

let mut t = TypedTensor::<f64>::zeros(vec![1]);
*t.get_mut(&[0]) = 7.0;
assert_eq!(t.host_data(), &[7.0]);

Trait Implementations

impl<T: Clone> Clone for TypedTensor<T>

fn clone(&self) -> TypedTensor<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for TypedTensor<T>

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

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(
    vec![1],
    vec![Complex32::new(1.0, 2.0)],
);
let tensor: Tensor = typed.into();
assert_eq!(tensor.shape(), &[1]);

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

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(
    vec![1],
    vec![Complex64::new(1.0, 2.0)],
);
let tensor: Tensor = typed.into();
assert_eq!(tensor.shape(), &[1]);

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

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(vec![2], vec![1.0_f32, 2.0]);
let tensor: Tensor = typed.into();
assert_eq!(tensor.shape(), &[2]);

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

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(vec![2], vec![1.0_f64, 2.0]);
let tensor: Tensor = typed.into();
assert_eq!(tensor.shape(), &[2]);

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

Converts to this type from the input type.