scikit-network 0.28.3__cp39-cp39-macosx_12_0_arm64.whl

sknetwork/utils/seeds.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Apr, 2019
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+import warnings
+from typing import Optional, Union
+
+import numpy as np
+
+
+def get_seeds(shape: tuple, seeds: Union[np.ndarray, dict], default_value: float = -1) -> np.ndarray:
+    """Get seeds as array."""
+    n = shape[0]
+    if isinstance(seeds, np.ndarray):
+        if len(seeds) != n:
+            raise ValueError('Dimensions mismatch between adjacency and seeds vector.')
+        else:
+            seeds = seeds.astype(float)
+    elif isinstance(seeds, dict):
+        keys, values = np.array(list(seeds.keys())), np.array(list(seeds.values()))
+        if np.min(values) < 0:
+            warnings.warn(Warning("Negative values will not be taken into account."))
+        seeds = default_value * np.ones(n)
+        seeds[keys] = values
+    else:
+        seeds = np.ones(n)
+    return seeds
+
+
+def stack_seeds(shape: tuple, seeds_row: Optional[Union[np.ndarray, dict]],
+                seeds_col: Optional[Union[np.ndarray, dict]] = None, default_value: float = -1) -> np.ndarray:
+    """Process seeds for rows and columns and stack the results into a single vector."""
+    n_row, n_col = shape
+    if seeds_row is None and seeds_col is None:
+        seeds_row = np.ones(n_row)
+        seeds_col = default_value * np.ones(n_col)
+    elif seeds_row is None:
+        seeds_row = default_value * np.ones(n_row)
+    elif seeds_col is None:
+        seeds_col = default_value * np.ones(n_col)
+    seeds_row = get_seeds(shape, seeds_row, default_value)
+    seeds_col = get_seeds((n_col,), seeds_col, default_value)
+    return np.hstack((seeds_row, seeds_col))
+
+
+def seeds2probs(n: int, seeds: np.ndarray = None) -> np.ndarray:
+    """Transform seed values into probability vector.
+
+    Parameters
+    ----------
+    n : int
+        Number of nodes.
+    seeds :
+        If ``None``, the uniform distribution is used.
+        Otherwise, a non-negative, non-zero vector or a dictionary must be provided.
+
+    Returns
+    -------
+    probs: np.ndarray
+        A probability vector.
+    """
+    if seeds is None:
+        return np.ones(n) / n
+    else:
+        seeds = get_seeds((n,), seeds)
+        probs = np.zeros_like(seeds, dtype=float)
+        ix = (seeds > 0)
+        probs[ix] = seeds[ix]
+        w: float = probs.sum()
+        if w > 0:
+            return probs / w
+        else:
+            raise ValueError('At least one seed must have a positive value.')

sknetwork/utils/simplex.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on June 4 2019
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+from typing import Union
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.linalg.normalization import normalize
+
+
+def projection_simplex_array(array: np.ndarray, scale: float = 1) -> np.ndarray:
+    """Project each line of the input onto the Euclidean simplex i.e. solve
+
+    :math:`\\underset{w}{min} ||w - x_i||_2^2` s.t. :math:`\\sum w_j = z, w_j \\ge 0`.
+
+    Parameters
+    ----------
+    array: np.ndarray
+        Data to project. Either one or two dimensional.
+    scale: float
+        Scale of the simplex i.e. sums of the projected coefficients.
+
+    Returns
+    -------
+    projection : np.ndarray
+        Array with the same shape as the input.
+
+    Example
+    -------
+    >>> X = np.array([[2, 2], [-0.75, 0.25]])
+    >>> projection_simplex_array(X)
+    array([[0.5, 0.5],
+           [0. , 1. ]])
+    """
+    if len(array.shape) == 1:
+        array = array.reshape(1, array.shape[0])
+    n_row, n_col = array.shape
+
+    sorted_array = -np.sort(-array)
+    cumsum_array = np.cumsum(sorted_array, axis=1) - scale
+    denom = 1 + np.arange(n_col)
+    condition = sorted_array - cumsum_array / denom > 0
+    max_index = np.argmax(condition / denom[::-1], axis=1)
+    threshold = (cumsum_array / denom)[np.arange(n_row), max_index]
+
+    return np.maximum(array - threshold[:, np.newaxis], 0)
+
+
+def projection_simplex_csr(matrix: sparse.csr_matrix, scale: float = 1):
+    """Project each line of the input onto the Euclidean simplex i.e. solve
+
+    :math:`\\underset{w}{min} ||w - x_i||_2^2` s.t. :math:`\\sum w_j = z, w_j \\ge 0`.
+
+    Parameters
+    ----------
+    matrix : sparse.csr_matrix
+        Matrix whose rows must be projected.
+    scale: float
+        Scale of the simplex i.e. sums of the projected coefficients.
+
+    Returns
+    -------
+    projection : sparse.csr_matrix
+        Matrix with the same shape as the input.
+
+    Examples
+    --------
+    >>> X = sparse.csr_matrix(np.array([[2, 2], [-0.75, 0.25]]))
+    >>> X_proj = projection_simplex_csr(X)
+    >>> X_proj.nnz
+    3
+    >>> X_proj.toarray()
+    array([[0.5, 0.5],
+           [0. , 1. ]])
+    """
+    data = matrix.data
+    if data.dtype == bool or (data.min() == data.max()):
+        return normalize(matrix, p=1)
+
+    indptr = matrix.indptr
+    new_data = np.zeros_like(data)
+
+    for i in range(indptr.size-1):
+        j1 = indptr[i]
+        j2 = indptr[i+1]
+        new_data[j1:j2] = projection_simplex_array(data[j1:j2], scale=scale)
+
+    new_matrix = sparse.csr_matrix((new_data, matrix.indices, indptr), shape=matrix.shape)
+    new_matrix.eliminate_zeros()
+    return new_matrix
+
+
+def projection_simplex(x: Union[np.ndarray, sparse.csr_matrix], scale: float = 1.):
+    """Project each line of the input onto the Euclidean simplex i.e. solve
+
+    :math:`\\underset{w}{min} ||w - x_i||_2^2` s.t. :math:`\\sum w_j = z, w_j \\ge 0`.
+
+    Parameters
+    ----------
+    x :
+        Data to project. Either one or two dimensional. Can be sparse or dense.
+    scale : float
+        Scale of the simplex i.e. sums of the projected coefficients.
+
+    Returns
+    -------
+    projection : np.ndarray or sparse.csr_matrix
+        Array with the same type and shape as the input.
+
+    Example
+    -------
+    >>> X = np.array([[2, 2], [-0.75, 0.25]])
+    >>> projection_simplex(X)
+    array([[0.5, 0.5],
+           [0. , 1. ]])
+    >>> X_csr = sparse.csr_matrix(X)
+    >>> X_proj = projection_simplex(X_csr)
+    >>> X_proj.nnz
+    3
+    >>> X_proj.toarray()
+    array([[0.5, 0.5],
+           [0. , 1. ]])
+
+    References
+    ----------
+    Duchi, J., Shalev-Shwartz, S., Singer, Y., & Chandra, T. (2008, July).
+    `Efficient projections onto the l 1-ball for learning in high dimensions.
+    <http://machinelearning.org/archive/icml2008/papers/361.pdf>`_
+    In Proceedings of the 25th international conference on Machine learning (pp. 272-279). ACM.
+    """
+    if isinstance(x, np.ndarray):
+        return projection_simplex_array(x, scale)
+    elif isinstance(x, sparse.csr_matrix):
+        return projection_simplex_csr(x, scale)
+    else:
+        raise TypeError('Input must be a numpy array or a CSR matrix.')

sknetwork/utils/tests/__init__.py

@@ -0,0 +1 @@
+"""tests for utils"""

sknetwork/utils/tests/test_base.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for base.py"""
+import unittest
+
+from sknetwork.utils.base import Algorithm
+
+
+class TestBase(unittest.TestCase):
+
+    def test_repr(self):
+        class Stub(Algorithm):
+            """Docstring"""
+            def __init__(self, some_param: int, another_param: str, random_state: int, some_unused_param: int):
+                self.some_param = some_param
+                self.another_param = another_param
+                self.random_state = random_state
+
+            def fit(self):
+                """Docstring"""
+                pass
+
+        stub = Stub(1, 'abc', 3, 4)
+        self.assertEqual(repr(stub), "Stub(some_param=1, another_param='abc')")
+
+    def test_fit(self):
+        stub = Algorithm()
+        self.assertRaises(NotImplementedError, stub.fit, None)

sknetwork/utils/tests/test_bunch.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for bunch"""
+
+import unittest
+
+from sknetwork.utils import Bunch
+
+
+class TestBunch(unittest.TestCase):
+
+    def test_key_error(self):
+        bunch = Bunch(a=1, b=2)
+        with self.assertRaises(AttributeError):
+            # noinspection PyStatementEffect
+            bunch.c

sknetwork/utils/tests/test_check.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for check.py"""
+import unittest
+
+from sknetwork.data import cyclic_digraph
+from sknetwork.data.test_graphs import test_graph_disconnect
+from sknetwork.utils.check import *
+from sknetwork.utils.format import check_csr_or_slr
+
+
+class TestChecks(unittest.TestCase):
+
+    def setUp(self):
+        """Simple graphs for tests."""
+        self.adjacency = cyclic_digraph(3)
+        self.dense_mat = np.identity(3)
+
+    def test_check_csr_slr(self):
+        with self.assertRaises(TypeError):
+            check_csr_or_slr(np.ones(3))
+
+    def test_check_square(self):
+        with self.assertRaises(ValueError):
+            check_square(np.ones((3, 7)))
+
+    def test_check_connected(self):
+        with self.assertRaises(ValueError):
+            check_connected(test_graph_disconnect())
+
+    def test_check_symmetry(self):
+        with self.assertRaises(ValueError):
+            check_symmetry(self.adjacency)
+
+    def test_nonnegative_entries(self):
+        self.assertTrue(has_nonnegative_entries(self.adjacency))
+        self.assertTrue(has_nonnegative_entries(self.dense_mat))
+
+    def test_check_nonnegative(self):
+        with self.assertRaises(ValueError):
+            check_nonnegative(-self.dense_mat)
+
+    def test_positive_entries(self):
+        self.assertFalse(has_positive_entries(self.dense_mat))
+        with self.assertRaises(TypeError):
+            # noinspection PyTypeChecker
+            has_positive_entries(self.adjacency)
+
+    def test_check_positive(self):
+        check_positive(np.ones(3))
+        with self.assertRaises(ValueError):
+            check_positive(-self.dense_mat)
+
+    def test_probas(self):
+        self.assertTrue(is_proba_array(np.array([.5, .5])))
+        check_is_proba(0.5)
+        with self.assertRaises(TypeError):
+            is_proba_array(np.ones((2, 2, 2)))
+        self.assertRaises(TypeError, check_is_proba, 'toto')
+        with self.assertRaises(ValueError):
+            check_is_proba(2)
+
+    def test_damping(self):
+        with self.assertRaises(ValueError):
+            check_damping_factor(1)
+
+    def test_error_make_weights(self):
+        with self.assertRaises(ValueError):
+            make_weights(distribution='junk', adjacency=self.adjacency)
+
+    def test_error_check_is_proba(self):
+        with self.assertRaises(TypeError):
+            # noinspection PyTypeChecker
+            check_is_proba('junk')
+        with self.assertRaises(ValueError):
+            check_is_proba(2)
+
+    def test_error_check_weights(self):
+        with self.assertRaises(ValueError):
+            check_weights(np.zeros(4), self.adjacency)
+        with self.assertRaises(TypeError):
+            # noinspection PyTypeChecker
+            check_weights(2, self.adjacency)
+        with self.assertRaises(ValueError):
+            check_weights(np.zeros(3), self.adjacency, positive_entries=True)
+        with self.assertRaises(ValueError):
+            check_weights(-np.ones(3), self.adjacency)
+
+    def test_random_state(self):
+        random_state = np.random.RandomState(1)
+        self.assertEqual(type(check_random_state(random_state)), np.random.RandomState)
+
+    def test_error_random_state(self):
+        with self.assertRaises(TypeError):
+            # noinspection PyTypeChecker
+            check_random_state('junk')
+
+    def test_check_labels(self):
+        with self.assertRaises(ValueError):
+            check_labels(np.ones(3))
+        labels = np.ones(5)
+        labels[0] = 0
+        classes, n_classes = check_labels(labels)
+        self.assertTrue(np.equal(classes, np.arange(2)).all())
+        self.assertEqual(n_classes, 2)
+
+    def test_check_n_jobs(self):
+        self.assertEqual(check_n_jobs(None), 1)
+        self.assertEqual(check_n_jobs(-1), None)
+        self.assertEqual(check_n_jobs(8), 8)
+
+    def test_check_n_neighbors(self):
+        with self.assertWarns(Warning):
+            check_n_neighbors(10, 5)
+
+    def test_adj_vector(self):
+        n = 10
+        vector1 = np.random.rand(n)
+        vector2 = sparse.csr_matrix(vector1)
+        adj1 = check_adjacency_vector(vector1)
+        adj2 = check_adjacency_vector(vector2)
+
+        self.assertEqual((adj1 - adj2).nnz, 0)
+        self.assertEqual(adj1.shape, (1, n))
+
+        with self.assertRaises(ValueError):
+            check_adjacency_vector(vector1, 2 * n)
+
+    def test_check_n_clusters(self):
+        with self.assertRaises(ValueError):
+            check_n_clusters(3, 2)
+        with self.assertRaises(ValueError):
+            check_n_clusters(0, 2, 1)
+
+    def test_min_size(self):
+        with self.assertRaises(ValueError):
+            check_min_size(1, 3)
+
+    def test_min_nnz(self):
+        with self.assertRaises(ValueError):
+            check_min_nnz(1, 3)
+
+    def test_dendrogram(self):
+        with self.assertRaises(ValueError):
+            check_dendrogram(np.ones((3, 3)))
+
+    def test_n_components(self):
+        self.assertEqual(5, check_n_components(5, 10))
+        with self.assertWarns(Warning):
+            self.assertEqual(2, check_n_components(5, 2))
+
+    def test_scaling(self):
+        adjacency = cyclic_digraph(3)
+        with self.assertRaises(ValueError):
+            check_scaling(-1, adjacency, regularize=True)
+        adjacency = test_graph_disconnect()
+        with self.assertRaises(ValueError):
+            check_scaling(-1, adjacency, regularize=False)
+
+    def test_boolean_entries(self):
+        with self.assertRaises(TypeError):
+            has_boolean_entries([True, 0, 2])
+        self.assertFalse(has_boolean_entries(np.array([0, 1, True])))
+
+    def test_boolean(self):
+        check_boolean(np.array([True, False, True]))
+        with self.assertRaises(ValueError):
+            check_boolean(np.array([True, 0, 2]))
+
+    def test_check_vector_format(self):
+        check_vector_format(np.arange(4), np.ones(4))
+        with self.assertRaises(ValueError):
+            check_vector_format(np.arange(4), np.ones((4, 3)))
+        with self.assertRaises(ValueError):
+            check_vector_format(np.arange(4), np.ones(5))
+
+    def test_has_self_loops(self):
+        self.assertTrue(has_self_loops(sparse.csr_matrix(np.array([[1, 0], [1, 1]]))))
+        self.assertFalse(has_self_loops(sparse.csr_matrix(np.array([[0, 0], [1, 1]]))))
+
+    def test_add_self_loops(self):
+        # Square adjacency
+        adjacency = sparse.csr_matrix(np.array([[0, 0], [1, 1]]))
+        self.assertFalse(has_self_loops(adjacency))
+        adjacency = add_self_loops(adjacency)
+        self.assertTrue(has_self_loops(adjacency))
+        # Non square adjacency
+        adjacency = sparse.csr_matrix(np.array([[0, 0, 1], [1, 1, 1]]))
+        n_row, n_col = adjacency.shape
+        self.assertTrue(has_self_loops(add_self_loops(adjacency)[:, :n_row]))

sknetwork/utils/tests/test_co_neighbor.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on October 2019
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+import unittest
+
+import numpy as np
+
+from sknetwork.data import movie_actor
+from sknetwork.linalg import CoNeighbor
+from sknetwork.utils import co_neighbor_graph
+
+
+class TestCoNeighbors(unittest.TestCase):
+
+    def setUp(self):
+        """Simple biadjacency for tests."""
+        self.biadjacency = movie_actor()
+
+    def test_exact(self):
+        n = self.biadjacency.shape[0]
+        adjacency = co_neighbor_graph(self.biadjacency, method='exact', normalized=False)
+        self.assertEqual(adjacency.shape, (n, n))
+        adjacency = co_neighbor_graph(self.biadjacency, method='exact')
+        self.assertEqual(adjacency.shape, (n, n))
+
+        operator = CoNeighbor(self.biadjacency)
+        x = np.random.randn(n)
+        y1 = adjacency.dot(x)
+        y2 = operator.dot(x)
+        self.assertAlmostEqual(np.linalg.norm(y1 - y2), 0)
+
+    def test_knn(self):
+        n = self.biadjacency.shape[0]
+        adjacency = co_neighbor_graph(self.biadjacency, method='knn')
+        self.assertEqual(adjacency.shape, (n, n))
+        adjacency = co_neighbor_graph(self.biadjacency, method='knn', normalized=False)
+        self.assertEqual(adjacency.shape, (n, n))
+
+    def test_invalid(self):
+        self.assertRaises(ValueError, co_neighbor_graph, self.biadjacency, method='toto')

sknetwork/utils/tests/test_format.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for format.py"""
+import unittest
+
+from sknetwork.data.test_graphs import *
+from sknetwork.utils.format import *
+
+
+class TestFormats(unittest.TestCase):
+
+    def setUp(self):
+        """Basic biadjacency for tests."""
+        self.biadjacency = test_bigraph()
+
+    def test_directed2undirected(self):
+        adjacency = test_digraph()
+        ref = directed2undirected(adjacency)
+        self.assertEqual(ref.shape, adjacency.shape)
+        self.assertTrue(is_symmetric(ref))
+
+        adjacency = test_graph().astype(bool)
+        n = adjacency.shape[0]
+        diff = directed2undirected(adjacency, weighted=False) - adjacency
+        self.assertEqual(diff.nnz, 0)
+
+        slr = SparseLR(adjacency, [(np.zeros(n), np.zeros(n))])
+        self.assertRaises(ValueError, directed2undirected, slr, weighted=False)
+        slr = 0.5 * directed2undirected(slr)
+        self.assertEqual(slr.shape, (n, n))
+
+        x = np.random.randn(n)
+        error = np.linalg.norm(slr.dot(x) - adjacency.dot(x))
+        self.assertAlmostEqual(error, 0)
+
+    def test_bipartite2directed(self):
+        n_row, n_col = self.biadjacency.shape
+        n = n_row + n_col
+
+        directed_graph = bipartite2directed(self.biadjacency)
+        self.assertEqual(directed_graph.shape, (n, n))
+
+        slr = SparseLR(self.biadjacency, [(np.ones(n_row), np.ones(n_col))])
+        directed_graph = bipartite2directed(slr)
+        self.assertTrue(type(directed_graph) == SparseLR)
+
+    def test_bipartite2undirected(self):
+        n_row, n_col = self.biadjacency.shape
+        n = n_row + n_col
+
+        undirected_graph = bipartite2undirected(self.biadjacency)
+        self.assertEqual(undirected_graph.shape, (n, n))
+        self.assertTrue(is_symmetric(undirected_graph))
+
+        slr = SparseLR(self.biadjacency, [(np.ones(n_row), np.ones(n_col))])
+        undirected_graph = bipartite2undirected(slr)
+        self.assertTrue(type(undirected_graph) == SparseLR)
+
+    def test_check(self):
+        with self.assertRaises(ValueError):
+            check_format(sparse.csr_matrix((3, 4)))

sknetwork/utils/tests/test_kmeans.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on October 2019
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+import unittest
+
+import numpy as np
+
+from sknetwork.utils import KMeansDense
+
+
+class TestKMeans(unittest.TestCase):
+
+    def test_kmeans(self):
+        x = np.random.randn(10, 3)
+        kmeans = KMeansDense(n_clusters=2)
+        labels = kmeans.fit_transform(x)
+        self.assertEqual(labels.shape, (x.shape[0],))
+        self.assertEqual(kmeans.cluster_centers_.shape, (kmeans.n_clusters, x.shape[1]))

sknetwork/utils/tests/test_knn.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on October 2019
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+import unittest
+
+import numpy as np
+from scipy import sparse
+from scipy.sparse.linalg import norm
+
+from sknetwork.utils import KNNDense, CNNDense
+
+
+class TestKNN(unittest.TestCase):
+
+    def test_basics(self):
+        x = np.array([[-2, -1], [-2, 1], [2, 1], [2, -1]])
+        knn = KNNDense(n_neighbors=1)
+        knn.fit(x)
+        truth = np.zeros(16).reshape((4, 4))
+        truth[0, 1] = 1
+        truth[2, 3] = 1
+        truth = sparse.csr_matrix(truth + truth.T)
+        self.assertAlmostEqual(norm(truth - knn.adjacency_), 0)
+
+    def test_pknn(self):
+        x = np.array([(0, 4), (1, 0), (2, 1), (3, 2), (4, 3)])
+        pknn = CNNDense(n_neighbors=1)
+        adj = pknn.fit_transform(x)
+        self.assertEqual(adj.shape, (5, 5))

sknetwork/utils/tests/test_membership.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in July 2022
+@author: Thomas Bonald <thomas.bonald@telecom-paris.fr>
+"""
+import unittest
+
+import numpy as np
+
+from sknetwork.utils.membership import get_membership, from_membership
+
+
+class TestMembership(unittest.TestCase):
+
+    def test_membership(self):
+        labels = np.array([0, 0, 1, 2, 1, 1])
+        membership = get_membership(labels)
+        self.assertEqual(membership.nnz, 6)
+        self.assertEqual(np.linalg.norm(labels - from_membership(membership)), 0)
+        labels = np.array([0, 0, 1, 2, 1, -1])
+        membership = get_membership(labels)
+        self.assertEqual(membership.nnz, 5)
+        self.assertEqual(np.linalg.norm(labels - from_membership(membership)), 0)

sknetwork/utils/tests/test_neighbors.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on December 2020
+@author: Thomas Bonald <bonald@enst.fr>
+"""
+import unittest
+
+import numpy as np
+from numpy.linalg import norm
+
+from sknetwork.data import karate_club, painters
+from sknetwork.utils import get_neighbors, get_degrees, get_weights
+
+
+class TestNeighbors(unittest.TestCase):
+
+    def test_graph(self):
+        adjacency = karate_club()
+        neighbors = get_neighbors(adjacency, 5)
+        degrees = get_degrees(adjacency)
+        neighbors_true = np.array([0, 6, 10, 16])
+        self.assertEqual(norm(neighbors - neighbors_true), 0)
+        self.assertEqual(degrees[5], 4)
+
+    def test_digraph(self):
+        adjacency = painters()
+        neighbors = get_neighbors(adjacency, 0)
+        out_degrees = get_degrees(adjacency)
+        out_weights = get_weights(adjacency)
+        neighbors_true = np.array([3, 10])
+        self.assertEqual(norm(neighbors - neighbors_true), 0)
+        self.assertEqual(out_degrees[0], 2)
+        self.assertEqual(out_weights[0], 2)
+        neighbors = get_neighbors(adjacency, 0, transpose=True)
+        in_degrees = get_degrees(adjacency, transpose=True)
+        in_weights = get_weights(adjacency, transpose=True)
+        neighbors_true = np.array([3,  6,  8, 10, 11])
+        self.assertEqual(norm(neighbors - neighbors_true), 0)
+        self.assertEqual(in_degrees[0], 5)
+        self.assertEqual(in_weights[0], 5)