Struct FactorizeResult 

#[non_exhaustive]
pub struct FactorizeResult<T: TensorIndex> {
    pub left: T,
    pub right: T,
    pub bond_index: T::Index,
    pub singular_values: Option<Vec<f64>>,
    pub rank: usize,
    /* private fields */
}

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, TensorContractionLike, IdxTensor,
};

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 = IdxTensor::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_pair(&result.right).unwrap();
assert!(tensor.distance(&recovered).unwrap() < 1e-12);

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

This struct is #[non_exhaustive]: it carries a private algorithm-internal field (incremental_qr_state) that downstream crates cannot see or set, so external construction always goes through FactorizeResult::new rather than struct-literal syntax.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

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.

Implementations

impl<T: TensorIndex> FactorizeResult<T>

pub fn new( left: T, right: T, bond_index: T::Index, singular_values: Option<Vec<f64>>, rank: usize, ) -> Self

Construct a factorization result without an algorithm-private update state.

Arguments

• left - Left factor tensor.
• right - Right factor tensor.
• bond_index - Index connecting the two factors.
• singular_values - Singular values when the result came from SVD.
• rank - Number of columns in the factorization.

Returns

A factorization result suitable for public factorization APIs. Native incremental QR callers attach their private update state afterward.

Examples

use tensor4all_core::{DynIndex, FactorizeResult, IdxTensor};

let left_index = DynIndex::new_dyn(1);
let bond = DynIndex::new_bond(1).unwrap();
let left = IdxTensor::from_dense(vec![left_index.clone(), bond.clone()], vec![1.0]).unwrap();
let right = IdxTensor::from_dense(vec![bond.clone()], vec![2.0]).unwrap();
let result = FactorizeResult::new(left, right, bond, None, 1);
assert_eq!(result.rank, 1);

Trait Implementations

impl<T: Clone + TensorIndex> 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 + TensorIndex> Debug for FactorizeResult<T>

where T::Index: Debug,

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

Formats the value using the given formatter.