Struct ComputationGraph 

pub struct ComputationGraph {
    pub inputs: Vec<NodeId>,
    pub outputs: Vec<NodeId>,
    pub metadata: GraphMetadata,
    /* private fields */
}

Computation graph representing a neural network or computation

Fields

inputs: Vec<NodeId>

Input nodes

outputs: Vec<NodeId>

Output nodes

metadata: GraphMetadata

Metadata

Implementations

impl ComputationGraph

pub fn new() -> Self

Create a new empty computation graph

pub fn add_node(&mut self, node: Node) -> NodeId

Add a node to the graph

pub fn add_edge(&mut self, from: NodeId, to: NodeId, edge: Edge)

Add an edge between nodes

pub fn add_input(&mut self, node: NodeId)

Mark a node as input

pub fn add_output(&mut self, node: NodeId)

Mark a node as output

pub fn nodes(&self) -> impl Iterator<Item = (NodeId, &Node)>

Get all nodes

pub fn edges(&self) -> impl Iterator<Item = (NodeId, NodeId, &Edge)> + '_

Get all edges

pub fn get_node(&self, id: NodeId) -> Option<&Node>

Get node by ID

pub fn get_node_mut(&mut self, id: NodeId) -> Option<&mut Node>

Get mutable node by ID

pub fn get_node_inputs(&self, id: NodeId) -> Vec<NodeId>

Get node inputs

pub fn get_node_outputs(&self, id: NodeId) -> Vec<NodeId>

Get node outputs

pub fn incoming_edges(&self, id: NodeId) -> Vec<(NodeId, NodeId, &Edge)>

Get incoming edges for a node

pub fn outgoing_edges(&self, id: NodeId) -> Vec<(NodeId, NodeId, &Edge)>

Get outgoing edges for a node

pub fn remove_node(&mut self, id: NodeId) -> Option<Node>

Remove a node from the graph

pub fn remove_edge(&mut self, from: NodeId, to: NodeId) -> bool

Remove an edge from the graph

pub fn node_count(&self) -> usize

Get number of nodes

pub fn edge_count(&self) -> usize

Get number of edges

pub fn is_empty(&self) -> bool

Check if graph is empty

pub fn validate(&self) -> JitResult<()>

Validate the graph structure

pub fn topological_sort(&self) -> JitResult<Vec<NodeId>>

Get topological ordering of nodes

pub fn subgraph(&self, node_ids: &[NodeId]) -> JitResult<ComputationGraph>

Clone with only specified nodes

pub fn strongly_connected_components(&self) -> Vec<Vec<NodeId>>

Get strongly connected components

pub fn memory_estimate(&self) -> usize

Get memory usage estimate in bytes

pub fn complexity_estimate(&self) -> usize

Get computational complexity estimate (FLOPs)

pub fn predecessors(&self, node_id: NodeId) -> impl Iterator<Item = NodeId> + '_

Get predecessors of a node (compatibility method)

pub fn successors(&self, node_id: NodeId) -> impl Iterator<Item = NodeId> + '_

Get successors of a node (compatibility method)

pub fn node(&self, id: NodeId) -> Option<&Node>

Get node by ID (compatibility method)

pub fn node_mut(&mut self, id: NodeId) -> Option<&mut Node>

Get mutable node by ID (compatibility method)

pub fn edges_directed( &self, node_id: NodeId, direction: Direction, ) -> impl Iterator<Item = EdgeReference<'_, Edge>>

Get directed edges for a node (compatibility method)

pub fn is_acyclic(&self) -> bool

Check if the graph is acyclic (compatibility method)

pub fn replace_node_with_input( &mut self, node_id: NodeId, replacement_id: NodeId, ) -> JitResult<()>

Replace a node with one of its inputs (for constant folding and branch elimination)

This operation:

1. Redirects all edges coming into node_id to replacement_id
2. Redirects all edges going out of node_id to come from replacement_id
3. Removes node_id from the graph

Arguments

• node_id - The node to replace
• replacement_id - The input node that will replace it

Returns

• Ok(()) if successful
• Err(JitError) if the replacement would create an invalid graph

pub fn replace_node_with_sequence( &mut self, node_id: NodeId, sequence: &[Node], ) -> JitResult<()>

Replace a node with a sequence of nodes (for loop unrolling and macro expansion)

This operation:

1. Inserts the sequence of nodes into the graph
2. Connects the first node in the sequence to the inputs of node_id
3. Connects the last node in the sequence to the outputs of node_id
4. Removes node_id from the graph

Arguments

• node_id - The node to replace
• sequence - The sequence of nodes to insert (must not be empty)

Returns

• Ok(()) if successful
• Err(JitError) if the sequence is empty or would create an invalid graph

Trait Implementations

impl Clone for ComputationGraph

fn clone(&self) -> ComputationGraph

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ComputationGraph

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

Formats the value using the given formatter.

impl Default for ComputationGraph

fn default() -> Self

Returns the “default value” for a type.