Struct Graph 

pub struct Graph { /* private fields */ }

Main computation graph structure

Implementations

impl Graph

pub fn compute_topological_order(&mut self) -> Result<&[NodeId], TensorError>

Compute and cache the topological order of nodes

pub fn validate(&self) -> Result<(), TensorError>

Validate the graph structure

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

Find all input nodes (nodes with no incoming data edges)

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

Find all output nodes (nodes with no outgoing data edges)

impl Graph

pub fn add_control_dependency( &mut self, from_node: NodeId, to_node: NodeId, ) -> Result<EdgeId, TensorError>

Add a control dependency between two nodes

pub fn add_control_dependencies( &mut self, from_node: NodeId, to_nodes: &[NodeId], ) -> Result<Vec<EdgeId>, TensorError>

Add control dependencies from one node to multiple nodes

pub fn get_control_dependencies(&self, node_id: NodeId) -> Vec<NodeId>

Get all nodes that this node has control dependencies on

pub fn get_control_dependents(&self, node_id: NodeId) -> Vec<NodeId>

Get all nodes that depend on this node via control dependencies

pub fn has_control_dependency(&self, from_node: NodeId, to_node: NodeId) -> bool

Check if there’s a control dependency between two nodes

pub fn remove_control_dependencies( &mut self, node_id: NodeId, ) -> Result<usize, TensorError>

Remove all control dependencies for a node (both incoming and outgoing)

pub fn create_control_context( &mut self, context_nodes: &[NodeId], ) -> Result<(), TensorError>

Create a control context - ensure all nodes in the list execute in order

impl Graph

pub fn new() -> Self

Create a new empty graph

pub fn add_node( &mut self, name: String, op_type: NodeType, device: Device, attributes: HashMap<String, AttributeValue>, ) -> Result<NodeId, TensorError>

Add a new node to the graph

pub fn add_edge( &mut self, from_node: NodeId, to_node: NodeId, from_output: usize, to_input: usize, dtype: DType, shape: Shape, is_control: bool, ) -> Result<EdgeId, TensorError>

Add a new edge to the graph

pub fn get_node(&self, node_id: NodeId) -> Option<&GraphNode>

Get a node by ID

pub fn get_node_by_name(&self, name: &str) -> Option<&GraphNode>

Get a node by name

pub fn get_edge(&self, edge_id: EdgeId) -> Option<&GraphEdge>

Get an edge by ID

pub fn nodes(&self) -> impl Iterator<Item = &GraphNode>

Iterate over all nodes

pub fn edges(&self) -> impl Iterator<Item = &GraphEdge>

Iterate over all edges

pub fn get_node_mut(&mut self, node_id: NodeId) -> Option<&mut GraphNode>

Get a mutable reference to a node

pub fn get_edge_mut(&mut self, edge_id: EdgeId) -> Option<&mut GraphEdge>

Get a mutable reference to an edge

pub fn node_count(&self) -> usize

Get the number of nodes

pub fn edge_count(&self) -> usize

Get the number of edges

impl Graph

pub fn extend_with_graph( &mut self, other: &Graph, node_prefix: Option<&str>, ) -> Result<HashMap<NodeId, NodeId>, TensorError>

Extend this graph with another graph

pub fn integrate_subgraph( &mut self, subgraph: &Graph, input_connections: &[(NodeId, usize, NodeId, usize)], output_connections: &[(NodeId, usize, NodeId, usize)], node_prefix: Option<&str>, ) -> Result<HashMap<NodeId, NodeId>, TensorError>

Integrate a subgraph into this graph at specific connection points

pub fn merge_graphs(graphs: &[&Graph]) -> Result<Graph, TensorError>

Merge multiple graphs into a single graph

pub fn add_node_auto_name( &mut self, base_name: &str, op_type: NodeType, device: Device, attributes: HashMap<String, AttributeValue>, ) -> Result<NodeId, TensorError>

Add a node with automatically generated unique name

pub fn add_operation_subgraph( &mut self, op_name: &str, inputs: &[NodeId], output_shapes: &[Shape], output_dtypes: &[DType], device: Device, attributes: HashMap<String, AttributeValue>, ) -> Result<Vec<NodeId>, TensorError>

Add a complete operation subgraph (operation with inputs and outputs)

pub fn insert_node_between( &mut self, from_node: NodeId, to_node: NodeId, new_node_name: String, new_node_type: NodeType, device: Device, attributes: HashMap<String, AttributeValue>, ) -> Result<NodeId, TensorError>

Insert a new node between two existing connected nodes

pub fn replace_node_with_subgraph( &mut self, node_to_replace: NodeId, replacement_graph: &Graph, input_mapping: &HashMap<usize, NodeId>, output_mapping: &HashMap<usize, NodeId>, ) -> Result<HashMap<NodeId, NodeId>, TensorError>

Replace a node with a subgraph

impl Graph

pub fn remove_node(&mut self, node_id: NodeId) -> Result<(), TensorError>

Remove a node and all its associated edges

pub fn remove_edge(&mut self, edge_id: EdgeId) -> Result<(), TensorError>

Remove an edge

pub fn replace_with_constant( &mut self, node_id: NodeId, constant_value: Tensor<f32>, ) -> Result<(), TensorError>

Replace a node with a constant value

pub fn redirect_node_outputs( &mut self, from_node: NodeId, to_node: NodeId, ) -> Result<usize, TensorError>

Redirect all outputs from one node to another

impl Graph

pub fn to_graph_def(&self) -> GraphDef

Convert graph to serializable format

pub fn from_graph_def(graph_def: &GraphDef) -> Result<Self, TensorError>

Create graph from serializable format

impl Graph

pub fn subgraph(&self, node_ids: &[NodeId]) -> Result<Graph, TensorError>

Create a subgraph containing only the specified nodes

pub fn subgraph_by_op_types( &self, op_types: &[&str], ) -> Result<Graph, TensorError>

Create a subgraph containing nodes of specific operation types

pub fn subgraph_by_device(&self, device: Device) -> Result<Graph, TensorError>

Create a subgraph containing nodes on a specific device

pub fn subgraph_with_dependencies( &self, root_nodes: &[NodeId], include_control_deps: bool, ) -> Result<Graph, TensorError>

Create a subgraph with all dependencies of the specified nodes

pub fn connected_component( &self, start_node: NodeId, ) -> Result<Graph, TensorError>

Find the connected component containing the specified node

pub fn forward_slice( &self, start_nodes: &[NodeId], include_control_deps: bool, ) -> Result<Graph, TensorError>

Create a forward slice from the given nodes (includes all nodes reachable forward)

pub fn subgraph_by_predicate<F>( &self, predicate: F, ) -> Result<Graph, TensorError>

where F: Fn(&GraphNode) -> bool,

Create a subgraph based on a custom predicate function

Trait Implementations

impl Clone for Graph

fn clone(&self) -> Graph

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Graph

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

Formats the value using the given formatter.

impl Default for Graph

fn default() -> Self

Returns the “default value” for a type.