graphrs 0.11.16

graphrs is a Rust package for the creation, manipulation and analysis of graphs.
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use super::Graph;
use crate::{Edge, Error, ErrorKind, Node};
use std::collections::HashSet;
use std::fmt::Display;
use std::hash::Hash;
use std::sync::Arc;

impl<T, A> Graph<T, A>
where
    T: Eq + Clone + PartialOrd + Ord + Hash + Send + Sync + Display,
    A: Clone,
{
    /**
    Returns the 1st-degree ego network for a specific node.

    # Arguments

    * `node`: The node to get the ego network for.

    # Examples

    ```
    use graphrs::generators;
    let graph = generators::social::karate_club_graph();
    let subgraph = graph.get_ego_graph(&4).unwrap();
    assert_eq!(subgraph.get_all_nodes().len(), 4);
    ```
    */
    pub fn get_ego_graph(&self, node: &T) -> Result<Graph<T, A>, Error> {
        if !self.has_node(node) {
            return Err(Error {
                kind: ErrorKind::NodeNotFound,
                message: "The node was not found in graph".to_string(),
            });
        }
        let neighbors: Vec<&T> = match self.specs.directed {
            true => self
                .get_successor_node_names(node.clone())
                .unwrap()
                .into_iter()
                .chain(
                    self.get_predecessor_node_names(node.clone())
                        .unwrap()
                        .into_iter(),
                )
                .collect(),
            false => self
                .get_neighbor_nodes(node.clone())
                .unwrap()
                .into_iter()
                .map(|n| &n.name)
                .collect(),
        };
        let mut neighbors: Vec<T> = neighbors.into_iter().cloned().collect();
        neighbors.push(node.clone());
        self.get_subgraph(&neighbors)
    }

    /**
    Returns an induced subgraph that contains only the specified nodes
    and the edges between those nodes.

    # Arguments

    * `nodes`: The nodes the subgraph must contain.

    # Examples

    ```
    use graphrs::generators;
    let graph = generators::social::karate_club_graph();
    let subgraph = graph.get_subgraph(&vec![4, 5, 6, 10, 16]).unwrap();
    assert_eq!(subgraph.get_all_nodes().len(), 5);
    ```
    */
    pub fn get_subgraph(&self, nodes: &[T]) -> Result<Graph<T, A>, Error> {
        if !self.has_nodes(nodes) {
            return Err(Error {
                kind: ErrorKind::NodeNotFound,
                message: "The node was not found in graph".to_string(),
            });
        }
        Ok(_get_subgraph(self, nodes))
    }
}

fn _get_subgraph<T, A>(graph: &Graph<T, A>, nodes: &[T]) -> Graph<T, A>
where
    T: Eq + Clone + PartialOrd + Ord + Hash + Send + Sync + Display,
    A: Clone,
{
    let nodes_set: HashSet<T> = nodes.iter().cloned().collect();
    let new_nodes = graph
        .get_all_nodes()
        .into_iter()
        .filter(|n| nodes_set.contains(&n.name))
        .cloned()
        .collect::<Vec<Arc<Node<T, A>>>>();
    let new_edges = graph
        .get_all_edges()
        .into_iter()
        .filter(|e| nodes_set.contains(&e.u) && nodes_set.contains(&e.v))
        .cloned()
        .collect::<Vec<Arc<Edge<T, A>>>>();
    Graph::new_from_nodes_and_edges(new_nodes, new_edges, graph.specs.clone()).unwrap()
}