Algorithm Result object complete rewrite, Add betweeen centrality, Add Zaks Karate Club

comparison-benchmark/rust/raphtory-rust-benchmark/src/main.rs

@@ -197,14 +197,12 @@ fn main() {
 
     // page rank with time
     now = Instant::now();
-    let _page_rank: Vec<_> = unweighted_page_rank(&g, 1000, None, None, true)
-        .into_iter()
-        .collect();
+    let _page_rank = unweighted_page_rank(&g, 1000, None, None, true);
     println!("Page rank: {} seconds", now.elapsed().as_secs_f64());
 
     // connected community_detection with time
     now = Instant::now();
-    let _cc: AlgorithmResult<String, u64> = weakly_connected_components(&g, usize::MAX, None);
+    let _cc = weakly_connected_components(&g, usize::MAX, None);
     println!(
         "Connected community_detection: {} seconds",
         now.elapsed().as_secs_f64()

docs/source/reference/algorithms/centrality.rst

@@ -7,3 +7,4 @@ Centrality
 
 .. autofunction:: raphtory.algorithms.hits
 
+.. autofunction:: raphtory.algorithms.betweenness_centrality

examples/rust/src/bin/hulongbay/main.rs

@@ -125,6 +125,7 @@ fn try_main() -> Result<(), Box<dyn Error>> {
     let components = weakly_connected_components(&graph, 5, Some(16));
 
     components
+        .result
         .into_iter()
         .counts_by(|(_, cc)| cc)
         .iter()

examples/rust/src/bin/lotr/main.rs

@@ -1,4 +1,3 @@
-use itertools::Itertools;
 use raphtory::{
     algorithms::pathing::temporal_reachability::temporally_reachable_nodes, core::utils::hashing,
     graph_loader::source::csv_loader::CsvLoader, prelude::*,
@@ -104,9 +103,12 @@ fn main() {
     assert!(graph.has_vertex(gandalf));
     assert_eq!(graph.vertex(gandalf).unwrap().name(), "Gandalf");
 
-    let r = temporally_reachable_nodes(&graph, None, 20, 31930, vec!["Gandalf"], None);
-    assert_eq!(
-        r.result.keys().sorted().collect_vec(),
-        vec!["Gandalf", "Saruman", "Wormtongue"]
-    )
+    let r: Vec<String> = temporally_reachable_nodes(&graph, None, 20, 31930, vec!["Gandalf"], None)
+        .get_all_values()
+        .into_iter()
+        .flatten()
+        .map(|(_, s)| s)
+        .collect();
+
+    assert_eq!(r, vec!["Gandalf", "Saruman", "Wormtongue"])
 }

python/src/lib.rs

@@ -69,6 +69,7 @@ fn raphtory(py: Python<'_>, m: &PyModule) -> PyResult<()> {
         algorithm_module,
         dijkstra_single_source_shortest_paths,
         global_reciprocity,
+        betweenness_centrality,
         all_local_reciprocity,
         triplet_count,
         local_triangle_count,
@@ -107,6 +108,7 @@ fn raphtory(py: Python<'_>, m: &PyModule) -> PyResult<()> {
         neo4j_movie_graph,
         stable_coin_graph,
         reddit_hyperlink_graph,
+        karate_club_graph,
     );
     m.add_submodule(graph_loader_module)?;
 

python/tests/test_algorithms.py

@@ -5,16 +5,16 @@ def test_degree_centrality():
     from raphtory.algorithms import degree_centrality
 
     g = Graph()
-    g.add_edge(0, 0, 1, {})
-    g.add_edge(0, 0, 2, {})
-    g.add_edge(0, 0, 3, {})
     g.add_edge(0, 1, 2, {})
     g.add_edge(0, 1, 3, {})
-    assert degree_centrality(g).get_all() == {
-        "0": 1.0,
+    g.add_edge(0, 1, 4, {})
+    g.add_edge(0, 2, 3, {})
+    g.add_edge(0, 2, 4, {})
+    assert degree_centrality(g).get_with_names() == {
         "1": 1.0,
-        "2": 2 / 3,
+        "2": 1.0,
         "3": 2 / 3,
+        "4": 2 / 3,
     }
 
 
@@ -45,12 +45,12 @@ def test_single_source_shortest_path():
     g.add_edge(0, 2, 4, {})
     res_one = single_source_shortest_path(g, 1, 1)
     res_two = single_source_shortest_path(g, 1, 2)
-    assert res_one.get_all() == {"1": ["1"], "2": ["1", "2"], "4": ["1", "4"]}
+    assert res_one.get_with_names() == {"1": ["1"], "2": ["1", "2"], "3": None, "4": ["1", "4"]}
     assert (
-        res_two.get_all()
+        res_two.get_with_names()
         == {"1": ["1"], "2": ["1", "2"], "3": ["1", "2", "3"], "4": ["1", "4"]}
     ) or (
-        res_two.get_all()
+        res_two.get_with_names()
         == {"1": ["1"], "3": ["1", "4", "3"], "2": ["1", "2"], "4": ["1", "4"]}
     )
 
@@ -84,4 +84,30 @@ def test_dijsktra_shortest_paths():
         dijkstra_single_source_shortest_paths(g, "A", ["F"], weight="NO")
     assert "Weight property not found on edges" in str(excinfo.value)
 
-
+
+def test_betweenness_centrality():
+    from raphtory import Graph
+    from raphtory.algorithms import betweenness_centrality
+    g = Graph()
+    edges = [
+        (0, 1),
+        (0, 2),
+        (0, 3),
+        (1, 2),
+        (1, 3),
+        (1, 4),
+        (2, 3),
+        (2, 4),
+        (2, 5),
+        (3, 2),
+        (3, 1),
+        (3, 3)
+    ]
+    for e in edges:
+        g.add_edge(0, e[0], e[1], {})
+
+    res = betweenness_centrality(g, normalized=False)
+    assert res.get_with_names() == { "0": 0.0, '1': 1.0, "2": 4.0, "3": 1.0, "4": 0.0, "5": 0.0 }
+
+    res = betweenness_centrality(g, normalized=True)
+    assert res.get_with_names() == { "0": 0.0, '1': 0.05, "2": 0.2, "3": 0.05, "4": 0.0, "5": 0.0}

python/tests/test_graph_gen.py

@@ -0,0 +1,6 @@
+def test_karate_club():
+    from raphtory.graph_loader import karate_club_graph
+    g = karate_club_graph()
+    assert g.count_vertices() == 34
+    assert g.count_edges() == 155
+

python/tests/test_graphdb.py

@@ -1254,22 +1254,22 @@ def test_connected_components():
     g = gen_graph()
     actual = algorithms.weakly_connected_components(g, 20)
     expected = {"1": 1, "2": 1, "3": 1, "4": 1, "5": 1, "6": 1, "7": 1, "8": 1}
-    assert actual.get_all() == expected
+    assert actual.get_with_names() == expected
     assert actual.get("1") == 1
 
 
 def test_empty_algo():
     g = Graph()
-    assert algorithms.weakly_connected_components(g, 20).get_all() == {}
-    assert algorithms.pagerank(g, 20).get_all() == {}
+    assert algorithms.weakly_connected_components(g, 20).get_with_names() == {}
+    assert algorithms.pagerank(g, 20).get_with_names() == {}
 
 
 def test_algo_result():
     g = gen_graph()
 
     actual = algorithms.weakly_connected_components(g, 20)
     expected = {"1": 1, "2": 1, "3": 1, "4": 1, "5": 1, "6": 1, "7": 1, "8": 1}
-    assert actual.get_all() == expected
+    assert actual.get_with_names() == expected
     assert actual.get("1") == 1
     assert actual.get("not a node") == None
     expected_array = [
@@ -1289,13 +1289,14 @@ def test_algo_result():
     assert len(actual.group_by()[1]) == 8
     assert type(actual.to_df()) == pandas.core.frame.DataFrame
     df = actual.to_df()
-    expected_result = pd.DataFrame({"Key": ["1"], "Value": [1]})
-    row_with_one = df[df["Key"] == "1"]
+    expected_result = pd.DataFrame({"Key": [1], "Value": [1]})
+    row_with_one = df[df["Key"] == 1]
     row_with_one.reset_index(inplace=True, drop=True)
+    print(row_with_one)
     assert row_with_one.equals(expected_result)
     # Algo Str u64
     actual = algorithms.weakly_connected_components(g)
-    all_res = actual.get_all()
+    all_res = actual.get_with_names()
     sorted_res = {k: all_res[k] for k in sorted(all_res)}
     assert sorted_res == {
         "1": 1,
@@ -1319,12 +1320,12 @@ def test_algo_result():
         "7": 0.14074777909144864,
         "8": 0.11786468661230831,
     }
-    assert actual.get_all() == expected_result
+    assert actual.get_with_names() == expected_result
     assert actual.get("Not a node") == None
     assert len(actual.to_df()) == 8
     # algo str vector
     actual = algorithms.temporally_reachable_nodes(g, 20, 11, [1, 2], [4, 5])
-    assert sorted(actual.get_all()) == ["1", "2", "3", "4", "5", "6", "7", "8"]
+    assert sorted(actual.get_with_names()) == ["1", "2", "3", "4", "5", "6", "7", "8"]
 
 
 def test_page_rank():
@@ -1340,7 +1341,7 @@ def test_page_rank():
         "7": 0.14074777909144864,
         "8": 0.11786468661230831,
     }
-    assert actual.get_all() == expected
+    assert actual.get_with_names() == expected
 
 
 def test_temporal_reachability():
@@ -1358,7 +1359,7 @@ def test_temporal_reachability():
         "8": [],
     }
 
-    assert actual.get_all() == expected
+    assert actual.get_with_names() == expected
 
 
 # def test_generic_taint_loader():
@@ -1747,13 +1748,13 @@ def test_balance_algorithm():
     ]
     for src, dst, val, time in edges_str:
         g.add_edge(time, src, dst, {"value_dec": val})
-    result = algorithms.balance(g, "value_dec", PyDirection("BOTH"), None).get_all()
+    result = algorithms.balance(g, "value_dec", PyDirection("BOTH"), None).get_with_names()
     assert result == {"1": -26.0, "2": 7.0, "3": 12.0, "4": 5.0, "5": 2.0}
 
-    result = algorithms.balance(g, "value_dec", PyDirection("IN"), None).get_all()
+    result = algorithms.balance(g, "value_dec", PyDirection("IN"), None).get_with_names()
     assert result == {"1": 6.0, "2": 12.0, "3": 15.0, "4": 20.0, "5": 2.0}
 
-    result = algorithms.balance(g, "value_dec", PyDirection("OUT"), None).get_all()
+    result = algorithms.balance(g, "value_dec", PyDirection("OUT"), None).get_with_names()
     assert result == {"1": -32.0, "2": -5.0, "3": -3.0, "4": -15.0, "5": 0.0}
 
 

raphtory-graphql/src/model/algorithm.rs

@@ -96,6 +96,15 @@ impl From<(String, f64)> for Pagerank {
     }
 }
 
+impl From<(String, Option<f64>)> for Pagerank {
+    fn from((name, rank): (String, Option<f64>)) -> Self {
+        Self {
+            name,
+            rank: rank.unwrap_or_default(), // use 0.0 if rank is None
+        }
+    }
+}
+
 impl From<(String, OrderedFloat<f64>)> for Pagerank {
     fn from((name, rank): (String, OrderedFloat<f64>)) -> Self {
         let rank = rank.into_inner();
@@ -134,6 +143,7 @@ impl Algorithm for Pagerank {
         let tol = ctx.args.get("tol").map(|v| v.f64()).transpose()?;
         let binding = unweighted_page_rank(graph, iter_count, threads, tol, true);
         let result = binding
+            .get_with_names()
             .into_iter()
             .map(|pair| FieldValue::owned_any(Pagerank::from(pair)));
         Ok(Some(FieldValue::list(result)))