Struct TTCache 

pub struct TTCache<T: TTScalar> { /* private fields */ }

Cached tensor train evaluator.

Wraps a tensor train and caches left and right partial contractions so that repeated evaluations sharing common prefixes or suffixes reuse previously computed results. This is particularly effective for batch evaluation via evaluate_many.

Examples

use tensor4all_simplett::{TensorTrain, AbstractTensorTrain, TTCache};

let tt = TensorTrain::<f64>::constant(&[2, 3, 4], 5.0);
let mut cache = TTCache::new(&tt);

// Single evaluation (caches intermediate contractions)
let val = cache.evaluate(&[1, 2, 3]).unwrap();
assert!((val - 5.0).abs() < 1e-12);

// Batch evaluation reuses cached partial contractions
let indices = vec![vec![0, 0, 0], vec![1, 2, 3], vec![0, 1, 2]];
let vals = cache.evaluate_many(&indices, None).unwrap();
assert!(vals.iter().all(|&v| (v - 5.0).abs() < 1e-12));

Implementations

impl<T: TTScalar + EinsumScalar> TTCache<T>

pub fn new<TT: AbstractTensorTrain<T>>(tt: &TT) -> Self

Create a new TTCache from a tensor train

pub fn with_site_dims<TT: AbstractTensorTrain<T>>( tt: &TT, site_dims: Vec<Vec<usize>>, ) -> Result<Self>

Create a new TTCache with custom site dimensions

This allows treating a single tensor site as multiple logical indices.

pub fn len(&self) -> usize

Number of sites

pub fn is_empty(&self) -> bool

Check if empty

pub fn site_dims(&self) -> &[Vec<usize>]

Get site dimensions

pub fn link_dims(&self) -> Vec<usize>

Get link dimensions

pub fn link_dim(&self, i: usize) -> usize

Get link dimension at position i (between site i and i+1)

pub fn clear_cache(&mut self)

Clear all cached values

pub fn evaluate_left(&mut self, indices: &[LocalIndex]) -> Vec<T>

Evaluate from the left up to (but not including) site end

Returns a vector of size link_dim(end-1) (or 1 if end == 0)

pub fn evaluate_right(&mut self, indices: &[LocalIndex]) -> Vec<T>

Evaluate from the right starting at site start

indices contains indices for sites start to n-1 Returns a vector of size link_dim(start-1) (or 1 if start == n)

pub fn evaluate(&mut self, indices: &[LocalIndex]) -> Result<T>

Evaluate the tensor train at a given index set using cache

pub fn evaluate_many( &mut self, indices: &[MultiIndex], split: Option<usize>, ) -> Result<Vec<T>>

Batch evaluate at multiple index sets

This method efficiently evaluates the tensor train at multiple indices by splitting at a given position and computing unique left/right environments.

Arguments

• indices - The indices to evaluate
• split - Optional split position. If None, uses a simple heuristic (checks 1/4, 1/2, 3/4 positions and picks the best). If you know the optimal split position (e.g., from TCI), pass Some(split) to avoid the search overhead.

Trait Implementations

impl<T: Clone + TTScalar> Clone for TTCache<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + TTScalar> Debug for TTCache<T>

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

Formats the value using the given formatter.