icentral-graph 0.1.0

A Rust library for advanced graph manipulation, focusing on minimum union cycles, betweenness centrality, and biconnected components.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

crate::ix!();

impl<GH> BuildGraphHashMappingForConnVertex<GH> for Graph<GH> 
where GH: InsertNode + InsertEdge + CreateNamedEmpty
{
    fn build_graphhash_mapping_for_conn_vertex_step(
        &self, 
        gh:         &mut GH,
        bfs_source: NodeId,
        conn_vert:  NodeId,
        item:       (NodeId, &Vec<NodeId>),
        muc_id:     MinimumUnionCycleId) 
    -> Result<(),BetweennessCentralityError> 
    {
        let visit_markers_name = name![self.name(), "build_graphhash_mapping_for_conn_vertex_step::visit_markers"];

        let mut visit_markers = VisitMarkers::new(
            self.num_nodes(), 
            visit_markers_name
        );

        visit_markers.visit(bfs_source);
        visit_markers.visit(conn_vert);

        let queue_name = name![
            self.name(),
            "build_graphhash_mapping_for_conn_vertex_step::queue"
        ];

        let mut queue = NodeIdQueue::empty(queue_name);

        queue.enqueue(bfs_source);

        while let Some(node) = queue.dequeue() {

            gh.insert_node(node);

            let nbrs = self.neighbors(node);

            for &bfs_nbr in nbrs.iter() {

                if visit_markers.unvisited(bfs_nbr) {

                    queue.enqueue(bfs_nbr);

                    visit_markers.visit(bfs_nbr);

                    if bfs_nbr != conn_vert {
                        gh.insert_edge(&Edge::new(node, bfs_nbr));
                    }
                }
            }
        }

        Ok(())
    }

    fn build_graphhash_mapping_for_conn_vertex(
        &self, 
        item:   (NodeId, &Vec<NodeId>),
        muc_id: MinimumUnionCycleId) 
    -> Result<(NodeId, Arc<GH>),BetweennessCentralityError> 
    {
        let conn_vert: NodeId = item.0;

        let gh_name = name![
            self.name(), 
            "build_graphhash_mapping_for_conn_vertex::gh"
        ];

        let mut gh: GH = GH::empty(gh_name);

        for &bfs_source in item.1.iter() {

            self.build_graphhash_mapping_for_conn_vertex_step(
                &mut gh, 
                bfs_source,
                conn_vert,
                item, 
                muc_id
            )?;
        }

        Ok((conn_vert,Arc::new(gh)))
    }
}