Struct FactorizeResult 

pub struct FactorizeResult<T: TensorLike> {
    pub left: T,
    pub right: T,
    pub bond_index: T::Index,
    pub singular_values: Option<Vec<f64>>,
    pub rank: usize,
}

Result of tensor factorization.

Contains the two factors, the bond index connecting them, and metadata about the decomposition. The original tensor can be recovered (up to truncation error) by contracting left and right along bond_index.

Examples

use tensor4all_core::{factorize, DynIndex, FactorizeOptions, TensorDynLen};

let i = DynIndex::new_dyn(3);
let j = DynIndex::new_dyn(4);
let data: Vec<f64> = (0..12).map(|x| x as f64).collect();
let tensor = TensorDynLen::from_dense(vec![i.clone(), j.clone()], data).unwrap();

let result = factorize(&tensor, &[i.clone()], &FactorizeOptions::svd()).unwrap();

// Contracting left * right recovers the original tensor
let recovered = result.left.contract(&result.right);
assert!(tensor.distance(&recovered) < 1e-12);

// SVD provides singular values
assert!(result.singular_values.is_some());
assert_eq!(result.singular_values.as_ref().unwrap().len(), result.rank);

Fields

left: T

Left factor tensor.

right: T

Right factor tensor.

bond_index: T::Index

Bond index connecting left and right factors.

singular_values: Option<Vec<f64>>

Singular values (only for SVD).

rank: usize

Rank of the factorization.

Trait Implementations

impl<T: Clone + TensorLike> Clone for FactorizeResult<T>

where T::Index: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + TensorLike> Debug for FactorizeResult<T>

where T::Index: Debug,

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

Formats the value using the given formatter.