add approximatly a million more tests

Author: arashbm

pyproject.toml

@@ -35,7 +35,7 @@ repository = "https://github.com/reticula-network/reticula-python"
 bug-tracker= "https://github.com/reticula-network/reticula-python/issues"
 
 [project.optional-dependencies]
-test = ["pytest", "hypothesis", "pytest-xdist"]
+test = ["pytest", "hypothesis", "pytest-xdist", "networkx"]
 
 [build-system]
 requires = [

tests/network_strategies.py

@@ -145,3 +145,44 @@ def directed_temporal_hypernetwork(draw: st.DrawFn,
                           st.floats(min_value=0, max_value=10))
     edges = st.lists(hyperedge, min_size=0, max_size=max_edges)
     return ret.directed_temporal_hypernetwork[VERT, TIME](draw(edges), verts)
+
+
+any_network = st.one_of(
+    undirected_network(),
+    directed_network(),
+    undirected_hypernetwork(),
+    directed_hypernetwork(),
+    undirected_temporal_network(),
+    directed_temporal_network(),
+    undirected_temporal_hypernetwork(),
+    directed_temporal_hypernetwork(),
+)
+
+any_directed_network = st.one_of(
+    directed_network(),
+    directed_temporal_network(),
+    directed_hypernetwork(),
+    directed_temporal_hypernetwork(),
+)
+
+
+any_undirected_network = st.one_of(
+    undirected_network(),
+    undirected_temporal_network(),
+    undirected_hypernetwork(),
+    undirected_temporal_hypernetwork(),
+)
+
+
+static_network = st.one_of(
+    undirected_network(),
+    directed_network(),
+    undirected_hypernetwork(),
+    directed_hypernetwork(),
+)
+
+any_dyadic_network = st.one_of(
+    undirected_network(),
+    directed_network(),
+    undirected_temporal_network(),
+    directed_temporal_network())

tests/test_algorithms.py

@@ -1,9 +1,10 @@
 import math
 
-import pytest
 import reticula as ret
+
+import pytest
 from hypothesis import given
-from network_strategies import undirected_network, directed_network
+from network_strategies import any_network, any_undirected_network
 
 
 def test_density():
@@ -152,21 +153,34 @@ def test_degree_sequence():
     assert set(inc_deg_seq) == {2, 2, 2}
 
 
-@given(undirected_network())
+@given(any_undirected_network)
 def test_degree_properties(net):
     for v in net.vertices():
         deg = ret.degree(net, v)
-        assert deg >= 0
         assert deg == len([e for e in net.edges() if v in e.incident_verts()])
 
 
-@given(directed_network())
+@given(any_network)
 def test_directed_degree_properties(net):
     for v in net.vertices():
         in_deg = ret.in_degree(net, v)
+        assert in_deg == len([
+            e for e in net.edges()
+            if v in e.mutated_verts()])
+
         out_deg = ret.out_degree(net, v)
-        assert in_deg >= 0
-        assert out_deg >= 0
+        assert out_deg == len([
+            e for e in net.edges()
+            if v in e.mutator_verts()])
+
+        inc_deg = ret.incident_degree(net, v)
+        assert inc_deg == len([
+            e for e in net.edges()
+            if v in e.incident_verts()])
+
+    for v in net.vertices():
+        assert ret.in_degree(net, v) >= 0
+        assert ret.out_degree(net, v) >= 0
 
 
 def test_attribute_assortativity():

tests/test_distributions.py

@@ -75,3 +75,12 @@ def test_residual_power_law_with_specified_mean():
 
     values = [dist(gen) for _ in range(100)]
     assert all(v >= 0.0 for v in values)
+
+
+def test_hawkes_univariate_exponential():
+    gen = ret.mersenne_twister(42)
+    hawkes_dist = ret.hawkes_univariate_exponential[ret.double](
+        mu=1.0, alpha=0.5, theta=2.0)
+
+    values = [hawkes_dist(gen) for _ in range(100)]
+    assert all(v >= 0.0 for v in values)

tests/test_event_graphs.py

@@ -0,0 +1,42 @@
+import reticula as ret
+
+
+def test_event_graph_creation():
+    edges = [(0, 1, 1.0), (1, 2, 2.0), (0, 2, 3.0)]
+    net = ret.directed_temporal_network[ret.int64, ret.double](edges)
+
+    adj = ret.temporal_adjacency.limited_waiting_time[net.edge_type()](2.0)
+    eg = ret.event_graph(net, adj)
+    assert eg.successors((1, 2, 2.0)) == []
+    assert eg.successors((0, 1, 1.0)) == [net.edge_type()(1, 2, 2.0)]
+    assert eg.predecessors((1, 2, 2.0)) == [net.edge_type()(0, 1, 1.0)]
+
+    adj = ret.temporal_adjacency.limited_waiting_time[net.edge_type()](0.5)
+    eg = ret.event_graph(net, adj)
+    assert eg.successors((1, 2, 2.0)) == []
+    assert eg.predecessors((1, 2, 2.0)) == []
+
+
+def test_implicit_event_graph():
+    edges = [(0, 1, 1.0), (1, 2, 2.0), (0, 2, 3.0)]
+    net = ret.directed_temporal_network[ret.int64, ret.double](edges)
+
+    adj = ret.temporal_adjacency.limited_waiting_time[net.edge_type()](2.0)
+    ieg = ret.implicit_event_graph[net.edge_type(), type(adj)](net, adj)
+    assert ieg.successors((1, 2, 2.0)) == []
+    assert ieg.successors((0, 1, 1.0)) == [net.edge_type()(1, 2, 2.0)]
+    assert ieg.predecessors((1, 2, 2.0)) == [net.edge_type()(0, 1, 1.0)]
+
+    ieg = ret.make_implicit_event_graph(net, adj)
+    assert ieg.successors((1, 2, 2.0)) == []
+    assert ieg.successors((0, 1, 1.0)) == [net.edge_type()(1, 2, 2.0)]
+    assert ieg.predecessors((1, 2, 2.0)) == [net.edge_type()(0, 1, 1.0)]
+
+    adj = ret.temporal_adjacency.limited_waiting_time[net.edge_type()](0.5)
+    ieg = ret.implicit_event_graph[net.edge_type(), type(adj)](net, adj)
+    assert ieg.successors((1, 2, 2.0)) == []
+    assert ieg.predecessors((1, 2, 2.0)) == []
+
+    ieg = ret.make_implicit_event_graph(net, adj)
+    assert ieg.successors((1, 2, 2.0)) == []
+    assert ieg.predecessors((1, 2, 2.0)) == []

tests/test_generation_operations.py

@@ -79,3 +79,142 @@ def test_graph_union():
     u = ret.graph_union(g1, g2)
     assert len(u.edges()) == len(g1.edges()) + 1
     assert set(u.vertices()) == set(g2.vertices())
+
+
+def test_square_grid_graph():
+    g = ret.square_grid_graph[ret.int64](side=3, dims=2)
+    assert len(g.vertices()) == 9
+    assert len(g.edges()) == 12
+
+
+def test_regular_ring_lattice():
+    g = ret.regular_ring_lattice[ret.int64](size=6, degree=2)
+    assert len(g.vertices()) == 6
+    assert all(ret.degree(g, v) == 2 for v in g.vertices())
+
+
+def test_random_barabasi_albert_graph():
+    gen = ret.mersenne_twister(42)
+    g = ret.random_barabasi_albert_graph[ret.int64](
+        n=10, m=2, random_state=gen)
+    assert len(g.vertices()) == 10
+    assert len(g.edges()) == 2*(10-2)
+
+
+def test_random_degree_sequence_graph():
+    gen = ret.mersenne_twister(42)
+    degree_seq = [2, 2, 2, 2]
+    g = ret.random_degree_sequence_graph[ret.int64](
+        degree_sequence=degree_seq, random_state=gen)
+    assert len(g.vertices()) == 4
+    assert all(ret.degree(g, v) == 2 for v in g.vertices())
+
+
+def test_random_directed_degree_sequence_graph():
+    gen = ret.mersenne_twister(42)
+    in_out_seq = [(1, 1), (1, 1), (1, 1)]
+    g = ret.random_directed_degree_sequence_graph[ret.int64](
+        in_out_degree_sequence=in_out_seq, random_state=gen)
+    assert len(g.vertices()) == 3
+    for v in g.vertices():
+        assert ret.in_degree(g, v) == 1
+        assert ret.out_degree(g, v) == 1
+
+
+def test_random_expected_degree_sequence_graph():
+    gen = ret.mersenne_twister(42)
+    weight_seq = [2.0, 2.0, 2.0, 2.0]
+    g = ret.random_expected_degree_sequence_graph[ret.int64](
+        weight_sequence=weight_seq, random_state=gen)
+    assert len(g.vertices()) == 4
+
+
+def test_random_directed_expected_degree_sequence_graph():
+    gen = ret.mersenne_twister(42)
+    in_out_weight_seq = [(1.0, 1.0), (1.0, 1.0), (1.0, 1.0)]
+    g = ret.random_directed_expected_degree_sequence_graph[ret.int64](
+        in_out_weight_sequence=in_out_weight_seq, random_state=gen)
+    assert len(g.vertices()) == 3
+
+
+def test_random_uniform_hypergraph():
+    gen = ret.mersenne_twister(42)
+    g = ret.random_uniform_hypergraph[ret.int64](
+        size=5, edge_degree=3, edge_prob=0.5, random_state=gen)
+    assert len(g.vertices()) == 5
+    for e in g.edges():
+        assert len(e.incident_verts()) == 3
+
+
+def test_random_directed_uniform_hypergraph():
+    gen = ret.mersenne_twister(42)
+    g = ret.random_directed_uniform_hypergraph[ret.int64](
+        size=5, edge_in_degree=2, edge_out_degree=2,
+        edge_prob=0.5, random_state=gen)
+    assert len(g.vertices()) == 5
+
+
+def test_random_expected_degree_sequence_hypergraph():
+    gen = ret.mersenne_twister(42)
+    vertex_weights = [3.0, 3.0, 3.0, 3.0]
+    edge_weights = [4.0, 4.0, 4.0]
+    g = ret.random_expected_degree_sequence_hypergraph[ret.int64](
+        vertex_weight_sequence=vertex_weights,
+        edge_weight_sequence=edge_weights, random_state=gen)
+    assert len(g.vertices()) == 4
+
+
+def test_random_directed_expected_degree_sequence_hypergraph():
+    gen = ret.mersenne_twister(42)
+    vertex_in_out_weights = [(1.0, 1.0), (1.0, 1.0),
+                             (1.0, 1.0)]
+    edge_in_out_weights = [(3.0, 3.0)]
+    g = ret.random_directed_expected_degree_sequence_hypergraph[ret.int64](
+        vertex_in_out_weight_sequence=vertex_in_out_weights,
+        edge_in_out_weight_sequence=edge_in_out_weights,
+        random_state=gen)
+    assert len(g.vertices()) == 3
+
+
+def test_random_fully_mixed_temporal_network():
+    gen = ret.mersenne_twister(42)
+    g = ret.random_fully_mixed_temporal_network[ret.int64](
+        size=4, rate=1.0, max_t=10.0, random_state=gen)
+    assert len(g.vertices()) == 4
+    t0, t1 = ret.time_window(g)
+    assert t0 >= 0.0
+    assert t1 <= 10.0
+
+
+def test_random_directed_fully_mixed_temporal_network():
+    gen = ret.mersenne_twister(42)
+    g = ret.random_directed_fully_mixed_temporal_network[ret.int64](
+        size=4, rate=1.0, max_t=10.0, random_state=gen)
+    assert len(g.vertices()) == 4
+    t0, t1 = ret.time_window(g)
+    assert t0 >= 0.0
+    assert t1 <= 10.0
+
+
+def test_random_link_activation_temporal_network():
+    gen = ret.mersenne_twister(42)
+    static_net = ret.complete_graph[ret.int64](size=3)
+    iet_dist = ret.exponential_distribution[ret.double](lmbda=1.0)
+    g = ret.random_link_activation_temporal_network(
+        base_net=static_net, max_t=5.0, iet_dist=iet_dist, random_state=gen)
+    assert len(g.vertices()) == 3
+    t0, t1 = ret.time_window(g)
+    assert t0 >= 0.0
+    assert t1 <= 5.0
+
+
+def test_random_node_activation_temporal_network():
+    gen = ret.mersenne_twister(42)
+    base_net = ret.complete_graph[ret.int64](size=4)
+    iet_dist = ret.exponential_distribution[ret.double](lmbda=1.0)
+    g = ret.random_node_activation_temporal_network(
+        base_net=base_net, max_t=5.0, iet_dist=iet_dist, random_state=gen)
+    assert len(g.vertices()) == 4
+    t0, t1 = ret.time_window(g)
+    assert t0 >= 0.0
+    assert t1 <= 5.0

tests/test_graph_operations.py

@@ -1,57 +1,15 @@
-from hypothesis import given, assume
 import math
 import statistics
 
+from hypothesis import given, assume
 from hypothesis import strategies as st
 import pytest
 
 import reticula as ret
 
 from network_strategies import (
-    undirected_network,
-    directed_network,
-    undirected_temporal_network,
-    directed_temporal_network,
-    undirected_hypernetwork,
-    directed_hypernetwork,
-    undirected_temporal_hypernetwork,
-    directed_temporal_hypernetwork
-)
-
-
-any_network = st.one_of(
-    undirected_network(),
-    directed_network(),
-    undirected_hypernetwork(),
-    directed_hypernetwork(),
-    undirected_temporal_network(),
-    directed_temporal_network(),
-    undirected_temporal_hypernetwork(),
-    directed_temporal_hypernetwork(),
-)
-
-any_directed_network = st.one_of(
-    directed_network(),
-    directed_temporal_network(),
-    directed_hypernetwork(),
-    directed_temporal_hypernetwork(),
-)
-
-
-any_undirected_network = st.one_of(
-    undirected_network(),
-    undirected_temporal_network(),
-    undirected_hypernetwork(),
-    undirected_temporal_hypernetwork(),
-)
-
-
-static_network = st.one_of(
-    undirected_network(),
-    directed_network(),
-    undirected_hypernetwork(),
-    directed_hypernetwork(),
-)
+    undirected_network, undirected_hypernetwork,
+    directed_network, any_network)
 
 
 @given(any_network)