changed tests with respect to changes in grid

different fixes at various points

HierMat/cluster.py

@@ -109,11 +109,8 @@ def diameter(self):
         """
         # get all points from grid in indices
         points = [self.grid.points[i] for i in self.indices]
-        # add relevant supports
-        for i in self.indices:
-            points.extend([p for p in self.grid.supports[i]])
         # compute distance matrix
-        dist_mat = [numpy.linalg.norm(x - y) for x in points for y in points]
+        dist_mat = [numpy.linalg.norm(numpy.array(x) - numpy.array(y)) for x in points for y in points]
         return max(dist_mat)
 
     def distance(self, other):

HierMat/examples/model_1d.py

@@ -143,4 +143,4 @@ def galerkin_1d_full(block_cluster_tree):
 
 
 if __name__ == '__main__':
-    model_1d(n=2**8, max_rank=1, n_min=1)
+    model_1d(n=2**5, max_rank=1, n_min=1)

HierMat/grid.py

@@ -5,16 +5,21 @@
 
 class Grid(object):
     """Discretized grid characterized by points and supports
+    
+    :param points: list of coordinates
+    
+        The points of the discretized Grid.
+        
+        For 1-dimensional problems this is a list of floats,
+        for higher dimension this is a list of tuples of floats
+            
+    :type points: list[tuple(float)]
+    :param supports: dictionary mapping points with their supports
+    :type supports: dict{point: support}
+    :raise ValueError: if points and supports have different length
     """
     def __init__(self, points, supports):
-        """Create a Grid
-
-        :param points: list of coordinates
-        :type points: list[numpy.array or list[float]]
-        :param supports: list of supports for every point
-        :type supports: dict{point: function}
-        :raise ValueError: if points and supports have different length
-        """
+        """Create a Grid"""
         # check input
         if len(points) != len(supports):
             raise ValueError('points and supports must be of same length')
@@ -23,9 +28,9 @@ def __init__(self, points, supports):
         self.supports = supports
 
     def __len__(self):
-        """Return length of points
+        """Return number of points
 
-        :return: length of points
+        :return: len(points)
         :rtype: int
         """
         return len(self.points)
@@ -75,14 +80,23 @@ def get_point(self, item):
         return self.points[item]
 
     def get_support(self, item):
-        """Return link at position item
+        """Return support for item
 
-        :param item: index
-        :type item: int
-        :return: supports
+        :param item: point
+        :type item: float or tuple(float)
+        :return: support
         """
         return self.supports[item]
 
+    def get_support_by_index(self, index):
+        """Return support for the i-th item
+
+        :param index: index
+        :type index: int
+        :return: support
+        """
+        return self.supports[self.get_point(index)]
+
     def dim(self):
         """Dimension of the Grid
         
@@ -95,7 +109,10 @@ def dim(self):
         :return: dimension
         :rtype: int
         """
-        return len(self[0])
+        try:
+            return len(self[0])
+        except TypeError:
+            return 1
 
 
 class GridIterator(object):

HierMat/utils.py

@@ -60,8 +60,6 @@ def plot(obj, filename=None, **kwargs):
     """
     if isinstance(obj, BlockClusterTree):
         return block_cluster_tree_plot(obj, filename, **kwargs)
-    elif isinstance(obj, Grid):
-        return grid_plot(obj, filename)
     else:
         raise NotImplementedError('object can not be plotted')
 
@@ -129,36 +127,6 @@ def block_cluster_tree_plot(obj, filename=None, ticks=False, face_color='#133f52
         plt.savefig(filename, format='png', facecolor=fig.get_facecolor(), edgecolor=None)
 
 
-def grid_plot(obj, filename=None):
-    """Plot a grid
-
-    :param filename: file to save the plot in. If not specified, the figure is returned
-    :type filename: str
-    """
-    # check dimensions:
-    d = obj.dim()
-    if d != 2:
-        raise NotImplementedError("Only 2D plot is supported for now")
-    import matplotlib.pyplot as plt
-
-    plt.rc('axes', linewidth=0.5, labelsize=4)
-    plt.rc('xtick', labelsize=4)
-    plt.rc('ytick', labelsize=4)
-    plt.rc('lines', linewidth=0.5)
-    plt.rc('lines', markersize=2)
-    plt.rc('lines', markeredgewidth=0.5)
-    fig = plt.figure(figsize=(3, 3), dpi=400)
-    length = len(obj.points)
-    for i in xrange(length):
-        plt.plot(obj.points[i][0], obj.points[i][1], 'xk')
-        for link in obj.supports[i]:
-            plt.plot([obj.points[i][0], link[0]], [obj.points[i][1], link[1]], '-b')
-    if not filename:
-        return fig
-    else:
-        plt.savefig(filename, format='png', facecolor=fig.get_facecolor(), edgecolor=None, bb_inches='tight')
-
-
 def load(filename):
     """Load a :class:`ClusterTree` or :class:`BlockClusterTree` from file
 

setup.py

@@ -35,7 +35,7 @@
 
 setup(
     name='HierMat',
-    version='0.6.4',
+    version='0.6.5',
     packages=['HierMat'],
     url='http://hierarchicalmatrices.readthedocs.io/en/latest/index.html',
     download_url='https://github.com/maekke97/HierarchicalMatrices',

tests/test_block_cluster_tree.py

@@ -19,17 +19,17 @@ def setUpClass(cls):
         cls.lim2 = 3
         cls.lim3 = 4
         cls.link_num = 4
-        cls.points1 = [numpy.array([float(i) / cls.lim1]) for i in xrange(cls.lim1)]
-        cls.links1 = [[cls.points1[l] for l in [random.randint(0, cls.lim1 - 1) for x in xrange(cls.link_num)]]
-                      for i in xrange(cls.lim1)]
-        cls.points2 = [numpy.array([float(i) / cls.lim2, float(j) / cls.lim2])
+        cls.points1 = [(float(i) / cls.lim1,) for i in xrange(cls.lim1)]
+        cls.links1 = {p: [cls.points1[l] for l in [random.randint(0, cls.lim1 - 1) for x in xrange(cls.link_num)]]
+                      for p in cls.points1}
+        cls.points2 = [(float(i) / cls.lim2, float(j) / cls.lim2)
                        for i in xrange(cls.lim2) for j in xrange(cls.lim2)]
-        cls.links2 = [[cls.points2[l] for l in [random.randint(0, cls.lim2 ** 2 - 1) for x in xrange(cls.link_num)]]
-                      for j in xrange(cls.lim2) for i in xrange(cls.lim2)]
-        cls.points3 = [numpy.array([float(i) / cls.lim3, float(j) / cls.lim3, float(k) / cls.lim3])
+        cls.links2 = {p: [cls.points2[l] for l in [random.randint(0, cls.lim2 ** 2 - 1) for x in xrange(cls.link_num)]]
+                      for p in cls.points2}
+        cls.points3 = [(float(i) / cls.lim3, float(j) / cls.lim3, float(k) / cls.lim3)
                        for i in xrange(cls.lim3) for j in xrange(cls.lim3) for k in xrange(cls.lim3)]
-        cls.links3 = [[cls.points3[l] for l in [random.randint(0, cls.lim3 ** 3 - 1) for x in xrange(cls.link_num)]]
-                      for k in xrange(cls.lim3) for j in xrange(cls.lim3) for i in xrange(cls.lim3)]
+        cls.links3 = {p: [cls.points3[l] for l in [random.randint(0, cls.lim3 ** 3 - 1) for x in xrange(cls.link_num)]]
+                      for p in cls.points3}
         cls.grid1 = Grid(cls.points1, cls.links1)
         cls.grid2 = Grid(cls.points2, cls.links2)
         cls.grid3 = Grid(cls.points3, cls.links3)

tests/test_cluster.py

@@ -14,17 +14,17 @@ def setUpClass(cls):
         cls.lim2 = 8
         cls.lim3 = 4
         cls.link_num = 4
-        cls.points1 = [numpy.array([float(i) / cls.lim1]) for i in xrange(cls.lim1)]
-        cls.links1 = [[cls.points1[l] for l in [random.randint(0, cls.lim1 - 1) for x in xrange(cls.link_num)]]
-                      for i in xrange(cls.lim1)]
-        cls.points2 = [numpy.array([float(i) / cls.lim2, float(j) / cls.lim2])
+        cls.points1 = [(float(i) / cls.lim1,) for i in xrange(cls.lim1)]
+        cls.links1 = {p: [cls.points1[l] for l in [random.randint(0, cls.lim1 - 1) for x in xrange(cls.link_num)]]
+                      for p in cls.points1}
+        cls.points2 = [(float(i) / cls.lim2, float(j) / cls.lim2)
                        for i in xrange(cls.lim2) for j in xrange(cls.lim2)]
-        cls.links2 = [[cls.points2[l] for l in [random.randint(0, cls.lim2 ** 2 - 1) for x in xrange(cls.link_num)]]
-                      for j in xrange(cls.lim2) for i in xrange(cls.lim2)]
-        cls.points3 = [numpy.array([float(i) / cls.lim3, float(j) / cls.lim3, float(k) / cls.lim3])
+        cls.links2 = {p: [cls.points2[l] for l in [random.randint(0, cls.lim2 ** 2 - 1) for x in xrange(cls.link_num)]]
+                      for p in cls.points2}
+        cls.points3 = [(float(i) / cls.lim3, float(j) / cls.lim3, float(k) / cls.lim3)
                        for i in xrange(cls.lim3) for j in xrange(cls.lim3) for k in xrange(cls.lim3)]
-        cls.links3 = [[cls.points3[l] for l in [random.randint(0, cls.lim3 ** 3 - 1) for x in xrange(cls.link_num)]]
-                      for k in xrange(cls.lim3) for j in xrange(cls.lim3) for i in xrange(cls.lim3)]
+        cls.links3 = {p: [cls.points3[l] for l in [random.randint(0, cls.lim3 ** 3 - 1) for x in xrange(cls.link_num)]]
+                      for p in cls.points3}
         cls.grid1 = Grid(cls.points1, cls.links1)
         cls.grid2 = Grid(cls.points2, cls.links2)
         cls.grid3 = Grid(cls.points3, cls.links3)

tests/test_cluster_tree.py

@@ -18,17 +18,17 @@ def setUpClass(cls):
         cls.lim2 = 8
         cls.lim3 = 4
         cls.link_num = 4
-        cls.points1 = [numpy.array([float(i) / cls.lim1]) for i in xrange(cls.lim1)]
-        cls.links1 = [[cls.points1[l] for l in [random.randint(0, cls.lim1 - 1) for x in xrange(cls.link_num)]]
-                      for i in xrange(cls.lim1)]
-        cls.points2 = [numpy.array([float(i) / cls.lim2, float(j) / cls.lim2])
+        cls.points1 = [(float(i) / cls.lim1,) for i in xrange(cls.lim1)]
+        cls.links1 = {p: [cls.points1[l] for l in [random.randint(0, cls.lim1 - 1) for x in xrange(cls.link_num)]]
+                      for p in cls.points1}
+        cls.points2 = [(float(i) / cls.lim2, float(j) / cls.lim2)
                        for i in xrange(cls.lim2) for j in xrange(cls.lim2)]
-        cls.links2 = [[cls.points2[l] for l in [random.randint(0, cls.lim2 ** 2 - 1) for x in xrange(cls.link_num)]]
-                      for j in xrange(cls.lim2) for i in xrange(cls.lim2)]
-        cls.points3 = [numpy.array([float(i) / cls.lim3, float(j) / cls.lim3, float(k) / cls.lim3])
+        cls.links2 = {p: [cls.points2[l] for l in [random.randint(0, cls.lim2 ** 2 - 1) for x in xrange(cls.link_num)]]
+                      for p in cls.points2}
+        cls.points3 = [(float(i) / cls.lim3, float(j) / cls.lim3, float(k) / cls.lim3)
                        for i in xrange(cls.lim3) for j in xrange(cls.lim3) for k in xrange(cls.lim3)]
-        cls.links3 = [[cls.points3[l] for l in [random.randint(0, cls.lim3 ** 3 - 1) for x in xrange(cls.link_num)]]
-                      for k in xrange(cls.lim3) for j in xrange(cls.lim3) for i in xrange(cls.lim3)]
+        cls.links3 = {p: [cls.points3[l] for l in [random.randint(0, cls.lim3 ** 3 - 1) for x in xrange(cls.link_num)]]
+                      for p in cls.points3}
         cls.grid1 = Grid(cls.points1, cls.links1)
         cls.grid2 = Grid(cls.points2, cls.links2)
         cls.grid3 = Grid(cls.points3, cls.links3)

tests/test_grid.py

@@ -14,17 +14,17 @@ def setUpClass(cls):
         cls.lim2 = 4
         cls.lim3 = 4
         cls.link_num = 2
-        cls.points1 = [numpy.array([float(i) / cls.lim1]) for i in xrange(cls.lim1)]
-        cls.links1 = [[cls.points1[l] for l in [random.randint(0, cls.lim1 - 1) for x in xrange(cls.link_num)]]
-                      for i in xrange(cls.lim1)]
-        cls.points2 = [numpy.array([float(i) / cls.lim2, float(j) / cls.lim2])
+        cls.points1 = [(float(i) / cls.lim1,) for i in xrange(cls.lim1)]
+        cls.links1 = {p: [cls.points1[l] for l in [random.randint(0, cls.lim1 - 1) for x in xrange(cls.link_num)]]
+                      for p in cls.points1}
+        cls.points2 = [(float(i) / cls.lim2, float(j) / cls.lim2)
                        for i in xrange(cls.lim2) for j in xrange(cls.lim2)]
-        cls.links2 = [[cls.points2[l] for l in [random.randint(0, cls.lim2 ** 2 - 1) for x in xrange(cls.link_num)]]
-                      for j in xrange(cls.lim2) for i in xrange(cls.lim2)]
-        cls.points3 = [numpy.array([float(i) / cls.lim3, float(j) / cls.lim3, float(k) / cls.lim3])
+        cls.links2 = {p: [cls.points2[l] for l in [random.randint(0, cls.lim2 ** 2 - 1) for x in xrange(cls.link_num)]]
+                      for p in cls.points2}
+        cls.points3 = [(float(i) / cls.lim3, float(j) / cls.lim3, float(k) / cls.lim3)
                        for i in xrange(cls.lim3) for j in xrange(cls.lim3) for k in xrange(cls.lim3)]
-        cls.links3 = [[cls.points3[l] for l in [random.randint(0, cls.lim3 ** 3 - 1) for x in xrange(cls.link_num)]]
-                      for k in xrange(cls.lim3) for j in xrange(cls.lim3) for i in xrange(cls.lim3)]
+        cls.links3 = {p: [cls.points3[l] for l in [random.randint(0, cls.lim3 ** 3 - 1) for x in xrange(cls.link_num)]]
+                      for p in cls.points3}
         cls.grid1 = Grid(cls.points1, cls.links1)
         cls.grid2 = Grid(cls.points2, cls.links2)
         cls.grid3 = Grid(cls.points3, cls.links3)
@@ -54,13 +54,21 @@ def test_get_point(self):
         self.assertTrue(numpy.array_equal(self.grid3.get_point(0), self.points3[0]))
         self.assertTrue(numpy.array_equal(self.grid3.get_point(-1), self.points3[-1]))
 
-    def test_get_link(self):
-        self.assertTrue(numpy.array_equal(self.grid1.get_support(0), self.links1[0]))
-        self.assertTrue(numpy.array_equal(self.grid1.get_support(-1), self.links1[-1]))
-        self.assertTrue(numpy.array_equal(self.grid2.get_support(0), self.links2[0]))
-        self.assertTrue(numpy.array_equal(self.grid2.get_support(-1), self.links2[-1]))
-        self.assertTrue(numpy.array_equal(self.grid3.get_support(0), self.links3[0]))
-        self.assertTrue(numpy.array_equal(self.grid3.get_support(-1), self.links3[-1]))
+    def test_get_support(self):
+        for p in self.points1:
+            self.assertEqual(self.grid1.get_support(p), self.links1[p])
+        for p in self.points2:
+            self.assertEqual(self.grid2.get_support(p), self.links2[p])
+        for p in self.points3:
+            self.assertEqual(self.grid3.get_support(p), self.links3[p])
+
+    def test_get_support_by_index(self):
+        self.assertTrue(numpy.array_equal(self.grid1.get_support_by_index(0), self.links1[self.points1[0]]))
+        self.assertTrue(numpy.array_equal(self.grid1.get_support_by_index(-1), self.links1[self.points1[-1]]))
+        self.assertTrue(numpy.array_equal(self.grid2.get_support_by_index(0), self.links2[self.points2[0]]))
+        self.assertTrue(numpy.array_equal(self.grid2.get_support_by_index(-1), self.links2[self.points2[-1]]))
+        self.assertTrue(numpy.array_equal(self.grid3.get_support_by_index(0), self.links3[self.points3[0]]))
+        self.assertTrue(numpy.array_equal(self.grid3.get_support_by_index(-1), self.links3[self.points3[-1]]))
 
     def test_iterator(self):
         iterator = self.grid1.__iter__()

tests/test_integration.py

@@ -2,6 +2,7 @@
 from unittest import TestCase
 
 import numpy
+import os
 
 from HierMat.block_cluster_tree import build_block_cluster_tree
 from HierMat.cluster import Cluster
@@ -21,17 +22,17 @@ def setUpClass(cls):
         cls.lim2 = 4
         cls.lim3 = 4
         cls.link_num = 4
-        cls.points1 = [numpy.array([float(i) / cls.lim1]) for i in xrange(cls.lim1)]
-        cls.links1 = [[cls.points1[l] for l in [random.randint(0, cls.lim1 - 1) for x in xrange(cls.link_num)]]
-                      for i in xrange(cls.lim1)]
-        cls.points2 = [numpy.array([float(i) / cls.lim2, float(j) / cls.lim2])
+        cls.points1 = [(float(i) / cls.lim1,) for i in xrange(cls.lim1)]
+        cls.links1 = {p: [cls.points1[l] for l in [random.randint(0, cls.lim1 - 1) for x in xrange(cls.link_num)]]
+                      for p in cls.points1}
+        cls.points2 = [(float(i) / cls.lim2, float(j) / cls.lim2)
                        for i in xrange(cls.lim2) for j in xrange(cls.lim2)]
-        cls.links2 = [[cls.points2[l] for l in [random.randint(0, cls.lim2 ** 2 - 1) for x in xrange(cls.link_num)]]
-                       for j in xrange(cls.lim2) for i in xrange(cls.lim2)]
-        cls.points3 = [numpy.array([float(i) / cls.lim3, float(j) / cls.lim3, float(k) / cls.lim3])
+        cls.links2 = {p: [cls.points2[l] for l in [random.randint(0, cls.lim2 ** 2 - 1) for x in xrange(cls.link_num)]]
+                      for p in cls.points2}
+        cls.points3 = [(float(i) / cls.lim3, float(j) / cls.lim3, float(k) / cls.lim3)
                        for i in xrange(cls.lim3) for j in xrange(cls.lim3) for k in xrange(cls.lim3)]
-        cls.links3 = [[cls.points3[l] for l in [random.randint(0, cls.lim3 ** 3 - 1) for x in xrange(cls.link_num)]]
-                      for k in xrange(cls.lim3) for j in xrange(cls.lim3) for i in xrange(cls.lim3)]
+        cls.links3 = {p: [cls.points3[l] for l in [random.randint(0, cls.lim3 ** 3 - 1) for x in xrange(cls.link_num)]]
+                      for p in cls.points3}
         cls.grid1 = Grid(cls.points1, cls.links1)
         cls.grid2 = Grid(cls.points2, cls.links2)
         cls.grid3 = Grid(cls.points3, cls.links3)
@@ -72,3 +73,12 @@ def test_setup(self):
 
     def test_model_1d(self):
         self.assertTrue(model_1d(n=2**6, max_rank=1, n_min=1))
+
+    @classmethod
+    def tearDownClass(cls):
+        created_files = ['gallmat_full.txt', 'hmat_full.txt', 'hmat.bin']
+        try:
+            for f in created_files:
+                os.remove(f)
+        except OSError:
+            pass

tests/test_splitable.py

@@ -17,17 +17,17 @@ def setUpClass(cls):
         cls.lim2 = 8
         cls.lim3 = 4
         cls.link_num = 4
-        cls.points1 = [numpy.array([float(i) / cls.lim1]) for i in xrange(cls.lim1)]
-        cls.links1 = [[cls.points1[l] for l in [random.randint(0, cls.lim1 - 1) for x in xrange(cls.link_num)]]
-                      for i in xrange(cls.lim1)]
-        cls.points2 = [numpy.array([float(i) / cls.lim2, float(j) / cls.lim2])
+        cls.points1 = [(float(i) / cls.lim1,) for i in xrange(cls.lim1)]
+        cls.links1 = {p: [cls.points1[l] for l in [random.randint(0, cls.lim1 - 1) for x in xrange(cls.link_num)]]
+                      for p in cls.points1}
+        cls.points2 = [(float(i) / cls.lim2, float(j) / cls.lim2)
                        for i in xrange(cls.lim2) for j in xrange(cls.lim2)]
-        cls.links2 = [[cls.points2[l] for l in [random.randint(0, cls.lim2 ** 2 - 1) for x in xrange(cls.link_num)]]
-                      for j in xrange(cls.lim2) for i in xrange(cls.lim2)]
-        cls.points3 = [numpy.array([float(i) / cls.lim3, float(j) / cls.lim3, float(k) / cls.lim3])
+        cls.links2 = {p: [cls.points2[l] for l in [random.randint(0, cls.lim2 ** 2 - 1) for x in xrange(cls.link_num)]]
+                      for p in cls.points2}
+        cls.points3 = [(float(i) / cls.lim3, float(j) / cls.lim3, float(k) / cls.lim3)
                        for i in xrange(cls.lim3) for j in xrange(cls.lim3) for k in xrange(cls.lim3)]
-        cls.links3 = [[cls.points3[l] for l in [random.randint(0, cls.lim3 ** 3 - 1) for x in xrange(cls.link_num)]]
-                      for k in xrange(cls.lim3) for j in xrange(cls.lim3) for i in xrange(cls.lim3)]
+        cls.links3 = {p: [cls.points3[l] for l in [random.randint(0, cls.lim3 ** 3 - 1) for x in xrange(cls.link_num)]]
+                      for p in cls.points3}
         cls.grid1 = Grid(cls.points1, cls.links1)
         cls.grid2 = Grid(cls.points2, cls.links2)
         cls.grid3 = Grid(cls.points3, cls.links3)
@@ -204,6 +204,9 @@ def test_get_patch_coordinates(self):
         self.assertEqual(coordinates[0], 0)
         self.assertEqual(coordinates[1], self.lim3 ** 3 - 1)
 
+    def test_get_grid_item_support(self):
+        self.assertRaises(NotImplementedError, self.dummy.get_grid_item_support, 0)
+
     def test_eq(self):
         self.assertRaises(NotImplementedError, self.dummy.__eq__, self.dummy)
         self.assertEqual(self.rc1, self.rc1)