Struct CsrGraph 

pub struct CsrGraph { /* private fields */ }

CSR (Compressed Sparse Row) graph

Optimized for:

• O(1) access to outgoing edges (via forward CSR)
• O(1) access to incoming edges (via reverse CSR)
• GPU-friendly memory layout
• Sparse matrix operations (via aprender)

Example

use trueno_graph::{CsrGraph, NodeId};

let mut graph = CsrGraph::new();
graph.add_edge(NodeId(0), NodeId(1), 1.0).unwrap();
graph.add_edge(NodeId(0), NodeId(2), 1.0).unwrap();

let neighbors = graph.outgoing_neighbors(NodeId(0)).unwrap();
assert_eq!(neighbors.len(), 2);

Implementations

impl CsrGraph

pub fn new() -> CsrGraph

Create new empty graph

pub fn from_edge_list( edges: &[(NodeId, NodeId, f32)], ) -> Result<CsrGraph, Error>

Create graph from edge list

Arguments

• edges - List of (source, target, weight) tuples

Errors

Returns error if edge list is invalid (e.g., negative node IDs)

pub fn add_edge( &mut self, src: NodeId, dst: NodeId, weight: f32, ) -> Result<(), Error>

Add edge to graph (dynamic insertion)

Note: For large graphs, use from_edge_list for better performance.

Errors

Returns error if graph is already finalized (immutable CSR)

pub fn outgoing_neighbors(&self, node: NodeId) -> Result<&[u32], Error>

Get outgoing neighbors (callees) of a node

Errors

Returns error if node ID is out of bounds

pub fn incoming_neighbors(&self, target: NodeId) -> Result<&[u32], Error>

Get incoming neighbors (callers) of a node

Returns O(1) access to incoming edges via reverse CSR.

Errors

Returns error if node ID is out of bounds

pub fn set_node_name(&mut self, node: NodeId, name: String)

Set node name (for debugging/export)

pub fn get_node_name(&self, node: NodeId) -> Option<&str>

Get node name

pub const fn num_nodes(&self) -> usize

Get number of nodes

pub fn num_edges(&self) -> usize

Get number of edges

pub fn row_offsets_slice(&self) -> &[u32]

Get row offsets as slice (for GPU upload)

pub fn col_indices_slice(&self) -> &[u32]

Get column indices as slice (for GPU upload)

pub fn edge_weights_slice(&self) -> &[f32]

Get edge weights as slice (for GPU upload)

pub fn adjacency(&self, node_id: NodeId) -> (&[u32], &[f32])

Get adjacency list for a specific node

Returns (targets, weights) slices for the node’s outgoing edges

pub fn iter_adjacency(&self) -> impl Iterator<Item = (NodeId, &[u32], &[f32])>

Iterate over all nodes and their adjacency lists

Yields (node_id, targets, weights) tuples

pub fn csr_components(&self) -> (&[u32], &[u32], &[f32])

Get CSR components (for aprender integration)

impl CsrGraph

pub async fn write_parquet<P>(&self, path: P) -> Result<(), Error>

where P: AsRef<Path>,

Write graph to Parquet files

Creates two files:

• {path}_edges.parquet: Edge list (source, target, weight)
• {path}_nodes.parquet: Node metadata (node_id, name)

Errors

Returns error if file I/O fails or Arrow conversion fails

pub async fn read_parquet<P>(path: P) -> Result<CsrGraph, Error>

where P: AsRef<Path>,

Read graph from Parquet files

Errors

Returns error if files don’t exist or Arrow conversion fails

Trait Implementations

impl Clone for CsrGraph

fn clone(&self) -> CsrGraph

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CsrGraph

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

Formats the value using the given formatter.

impl Default for CsrGraph

fn default() -> CsrGraph

Returns the “default value” for a type.