Struct TemporalGraph 

pub struct TemporalGraph { /* private fields */ }

A temporal (dynamic) graph stored as a sorted stream of timed edge contacts.

Nodes are identified by consecutive usize indices 0..n_nodes. Edges are kept sorted by timestamp to enable efficient windowed queries.

Example

use scirs2_graph::temporal_graph::{TemporalGraph, TemporalEdge};

let mut tg = TemporalGraph::new(4);
tg.add_edge(TemporalEdge::new(0, 1, 1.0));
tg.add_edge(TemporalEdge::new(1, 2, 2.0));
tg.add_edge(TemporalEdge::new(2, 3, 3.0));

let snap = tg.snapshot(0.5, 2.5);
assert_eq!(snap.node_count(), 3); // nodes 0,1,2 appear in edges

Implementations

impl TemporalGraph

pub fn new(n_nodes: usize) -> Self

Create an empty temporal graph with a fixed node count.

pub fn n_nodes(&self) -> usize

Number of nodes (constant after construction).

pub fn n_edges(&self) -> usize

Number of temporal edge contacts stored.

pub fn node_count(&self) -> usize

Alias for [] — returns the number of nodes in this temporal graph.

Provided for compatibility with code expecting a method.

pub fn sorted_edges_cloned(&self) -> Vec<TemporalEdge>

Return a sorted clone of all temporal edges.

Unlike this method does not require a mutable reference; instead it returns an owned sorted by timestamp. This is slightly less efficient than the mutable version (one extra allocation + possible sort), but works with &self borrows.

pub fn add_edge(&mut self, edge: TemporalEdge)

Add a temporal edge. Marks the edge list as unsorted when the new timestamp is earlier than the last stored timestamp.

pub fn edges(&mut self) -> &[TemporalEdge]

Return a read-only slice of all temporal edges (in sorted order).

pub fn edges_in_window(&mut self, t_start: f64, t_end: f64) -> &[TemporalEdge]

Return an iterator over edges in the time window [t_start, t_end).

pub fn snapshot(&mut self, t_start: f64, t_end: f64) -> Graph<usize, f64>

Build a static (undirected, weighted) snapshot of the temporal graph for all contacts that fall in the half-open window [t_start, t_end).

Repeated contacts between the same pair of nodes accumulate their weights (or count as 1.0 each when no weight is present).

pub fn temporal_neighbors( &mut self, node: usize, t_start: f64, t_end: f64, ) -> Vec<(usize, f64)>

Return all neighbours of node reachable in the time window [t_start, t_end), together with the earliest contact timestamp.

Both directions of each edge are considered (undirected semantics).

pub fn temporal_path( &mut self, source: usize, target: usize, t_start: f64, t_end: f64, ) -> Option<Vec<usize>>

Find a time-respecting path from source to target using only edges with timestamps in [t_start, t_end).

Uses a Dijkstra-like priority queue keyed on the earliest-arrival time at each node, guaranteeing the fastest-arrival (foremost) path.

Returns None when no such path exists.

pub fn temporal_betweenness(&mut self, t_start: f64, t_end: f64) -> Vec<f64>

Compute temporal betweenness centrality for all nodes.

For each ordered pair (s, t) we find the set of foremost (earliest-arrival) paths using the method above and give each intermediate node 1 / |paths| credit.

Returns a vector of length n_nodes.

pub fn aggregate_graph(&mut self) -> Graph<usize, f64>

Collapse the temporal graph to a static undirected weighted graph by summing contact weights over all time.

Trait Implementations

impl Clone for TemporalGraph

fn clone(&self) -> TemporalGraph

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TemporalGraph

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

Formats the value using the given formatter.