Struct NodeNameNetwork 

pub struct NodeNameNetwork<NodeName>
where
    NodeName: Clone + Hash + Eq + Send + Sync + Debug,
{ /* private fields */ }

Node Name Network - Pure graph structure for node connections.

Represents the topology of a network without any data attached to nodes or edges. This is useful for graph algorithms that only need connectivity information.

Type Parameters

• NodeName: Node name type (must be Clone, Hash, Eq, Send, Sync, Debug)

Implementations

impl<NodeName> NodeNameNetwork<NodeName>

where NodeName: Clone + Hash + Eq + Send + Sync + Debug,

pub fn new() -> Self

Create a new empty NodeNameNetwork.

pub fn with_capacity(nodes: usize, edges: usize) -> Self

Create a new NodeNameNetwork with initial capacity.

pub fn add_node(&mut self, node_name: NodeName) -> Result<NodeIndex, String>

Add a node to the network.

Returns an error if the node already exists.

pub fn has_node(&self, node_name: &NodeName) -> bool

Check if a node exists.

pub fn add_edge( &mut self, n1: &NodeName, n2: &NodeName, ) -> Result<EdgeIndex, String>

Add an edge between two nodes.

Returns an error if either node doesn’t exist.

pub fn node_index(&self, node_name: &NodeName) -> Option<NodeIndex>

Get the NodeIndex for a node name.

pub fn node_name(&self, node: NodeIndex) -> Option<&NodeName>

Get the node name for a NodeIndex.

pub fn rename_node( &mut self, old_name: &NodeName, new_name: NodeName, ) -> Result<(), String>

Rename an existing node.

pub fn node_names(&self) -> Vec<&NodeName>

Get all node names.

pub fn node_count(&self) -> usize

Get the number of nodes.

pub fn edge_count(&self) -> usize

Get the number of edges.

pub fn graph(&self) -> &StableGraph<(), (), Undirected>

Get a reference to the internal graph.

pub fn graph_mut(&mut self) -> &mut StableGraph<(), (), Undirected>

Get a mutable reference to the internal graph.

Warning: Directly modifying the internal graph can break the node-name-to-index mapping.

pub fn post_order_dfs(&self, root: &NodeName) -> Option<Vec<NodeName>>

Perform a post-order DFS traversal starting from the given root node.

Returns node names in post-order (children before parents, leaves first).

Arguments

• root - The node name to start traversal from

Returns

Some(Vec<NodeName>) with nodes in post-order, or None if root doesn’t exist.

pub fn post_order_dfs_by_index(&self, root: NodeIndex) -> Vec<NodeIndex>

Perform a post-order DFS traversal starting from the given root NodeIndex.

Returns NodeIndex in post-order (children before parents, leaves first).

pub fn euler_tour_edges( &self, root: &NodeName, ) -> Option<Vec<(NodeIndex, NodeIndex)>>

Perform an Euler tour traversal starting from the given root node.

Delegates to NamedGraph::euler_tour_edges.

pub fn euler_tour_edges_by_index( &self, root: NodeIndex, ) -> Vec<(NodeIndex, NodeIndex)>

Perform an Euler tour traversal starting from the given root NodeIndex.

Delegates to NamedGraph::euler_tour_edges_by_index.

pub fn euler_tour_vertices(&self, root: &NodeName) -> Option<Vec<NodeIndex>>

Perform an Euler tour traversal and return the vertex sequence.

Delegates to NamedGraph::euler_tour_vertices.

pub fn euler_tour_vertices_by_index(&self, root: NodeIndex) -> Vec<NodeIndex>

Perform an Euler tour traversal and return the vertex sequence by NodeIndex.

Delegates to NamedGraph::euler_tour_vertices_by_index.

pub fn path_between( &self, from: NodeIndex, to: NodeIndex, ) -> Option<Vec<NodeIndex>>

Find the shortest path between two nodes using A* algorithm.

Since this is an unweighted graph, we use unit edge weights.

Returns

Some(Vec<NodeIndex>) containing the path from from to to (inclusive), or None if no path exists.

pub fn is_connected_subset(&self, nodes: &HashSet<NodeIndex>) -> bool

Check if a subset of nodes forms a connected subgraph.

Uses DFS to verify that all nodes in the subset are reachable from each other within the induced subgraph.

Returns

true if the subset is connected (or empty), false otherwise.

pub fn steiner_tree_nodes( &self, terminals: &HashSet<NodeIndex>, ) -> HashSet<NodeIndex>

Compute the Steiner tree nodes spanning a set of terminal nodes.

For tree graphs, the Steiner tree is the union of the unique paths from one terminal to every other terminal.

Arguments

• terminals - Terminal node indices to span

Returns

The set of nodes in the minimal connected subtree spanning terminals.

Examples

use std::collections::HashSet;
use tensor4all_treetn::NodeNameNetwork;

let mut net: NodeNameNetwork<String> = NodeNameNetwork::new();
let a = net.add_node("A".to_string()).unwrap();
let b = net.add_node("B".to_string()).unwrap();
let c = net.add_node("C".to_string()).unwrap();
net.add_edge(&"A".to_string(), &"B".to_string()).unwrap();
net.add_edge(&"B".to_string(), &"C".to_string()).unwrap();

let steiner = net.steiner_tree_nodes(&[a, c].into_iter().collect::<HashSet<_>>());
assert_eq!(steiner, [a, b, c].into_iter().collect());

pub fn edges_to_canonicalize( &self, current_region: Option<&HashSet<NodeIndex>>, target: NodeIndex, ) -> CanonicalizeEdges

Compute edges to canonicalize from current state to target.

Arguments

• current_region - Current ortho region (None = not canonicalized)
• target - Target node for the orthogonality center

Returns

Ordered CanonicalizeEdges to process for canonicalization.

pub fn edges_to_canonicalize_by_names( &self, target: &NodeName, ) -> Option<Vec<(NodeName, NodeName)>>

Compute edges to canonicalize from leaves to target, returning node names.

This is similar to edges_to_canonicalize(None, target) but returns (from_name, to_name) pairs instead of (NodeIndex, NodeIndex).

Useful for operations that work with two networks that have the same topology but different NodeIndex values (e.g., contract_zipup).

Arguments

• target - Target node name for the orthogonality center

Returns

None if target node doesn’t exist, otherwise a vector of (from, to) pairs where from is the node being processed and to is its parent (towards target).

pub fn edges_to_canonicalize_to_region( &self, target_region: &HashSet<NodeIndex>, ) -> CanonicalizeEdges

Compute edges to canonicalize from leaves towards a connected region (multiple centers).

Given a set of target nodes forming a connected region, this function returns all edges (src, dst) where:

• src is a node outside the target region
• dst is the next node towards the target region

The edges are ordered so that nodes farther from the target region are processed first (children before parents), which is the correct order for canonicalization.

Arguments

• target_region - Set of NodeIndex that forms the canonical center region (must be non-empty and connected)

Returns

CanonicalizeEdges with all edges pointing towards the target region. Returns empty edges if target_region is empty.

Panics

Does not panic, but if target_region is disconnected, behavior is undefined (may return partial results).

pub fn edges_to_canonicalize_to_region_by_names( &self, target_region: &HashSet<NodeName>, ) -> Option<Vec<(NodeName, NodeName)>>

Compute edges to canonicalize towards a region, returning node names.

This is similar to edges_to_canonicalize_to_region but takes and returns node names instead of NodeIndex.

Arguments

• target_region - Set of node names that forms the canonical center region

Returns

None if any target node doesn’t exist, otherwise Some(Vec<(from, to)>) where edges point towards the target region.

pub fn same_topology(&self, other: &Self) -> bool

Check if two networks have the same topology (same nodes and edges).

Trait Implementations

impl<NodeName> Clone for NodeNameNetwork<NodeName>

where NodeName: Clone + Hash + Eq + Send + Sync + Debug + Clone,

fn clone(&self) -> NodeNameNetwork<NodeName>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<NodeName> Debug for NodeNameNetwork<NodeName>

where NodeName: Clone + Hash + Eq + Send + Sync + Debug + Debug,

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

Formats the value using the given formatter.

impl<NodeName> Default for NodeNameNetwork<NodeName>

where NodeName: Clone + Hash + Eq + Send + Sync + Debug,

fn default() -> Self

Returns the “default value” for a type.