Struct Subscripts 

pub struct Subscripts {
    pub inputs: Vec<Vec<u32>>,
    pub output: Vec<u32>,
}

Einsum subscripts using integer labels (omeinsum-rs compatible).

Each dimension is represented by a u32 label. Labels shared across multiple input tensors are contracted (summed over). Repeated labels within one input select a diagonal before any reduction; if the repeated label is absent from the output, the diagonal is reduced. Repeated labels in the output embed the input on a diagonal.

Examples

use tenferro_einsum::Subscripts;

// Matrix multiplication: C_{ik} = Σ_j A_{ij} * B_{jk}
let subs = Subscripts::new(&[&[0, 1], &[1, 2]], &[0, 2]);
assert_eq!(subs.inputs.len(), 2);
assert_eq!(subs.output, vec![0, 2]);

use tenferro_einsum::Subscripts;

// Parse from string notation
let subs = Subscripts::parse("ij,jk->ik").unwrap();
assert_eq!(subs.inputs.len(), 2);

use tenferro_einsum::Subscripts;

let trace = Subscripts::parse("ii->").unwrap();
let diagonal = Subscripts::parse("ii->i").unwrap();
let embed = Subscripts::parse("i->ii").unwrap();
let higher_rank = Subscripts::parse("iij->ij").unwrap();

assert!(trace.output.is_empty());
assert_eq!(diagonal.output, vec![b'i' as u32]);
assert_eq!(embed.output, vec![b'i' as u32, b'i' as u32]);
assert_eq!(higher_rank.inputs[0], vec![b'i' as u32, b'i' as u32, b'j' as u32]);

Fields

inputs: Vec<Vec<u32>>

Index labels for each input tensor.

output: Vec<u32>

Index labels for the output tensor.

Implementations

impl Subscripts

pub fn new(inputs: &[&[u32]], output: &[u32]) -> Self

Create subscripts from integer label arrays.

Arguments

• inputs — Index labels for each input tensor
• output — Index labels for the output tensor

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

Parse subscripts from NumPy/PyTorch-style string notation.

Each Unicode alphanumeric character represents a dimension label. Labels are mapped to integer IDs via Unicode scalar values (char as u32). Input tensors are separated by commas, and -> separates inputs from the output.

Parentheses are rejected by this flat parser. Use crate::NestedEinsum::parse when notation specifies a parenthesized contraction order.

Examples

• "ij,jk->ik" — matrix multiplication
• "ii->" — diagonal extraction followed by reduction (trace)
• "ii->i" — diagonal extraction
• "i->ii" — diagonal embedding
• "iij->ij" — higher-rank diagonal extraction
• "ijk->" — full contraction (scalar result)

Errors

Returns Error::InvalidSubscripts if the notation is malformed or contains parenthesized contraction order.

Trait Implementations

impl Clone for Subscripts

fn clone(&self) -> Subscripts

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Subscripts

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

Formats the value using the given formatter.

impl Eq for Subscripts

impl From<&EinsumSubscripts> for Subscripts

fn from(subscripts: &EinsumSubscripts) -> Self

Converts to this type from the input type.

impl From<&Subscripts> for EinsumSubscripts

fn from(subscripts: &Subscripts) -> Self

Converts to this type from the input type.

impl From<EinsumSubscripts> for Subscripts

fn from(subscripts: EinsumSubscripts) -> Self

Converts to this type from the input type.

impl From<Subscripts> for EinsumSubscripts

fn from(subscripts: Subscripts) -> Self

Converts to this type from the input type.

impl Hash for Subscripts

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Subscripts

fn eq(&self, other: &Subscripts) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Subscripts