closeness example

Author: dizzyi

examples/centrality.rs

@@ -166,6 +166,52 @@ fn katz_centrality_impl_example() {
     println!("{:.5?}", centrality); // [0.23167, 0.71650, 0.65800]
 }
 
+fn closeness_centrality_example() {
+    use graphina::core::types::Graph;
+
+    use graphina::centrality::algorithms::closeness_centrality;
+
+    let mut graph = Graph::new();
+    let ids = (0..5).map(|i| graph.add_node(i)).collect::<Vec<_>>();
+    let edges = [(0, 1, 1.0), (0, 2, 1.0), (1, 3, 1.0)];
+    for (s, d, w) in edges {
+        graph.add_edge(ids[s], ids[d], w);
+    }
+
+    let centrality = closeness_centrality(&graph, false).unwrap();
+    println!("{:.5?}", centrality); // [0.75000, 0.75000, 0.50000, 0.50000, 0.00000]
+}
+
+fn closeness_centrality_impl_example() {
+    use graphina::core::types::Graph;
+
+    use graphina::centrality::algorithms::closeness_centrality_impl;
+
+    let mut graph: Graph<i32, (String, f64)> = Graph::new();
+
+    let ids = (0..5).map(|i| graph.add_node(i)).collect::<Vec<_>>();
+
+    let edges = [
+        (0, 1, ("friend".to_string(), 0.9)),
+        (0, 2, ("family".to_string(), 0.8)),
+        (1, 3, ("friend".to_string(), 0.7)),
+        (2, 4, ("enemy".to_string(), 0.1)),
+    ];
+    for (s, d, w) in edges {
+        graph.add_edge(ids[s], ids[d], w);
+    }
+
+    let eval_cost = |(s, f): &(String, f64)| match s.as_str() {
+        "friend" => Some(1.0 / *f / 2.0),
+        "family" => Some(1.0 / *f / 4.0),
+        "enemy" => None,
+        _ => Some(1.0 / *f),
+    };
+
+    let centrality = closeness_centrality_impl(&graph, eval_cost, true).unwrap();
+    println!("{:.5?}", centrality); // [1.05244, 1.05244, 0.81436, 0.63088, 0.00000]
+}
+
 macro_rules! run_examples {
     ($($func:ident),* $(,)?) => {
         $(
@@ -189,6 +235,9 @@ fn main() {
         // katz centrality
         katz_centrality_example,
         katz_centrality_numpy_example,
-        katz_centrality_impl_example
+        katz_centrality_impl_example,
+        // closeness centrality
+        closeness_centrality_example,
+        closeness_centrality_impl_example,
     );
 }

src/centrality/algorithms.rs

@@ -581,19 +581,54 @@ where
 ///
 /// Closeness = (n - 1) / (sum of shortest-path distances).
 ///
+/// where n is number of reachable nodes.
+///
 /// # Arguments
 ///
 /// * `graph`: the targeted graph.
 /// * `eval_cost`: callback to evaluate the cost of edges in the graph, returning
 ///   - `Some(f64)` for cost
 ///   - `None` for impassable
+/// * `wf_improved`: whether or not to scale the result by reachability ratio.
 ///
 /// # Returns
 ///
 /// a vector of `f64` representing closeness centralities of each node in the graph.
+///
+/// # Example
+/// ```rust
+/// use graphina::core::types::Graph;
+///
+/// use graphina::centrality::algorithms::closeness_centrality_impl;
+///
+/// let mut graph: Graph<i32, (String, f64)> = Graph::new();
+///
+/// let ids = (0..5).map(|i| graph.add_node(i)).collect::<Vec<_>>();
+///
+/// let edges = [
+///     (0, 1, ("friend".to_string(), 0.9)),
+///     (0, 2, ("family".to_string(), 0.8)),
+///     (1, 3, ("friend".to_string(), 0.7)),
+///     (2, 4, ("enemy".to_string(), 0.1)),
+/// ];
+/// for (s, d, w) in edges {
+///     graph.add_edge(ids[s], ids[d], w);
+/// }
+///
+/// let eval_cost = |(s, f): &(String, f64)| match s.as_str() {
+///     "friend" => Some(1.0 / *f / 2.0),
+///     "family" => Some(1.0 / *f / 4.0),
+///     "enemy" => None,
+///     _ => Some(1.0 / *f),
+/// };
+///
+/// let centrality = closeness_centrality_impl(&graph, eval_cost, true).unwrap();
+/// println!("{:.5?}", centrality); // [1.05244, 1.05244, 0.81436, 0.63088, 0.00000]
+/// ```
 pub fn closeness_centrality_impl<A, W, Ty>(
     graph: &BaseGraph<A, W, Ty>,
     eval_cost: impl Fn(&W) -> Option<f64>,
+    wf_improved: bool,
 ) -> Result<Vec<f64>, GraphinaException>
 where
     A: Debug,
@@ -605,32 +640,60 @@ where
     let mut closeness = vec![0.0; n];
     for (node, _) in graph.nodes() {
         let (distances, _) = dijkstra_path_impl(graph, node, None, &eval_cost)?;
+        let reachable = distances.iter().filter(|d| d.is_some()).count() as f64;
         let sum: f64 = distances.iter().filter_map(|d| d.to_owned()).sum();
         if sum > 0.0 {
-            closeness[node.index()] = (n as f64 - 1.0) / sum;
+            closeness[node.index()] = (reachable - 1.0) / sum;
+        }
+        if wf_improved {
+            closeness[node.index()] *= (reachable - 1.0) / (n as f64 - 1.0);
         }
     }
     Ok(closeness)
 }
 
 /// Compute closeness centrality using Dijkstra’s algorithm.
+///
 /// Closeness = (n - 1) / (sum of shortest-path distances).
+///
+/// where n is number of reachable nodes.
+///
+/// # Arguments
+///
+/// * `graph`: the targeted graph.
+/// * `wf_improved`: whether or not to scale the result by reachability ratio.
+///
+/// # Returns
+///
+/// a vector of `f64` representing closeness centralities of each node in the graph.
+///
+/// # Example
+/// ```rust
+/// use graphina::core::types::Graph;
+///
+/// use graphina::centrality::algorithms::closeness_centrality;
+///
+/// let mut graph = Graph::new();
+/// let ids = (0..5).map(|i| graph.add_node(i)).collect::<Vec<_>>();
+/// let edges = [(0, 1, 1.0), (0, 2, 1.0), (1, 3, 1.0)];
+/// for (s, d, w) in edges {
+///     graph.add_edge(ids[s], ids[d], w);
+/// }
+///
+/// let centrality = closeness_centrality(&graph, false).unwrap();
+/// println!("{:.5?}", centrality); // [0.75000, 0.75000, 0.50000, 0.50000, 0.00000]    
+/// ```
 pub fn closeness_centrality<A, Ty>(
-    graph: &BaseGraph<A, ordered_float::OrderedFloat<f64>, Ty>,
+    graph: &BaseGraph<A, f64, Ty>,
+    wf_improved: bool,
 ) -> Result<Vec<f64>, GraphinaException>
 where
-    Ty: GraphConstructor<A, ordered_float::OrderedFloat<f64>>,
+    A: Debug,
+    Ty: GraphConstructor<A, f64>,
+    BaseGraph<A, f64, Ty>: GraphinaGraph<A, f64>,
 {
-    let n = graph.node_count();
-    let mut closeness = vec![0.0; n];
-    for (node, _) in graph.nodes() {
-        let distances = dijkstra(graph, node)?;
-        let sum: f64 = distances.iter().filter_map(|d| d.map(|od| od.0)).sum();
-        if sum > 0.0 {
-            closeness[node.index()] = (n as f64 - 1.0) / sum;
-        }
-    }
-    Ok(closeness)
+    let eval_cost = |f: &f64| Some(*f);
+    closeness_centrality_impl(graph, eval_cost, wf_improved)
 }
 
 //

tests/test_centrality_algorithms.rs

@@ -59,8 +59,8 @@ fn test_degree_centrality() {
 
 #[test]
 fn test_closeness_centrality() {
-    let graph = build_test_graph_ordered();
-    let closeness = closeness_centrality(&graph).unwrap();
+    let graph = build_test_graph_f64();
+    let closeness = closeness_centrality(&graph, false).unwrap();
     // In our strongly connected graph with all edges = 1.0,
     // each node's distances: two neighbors at 1 and one at 2 -> sum = 4.
     // Closeness = (n-1)/sum = 3/4 = 0.75.