scikit-network 0.31.0__cp38-cp38-win_amd64.whl → 0.32.1__cp38-cp38-win_amd64.whl

sknetwork/topology/structure.py

@@ -6,13 +6,14 @@ Created in July 2019
 @author: Quentin Lutz <qlutz@enst.fr>
 @author: Thomas Bonald <tbonald@enst.fr>
 """
-from typing import Tuple, Optional, Union
+from typing import Tuple, Optional, Union, List
 
 import numpy as np
 from scipy import sparse
 
 from sknetwork.utils.check import is_symmetric, check_format
 from sknetwork.utils.format import get_adjacency
+from sknetwork.path import get_distances
 
 
 def get_connected_components(input_matrix: sparse.csr_matrix, connection: str = 'weak', force_bipartite: bool = False) \
@@ -191,44 +192,3 @@ def is_bipartite(adjacency: sparse.csr_matrix, return_biadjacency: bool = False)
         return True
 
 
-def is_acyclic(adjacency: sparse.csr_matrix, directed: Optional[bool] = None) -> bool:
-    """Check whether a graph has no cycle.
-
-    Parameters
-    ----------
-    adjacency:
-        Adjacency matrix of the graph.
-    directed:
-        Whether to consider the graph as directed (inferred if not specified).
-    Returns
-    -------
-    is_acyclic : bool
-        A boolean with value True if the graph has no cycle and False otherwise.
-
-    Example
-    -------
-    >>> from sknetwork.topology import is_acyclic
-    >>> from sknetwork.data import star, grid
-    >>> is_acyclic(star())
-    True
-    >>> is_acyclic(grid())
-    False
-    """
-    if directed is False:
-        # the graph must be undirected
-        if not is_symmetric(adjacency):
-            raise ValueError("The adjacency matrix is not symmetric. The parameter 'directed' must be True.")
-    elif directed is None:
-        # if not specified, infer from the graph
-        directed = not is_symmetric(adjacency)
-    has_loops = (adjacency.diagonal() > 0).any()
-    if has_loops:
-        return False
-    else:
-        n_cc = sparse.csgraph.connected_components(adjacency, directed, connection='strong', return_labels=False)
-        n_nodes = adjacency.shape[0]
-        if directed:
-            return n_cc == n_nodes
-        else:
-            n_edges = adjacency.nnz // 2
-            return n_cc == n_nodes - n_edges

sknetwork/topology/tests/test_cycles.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+""""tests for cycles.py"""
+import unittest
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.data import star_wars, house, cyclic_digraph, cyclic_graph, linear_digraph, linear_graph
+from sknetwork.topology import is_connected, is_acyclic, get_cycles, break_cycles
+from sknetwork.utils.format import bipartite2undirected, directed2undirected
+
+
+class TestCycle(unittest.TestCase):
+
+    def test_is_acyclic(self):
+        adjacency_with_self_loops = sparse.identity(2, format='csr')
+        self.assertFalse(is_acyclic(adjacency_with_self_loops))
+        self.assertFalse(is_acyclic(adjacency_with_self_loops, directed=True))
+        directed_cycle = cyclic_digraph(3)
+        self.assertFalse(is_acyclic(directed_cycle))
+        with self.assertRaises(ValueError):
+            is_acyclic(directed_cycle, directed=False)
+        undirected_line = linear_graph(2)
+        self.assertTrue(is_acyclic(undirected_line))
+        self.assertFalse(is_acyclic(undirected_line, directed=True))
+        acyclic_graph = linear_digraph(2)
+        self.assertTrue(is_acyclic(acyclic_graph))
+
+    def test_get_cycles(self):
+        adjacency_with_self_loops = sparse.identity(2, format='csr')
+        node_cycles = get_cycles(adjacency_with_self_loops, directed=True)
+        self.assertEqual(node_cycles, [[0], [1]])
+
+        cycle_adjacency = cyclic_digraph(4)
+        node_cycles = get_cycles(cycle_adjacency, directed=True)
+        self.assertEqual(sorted(node_cycles[0]), [0, 1, 2, 3])
+        adjacency_with_subcycles = cycle_adjacency + sparse.csr_matrix(([1], ([1], [3])), shape=cycle_adjacency.shape)
+        node_cycles = get_cycles(adjacency_with_subcycles, directed=True)
+        self.assertEqual(node_cycles, [[0, 1, 3], [0, 1, 2, 3]])
+
+        undirected_cycle = cyclic_graph(4)
+        node_cycles = get_cycles(undirected_cycle, directed=False)
+        self.assertEqual(sorted(node_cycles[0]), [0, 1, 2, 3])
+
+        disconnected_cycles = sparse.csr_matrix(([1, 1, 1], ([1, 2, 3], [2, 3, 1])), shape=(4, 4))
+        node_cycles = get_cycles(disconnected_cycles, directed=True)
+        self.assertEqual(sorted(node_cycles[0]), [1, 2, 3])
+
+    def test_break_cycles(self):
+        cycle_adjacency = cyclic_digraph(4)
+        acyclic_graph = break_cycles(cycle_adjacency, root=0, directed=True)
+        self.assertTrue(is_acyclic(acyclic_graph))
+        adjacency_with_subcycles = cycle_adjacency + sparse.csr_matrix(([1], ([1], [0])), shape=cycle_adjacency.shape)
+        acyclic_graph = break_cycles(adjacency_with_subcycles, root=0, directed=True)
+        self.assertTrue(is_acyclic(acyclic_graph))
+
+        undirected_cycle = house(metadata=False)
+        acyclic_graph = break_cycles(undirected_cycle, root=0, directed=False)
+        self.assertTrue(is_acyclic(acyclic_graph))
+
+        disconnected_cycles = sparse.csr_matrix(([1, 1, 1, 1, 1], ([0, 1, 2, 3, 4], [1, 0, 3, 4, 2])), shape=(5, 5))
+        self.assertFalse(is_connected(disconnected_cycles))
+        acyclic_graph = break_cycles(disconnected_cycles, root=[0, 2], directed=True)
+        self.assertTrue(is_acyclic(acyclic_graph))

sknetwork/topology/tests/test_structure.py

@@ -6,9 +6,9 @@ import unittest
 import numpy as np
 from scipy import sparse
 
-from sknetwork.data import star_wars, cyclic_digraph, linear_digraph, linear_graph
+from sknetwork.data import star_wars, house, cyclic_digraph, cyclic_graph, linear_digraph, linear_graph
 from sknetwork.topology import get_connected_components, get_largest_connected_component
-from sknetwork.topology import is_connected, is_bipartite, is_acyclic
+from sknetwork.topology import is_connected, is_bipartite
 from sknetwork.utils.format import bipartite2undirected, directed2undirected
 
 
@@ -83,17 +83,3 @@ class TestStructure(unittest.TestCase):
         adjacency = directed2undirected(cyclic_digraph(3))
         bipartite = is_bipartite(adjacency, return_biadjacency=False)
         self.assertEqual(bipartite, False)
-
-    def test_is_acyclic(self):
-        adjacency_with_self_loops = sparse.identity(2, format='csr')
-        self.assertFalse(is_acyclic(adjacency_with_self_loops))
-        self.assertFalse(is_acyclic(adjacency_with_self_loops, directed=True))
-        directed_cycle = cyclic_digraph(3)
-        self.assertFalse(is_acyclic(directed_cycle))
-        with self.assertRaises(ValueError):
-            is_acyclic(directed_cycle, directed=False)
-        undirected_line = linear_graph(2)
-        self.assertTrue(is_acyclic(undirected_line))
-        self.assertFalse(is_acyclic(undirected_line, directed=True))
-        acyclic_graph = linear_digraph(2)
-        self.assertTrue(is_acyclic(acyclic_graph))