scikit-network 0.30.0__cp39-cp39-win_amd64.whl → 0.32.1__cp39-cp39-win_amd64.whl

sknetwork/path/tests/test_dag.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+""""tests for search.py"""
+
+import unittest
+
+import numpy as np
+
+from sknetwork.data import cyclic_digraph
+from sknetwork.data.test_graphs import *
+from sknetwork.path import get_dag
+
+
+class TestSearch(unittest.TestCase):
+
+    def test(self):
+        adjacency = cyclic_digraph(3)
+        dag = get_dag(adjacency)
+        self.assertEqual(dag.nnz, 2)
+
+        adjacency = test_graph_empty()
+        dag = get_dag(adjacency)
+        self.assertEqual(dag.nnz, 0)
+
+        adjacency = test_graph()
+        dag = get_dag(adjacency)
+        self.assertEqual(dag.nnz, 12)
+        dag = get_dag(adjacency, order=np.arange(10) % 3)
+        self.assertEqual(dag.nnz, 10)
+
+        adjacency = test_disconnected_graph()
+        dag = get_dag(adjacency, 3)
+        self.assertEqual(dag.nnz, 1)
+
+        adjacency = test_digraph()
+        dag = get_dag(adjacency, 1)
+        self.assertEqual(dag.nnz, 4)

sknetwork/path/tests/test_distances.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+""""tests for distances.py"""
+import unittest
+
+from sknetwork.data.test_graphs import *
+from sknetwork.path.distances import get_distances
+
+
+class TestDistances(unittest.TestCase):
+
+    def test_input(self):
+        adjacency = test_graph()
+        with self.assertRaises(ValueError):
+            get_distances(adjacency)
+        with self.assertRaises(ValueError):
+            get_distances(adjacency, source=0, source_row=5)
+
+    def test_algo(self):
+        adjacency = test_graph()
+        distances = get_distances(adjacency, 0)
+        distances_ = np.array([0, 1, 3, 2, 2, 3, 2, 3, 4, 4])
+        self.assertTrue(all(distances == distances_))
+        distances = get_distances(adjacency, 0, transpose=True)
+        self.assertTrue(all(distances == distances_))
+        distances = get_distances(adjacency, [0, 5])
+        distances_ = np.array([0, 1, 3, 2, 1, 0, 1, 2, 4, 3])
+        self.assertTrue(all(distances == distances_))
+
+        adjacency = test_graph_empty()
+        source = [0, 3]
+        distances = get_distances(adjacency, source)
+        distances_ = -np.ones(len(distances), dtype=int)
+        distances_[source] = 0
+        self.assertTrue(all(distances == distances_))
+
+        adjacency = test_digraph()
+        distances = get_distances(adjacency, [0])
+        distances_ = np.array([0, 1, 3, 2, 2, 3, -1, -1, -1, -1])
+        self.assertTrue(all(distances == distances_))
+        distances = get_distances(adjacency, [0], transpose=True)
+        self.assertTrue(sum(distances < 0) == 9)
+        distances = get_distances(adjacency, [0, 5], transpose=True)
+        distances_ = np.array([0, 2, -1, -1, 1, 0, 1, -1, -1, -1])
+        self.assertTrue(all(distances == distances_))
+
+        biadjacency = test_bigraph()
+        distances_row, distances_col = get_distances(biadjacency, [0])
+        distances_row_, distances_col_ = np.array([0, -1, 2, -1, -1, -1]), np.array([3,  1, -1, -1, -1, -1, -1, -1])
+        self.assertTrue(all(distances_row == distances_row_))
+        self.assertTrue(all(distances_col == distances_col_))
+
+        adjacency = test_graph()
+        distances_row, distances_col = get_distances(adjacency, source_col=[0])
+        self.assertTrue(all(distances_row % 2))
+        self.assertTrue(all((distances_col + 1) % 2))
+
+        biadjacency = test_bigraph()
+        distances_row, distances_col = get_distances(biadjacency, source=0, source_col=[1, 2])
+        distances_row_, distances_col_ = np.array([0,  1,  1, -1, -1, -1]), np.array([2,  0,  0,  2, -1, -1, -1, -1])
+        self.assertTrue(all(distances_row == distances_row_))
+        self.assertTrue(all(distances_col == distances_col_))

sknetwork/path/tests/test_search.py

@@ -7,19 +7,34 @@ import unittest
 import numpy as np
 
 from sknetwork.data import cyclic_digraph
-from sknetwork.path import breadth_first_search, depth_first_search
+from sknetwork.data.test_graphs import *
+from sknetwork.path import breadth_first_search
 
 
 class TestSearch(unittest.TestCase):
 
-    def setUp(self) -> None:
-        """Load graph for tests."""
-        self.adjacency = cyclic_digraph(3).astype(bool)
-
     def test_bfs(self):
-        self.assertTrue((breadth_first_search(
-            self.adjacency, 0, return_predecessors=False) == np.array([0, 1, 2])).all())
-
-    def test_dfs(self):
-        self.assertTrue((depth_first_search(
-            self.adjacency, 0, return_predecessors=False) == np.array([0, 1, 2])).all())
+        adjacency = cyclic_digraph(3)
+        search = breadth_first_search(adjacency, 0)
+        search_ = np.arange(3)
+        self.assertTrue(all(search == search_))
+
+        adjacency = test_graph_empty()
+        search = breadth_first_search(adjacency, 0)
+        search_ = np.array([0])
+        self.assertTrue(all(search == search_))
+
+        adjacency = test_graph()
+        search = breadth_first_search(adjacency, 3)
+        search_ = np.array([3, 1, 2, 0, 4, 6, 8, 5, 7, 9])
+        self.assertTrue(all(search == search_))
+
+        adjacency = test_disconnected_graph()
+        search = breadth_first_search(adjacency, 2)
+        search_ = np.array([2, 3])
+        self.assertTrue(all(search == search_))
+
+        adjacency = test_digraph()
+        search = breadth_first_search(adjacency, 1)
+        search_ = {1, 3, 4, 2, 5}
+        self.assertTrue(set(list(search)) == search_)

sknetwork/path/tests/test_shortest_path.py

@@ -3,43 +3,38 @@
 """"tests for shortest_path.py"""
 import unittest
 
-from sknetwork.data import karate_club, cyclic_digraph
-from sknetwork.path.shortest_path import get_distances, get_shortest_path
-import numpy as np
-from scipy.sparse import csr_matrix
+from sknetwork.data.test_graphs import *
+from sknetwork.path.shortest_path import get_shortest_path
 
 
 class TestShortestPath(unittest.TestCase):
 
-    def test_parallel(self):
-        adjacency = karate_club()
-        dist1 = get_distances(adjacency)
-        dist2 = get_distances(adjacency, n_jobs=-1)
-        self.assertTrue((dist1 == dist2).all())
-
-    def test_predecessors(self):
-        adjacency = karate_club()
-        _, predecessors = get_distances(adjacency, return_predecessors=True)
-        self.assertTupleEqual(predecessors.shape, adjacency.shape)
-
-    def test_shortest_paths(self):
-        with self.assertRaises(ValueError):
-            get_shortest_path(cyclic_digraph(3), [0, 1], [0, 1])
-
-    def test_error_on_parallel_FW(self):
-        adjacency = karate_club()
-        self.assertRaises(ValueError, get_distances, adjacency, n_jobs=2, method='FW')
-
-    def test_error_neg_cycle_parallel(self):
-        adj = np.ones((5, 5), dtype=int)
-        adj[:][:] = -1
-        adj = csr_matrix(adj)
-        with self.assertRaises(ValueError):
-            get_distances(adj, method='BF', n_jobs=2)
-
-    def test_error_neg_cycle(self):
-        adj = np.ones((5, 5), dtype=int)
-        adj[:][:] = -1
-        adj = csr_matrix(adj)
-        with self.assertRaises(ValueError):
-            get_distances(adj, method='BF', n_jobs=1)
+    def test_path(self):
+        adjacency = test_graph_empty()
+        path = get_shortest_path(adjacency, 0)
+        self.assertEqual(path.nnz, 0)
+
+        adjacency = test_graph()
+        path = get_shortest_path(adjacency, 0)
+        self.assertEqual(path.nnz, 10)
+        path = get_shortest_path(adjacency, [0, 4, 6])
+        self.assertEqual(path.nnz, 10)
+        path = get_shortest_path(adjacency, np.arange(10))
+        self.assertEqual(path.nnz, 0)
+        path = get_shortest_path(adjacency, [0, 5])
+        self.assertEqual(path.nnz, 9)
+
+        adjacency = test_disconnected_graph()
+        path = get_shortest_path(adjacency, 4)
+        self.assertEqual(path.nnz, 5)
+
+        adjacency = test_digraph()
+        path = get_shortest_path(adjacency, 0)
+        self.assertEqual(path.nnz, 5)
+
+        biadjacency = test_bigraph()
+        path = get_shortest_path(biadjacency, 0)
+        self.assertEqual(path.nnz, 3)
+        self.assertTrue(path.shape[0] == np.sum(biadjacency.shape))
+        path = get_shortest_path(biadjacency, source_col=np.arange(biadjacency.shape[1]))
+        self.assertEqual(path.nnz, biadjacency.nnz)

sknetwork/ranking/__init__.py

@@ -2,7 +2,6 @@
 from sknetwork.ranking.base import BaseRanking
 from sknetwork.ranking.betweenness import Betweenness
 from sknetwork.ranking.closeness import Closeness
-from sknetwork.ranking.harmonic import Harmonic
 from sknetwork.ranking.hits import HITS
 from sknetwork.ranking.katz import Katz
 from sknetwork.ranking.pagerank import PageRank

sknetwork/ranking/base.py

@@ -1,14 +1,14 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
-Created on November 2019
+Created in November 2019
 @author: Nathan de Lara <nathan.delara@polytechnique.org>
 """
 from abc import ABC
 
 import numpy as np
 
-from sknetwork.utils.base import Algorithm
+from sknetwork.base import Algorithm
 
 
 class BaseRanking(Algorithm, ABC):
@@ -26,20 +26,25 @@ class BaseRanking(Algorithm, ABC):
     def __init__(self):
         self.scores_ = None
 
-    def fit_predict(self, *args, **kwargs) -> np.ndarray:
-        """Fit algorithm to data and return the scores. Same parameters as the ``fit`` method.
+    def predict(self, columns: bool = False) -> np.ndarray:
+        """Return the scores predicted by the algorithm.
+
+        Parameters
+        ----------
+        columns : bool
+            If ``True``, return the prediction for columns.
 
         Returns
         -------
         scores : np.ndarray
             Scores.
         """
-        self.fit(*args, **kwargs)
+        if columns:
+            return self.scores_col_
         return self.scores_
 
-    def fit_transform(self, *args, **kwargs) -> np.ndarray:
-        """Fit algorithm to data and return the scores. Alias for ``fit_predict``.
-        Same parameters as the ``fit`` method.
+    def fit_predict(self, *args, **kwargs) -> np.ndarray:
+        """Fit algorithm to data and return the scores. Same parameters as the ``fit`` method.
 
         Returns
         -------