Raise Exception on unrecognized sparse fmt (#26)

* ENH: add W.to_sparse W.from_sparse

* Raise ValueError not Warning on bad sparse format

Author: sjsrey

libpysal/weights/tests/test_weights.py

@@ -2,6 +2,7 @@
 import tempfile
 
 import unittest
+import pytest
 from ..weights import W, WSP
 from .. import util
 from ..util import WSP2W, lat2W
@@ -10,6 +11,7 @@
 from ... import examples
 from ..distance import KNN
 import numpy as np
+import scipy.sparse
 
 NPTA3E = np.testing.assert_array_almost_equal
 
@@ -44,6 +46,7 @@ def setUp(self):
         }
 
         self.w3x3 = util.lat2W(3, 3)
+        self.w_islands = W({0: [1], 1: [0, 2], 2: [1], 3: []})
 
     def test_W(self):
         w = W(self.neighbors, self.weights, silence_warnings=True)
@@ -355,6 +358,33 @@ def test_roundtrip_write(self):
             new = W.from_file(path)
         np.testing.assert_array_equal(self.w.sparse.toarray(), new.sparse.toarray())
 
+    def test_to_sparse(self):
+        sparse = self.w_islands.to_sparse()
+        np.testing.assert_array_equal(sparse.data, [1, 1, 1, 1, 0])
+        np.testing.assert_array_equal(sparse.row, [0, 1, 1, 2, 3])
+        np.testing.assert_array_equal(sparse.col, [1, 0, 2, 1, 3])
+        sparse = self.w_islands.to_sparse("bsr")
+        self.assertIsInstance(sparse, scipy.sparse._arrays.bsr_array)
+        sparse = self.w_islands.to_sparse("csr")
+        self.assertIsInstance(sparse, scipy.sparse._arrays.csr_array)
+        sparse = self.w_islands.to_sparse("coo")
+        self.assertIsInstance(sparse, scipy.sparse._arrays.coo_array)
+        sparse = self.w_islands.to_sparse("csc")
+        self.assertIsInstance(sparse, scipy.sparse._arrays.csc_array)
+        sparse = self.w_islands.to_sparse()
+        self.assertIsInstance(sparse, scipy.sparse._arrays.coo_array)
+
+    def test_sparse_fmt(self):
+        with pytest.raises(ValueError) as exc_info:
+            sparse = self.w_islands.to_sparse("dog")
+
+    def test_from_sparse(self):
+        sparse = self.w_islands.to_sparse()
+        w = W.from_sparse(sparse)
+        self.assertEqual(w.n, 4)
+        self.assertEqual(len(w.islands), 0)
+        self.assertEqual(w.neighbors[3], [3])
+
 
 class Test_WSP_Back_To_W(unittest.TestCase):
     # Test to make sure we get back to the same W functionality

libpysal/weights/weights.py

@@ -10,6 +10,8 @@
 import numpy as np
 import scipy.sparse
 from scipy.sparse.csgraph import connected_components
+from sklearn import preprocessing
+from collections import defaultdict
 
 # from .util import full, WSP2W resolve import cycle by
 # forcing these into methods
@@ -445,6 +447,73 @@ def sparse(self):
             self._cache["sparse"] = self._sparse
         return self._sparse
 
+    @classmethod
+    def from_sparse(cls, sparse):
+        """Convert a ``scipy.sparse`` array to a PySAL ``W`` object.
+
+        Parameters
+        ----------
+        sparse : scipy.sparse array
+
+        Returns
+        -------
+        w : libpysal.weights.W
+            A ``W`` object containing the same graph as the ``scipy.sparse`` graph.
+
+
+        Notes
+        -----
+        When the sparse array has a zero in its data attribute, and
+        the corresponding row and column values are equal, the value
+        for the pysal weight will be 0 for the "loop".
+        """
+        coo = sparse.tocoo()
+        neighbors = defaultdict(list)
+        weights = defaultdict(list)
+        for k, v, w in zip(coo.row, coo.col, coo.data):
+            neighbors[k].append(v)
+            weights[k].append(w)
+        return W(neighbors=neighbors, weights=weights)
+
+    def to_sparse(self, fmt="coo"):
+        """Generate a ``scipy.sparse`` array object from a pysal W.
+
+        Parameters
+        ----------
+        fmt : {'bsr', 'coo', 'csc', 'csr'}
+          scipy.sparse format
+
+        Returns
+        -------
+        scipy.sparse array
+          A scipy.sparse array with a format of fmt.
+
+        Notes
+        -----
+        The keys of the w.neighbors are encoded
+        to determine row,col in the sparse array.
+
+        """
+        disp = {}
+        disp["bsr"] = scipy.sparse.bsr_array
+        disp["coo"] = scipy.sparse.coo_array
+        disp["csc"] = scipy.sparse.csc_array
+        disp["csr"] = scipy.sparse.csr_array
+        fmt_l = fmt.lower()
+        if fmt_l in disp:
+            adj_list = self.to_adjlist(drop_islands=False)
+            data = adj_list.weight
+            row = adj_list.focal
+            col = adj_list.neighbor
+            le = preprocessing.LabelEncoder()
+            le.fit(row)
+            row = le.transform(row)
+            col = le.transform(col)
+            n = self.n
+            return disp[fmt_l]((data, (row, col)), shape=(n, n))
+        else:
+            raise ValueError(f"unsupported sparse format: {fmt}")
+
     @property
     def n_components(self):
         """Store whether the adjacency matrix is fully connected."""
@@ -1366,7 +1435,7 @@ def plot(
         ax.scatter(
             gdf.centroid.apply(lambda p: p.x),
             gdf.centroid.apply(lambda p: p.y),
-            **node_kws
+            **node_kws,
         )
         return f, ax