modularitypruning 1.5.1__tar.gz → 2.0.0__tar.gz

{modularitypruning-1.5.1 → modularitypruning-2.0.0}/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.4
 Name: modularitypruning
-Version: 1.5.1
+Version: 2.0.0
 Summary: Pruning tool to identify small subsets of network partitions that are significant from the perspective of stochastic block model inference.
 Author-email: Ryan Gibson <ryan.alex.gibson@gmail.com>
 License-Expression: MIT
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -15,7 +14,8 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.9
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: leidenalg
@@ -35,17 +35,23 @@ Dynamic: license-file
 
 ModularityPruning is a pruning tool to identify small subsets of network
 partitions that are significant from the perspective of stochastic block model
-inference. This method works for single-layer and multi-layer networks, as well
-as for restricting focus to a fixed number of communities when desired.
+inference. It:
+
+- Works for single-layer and multi-layer networks
+- Supports both directed and undirected networks
+- Supports weighted networks via the `weight` edge attribute
+- Restricts focus to a fixed number of communities when desired
+- Contains a faster and more robust implementation of the CHAMP (Convex Hull of
+  Admissible Modularity Partitions) algorithm (see `CHAMP_2D` and `CHAMP_3D`)
 
 See the [documentation](https://modularitypruning.readthedocs.io/en/latest/)
 or the journal article at https://doi.org/10.1038/s41598-022-20142-6 for more
 information.
 
 Significantly more details can be found in the article's
-[Supplementary Information](
-https://static-content.springer.com/esm/art%3A10.1038%2Fs41598-022-20142-6/MediaObjects/41598_2022_20142_MOESM1_ESM.pdf
-).
+[Supplementary Information](https://static-content.springer.com/esm/art%3A10.1038%2Fs41598-022-20142-6/MediaObjects/41598_2022_20142_MOESM1_ESM.pdf).
+
+Note: support for weighted and directed networks is an extension beyond the original publication.
 
 ## Installation
 
@@ -60,7 +66,12 @@ Alternatively, you can install it from this repository directly:
 
     git clone https://github.com/ragibson/ModularityPruning
     cd ModularityPruning
-    python3 setup.py install
+    pip install .
+
+For modularitypruning development, it is best to use a strict editable install
+so that `pytest` and `mypy` can pick up changes immediately.
+
+    pip install --editable . --config-settings editable_mode=strict
 
 <a name = "Basic Usage"></a>
 
@@ -84,7 +95,7 @@ partitions = repeated_leiden_from_gammas(G, np.linspace(0, 2, 1000))
 # prune to the stable partitions from gamma=0 to gamma=2
 stable_partitions = prune_to_stable_partitions(G, partitions, 0, 2)
 print(stable_partitions)
-``` 
+```
 
 This prints
 

{modularitypruning-1.5.1 → modularitypruning-2.0.0}/README.md

@@ -4,17 +4,23 @@
 
 ModularityPruning is a pruning tool to identify small subsets of network
 partitions that are significant from the perspective of stochastic block model
-inference. This method works for single-layer and multi-layer networks, as well
-as for restricting focus to a fixed number of communities when desired.
+inference. It:
+
+- Works for single-layer and multi-layer networks
+- Supports both directed and undirected networks
+- Supports weighted networks via the `weight` edge attribute
+- Restricts focus to a fixed number of communities when desired
+- Contains a faster and more robust implementation of the CHAMP (Convex Hull of
+  Admissible Modularity Partitions) algorithm (see `CHAMP_2D` and `CHAMP_3D`)
 
 See the [documentation](https://modularitypruning.readthedocs.io/en/latest/)
 or the journal article at https://doi.org/10.1038/s41598-022-20142-6 for more
 information.
 
 Significantly more details can be found in the article's
-[Supplementary Information](
-https://static-content.springer.com/esm/art%3A10.1038%2Fs41598-022-20142-6/MediaObjects/41598_2022_20142_MOESM1_ESM.pdf
-).
+[Supplementary Information](https://static-content.springer.com/esm/art%3A10.1038%2Fs41598-022-20142-6/MediaObjects/41598_2022_20142_MOESM1_ESM.pdf).
+
+Note: support for weighted and directed networks is an extension beyond the original publication.
 
 ## Installation
 
@@ -29,7 +35,12 @@ Alternatively, you can install it from this repository directly:
 
     git clone https://github.com/ragibson/ModularityPruning
     cd ModularityPruning
-    python3 setup.py install
+    pip install .
+
+For modularitypruning development, it is best to use a strict editable install
+so that `pytest` and `mypy` can pick up changes immediately.
+
+    pip install --editable . --config-settings editable_mode=strict
 
 <a name = "Basic Usage"></a>
 
@@ -53,7 +64,7 @@ partitions = repeated_leiden_from_gammas(G, np.linspace(0, 2, 1000))
 # prune to the stable partitions from gamma=0 to gamma=2
 stable_partitions = prune_to_stable_partitions(G, partitions, 0, 2)
 print(stable_partitions)
-``` 
+```
 
 This prints
 

{modularitypruning-1.5.1 → modularitypruning-2.0.0}/modularitypruning.egg-info/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.4
 Name: modularitypruning
-Version: 1.5.1
+Version: 2.0.0
 Summary: Pruning tool to identify small subsets of network partitions that are significant from the perspective of stochastic block model inference.
 Author-email: Ryan Gibson <ryan.alex.gibson@gmail.com>
 License-Expression: MIT
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -15,7 +14,8 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.9
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: leidenalg
@@ -35,17 +35,23 @@ Dynamic: license-file
 
 ModularityPruning is a pruning tool to identify small subsets of network
 partitions that are significant from the perspective of stochastic block model
-inference. This method works for single-layer and multi-layer networks, as well
-as for restricting focus to a fixed number of communities when desired.
+inference. It:
+
+- Works for single-layer and multi-layer networks
+- Supports both directed and undirected networks
+- Supports weighted networks via the `weight` edge attribute
+- Restricts focus to a fixed number of communities when desired
+- Contains a faster and more robust implementation of the CHAMP (Convex Hull of
+  Admissible Modularity Partitions) algorithm (see `CHAMP_2D` and `CHAMP_3D`)
 
 See the [documentation](https://modularitypruning.readthedocs.io/en/latest/)
 or the journal article at https://doi.org/10.1038/s41598-022-20142-6 for more
 information.
 
 Significantly more details can be found in the article's
-[Supplementary Information](
-https://static-content.springer.com/esm/art%3A10.1038%2Fs41598-022-20142-6/MediaObjects/41598_2022_20142_MOESM1_ESM.pdf
-).
+[Supplementary Information](https://static-content.springer.com/esm/art%3A10.1038%2Fs41598-022-20142-6/MediaObjects/41598_2022_20142_MOESM1_ESM.pdf).
+
+Note: support for weighted and directed networks is an extension beyond the original publication.
 
 ## Installation
 
@@ -60,7 +66,12 @@ Alternatively, you can install it from this repository directly:
 
     git clone https://github.com/ragibson/ModularityPruning
     cd ModularityPruning
-    python3 setup.py install
+    pip install .
+
+For modularitypruning development, it is best to use a strict editable install
+so that `pytest` and `mypy` can pick up changes immediately.
+
+    pip install --editable . --config-settings editable_mode=strict
 
 <a name = "Basic Usage"></a>
 
@@ -84,7 +95,7 @@ partitions = repeated_leiden_from_gammas(G, np.linspace(0, 2, 1000))
 # prune to the stable partitions from gamma=0 to gamma=2
 stable_partitions = prune_to_stable_partitions(G, partitions, 0, 2)
 print(stable_partitions)
-``` 
+```
 
 This prints
 

{modularitypruning-1.5.1 → modularitypruning-2.0.0}/modularitypruning.egg-info/SOURCES.txt

@@ -24,4 +24,5 @@ utilities/parameter_estimation.py
 utilities/parameter_estimation_utilities.py
 utilities/partition_utilities.py
 utilities/plotting.py
-utilities/progress.py
+utilities/py.typed
+utilities/types.py

{modularitypruning-1.5.1 → modularitypruning-2.0.0}/pyproject.toml

@@ -4,10 +4,10 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "modularitypruning"
-version = "1.5.1"
+version = "2.0.0"
 description = "Pruning tool to identify small subsets of network partitions that are significant from the perspective of stochastic block model inference."
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 license = "MIT"
 authors = [
     { name = "Ryan Gibson", email = "ryan.alex.gibson@gmail.com" }
@@ -17,14 +17,14 @@ classifiers = [
     "Development Status :: 5 - Production/Stable",
     "Topic :: Scientific/Engineering :: Information Analysis",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
     "Programming Language :: Python :: 3.15",
-    "Programming Language :: Python :: 3 :: Only"
+    "Programming Language :: Python :: 3 :: Only",
+    "Typing :: Typed"
 ]
 dependencies = [
     "leidenalg",
@@ -44,5 +44,8 @@ packages = ["modularitypruning"]
 [tool.setuptools.package-dir]
 modularitypruning = "utilities"
 
+[tool.setuptools.package-data]
+modularitypruning = ["py.typed"]
+
 [tool.autopep8]
 max_line_length = 120

modularitypruning-2.0.0/tests/test_champ_coefficients_2D.py

@@ -0,0 +1,122 @@
+import unittest
+from random import seed
+
+from modularitypruning.champ_utilities import partition_coefficients_2D
+from modularitypruning.leiden_utilities import leiden_part_with_membership, repeated_leiden_from_gammas
+
+from .shared_testing_functions import generate_connected_ER, generate_SBM, \
+    generate_random_values, generate_random_partitions, generate_igraph_famous
+
+
+class TestCHAMPCoefficients2D(unittest.TestCase):
+    def assert_partition_coefficient_correctness(self, G, partitions, coefficients):
+        A_hats, P_hats = coefficients
+
+        for membership, A_hat, P_hat in zip(partitions, A_hats, P_hats):
+            leiden_part = leiden_part_with_membership(G, membership)
+
+            # Q(gamma=0) = sum_{ij} A_{ij} delta(c_i, c_j) = A_hat
+            leiden_A_hat = leiden_part.quality(resolution_parameter=0)
+
+            # Q(gamma=0) - Q(gamma=1)
+            #   = sum_{ij} (A_{ij} - gamma*P_{ij} - A_{ij}) delta(c_i, c_j)
+            #   = sum_{ij} P_{ij} delta(c_i, c_j)
+            #   = P_hat
+            leiden_P_hat = leiden_A_hat - leiden_part.quality(resolution_parameter=1)
+
+            self.assertAlmostEqual(A_hat, leiden_A_hat, places=8)
+            self.assertAlmostEqual(P_hat, leiden_P_hat, places=8)
+
+    def assert_partition_coefficient_correctness_ER(self, n=100, m=500, directed=False,
+                                                    num_partitions=10, K_max=5, weighted=False):
+        G = generate_connected_ER(n=n, m=m, directed=directed, weighted=weighted)
+        partitions = generate_random_partitions(num_nodes=n, num_partitions=num_partitions, K_max=K_max)
+        coefficients = partition_coefficients_2D(G, partitions)
+        self.assert_partition_coefficient_correctness(G, partitions, coefficients)
+
+    def test_partition_coefficient_correctness_undirected_varying_n(self):
+        for n in [50, 100, 250, 500]:
+            for weighted in [False, True]:
+                with self.subTest(n=n, weighted=weighted):
+                    self.assert_partition_coefficient_correctness_ER(n=n, m=5 * n, weighted=weighted)
+
+    def test_partition_coefficient_correctness_undirected_varying_m(self):
+        for m in [200, 500, 1000]:
+            for weighted in [False, True]:
+                with self.subTest(m=m, weighted=weighted):
+                    self.assert_partition_coefficient_correctness_ER(m=m, weighted=weighted)
+
+    def test_partition_coefficient_correctness_undirected_varying_num_partitions(self):
+        for num_partitions in [10, 100, 1000]:
+            for weighted in [False, True]:
+                with self.subTest(num_partitions=num_partitions, weighted=weighted):
+                    self.assert_partition_coefficient_correctness_ER(num_partitions=num_partitions,
+                                                                     weighted=weighted)
+
+    def test_partition_coefficient_correctness_undirected_varying_K_max(self):
+        for K_max in [2, 5, 10, 20]:
+            for weighted in [False, True]:
+                with self.subTest(K_max=K_max, weighted=weighted):
+                    self.assert_partition_coefficient_correctness_ER(num_partitions=100, K_max=K_max,
+                                                                     weighted=weighted)
+
+    def test_partition_coefficient_correctness_directed_varying_n(self):
+        for n in [50, 100, 250, 500]:
+            for weighted in [False, True]:
+                with self.subTest(n=n, weighted=weighted):
+                    self.assert_partition_coefficient_correctness_ER(n=n, m=10 * n, directed=True,
+                                                                     weighted=weighted)
+
+    def test_partition_coefficient_correctness_directed_varying_m(self):
+        for m in [400, 1000, 2000]:
+            for weighted in [False, True]:
+                with self.subTest(m=m, weighted=weighted):
+                    self.assert_partition_coefficient_correctness_ER(m=m, directed=True, weighted=weighted)
+
+    def test_partition_coefficient_correctness_directed_varying_num_partitions(self):
+        for num_partitions in [10, 100, 1000]:
+            for weighted in [False, True]:
+                with self.subTest(num_partitions=num_partitions, weighted=weighted):
+                    self.assert_partition_coefficient_correctness_ER(directed=True, num_partitions=num_partitions,
+                                                                     weighted=weighted)
+
+    def test_partition_coefficient_correctness_directed_varying_K_max(self):
+        for K_max in [2, 5, 10, 20]:
+            for weighted in [False, True]:
+                with self.subTest(K_max=K_max, weighted=weighted):
+                    self.assert_partition_coefficient_correctness_ER(directed=True, num_partitions=100, K_max=K_max,
+                                                                     weighted=weighted)
+
+    def test_partition_coefficient_correctness_directed_SBM(self):
+        """Test on asymmetric directed SBMs, unweighted and weighted."""
+        for q in [2, 3, 5]:
+            for weighted in [False, True]:
+                with self.subTest(q=q, weighted=weighted):
+                    G, _, _ = generate_SBM(q, directed=True, weighted=weighted)
+                    partitions = generate_random_partitions(num_nodes=G.vcount(), num_partitions=100, K_max=q)
+                    coefficients = partition_coefficients_2D(G, partitions)
+                    self.assert_partition_coefficient_correctness(G, partitions, coefficients)
+
+    def test_partition_coefficient_correctness_igraph_famous_leiden(self):
+        """Test partition coefficient correctness on various famous graphs while obtaining partitions via Leiden.
+
+        The correctness is checked for the original undirected and (symmetric) directed variants.
+        """
+
+        for name, G in generate_igraph_famous():
+            gammas = generate_random_values(100, start_value=0, end_value=5)
+            with self.subTest(graph=name, directed=False):
+                partitions = repeated_leiden_from_gammas(G, gammas)
+                coefficients = partition_coefficients_2D(G, partitions)
+                self.assert_partition_coefficient_correctness(G, partitions, coefficients)
+
+            G.to_directed()  # check the directed version of the graph as well
+            with self.subTest(graph=name, directed=True):
+                partitions = repeated_leiden_from_gammas(G, gammas)
+                coefficients = partition_coefficients_2D(G, partitions)
+                self.assert_partition_coefficient_correctness(G, partitions, coefficients)
+
+
+if __name__ == "__main__":
+    seed(0)
+    unittest.main()

modularitypruning-2.0.0/tests/test_champ_coefficients_3D.py

@@ -0,0 +1,177 @@
+import unittest
+from random import seed
+
+from modularitypruning.champ_utilities import partition_coefficients_3D
+from modularitypruning.leiden_utilities import multilayer_leiden_part_with_membership, leiden_part_with_membership
+
+from .shared_testing_functions import generate_connected_multilayer_ER, generate_random_partitions, \
+    generate_temporal_SBM
+
+
+class TestCHAMPCoefficients3D(unittest.TestCase):
+    def assert_partition_coefficient_correctness(self, G_intralayer, G_interlayer, layer_membership,
+                                                 partitions, coefficients):
+        A_hats, P_hats, C_hats = coefficients
+
+        for membership, A_hat, P_hat, C_hat in zip(partitions, A_hats, P_hats, C_hats):
+            intralayer_parts, interlayer_part = multilayer_leiden_part_with_membership(G_intralayer, G_interlayer,
+                                                                                       layer_membership,
+                                                                                       community_membership=membership)
+
+            # Q_intralayer(gamma=0) = sum_{ij} A_{ij} delta(c_i, c_j) = A_hat
+            leiden_A_hat = sum(p.quality(resolution_parameter=0) for p in intralayer_parts)
+
+            # Q_intralayer(gamma=0) - Q_intralayer(gamma=1)
+            #   = sum_{ij} (A_{ij} - gamma*P_{ij} - A_{ij}) delta(c_i, c_j)
+            #   = sum_{ij} P_{ij} delta(c_i, c_j)
+            #   = P_hat
+            leiden_P_hat = leiden_A_hat - sum(p.quality(resolution_parameter=1) for p in intralayer_parts)
+
+            # Q_interlayer(omega=0)
+            #   = sum_{ij} (C_{ij} - omega*P{ij}) delta(c_i, c_j)
+            #   = sum_{ij} C_{ij} delta(c_i, c_j)
+            #   = C_hat
+            leiden_C_hat = interlayer_part.quality(resolution_parameter=0)
+
+            self.assertAlmostEqual(A_hat, leiden_A_hat, places=8)
+            self.assertAlmostEqual(P_hat, leiden_P_hat, places=8)
+            self.assertAlmostEqual(C_hat, leiden_C_hat, places=8)
+
+            # Also test against an alternate, per-layer calculation of P_hat
+            alternate_P_hat = 0
+            for layer in set(layer_membership):
+                this_layer_indices = [i for i, l in enumerate(layer_membership) if layer == l]
+                layer_subgraph = G_intralayer.subgraph(this_layer_indices)
+                layer_community_membership = [community for i, community in enumerate(membership)
+                                              if layer_membership[i] == layer]
+                layer_part = leiden_part_with_membership(layer_subgraph, layer_community_membership)
+                alternate_P_hat += (layer_part.quality(resolution_parameter=0.0) -
+                                    layer_part.quality(resolution_parameter=1.0))
+            self.assertAlmostEqual(alternate_P_hat, P_hat, places=8)
+
+    def assert_partition_coefficient_correctness_ER(self, num_nodes_per_layer=100, m=25000, num_layers=10,
+                                                    directed=False, num_partitions=10, K_max=10, weighted=False):
+        G_intralayer, G_interlayer, layer_membership = generate_connected_multilayer_ER(
+            num_nodes_per_layer=num_nodes_per_layer, m=m, num_layers=num_layers, directed=directed,
+            weighted=weighted)
+        partitions = generate_random_partitions(num_nodes=G_intralayer.vcount(), num_partitions=num_partitions,
+                                                K_max=K_max)
+        coefficients = partition_coefficients_3D(G_intralayer, G_interlayer, layer_membership, partitions)
+        self.assert_partition_coefficient_correctness(G_intralayer, G_interlayer, layer_membership, partitions,
+                                                      coefficients)
+
+    def test_partition_coefficient_correctness_undirected_varying_num_nodes_per_layer(self):
+        for num_nodes_per_layer in [50, 100, 250, 500]:
+            for weighted in [False, True]:
+                with self.subTest(num_nodes_per_layer=num_nodes_per_layer, weighted=weighted):
+                    self.assert_partition_coefficient_correctness_ER(num_nodes_per_layer=num_nodes_per_layer,
+                                                                     m=50 * num_nodes_per_layer,
+                                                                     weighted=weighted)
+
+    def test_partition_coefficient_correctness_undirected_varying_m(self):
+        for m in [5000, 10000, 15000, 20000]:
+            for weighted in [False, True]:
+                with self.subTest(m=m, weighted=weighted):
+                    self.assert_partition_coefficient_correctness_ER(m=m, weighted=weighted)
+
+    def test_partition_coefficient_correctness_undirected_varying_num_layers(self):
+        for num_layers in [5, 10, 20, 30]:
+            for weighted in [False, True]:
+                with self.subTest(num_layers=num_layers, weighted=weighted):
+                    self.assert_partition_coefficient_correctness_ER(num_layers=num_layers, weighted=weighted)
+
+    def test_partition_coefficient_correctness_undirected_varying_num_partitions(self):
+        for num_partitions in [5, 10, 100, 250]:
+            for weighted in [False, True]:
+                with self.subTest(num_partitions=num_partitions, weighted=weighted):
+                    self.assert_partition_coefficient_correctness_ER(num_partitions=num_partitions,
+                                                                     weighted=weighted)
+
+    def test_partition_coefficient_correctness_undirected_varying_K_max(self):
+        for K_max in [2, 5, 10, 25]:
+            for weighted in [False, True]:
+                with self.subTest(K_max=K_max, weighted=weighted):
+                    self.assert_partition_coefficient_correctness_ER(K_max=K_max, weighted=weighted)
+
+    def test_partition_coefficient_correctness_directed_varying_num_nodes_per_layer(self):
+        for num_nodes_per_layer in [50, 100, 250, 500]:
+            for weighted in [False, True]:
+                with self.subTest(num_nodes_per_layer=num_nodes_per_layer, weighted=weighted):
+                    self.assert_partition_coefficient_correctness_ER(num_nodes_per_layer=num_nodes_per_layer,
+                                                                     m=100 * num_nodes_per_layer, directed=True,
+                                                                     weighted=weighted)
+
+    def test_partition_coefficient_correctness_directed_varying_m(self):
+        for m in [10000, 20000, 30000, 40000]:
+            for weighted in [False, True]:
+                with self.subTest(m=m, weighted=weighted):
+                    self.assert_partition_coefficient_correctness_ER(m=m, directed=True, weighted=weighted)
+
+    def test_partition_coefficient_correctness_directed_varying_num_layers(self):
+        for num_layers in [5, 10, 20, 30]:
+            for weighted in [False, True]:
+                with self.subTest(num_layers=num_layers, weighted=weighted):
+                    self.assert_partition_coefficient_correctness_ER(num_layers=num_layers, directed=True,
+                                                                     weighted=weighted)
+
+    def test_partition_coefficient_correctness_directed_varying_num_partitions(self):
+        for num_partitions in [5, 10, 100, 250]:
+            for weighted in [False, True]:
+                with self.subTest(num_partitions=num_partitions, weighted=weighted):
+                    self.assert_partition_coefficient_correctness_ER(directed=True, num_partitions=num_partitions,
+                                                                     weighted=weighted)
+
+    def test_partition_coefficient_correctness_directed_varying_K_max(self):
+        for K_max in [2, 5, 10, 25]:
+            for weighted in [False, True]:
+                with self.subTest(K_max=K_max, weighted=weighted):
+                    self.assert_partition_coefficient_correctness_ER(directed=True, K_max=K_max, weighted=weighted)
+
+    def assert_partition_coefficient_correctness_SBM(self, num_layers, weighted):
+        num_nodes_per_layer = 100
+        first_layer_membership = [i // (num_nodes_per_layer // 3) for i in range(num_nodes_per_layer)]
+
+        G_intralayer, G_interlayer, layer_membership = generate_temporal_SBM(
+            copying_probability=0.9, p_in=0.25, p_out=0.05, first_layer_membership=first_layer_membership,
+            num_layers=num_layers, weighted=weighted, directed=True)
+
+        partitions = generate_random_partitions(num_nodes=G_intralayer.vcount(), num_partitions=100, K_max=3)
+        coefficients = partition_coefficients_3D(G_intralayer, G_interlayer, layer_membership, partitions)
+
+        self.assert_partition_coefficient_correctness(G_intralayer, G_interlayer, layer_membership, partitions,
+                                                      coefficients)
+
+    def test_partition_coefficient_correctness_directed_SBM(self):
+        """Test on asymmetric directed SBMs, unweighted and weighted."""
+        for num_layers in [4, 5]:
+            for weighted in [False, True]:
+                with self.subTest(num_layers=num_layers, weighted=weighted):
+                    self.assert_partition_coefficient_correctness_SBM(num_layers=num_layers, weighted=weighted)
+
+    def test_partition_coefficient_correctness_interleaved_directedness(self):
+        """Test partition coefficient correctness when directedness of interlayer and intralayer edges do not match."""
+        for weighted in [False, True]:
+            # Intralayer directed edges, but interlayer undirected ones
+            with self.subTest(intralayer_directed=True, weighted=weighted):
+                G_intralayer, G_interlayer, layer_membership = generate_connected_multilayer_ER(
+                    num_nodes_per_layer=100, m=5000, num_layers=10, directed=False, weighted=weighted)
+                G_intralayer.to_directed()
+                partitions = generate_random_partitions(num_nodes=G_intralayer.vcount(), num_partitions=10, K_max=10)
+                coefficients = partition_coefficients_3D(G_intralayer, G_interlayer, layer_membership, partitions)
+                self.assert_partition_coefficient_correctness(G_intralayer, G_interlayer, layer_membership, partitions,
+                                                              coefficients)
+
+            # Interlayer directed edges, but intralayer undirected ones
+            with self.subTest(intralayer_directed=False, weighted=weighted):
+                G_intralayer, G_interlayer, layer_membership = generate_connected_multilayer_ER(
+                    num_nodes_per_layer=100, m=5000, num_layers=10, directed=False, weighted=weighted)
+                G_interlayer.to_directed()
+                partitions = generate_random_partitions(num_nodes=G_intralayer.vcount(), num_partitions=10, K_max=10)
+                coefficients = partition_coefficients_3D(G_intralayer, G_interlayer, layer_membership, partitions)
+                self.assert_partition_coefficient_correctness(G_intralayer, G_interlayer, layer_membership, partitions,
+                                                              coefficients)
+
+
+if __name__ == "__main__":
+    seed(0)
+    unittest.main()