Struct StructuredTensor 

pub struct StructuredTensor<T: Scalar>(pub StructuredTensor<T>);

AD-capable structured tensor wrapper shared by dynamic tenferro frontends.

This newtype keeps Differentiable and placement helpers on top of tenferro_tensor::StructuredTensor<T>.

Examples

use tenferro_internal_frontend_core::StructuredTensor;
use tenferro_tensor::{MemoryOrder, Tensor};

let payload = Tensor::<f64>::from_slice(&[1.0, 2.0], &[2], MemoryOrder::ColumnMajor).unwrap();
let wrapped = StructuredTensor::from(payload);
assert!(wrapped.is_dense());

Tuple Fields

0: StructuredTensor<T>

Implementations

impl<T: Scalar> StructuredTensor<T>

pub fn with_payload_like(&self, payload: Tensor<T>) -> Result<Self>

pub fn into_payload(self) -> Tensor<T>

pub fn permute_logical(&self, perm: &[usize]) -> Result<Self>

pub fn conj(&self) -> Self

where T: Conjugate,

pub fn to_dense(&self) -> Result<Tensor<T>>

pub fn memory_space(&self) -> LogicalMemorySpace

pub fn preferred_compute_device(&self) -> Option<ComputeDevice>

pub fn set_preferred_compute_device(&mut self, device: Option<ComputeDevice>)

pub fn to_memory_space_async(&self, target: LogicalMemorySpace) -> Result<Self>

pub fn wait(&self)

pub fn is_ready(&self) -> bool

Methods from Deref<Target = StructuredTensor<T>>

pub fn to_dense(&self) -> Result<Tensor<T>, Error>

Materialize this structured tensor into a dense tensor.

Examples

use tenferro_tensor::{MemoryOrder, StructuredTensor, Tensor};

let payload =
    Tensor::<f64>::from_slice(&[1.0, 2.0], &[2], MemoryOrder::ColumnMajor).unwrap();
let x = StructuredTensor::from_diagonal_vector(payload, 2).unwrap();
let dense = x.to_dense().unwrap();
assert_eq!(dense.dims(), &[2, 2]);
assert_eq!(dense.get(&[0, 0]), Some(&1.0));
assert_eq!(dense.get(&[0, 1]), Some(&0.0));

pub fn permute_logical( &self, perm: &[usize], ) -> Result<StructuredTensor<T>, Error>

Returns the same logical tensor with permuted logical axes.

This permutes both the logical axes and the compressed payload class order, then rebuilds the canonical axis-class representation.

Examples

use tenferro_tensor::{MemoryOrder, StructuredTensor, Tensor};

let dense = Tensor::<f64>::from_slice(
    &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0],
    &[2, 3],
    MemoryOrder::ColumnMajor,
)
.unwrap();
let x = StructuredTensor::from_dense(dense);
let y = x.permute_logical(&[1, 0]).unwrap();
assert_eq!(y.logical_dims(), &[3, 2]);

pub fn conj(&self) -> StructuredTensor<T>

where T: Conjugate,

Returns the same structured tensor with payload conjugation toggled.

Examples

use num_complex::Complex64;
use tenferro_tensor::{MemoryOrder, StructuredTensor, Tensor};

let payload = Tensor::<Complex64>::from_slice(
    &[Complex64::new(1.0, 2.0), Complex64::new(3.0, 4.0)],
    &[2],
    MemoryOrder::ColumnMajor,
)
.unwrap();
let x = StructuredTensor::from_diagonal_vector(payload, 2).unwrap();
let y = x.conj();
assert_eq!(y.logical_dims(), x.logical_dims());

pub fn payload(&self) -> &Tensor<T>

Borrow the compressed payload tensor.

Examples

use tenferro_tensor::{MemoryOrder, StructuredTensor, Tensor};

let dense =
    Tensor::<f64>::from_slice(&[1.0, 2.0], &[2], MemoryOrder::ColumnMajor).unwrap();
let x = StructuredTensor::from_dense(dense);
assert_eq!(x.payload().dims(), &[2]);

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

Returns logical dimensions.

Examples

use tenferro_tensor::{MemoryOrder, StructuredTensor, Tensor};

let payload =
    Tensor::<f64>::from_slice(&[1.0, 2.0], &[2], MemoryOrder::ColumnMajor).unwrap();
let x = StructuredTensor::from_diagonal_vector(payload, 2).unwrap();
assert_eq!(x.logical_dims(), &[2, 2]);

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

Returns axis classes for logical axes.

Examples

use tenferro_tensor::{MemoryOrder, StructuredTensor, Tensor};

let payload =
    Tensor::<f64>::from_slice(&[1.0, 2.0], &[2], MemoryOrder::ColumnMajor).unwrap();
let x = StructuredTensor::from_diagonal_vector(payload, 2).unwrap();
assert_eq!(x.axis_classes(), &[0, 0]);

pub fn class_count(&self) -> usize

Returns the number of distinct axis classes.

Examples

use tenferro_tensor::{MemoryOrder, StructuredTensor, Tensor};

let payload =
    Tensor::<f64>::from_slice(&[1.0, 2.0], &[2], MemoryOrder::ColumnMajor).unwrap();
let x = StructuredTensor::from_diagonal_vector(payload, 3).unwrap();
assert_eq!(x.class_count(), 1);

pub fn is_dense(&self) -> bool

Returns true when the layout is dense.

Examples

use tenferro_tensor::{MemoryOrder, StructuredTensor, Tensor};

let dense = Tensor::<f64>::from_slice(
    &[1.0, 2.0, 3.0, 4.0],
    &[2, 2],
    MemoryOrder::ColumnMajor,
)
.unwrap();
let x = StructuredTensor::from_dense(dense);
assert!(x.is_dense());

pub fn is_diag(&self) -> bool

Returns true when the layout is a pure diagonal.

Examples

use tenferro_tensor::{MemoryOrder, StructuredTensor, Tensor};

let payload =
    Tensor::<f64>::from_slice(&[1.0, 2.0], &[2], MemoryOrder::ColumnMajor).unwrap();
let x = StructuredTensor::from_diagonal_vector(payload, 2).unwrap();
assert!(x.is_diag());

pub fn with_payload_like( &self, payload: Tensor<T>, ) -> Result<StructuredTensor<T>, Error>

Rebuild the same structured layout with a different payload tensor.

Examples

use tenferro_tensor::{MemoryOrder, StructuredTensor, Tensor};

let payload =
    Tensor::<f64>::from_slice(&[1.0, 2.0], &[2], MemoryOrder::ColumnMajor).unwrap();
let layout = StructuredTensor::from_diagonal_vector(payload, 2).unwrap();
let replacement =
    Tensor::<f64>::from_slice(&[3.0, 4.0], &[2], MemoryOrder::ColumnMajor).unwrap();
let updated = layout.with_payload_like(replacement).unwrap();
assert!(updated.is_diag());

Trait Implementations

impl<T: Scalar> AsRef<Tensor<T>> for StructuredTensor<T>

fn as_ref(&self) -> &Tensor<T>

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Clone + Scalar> Clone for StructuredTensor<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Scalar> Debug for StructuredTensor<T>

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

Formats the value using the given formatter.

impl<T: Scalar> Deref for StructuredTensor<T>

type Target = StructuredTensor<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Scalar> DerefMut for StructuredTensor<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T> Differentiable for StructuredTensor<T>

where T: Scalar,

type Tangent = StructuredTensor<T>

The tangent type for this value.

fn zero_tangent(&self) -> Self::Tangent

Returns the zero tangent for this value (additive identity).

fn accumulate_tangent(a: Self::Tangent, b: &Self::Tangent) -> Self::Tangent

Accumulates (adds) two tangents: a + b.

fn num_elements(&self) -> usize

Returns the number of scalar elements in this value.

fn seed_cotangent(&self) -> Self::Tangent

Returns the seed cotangent for reverse-mode pullback.

impl From<StructuredTensor<Complex<f32>>> for DynTensor

fn from(value: StructuredTensor<Complex32>) -> Self

Converts to this type from the input type.

impl From<StructuredTensor<Complex<f64>>> for DynTensor

fn from(value: StructuredTensor<Complex64>) -> Self

Converts to this type from the input type.

impl<T: Scalar> From<StructuredTensor<T>> for StructuredTensor<T>

fn from(inner: StructuredTensor<T>) -> Self

Converts to this type from the input type.

impl From<StructuredTensor<f32>> for DynTensor

fn from(value: StructuredTensor<f32>) -> Self

Converts to this type from the input type.

impl From<StructuredTensor<f64>> for DynTensor

fn from(value: StructuredTensor<f64>) -> Self

Converts to this type from the input type.

impl<T: Scalar> From<Tensor<T>> for StructuredTensor<T>

fn from(tensor: Tensor<T>) -> Self

Converts to this type from the input type.