scikit-network 0.28.3__cp39-cp39-macosx_12_0_arm64.whl

sknetwork/linalg/ppr_solver.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Apr 2020
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+from typing import Union
+
+import numpy as np
+from scipy import sparse
+from scipy.sparse.linalg import eigs, LinearOperator, bicgstab
+
+from sknetwork.linalg.diteration import diffusion
+from sknetwork.linalg.push import push_pagerank
+from sknetwork.linalg.normalization import normalize
+from sknetwork.linalg.polynome import Polynome
+
+
+class RandomSurferOperator(LinearOperator):
+    """Random surfer as a LinearOperator
+
+    Parameters
+    ----------
+    adjacency :
+        Adjacency matrix of the graph as a CSR or a LinearOperator.
+    damping_factor : float
+        Probability to continue the random walk.
+    seeds :
+        Probability vector for seeds.
+
+    Attributes
+    ----------
+    a : sparse.csr_matrix
+        Scaled transposed transition matrix.
+    b : np.ndarray
+        Scaled restart probability vector.
+    """
+
+    def __init__(self, adjacency: Union[sparse.csr_matrix, LinearOperator], seeds: np.ndarray, damping_factor):
+        super(RandomSurferOperator, self).__init__(shape=adjacency.shape, dtype=float)
+
+        n = adjacency.shape[0]
+        out_degrees = adjacency.dot(np.ones(n)).astype(bool)
+
+        if hasattr(adjacency, 'left_sparse_dot'):
+            self.a = damping_factor * normalize(adjacency).T
+        else:
+            self.a = (damping_factor * normalize(adjacency)).T.tocsr()
+        self.b = (np.ones(n) - damping_factor * out_degrees) * seeds
+
+    def _matvec(self, x: np.ndarray):
+        return self.a.dot(x) + self.b * x.sum()
+
+
+def get_pagerank(adjacency: Union[sparse.csr_matrix, LinearOperator], seeds: np.ndarray, damping_factor: float,
+                 n_iter: int, tol: float = 1e-6, solver: str = 'piteration') -> np.ndarray:
+    """Solve the Pagerank problem. Formally,
+
+    :math:`x = \\alpha Px + (1-\\alpha)y`,
+
+    where :math:`P = (D^{-1}A)^T` is the transition matrix and :math:`y` is the personalization probability vector.
+
+    Parameters
+    ----------
+    adjacency : sparse.csr_matrix
+        Adjacency matrix of the graph.
+    seeds : np.ndarray
+        Personalization array. Must be a valid probability vector.
+    damping_factor : float
+        Probability to continue the random walk.
+    n_iter : int
+        Number of iterations for some of the solvers such as ``'piteration'`` or ``'diteration'``.
+    tol : float
+        Tolerance for the convergence of some solvers such as ``'bicgstab'`` or ``'lanczos'`` or ``'push'``.
+    solver : :obj:`str`
+        Which solver to use: ``'piteration'``, ``'diteration'``, ``'bicgstab'``, ``'lanczos'``, ``̀'RH'``, ``'push'``.
+
+    Returns
+    -------
+    pagerank : np.ndarray
+        Probability vector.
+
+    Examples
+    --------
+    >>> from sknetwork.data import house
+    >>> adjacency = house()
+    >>> seeds = np.array([1, 0, 0, 0, 0])
+    >>> scores = get_pagerank(adjacency, seeds, damping_factor=0.85, n_iter=10)
+    >>> np.round(scores, 2)
+    array([0.29, 0.24, 0.12, 0.12, 0.24])
+
+
+    References
+    ----------
+    * Hong, D. (2012). `Optimized on-line computation of pagerank algorithm.
+      <https://arxiv.org/pdf/1202.6158.pdf>`_
+      arXiv preprint arXiv:1202.6158.
+    * Van der Vorst, H. A. (1992). `Bi-CGSTAB:
+      <https://en.wikipedia.org/wiki/Biconjugate_gradient_stabilized_method>`_
+      A fast and smoothly converging variant of Bi-CG for the solution of nonsymmetric linear systems.
+      SIAM Journal on scientific and Statistical Computing, 13(2), 631-644.
+    * Lanczos, C. (1950).
+      `An iteration method for the solution of the eigenvalue problem of linear differential and integral operators.
+      <http://www.cs.umd.edu/~oleary/lanczos1950.pdf>`_
+      Los Angeles, CA: United States Governm. Press Office.
+    * Whang, J. , Lenharth, A. , Dhillon, I. , & Pingali, K. . (2015).
+      `Scalable Data-Driven PageRank: Algorithms, System Issues, and Lessons Learned`. 9233, 438-450.
+      <https://www.cs.utexas.edu/users/inderjit/public_papers/scalable_pagerank_europar15.pdf>
+    """
+    n = adjacency.shape[0]
+
+    if solver == 'diteration':
+        if not isinstance(adjacency, sparse.csr_matrix):
+            raise ValueError('D-iteration is not compatible with linear operators.')
+        adjacency = normalize(adjacency, p=1)
+        indptr = adjacency.indptr.astype(np.int32)
+        indices = adjacency.indices.astype(np.int32)
+        data = adjacency.data.astype(np.float32)
+        damping_factor = np.float32(damping_factor)
+        n_iter = np.int32(n_iter)
+        tol = np.float32(tol)
+
+        scores = np.zeros(n, dtype=np.float32)
+        fluid = (1 - damping_factor) * seeds.astype(np.float32)
+        diffusion(indptr, indices, data, scores, fluid, damping_factor, n_iter, tol)
+
+    elif solver == 'push':
+        n = adjacency.shape[0]
+        damping_factor = np.float32(damping_factor)
+        tol = np.float32(tol)
+        degrees = adjacency.dot(np.ones(n)).astype(np.int32)
+        rev_adjacency = adjacency.transpose().tocsr()
+
+        indptr = adjacency.indptr.astype(np.int32)
+        indices = adjacency.indices.astype(np.int32)
+        rev_indptr = rev_adjacency.indptr.astype(np.int32)
+        rev_indices = rev_adjacency.indices.astype(np.int32)
+
+        scores = push_pagerank(n, degrees, indptr, indices,
+                               rev_indptr, rev_indices,
+                               seeds.astype(np.float32),
+                               damping_factor, tol)
+
+    elif solver == 'RH':
+        coeffs = np.ones(n_iter + 1)
+        polynome = Polynome(damping_factor * normalize(adjacency, p=1).T.tocsr(), coeffs)
+        scores = polynome.dot(seeds)
+
+    else:
+        rso = RandomSurferOperator(adjacency, seeds, damping_factor)
+        v0 = rso.b
+        if solver == 'bicgstab':
+            scores, info = bicgstab(sparse.eye(n, format='csr') - rso.a, rso.b, atol=tol, x0=v0)
+        elif solver == 'lanczos':
+            # noinspection PyTypeChecker
+            _, scores = sparse.linalg.eigs(rso, k=1, tol=tol, v0=v0)
+            scores = abs(scores.flatten().real)
+        elif solver == 'piteration':
+            scores = v0
+            for i in range(n_iter):
+                scores_ = rso.dot(scores)
+                scores_ /= scores_.sum()
+                if np.linalg.norm(scores - scores_, ord=1) < tol:
+                    break
+                else:
+                    scores = scores_
+        else:
+            raise ValueError('Unknown solver.')
+
+    return scores / scores.sum()

sknetwork/linalg/push.pyx

@@ -0,0 +1,73 @@
+# distutils: language = c++
+# cython: language_level=3
+# cython: linetrace=True
+# distutils: define_macros=CYTHON_TRACE_NOGIL=1
+"""
+Created on Mars 2021
+@author: Wenzhuo Zhao <wenzhuo.zhao@etu.sorbonne-universite.fr>
+"""
+from libcpp.queue cimport queue
+from cython.parallel cimport prange
+import numpy as np
+cimport numpy as cnp
+cimport cython
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def push_pagerank(int n, cnp.ndarray[cnp.int32_t, ndim=1] degrees,
+                  int[:] indptr, int[:] indices,
+                  int[:] rev_indptr, int[:] rev_indices,
+                  cnp.ndarray[cnp.float32_t, ndim=1] seeds,
+                  cnp.float32_t damping_factor, cnp.float32_t tol):
+    """Push-based PageRank"""
+    cdef cnp.ndarray[cnp.float32_t, ndim=1] residuals
+    cdef int vertex
+    cdef int neighbor
+    cdef int j1
+    cdef int j2
+    cdef int j
+    cdef int[:] indexes
+    cdef int index
+    cdef float probability
+    cdef queue[int] worklist
+    cdef cnp.ndarray[cnp.float32_t, ndim=1] scores
+    cdef cnp.float32_t tmp
+    cdef float norm
+
+    residuals = np.zeros(n, dtype=np.float32)
+    for vertex in prange(n, nogil=True):
+        j1 = rev_indptr[vertex]
+        j2 = rev_indptr[vertex + 1]
+        # iterate node's in-coming neighbors
+        for j in range(j1, j2):
+            neighbor = rev_indices[j]
+            residuals[vertex] += 1 / degrees[neighbor]
+        """add the probability of seeds"""
+        residuals[vertex] *= (1 - damping_factor) * \
+            damping_factor * (1 + seeds[vertex])
+
+    # node with high residual value will be processed first
+    indexes = np.argsort(-residuals).astype(np.int32)
+    for index in indexes:
+        worklist.push(index)
+    scores = np.full(n, (1 - damping_factor), dtype=np.float32)
+
+    while not worklist.empty():
+        vertex = worklist.front()
+        worklist.pop()
+        # scores[v]_new
+        scores[vertex] += residuals[vertex]
+        # iterate node's out-coming neighbors
+        j1 = indptr[vertex]
+        j2 = indptr[vertex + 1]
+        for j in prange(j1, j2, nogil=True):
+            neighbor = indices[j]
+            tmp = residuals[neighbor]
+            residuals[neighbor] += residuals[vertex] * \
+                (1 - damping_factor) / degrees[vertex]
+            if residuals[neighbor] > tol > tmp:
+                worklist.push(neighbor)
+    norm = np.linalg.norm(scores, 1)
+    scores /= norm
+    return scores

sknetwork/linalg/sparse_lowrank.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Apr 19 2019
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+from typing import Union, Tuple
+
+import numpy as np
+from scipy import sparse
+from scipy.sparse.linalg import LinearOperator
+
+
+class SparseLR(LinearOperator):
+    """Class for matrices with "sparse + low rank" structure.
+    Example:
+
+    :math:`A + xy^T`
+
+    Parameters
+    ----------
+    sparse_mat: scipy.spmatrix
+        Sparse component. Is converted to csr format automatically.
+    low_rank_tuples: list
+        Single tuple of arrays of list of tuples, representing the low rank components [(x1, y1), (x2, y2),...].
+        Each low rank component is of the form :math:`xy^T`.
+
+    Examples
+    --------
+    >>> from scipy import sparse
+    >>> from sknetwork.linalg import SparseLR
+    >>> adjacency = sparse.eye(2, format='csr')
+    >>> slr = SparseLR(adjacency, (np.ones(2), np.ones(2)))
+    >>> x = np.ones(2)
+    >>> slr.dot(x)
+    array([3., 3.])
+    >>> slr.sum(axis=0)
+    array([3., 3.])
+    >>> slr.sum(axis=1)
+    array([3., 3.])
+    >>> slr.sum()
+    6.0
+
+    References
+    ----------
+    De Lara (2019). `The Sparse + Low Rank trick for Matrix Factorization-Based Graph Algorithms.
+    <http://www.mlgworkshop.org/2019/papers/MLG2019_paper_1.pdf>`_
+    Proceedings of the 15th International Workshop on Mining and Learning with Graphs (MLG).
+    """
+    def __init__(self, sparse_mat: Union[sparse.csr_matrix, sparse.csc_matrix], low_rank_tuples: Union[list, Tuple],
+                 dtype=float):
+        n_row, n_col = sparse_mat.shape
+        self.sparse_mat = sparse_mat.tocsr().astype(dtype)
+        super(SparseLR, self).__init__(dtype=dtype, shape=(n_row, n_col))
+
+        if isinstance(low_rank_tuples, Tuple):
+            low_rank_tuples = [low_rank_tuples]
+        self.low_rank_tuples = []
+        for x, y in low_rank_tuples:
+            if x.shape == (n_row,) and y.shape == (n_col,):
+                self.low_rank_tuples.append((x.astype(self.dtype), y.astype(self.dtype)))
+            else:
+                raise ValueError('For each low rank tuple, x (resp. y) should be a vector of length {} (resp. {})'
+                                 .format(n_row, n_col))
+
+    def __neg__(self):
+        return SparseLR(-self.sparse_mat, [(-x, y) for (x, y) in self.low_rank_tuples])
+
+    def __add__(self, other: 'SparseLR'):
+        if type(other) == sparse.csr_matrix:
+            return SparseLR(self.sparse_mat + other, self.low_rank_tuples)
+        else:
+            return SparseLR(self.sparse_mat + other.sparse_mat, self.low_rank_tuples + other.low_rank_tuples)
+
+    def __sub__(self, other):
+        return self.__add__(-other)
+
+    def __mul__(self, other):
+        return SparseLR(other * self.sparse_mat, [(other * x, y) for (x, y) in self.low_rank_tuples])
+
+    def _matvec(self, matrix: np.ndarray):
+        """Right dot product with a dense matrix.
+
+        Parameters
+        ----------
+        matrix:
+            Matrix.
+
+        Returns
+        -------
+        Dot product as a dense array
+        """
+        prod = self.sparse_mat.dot(matrix)
+        if len(matrix.shape) == 1:
+            for (x, y) in self.low_rank_tuples:
+                prod += x * matrix.dot(y)
+        else:
+            transposed = matrix.T
+            for (x, y) in self.low_rank_tuples:
+                prod += x[:, np.newaxis].dot(transposed.dot(y)[:, np.newaxis].T)
+        return prod
+
+    def _transpose(self):
+        """Transposed operator."""
+        transposed_sparse = sparse.csr_matrix(self.sparse_mat.T)
+        transposed_tuples = [(y, x) for (x, y) in self.low_rank_tuples]
+        return SparseLR(transposed_sparse, transposed_tuples)
+
+    def _adjoint(self):
+        return self.transpose()
+
+    def left_sparse_dot(self, matrix: sparse.csr_matrix):
+        """Left dot product with a sparse matrix."""
+        return SparseLR(matrix.dot(self.sparse_mat), [(matrix.dot(x), y) for (x, y) in self.low_rank_tuples])
+
+    def right_sparse_dot(self, matrix: sparse.csr_matrix):
+        """Right dot product with a sparse matrix."""
+        return SparseLR(self.sparse_mat.dot(matrix), [(x, matrix.T.dot(y)) for (x, y) in self.low_rank_tuples])
+
+    def sum(self, axis=None):
+        """Row-wise, column-wise or total sum of operator's coefficients.
+
+        Parameters
+        ----------
+        axis :
+            If 0, return column-wise sum. If 1, return row-wise sum. Otherwise, return total sum.
+        """
+        if axis == 0:
+            s = self.T.dot(np.ones(self.shape[0]))
+        elif axis == 1:
+            s = self.dot(np.ones(self.shape[1]))
+        else:
+            s = self.dot(np.ones(self.shape[1])).sum()
+        return s
+
+    def astype(self, dtype: Union[str, np.dtype]):
+        """Change dtype of the object."""
+        self.sparse_mat = self.sparse_mat.astype(dtype)
+        self.low_rank_tuples = [(x.astype(dtype), y.astype(dtype)) for (x, y) in self.low_rank_tuples]
+        self.dtype = np.dtype(dtype)
+
+        return self

sknetwork/linalg/svd_solver.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+# coding: utf-8
+"""
+Created on July 10 2019
+
+Authors:
+Nathan De Lara <nathan.delara@telecom-paris.fr>
+"""
+from abc import ABC
+from typing import Union
+
+import numpy as np
+from scipy import sparse
+from scipy.sparse.linalg import svds
+
+from sknetwork.utils.base import Algorithm
+
+
+class SVDSolver(Algorithm, ABC):
+    """Generic class for SVD-solvers.
+
+    Attributes
+    ----------
+    singular_vectors_left_: np.ndarray
+        Two-dimensional array, each column is a left singular vector of the input.
+    singular_vectors_right_: np.ndarray
+        Two-dimensional array, each column is a right singular vector of the input.
+    singular_values_: np.ndarray
+        Singular values.
+    """
+    def __init__(self):
+        self.singular_vectors_left_ = None
+        self.singular_vectors_right_ = None
+        self.singular_values_ = None
+
+
+class LanczosSVD(SVDSolver):
+    """SVD solver using Lanczos method on :math:`AA^T` or :math:`A^TA`.
+
+    Parameters
+    ----------
+    n_iter : int
+        Maximum number of Arnoldi update iterations allowed.
+        Default = 10 * nb or rows or columns.
+    tol : float
+        Relative accuracy for eigenvalues (stopping criterion).
+        Default = 0 (machine precision).
+
+    Attributes
+    ----------
+    singular_vectors_left_: np.ndarray
+        Two-dimensional array, each column is a left singular vector of the input.
+    singular_vectors_right_: np.ndarray
+        Two-dimensional array, each column is a right singular vector of the input.
+    singular_values_: np.ndarray
+        Singular values.
+
+    See Also
+    --------
+    scipy.sparse.linalg.svds
+    """
+    def __init__(self, n_iter: int = None, tol: float = 0.):
+        super(LanczosSVD, self).__init__()
+        self.n_iter = n_iter
+        self.tol = tol
+
+    def fit(self, matrix: Union[sparse.csr_matrix, sparse.linalg.LinearOperator], n_components: int,
+            init_vector: np.ndarray = None):
+        """Perform singular value decomposition on input matrix.
+
+        Parameters
+        ----------
+        matrix :
+            Matrix to decompose.
+        n_components : int
+            Number of singular values to compute
+        init_vector : np.ndarray
+            Starting vector for iteration.
+            Default = random.
+        Returns
+        -------
+        self: :class:`SVDSolver`
+        """
+        u, s, vt = svds(matrix.astype(float), n_components, v0=init_vector)
+        # order the singular values by decreasing order
+        index = np.argsort(-s)
+        self.singular_vectors_left_ = u[:, index]
+        self.singular_vectors_right_ = vt.T[:, index]
+        self.singular_values_ = s[index]
+
+        return self

sknetwork/linalg/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for linalg"""

sknetwork/linalg/tests/test_eig.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for eigenvalue solver."""
+
+import unittest
+
+import numpy as np
+
+from sknetwork.data import miserables, karate_club
+from sknetwork.linalg import LanczosEig, SparseLR
+
+
+def eigenvector_err(matrix, eigenvectors, eigenvalues):
+    """Approximation error for eigenvectors."""
+    err = matrix.dot(eigenvectors) - eigenvectors * eigenvalues
+    return np.linalg.norm(err)
+
+
+# noinspection DuplicatedCode
+class TestSolvers(unittest.TestCase):
+
+    def setUp(self):
+        """Load les Miserables and regularized version"""
+        self.adjacency = miserables()
+        self.random_state = np.random.RandomState(123)
+        n = self.adjacency.shape[0]
+        x = np.random.random(n)
+        self.slr = SparseLR(self.adjacency, [(x, x)])
+
+    def test_lanczos(self):
+        solver = LanczosEig('LM')
+        solver.fit(self.adjacency, 2)
+        self.assertEqual(len(solver.eigenvalues_), 2)
+        self.assertAlmostEqual(eigenvector_err(self.adjacency, solver.eigenvectors_, solver.eigenvalues_), 0)
+
+        solver.fit(self.slr, 2)
+        self.assertEqual(len(solver.eigenvalues_), 2)
+        self.assertAlmostEqual(eigenvector_err(self.slr, solver.eigenvectors_, solver.eigenvalues_), 0)
+
+        adjacency = karate_club()
+        solver = LanczosEig('SM')
+        solver.fit(adjacency, 2)
+        self.assertEqual(len(solver.eigenvalues_), 2)
+        self.assertAlmostEqual(eigenvector_err(adjacency, solver.eigenvectors_, solver.eigenvalues_), 0)

sknetwork/linalg/tests/test_laplacian.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for laplacian."""
+
+import unittest
+
+import numpy as np
+
+from sknetwork.data.test_graphs import test_graph
+from sknetwork.linalg import get_laplacian
+
+
+class TestLaplacian(unittest.TestCase):
+
+    def test(self):
+        adjacency = test_graph()
+        laplacian = get_laplacian(adjacency)
+        self.assertEqual(np.linalg.norm(laplacian.dot(np.ones(adjacency.shape[0]))), 0)

sknetwork/linalg/tests/test_normalization.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on April 2020
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+
+import unittest
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.linalg import normalize, CoNeighbor
+
+
+class TestNormalization(unittest.TestCase):
+
+    def test_formats(self):
+        n = 5
+        mat1 = normalize(np.eye(n))
+        mat2 = normalize(sparse.eye(n))
+        mat3 = normalize(CoNeighbor(mat2))
+
+        x = np.random.randn(n)
+        self.assertAlmostEqual(np.linalg.norm(mat1.dot(x) - x), 0)
+        self.assertAlmostEqual(np.linalg.norm(mat2.dot(x) - x), 0)
+        self.assertAlmostEqual(np.linalg.norm(mat3.dot(x) - x), 0)
+
+        mat1 = np.random.rand(n**2).reshape((n, n))
+        mat2 = sparse.csr_matrix(mat1)
+        mat1 = normalize(mat1, p=2)
+        mat2 = normalize(mat2, p=2)
+        self.assertAlmostEqual(np.linalg.norm(mat1.dot(x) - mat2.dot(x)), 0)
+
+        with self.assertRaises(NotImplementedError):
+            normalize(mat3, p=2)
+        with self.assertRaises(NotImplementedError):
+            normalize(mat1, p=3)

sknetwork/linalg/tests/test_operators.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Apr 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, normalize
+from sknetwork.linalg.basics import safe_sparse_dot
+
+
+class TestOperators(unittest.TestCase):
+
+    def test_laplacian(self):
+        for adjacency in [test_graph(), test_graph_disconnect()]:
+            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_graph_disconnect()]:
+            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)
+        transition = normalize(operator)
+        x = transition.dot(np.ones(transition.shape[1]))
+
+        self.assertAlmostEqual(np.linalg.norm(x - np.ones(operator.shape[0])), 0)
+        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)
+