Enum NestedEinsum 

pub enum NestedEinsum {
    Leaf(usize),
    Node {
        subscripts: Subscripts,
        children: Vec<NestedEinsum>,
    },
}

Recursive einsum tree that preserves parenthesized grouping.

NestedEinsum mirrors OMEinsum.jl’s NestedEinsum: each internal node holds Subscripts describing how its children are contracted, and leaf nodes reference an original input tensor by index.

Construction

Use NestedEinsum::parse to build a tree from parenthesized string notation such as "(ij,jk),kl->il". Without parentheses the result is a flat root node whose children are all leaves.

Examples

use tenferro_einsum::NestedEinsum;

// Flat (no grouping): root with two leaves
let flat = NestedEinsum::parse("ij,jk->ik").unwrap();
assert!(matches!(flat, NestedEinsum::Node { .. }));

// Grouped: contract first two operands, then with third
let grouped = NestedEinsum::parse("(ij,jk),kl->il").unwrap();
assert!(matches!(grouped, NestedEinsum::Node { .. }));

Variants

Leaf(usize)

A leaf referencing one of the original input tensors by index.

Node

An internal node that contracts its children according to subscripts.

Fields

subscripts: Subscripts

The subscripts for this contraction: one input per child, plus output.

children: Vec<NestedEinsum>

Child sub-expressions (leaves or further nodes).

Implementations

impl NestedEinsum

pub fn count_leaves(&self) -> usize

Count the total number of leaf operands in the tree.

pub fn parse(notation: &str) -> Result<Self>

Parse parenthesized einsum notation into a recursive tree.

Notation follows the standard "inputs->output" format with optional parentheses to specify contraction order. Each parenthesized group becomes an internal NestedEinsum::Node; bare operands become NestedEinsum::Leaf nodes.

Examples

use tenferro_einsum::NestedEinsum;

let nested = NestedEinsum::parse("(ij,jk),kl->il").unwrap();
// Root has two children: a group node and a leaf
match &nested {
    NestedEinsum::Node { children, .. } => assert_eq!(children.len(), 2),
    _ => panic!("expected Node"),
}

Errors

Returns an error if parentheses are mismatched or the notation is otherwise malformed.

Trait Implementations

impl Clone for NestedEinsum

fn clone(&self) -> NestedEinsum

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NestedEinsum

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

Formats the value using the given formatter.