scikit-network 0.33.0__cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

sknetwork/linalg/tests/test_operators.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in April 2020
+@author: Thomas Bonald <bonald@enst.fr>
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+import unittest
+
+from sknetwork.data.test_graphs import *
+from sknetwork.linalg import Laplacian, Normalizer, CoNeighbor
+from sknetwork.linalg.basics import safe_sparse_dot
+
+
+class TestOperators(unittest.TestCase):
+
+    def test_laplacian(self):
+        for adjacency in [test_graph(), test_disconnected_graph()]:
+            n = adjacency.shape[1]
+            # regular Laplacian
+            laplacian = Laplacian(adjacency)
+            self.assertAlmostEqual(np.linalg.norm(laplacian.dot(np.ones(n))), 0)
+            # normalized Laplacian
+            laplacian = Laplacian(adjacency, normalized_laplacian=True)
+            weights = adjacency.dot(np.ones(n))
+            self.assertAlmostEqual(np.linalg.norm(laplacian.dot(np.sqrt(weights))), 0)
+            # regularization
+            regularization = 0.1
+            laplacian = Laplacian(adjacency, regularization=regularization, normalized_laplacian=True)
+            weights = adjacency.dot(np.ones(n)) + regularization
+            self.assertAlmostEqual(np.linalg.norm(laplacian.dot(np.sqrt(weights))), 0)
+            # product
+            shape = (n, 3)
+            self.assertEqual(laplacian.dot(np.ones(shape)).shape, shape)
+            self.assertEqual(safe_sparse_dot(laplacian, np.ones(shape)).shape, shape)
+
+    def test_normalizer(self):
+        for adjacency in [test_graph(), test_disconnected_graph()]:
+            n_row, n_col = adjacency.shape
+            # square matrix
+            normalizer = Normalizer(adjacency)
+            non_zeros = adjacency.dot(np.ones(n_col)) > 0
+            self.assertAlmostEqual(np.linalg.norm(normalizer.dot(np.ones(n_col)) - non_zeros), 0)
+            # single row
+            normalizer = Normalizer(adjacency[1])
+            self.assertAlmostEqual(float(normalizer.dot(np.ones(n_col))), 1)
+            normalizer = Normalizer(adjacency[2].toarray().ravel())
+            self.assertAlmostEqual(float(normalizer.dot(np.ones(n_col))), 1)
+            # regularization
+            normalizer = Normalizer(adjacency, 1)
+            self.assertAlmostEqual(np.linalg.norm(normalizer.dot(np.ones(n_col)) - np.ones(n_row)), 0)
+
+    def test_coneighbors(self):
+        biadjacency = test_bigraph()
+        operator = CoNeighbor(biadjacency)
+        operator.astype('float')
+        operator.right_sparse_dot(sparse.eye(operator.shape[1], format='csr'))
+
+        operator1 = CoNeighbor(biadjacency, normalized=False)
+        operator2 = CoNeighbor(biadjacency, normalized=False)
+        x = np.random.randn(operator.shape[1])
+        x1 = (-operator1).dot(x)
+        x2 = (operator2 * -1).dot(x)
+        x3 = operator1.T.dot(x)
+        self.assertAlmostEqual(np.linalg.norm(x1 - x2), 0)
+        self.assertAlmostEqual(np.linalg.norm(x2 - x3), 0)

sknetwork/linalg/tests/test_polynome.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for polynomials."""
+
+import unittest
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.data.test_graphs import test_graph
+from sknetwork.linalg import Polynome
+
+
+class TestPolynome(unittest.TestCase):
+
+    def test_init(self):
+        adjacency = test_graph()
+        with self.assertRaises(ValueError):
+            Polynome(adjacency, np.array([]))
+
+    def test_operations(self):
+        adjacency = test_graph()
+        n = adjacency.shape[0]
+        polynome = Polynome(adjacency, np.arange(3))
+        x = np.random.randn(n)
+
+        y1 = (polynome * 2).dot(x)
+        y2 = (-polynome).dot(x)
+        self.assertAlmostEqual(np.linalg.norm(0.5 * y1 + y2), 0)
+
+    def test_dot(self):
+        adjacency = sparse.eye(5, format='csr')
+        polynome = Polynome(adjacency, np.arange(2))
+
+        x = np.random.randn(5, 3)
+        y = polynome.dot(x)
+        self.assertAlmostEqual(np.linalg.norm(x - y), 0)
+

sknetwork/linalg/tests/test_ppr.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for d-iteration"""
+import unittest
+
+import numpy as np
+
+from sknetwork.data import house, karate_club
+from sknetwork.data.parse import from_edge_list
+from sknetwork.data.test_graphs import *
+from sknetwork.linalg.operators import Regularizer
+from sknetwork.linalg.ppr_solver import get_pagerank
+from sknetwork.utils.check import is_proba_array
+
+
+class TestPPR(unittest.TestCase):
+
+    def test_diteration(self):
+        # test convergence by tolerance
+        for adjacency in [house(), test_graph(), test_digraph()]:
+            seeds = np.ones(adjacency.shape[0]) / adjacency.shape[0]
+            pr = get_pagerank(adjacency, damping_factor=0.85, n_iter=100, tol=10, solver='diteration', seeds=seeds)
+            self.assertTrue(is_proba_array(pr))
+
+        # test graph with some null out-degree
+        adjacency = from_edge_list([(0, 1)])
+        seeds = np.ones(adjacency.shape[0]) / adjacency.shape[0]
+        pr = get_pagerank(adjacency, damping_factor=0.85, n_iter=100, tol=10, solver='diteration', seeds=seeds)
+        self.assertTrue(is_proba_array(pr))
+
+        # test invalid entry
+        adjacency = Regularizer(house(), 0.1)
+        seeds = np.ones(adjacency.shape[0]) / adjacency.shape[0]
+        with self.assertRaises(ValueError):
+            get_pagerank(adjacency, damping_factor=0.85, n_iter=100, tol=10, solver='diteration', seeds=seeds)
+
+    def test_push(self):
+        # test convergence by tolerance
+        adjacency = karate_club()
+        seeds = np.ones(adjacency.shape[0]) / adjacency.shape[0]
+        pr = get_pagerank(adjacency, damping_factor=0.85,
+                          n_iter=100, tol=1e-1, solver='push', seeds=seeds)
+        self.assertTrue(is_proba_array(pr))
+
+    def test_piteration(self):
+        # test on SparseLR matrix
+        adjacency = Regularizer(house(), 0.1)
+        seeds = np.ones(adjacency.shape[0]) / adjacency.shape[0]
+        pr = get_pagerank(adjacency, damping_factor=0.85, n_iter=100, tol=10, solver='piteration', seeds=seeds)
+        self.assertTrue(is_proba_array(pr))

sknetwork/linalg/tests/test_sparse_lowrank.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for embeddings metrics."""
+
+import unittest
+
+import numpy as np
+
+from sknetwork.data import house, star_wars
+from sknetwork.linalg.sparse_lowrank import SparseLR
+
+
+class TestSparseLowRank(unittest.TestCase):
+
+    def setUp(self):
+        """Simple regularized adjacency and biadjacency for tests."""
+        self.undirected = SparseLR(house(), [(np.ones(5), np.ones(5))])
+        self.bipartite = SparseLR(star_wars(), [(np.ones(4), np.ones(3))])
+
+    def test_init(self):
+        with self.assertRaises(ValueError):
+            SparseLR(house(), [(np.ones(5), np.ones(4))])
+        with self.assertRaises(ValueError):
+            SparseLR(house(), [(np.ones(4), np.ones(5))])
+
+    def test_addition(self):
+        addition = self.undirected + self.undirected
+        expected = SparseLR(2 * house(), [(np.ones(5), 2 * np.ones(5))])
+        err = (addition.sparse_mat - expected.sparse_mat).count_nonzero()
+        self.assertEqual(err, 0)
+        x = np.random.rand(5)
+        self.assertAlmostEqual(np.linalg.norm(addition.dot(x) - expected.dot(x)), 0)
+
+    def test_operations(self):
+        adjacency = self.undirected.sparse_mat
+        slr = -self.undirected
+        slr += adjacency
+        slr -= adjacency
+        slr.left_sparse_dot(adjacency)
+        slr.right_sparse_dot(adjacency)
+        slr.astype(float)
+
+    def test_product(self):
+        prod = self.undirected.dot(np.ones(5))
+        self.assertEqual(prod.shape, (5,))
+        prod = self.bipartite.dot(np.ones(3))
+        self.assertEqual(np.linalg.norm(prod - np.array([5., 4., 6., 5.])), 0.)
+        prod = self.bipartite.dot(0.5 * np.ones(3))
+        self.assertEqual(np.linalg.norm(prod - np.array([2.5, 2., 3., 2.5])), 0.)
+        prod = (2 * self.bipartite).dot(0.5 * np.ones(3))
+        self.assertEqual(np.linalg.norm(prod - 2 * np.array([2.5, 2., 3., 2.5])), 0.)
+
+    def test_transposition(self):
+        transposed = self.undirected.T
+        error = (self.undirected.sparse_mat - transposed.sparse_mat).data
+        self.assertEqual(abs(error).sum(), 0.)
+        transposed = self.bipartite.T
+        x, y = transposed.low_rank_tuples[0]
+        self.assertTrue((x == np.ones(3)).all())
+        self.assertTrue((y == np.ones(4)).all())
+

sknetwork/linalg/tests/test_svd.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for svd."""
+
+import unittest
+
+import numpy as np
+
+from sknetwork.data import movie_actor
+from sknetwork.linalg import LanczosSVD, SparseLR
+
+
+def svd_err(matrix, u, v, sigma):
+    """Approximation error for singular vectors."""
+    err = matrix.dot(v) - u * sigma
+    return np.linalg.norm(err)
+
+
+# noinspection DuplicatedCode
+class TestSolvers(unittest.TestCase):
+
+    def setUp(self):
+        """Simple biadjacency for tests."""
+        self.biadjacency = movie_actor()
+        n_row, n_col = self.biadjacency.shape
+        self.slr = SparseLR(self.biadjacency, [(np.random.rand(n_row), np.random.rand(n_col))])
+
+    def test_lanczos(self):
+        solver = LanczosSVD()
+        solver.fit(self.biadjacency, 2)
+        self.assertEqual(len(solver.singular_values_), 2)
+        self.assertAlmostEqual(svd_err(self.biadjacency, solver.singular_vectors_left_, solver.singular_vectors_right_,
+                                       solver.singular_values_), 0)
+
+        solver.fit(self.slr, 2)
+        self.assertEqual(len(solver.singular_values_), 2)
+        self.assertAlmostEqual(svd_err(self.slr, solver.singular_vectors_left_, solver.singular_vectors_right_,
+                                       solver.singular_values_), 0)

sknetwork/linkpred/__init__.py

@@ -0,0 +1,2 @@
+"""link prediction module"""
+from sknetwork.linkpred.nn import NNLinker

sknetwork/linkpred/base.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in March 2022
+@author: Thomas Bonald <thomas.bonald@telecom-paris.fr>
+"""
+from abc import ABC
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.base import Algorithm
+
+
+class BaseLinker(Algorithm, ABC):
+    """Base class for link prediction.
+
+    Attributes
+    ----------
+    links_: sparse.csr_matrix
+        Link matrix.
+    """
+
+    def __init__(self):
+        self.links_ = None
+
+    def predict(self) -> sparse.csr_matrix:
+        """Return the predicted links.
+
+        Returns
+        -------
+        links_ : sparse.csr_matrix
+            Link matrix.
+        """
+        return self.links_
+
+    def fit_predict(self, *args, **kwargs) -> sparse.csr_matrix:
+        """Fit algorithm to data and return the links. Same parameters as the ``fit`` method.
+
+        Returns
+        -------
+        links_ : sparse.csr_matrix
+            Link matrix.
+        """
+        self.fit(*args, **kwargs)
+        return self.links_

sknetwork/linkpred/nn.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in March 2023
+@author: Thomas Bonald <thomas.bonald@telecom-paris.fr>
+"""
+from typing import Optional, Union
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.linkpred.base import BaseLinker
+from sknetwork.embedding.base import BaseEmbedding
+from sknetwork.linalg.normalizer import normalize
+from sknetwork.utils.check import check_n_neighbors
+from sknetwork.utils.format import get_adjacency
+
+
+class NNLinker(BaseLinker):
+    """Link prediction by nearest neighbors in the embedding space, using cosine similarity.
+
+    For bipartite graphs, predict links between rows and columns only.
+
+    Parameters
+    ----------
+    n_neighbors : int
+        Number of nearest neighbors. If ``None``, all nodes are considered.
+    threshold : float
+        Threshold on cosine similarity. Only links above this threshold are kept.
+    embedding_method : :class:`BaseEmbedding`
+        Embedding method used to represent nodes in vector space.
+        If ``None`` (default), use identity.
+
+    Attributes
+    ----------
+    links_ : sparse.csr_matrix
+        Link matrix.
+
+    Example
+    -------
+    >>> from sknetwork.linkpred import NNLinker
+    >>> from sknetwork.data import karate_club
+    >>> linker = NNLinker(n_neighbors=5, threshold=0.5)
+    >>> graph = karate_club(metadata=True)
+    >>> adjacency = graph.adjacency
+    >>> links = linker.fit_predict(adjacency)
+    >>> links.shape
+    (34, 34)
+    """
+    def __init__(self, n_neighbors: Optional[int] = 10, threshold: float = 0,
+                 embedding_method: Optional[BaseEmbedding] = None):
+        super(NNLinker, self).__init__()
+        self.n_neighbors = n_neighbors
+        self.threshold = threshold
+        self.embedding_method = embedding_method
+        self.bipartite = None
+
+    def _fit_core(self, embedding, mask):
+        n = embedding.shape[0]
+        n_row = len(mask)
+        if n_row < n:
+            # bipartite graphs
+            index_col = np.arange(n_row, n)
+            n_col = n - n_row
+        else:
+            index_col = np.arange(n)
+            n_col = n
+        n_neighbors = check_n_neighbors(self.n_neighbors, len(index_col))
+
+        row = []
+        col = []
+        data = []
+
+        for i in np.flatnonzero(mask):
+            vector = embedding[i]
+            if sparse.issparse(vector):
+                vector = vector.toarray().ravel()
+            similarities = embedding[index_col].dot(vector)
+            nn = np.argpartition(-similarities, n_neighbors)[:n_neighbors]
+            mask_nn = np.zeros(n_col, dtype=bool)
+            mask_nn[nn] = 1
+            mask_nn[similarities < self.threshold] = 0
+            nn = np.flatnonzero(mask_nn)
+
+            row += len(nn) * [i]
+            col += list(nn)
+            data += list(similarities[nn])
+
+        links = sparse.csr_matrix((data, (row, col)), shape=(n_row, n_col))
+
+        return links
+
+    def fit(self, input_matrix: Union[sparse.csr_matrix, np.ndarray], index: Optional[np.ndarray] = None) -> 'NNLinker':
+        """Link prediction by nearest neighbors in the embedding space, using cosine similarity
+
+        Parameters
+        ----------
+        input_matrix : sparse.csr_matrix, np.ndarray
+            Adjacency matrix or biadjacency matrix of the graph.
+        index : np.ndarray
+            Index of source nodes to consider. If ``None``, the links are predicted for all nodes.
+
+        Returns
+        -------
+        self: :class:`NN`
+        """
+        n_row, _ = input_matrix.shape
+
+        adjacency, self.bipartite = get_adjacency(input_matrix)
+
+        if index is None:
+            index = np.arange(n_row)
+        mask = np.zeros(n_row, dtype=bool)
+        mask[index] = 1
+
+        if self.embedding_method is None:
+            embedding = adjacency
+        else:
+            embedding = self.embedding_method.fit_transform(adjacency)
+
+        embedding = normalize(embedding, p=2)
+        links = self._fit_core(embedding, mask)
+
+        self.links_ = links
+
+        return self

sknetwork/linkpred/tests/__init__.py

@@ -0,0 +1 @@
+"""tests for link prediction"""

sknetwork/linkpred/tests/test_nn.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for link prediction by nearest neighbors"""
+import unittest
+
+from sknetwork.linkpred import NNLinker
+from sknetwork.data.test_graphs import *
+from sknetwork.embedding import Spectral
+from sknetwork.utils import get_degrees
+
+
+class TestNNLinker(unittest.TestCase):
+
+    def test_link_prediction(self):
+        for input_matrix in [test_graph(), test_digraph(), test_bigraph()]:
+
+            n_neighbors = 5
+            threshold = 0.2
+            algo = NNLinker(n_neighbors=n_neighbors, threshold=threshold)
+            links = algo.fit_predict(input_matrix)
+            self.assertTrue(links.shape == input_matrix.shape)
+            self.assertTrue(np.all(get_degrees(links) <= n_neighbors))
+            self.assertTrue(np.all(links.data >= threshold))
+
+            algo = NNLinker(embedding_method=Spectral(2))
+            links = algo.fit_predict(input_matrix)
+            self.assertTrue(links.shape == input_matrix.shape)

sknetwork/log.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in December 2019
+@author: Quentin Lutz <qlutz@enst.fr>
+"""
+
+
+class Log:
+    """Log class for verbosity features"""
+    def __init__(self, verbose: bool = False):
+        self.verbose = verbose
+        self.log = ''
+
+    def print_log(self, *args):
+        """Fill log with text."""
+        if self.verbose:
+            print(*args)
+        self.log += ' '.join(map(str, args)) + '\n'

sknetwork/path/__init__.py

@@ -0,0 +1,5 @@
+"""Path module"""
+from sknetwork.path.dag import get_dag
+from sknetwork.path.distances import get_distances
+from sknetwork.path.search import breadth_first_search
+from sknetwork.path.shortest_path import get_shortest_path

sknetwork/path/dag.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in May 2023
+@author: Thomas Bonald <bonald@enst.fr>
+"""
+from typing import Iterable, Optional, Union
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.path.distances import get_distances
+from sknetwork.utils.check import check_format, check_square
+
+
+def get_dag(adjacency: sparse.csr_matrix, source: Optional[Union[int, Iterable]] = None,
+            order: Optional[np.ndarray] = None) -> sparse.csr_matrix:
+    """Get a Directed Acyclic Graph (DAG) from a graph.
+    If the order is specified, keep only edges i -> j such that 0 <= order[i] < order[j].
+    If the source is specified, use the distances from this source node (or set of source nodes) as order.
+    If neither the order nor the source is specified, use the node indices as order.
+
+    Parameters
+    ----------
+    adjacency :
+        Adjacency matrix of the graph.
+    source :
+        Source node (or set of source nodes).
+    order :
+        Order of nodes. Negative values ignored.
+
+    Returns
+    -------
+    dag :
+        Adjacency matrix of the directed acyclic graph.
+    """
+    adjacency = check_format(adjacency, allow_empty=True)
+    check_square(adjacency)
+
+    if order is None:
+        if source is None:
+            order = np.arange(adjacency.shape[0])
+        else:
+            order = get_distances(adjacency, source)
+
+    dag = adjacency.astype(bool).tocoo()
+    for value in np.unique(order):
+        if value < 0:
+            dag.data[order[dag.row] == value] = 0
+        else:
+            dag.data[(order[dag.row] == value) & (order[dag.col] <= value)] = 0
+    dag.eliminate_zeros()
+
+    return dag.tocsr()

sknetwork/path/distances.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in May 2023
+@author: Thomas Bonald <bonald@enst.fr>
+"""
+from typing import Iterable, Optional, Union, Tuple
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.utils.format import get_adjacency
+
+
+def get_distances(input_matrix: sparse.csr_matrix, source: Optional[Union[int, Iterable]] = None,
+                  source_row: Optional[Union[int, Iterable]] = None,
+                  source_col: Optional[Union[int, Iterable]] = None, transpose: bool = False,
+                  force_bipartite: bool = False) \
+        -> Union[np.ndarray, Tuple[np.ndarray, np.ndarray], Tuple[np.ndarray, np.ndarray]]:
+    """Get the distances from a source (or a set of sources) in number of hops.
+
+    Parameters
+    ----------
+    input_matrix :
+        Adjacency matrix or biadjacency matrix of the graph.
+    source :
+        If an integer, index of the source node.
+        If a list or array, indices of source nodes (the shortest distances to one of these nodes is returned).
+    source_row, source_col :
+        For bipartite graphs, index of source nodes on rows and columns.
+        The parameter source_row is an alias for source (at least one of them must be ``None``).
+    transpose :
+        If ``True``, transpose the input matrix.
+    force_bipartite :
+        If ``True``, consider the input matrix as the biadjacency matrix of a bipartite graph.
+        Set to ``True`` is the parameters source_row or source_col re specified.
+
+    Returns
+    -------
+    distances : np.ndarray of shape (n_nodes,)
+        Vector of distances from source (distance = -1 if no path exists from the source).
+        For a bipartite graph, two vectors are returned, one for the rows and one for the columns.
+
+    Examples
+    --------
+    >>> from sknetwork.data import cyclic_digraph
+    >>> adjacency = cyclic_digraph(3)
+    >>> get_distances(adjacency, source=0)
+    array([0, 1, 2])
+    >>> get_distances(adjacency, source=[0, 2])
+    array([0, 1, 0])
+    """
+    if transpose:
+        matrix = sparse.csr_matrix(input_matrix.T)
+    else:
+        matrix = input_matrix
+    if source_row is not None or source_col is not None:
+        force_bipartite = True
+    adjacency, bipartite = get_adjacency(matrix, force_bipartite=force_bipartite, allow_empty=True)
+    adjacency_transpose = adjacency.astype(bool).T.tocsr()
+    n_row, n_col = matrix.shape
+    n_nodes = adjacency.shape[0]
+
+    mask = np.zeros(n_nodes, dtype=bool)
+    if bipartite:
+        if source is not None:
+            if source_row is not None:
+                raise ValueError('Only one of the parameters source and source_row can be specified.')
+            source_row = source
+        if source_row is None and source_col is None:
+            raise ValueError('At least one of the parameters source_row or source_col must be specified.')
+        if source_row is not None:
+            mask[source_row] = 1
+        if source_col is not None:
+            mask[n_row + np.array(source_col)] = 1
+    else:
+        if source is None:
+            raise ValueError('The parameter source must be specified.')
+        mask[source] = 1
+
+    distances = -np.ones(n_nodes, dtype=int)
+    distances[mask] = 0
+
+    distance = 0
+    reach = mask
+
+    while 1:
+        distance += 1
+        mask = adjacency_transpose.dot(reach).astype(bool) & ~reach
+        if np.sum(mask) == 0:
+            break
+        distances[mask] = distance
+        reach |= mask
+
+    if bipartite:
+        return distances[:n_row], distances[n_row:]
+    else:
+        return distances

sknetwork/path/search.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in May 2023
+"""
+import numpy as np
+from scipy import sparse
+
+from sknetwork.path.distances import get_distances
+
+
+def breadth_first_search(adjacency: sparse.csr_matrix, source: int):
+    """Breadth-first ordering starting from some node.
+
+    Parameters
+    ----------
+    adjacency :
+        Adjacency matrix of the graph.
+    source : int
+        Source node.
+
+    Returns
+    -------
+    index : np.ndarray
+        Node index corresponding to the breadth-first-search from the source.
+        The length of the vector is the number of nodes reachable from the source.
+    """
+    distances = get_distances(adjacency, source)
+    indices = np.argsort(distances)
+    n = np.sum(distances < 0)
+    return indices[n:]