ENH: Tensor-valued DiscreteLp

examples/tomo/ray_trafo_parallel_2d.py

@@ -28,7 +28,7 @@
 # projection data (or any element in the projection space).
 backproj = ray_trafo.adjoint(proj_data)
 
-# Shows a slice of the phantom, projections, and reconstruction
+# Show a slice of the phantom, projections, and reconstruction
 phantom.show(title='Phantom')
 proj_data.show(title='Projection data (sinogram)')
 backproj.show(title='Back-projected data', force_show=True)

odl/discr/discr_mappings.py

@@ -79,10 +79,11 @@ def __init__(self, map_type, fspace, partition, tspace, linear=False):
                              'of the function set {}'
                              ''.format(partition, fspace.domain, fspace))
 
-        if tspace.shape != partition.shape:
-            raise ValueError('`tspace.shape` not equal to `partition.shape`: '
-                             '{} != {}'
-                             ''.format(tspace.shape, partition.shape))
+        if tspace.shape != fspace.shape_out + partition.shape:
+            raise ValueError(
+                '`tspace.shape` not equal to '
+                '`fspace.shape_out +  partition.shape`: {} != {}'
+                ''.format(tspace.shape, fspace.shape_out + partition.shape))
 
         domain = fspace if map_type == 'sampling' else tspace
         range = tspace if map_type == 'sampling' else fspace
@@ -323,7 +324,7 @@ def __init__(self, fspace, partition, tspace, variant='left'):
         data type in 2d:
 
         >>> rect = odl.IntervalProd([0, 0], [1, 1])
-        >>> fspace = odl.FunctionSpace(rect, out_dtype='U1')
+        >>> fspace = odl.FunctionSpace(rect, dtype_out='U1')
 
         Partitioning the domain uniformly with no nodes on the boundary
         (will shift the grid points):

odl/discr/discr_ops.py

@@ -524,7 +524,7 @@ def _resize_discr(discr, newshp, offset, discr_kwargs):
             new_maxpt.append(grid_max[axis] + (num_r + 0.5) * cell_size[axis])
 
     fspace = FunctionSpace(IntervalProd(new_minpt, new_maxpt),
-                           out_dtype=dtype)
+                           dtype_out=dtype)
     tspace = tensor_space(newshp, dtype=dtype, impl=impl, exponent=exponent,
                           weighting=weighting)
 

odl/discr/discretization.py

@@ -375,6 +375,13 @@ def __eq__(self, other):
     def __getitem__(self, indices):
         """Return ``self[indices]``.
 
+        .. note::
+            This is a basic implementation that does little more than
+            propagating the indexing to the `tensor` attribute. In
+            particular, the result will **not** be wrapped as a
+            `DiscretizedSpaceElement` again. Subclasses should take
+            care of that by overriding ``__getitem__``.
+
         Parameters
         ----------
         indices : int or `slice`
@@ -417,9 +424,9 @@ def sampling(self, ufunc, **kwargs):
         Parameters
         ----------
         ufunc : ``self.space.fspace`` element
-            The continuous function that should be samplingicted.
+            The continuous function that should be sampled.
         kwargs :
-            Additional arugments for the sampling operator implementation
+            Additional arguments for the sampling operator implementation.
 
         Examples
         --------
@@ -445,7 +452,7 @@ def interpolation(self):
         Returns
         -------
         interpolation_op : `FunctionSpaceMapping`
-            Operatior representing a continuous interpolation of this
+            Operator representing a continuous interpolation of this
             element.
 
         Examples

odl/discr/grid.py

@@ -18,7 +18,7 @@
 from odl.set import Set, IntervalProd
 from odl.util import (
     normalized_index_expression, normalized_scalar_param_list, safe_int_conv,
-    array_str, signature_string, indent, npy_printoptions)
+    array_str, signature_string, indent, npy_printoptions, array_hash)
 
 
 __all__ = ('RectGrid', 'uniform_grid', 'uniform_grid_fromintv')
@@ -521,8 +521,9 @@ def __eq__(self, other):
     def __hash__(self):
         """Return ``hash(self)``."""
         # TODO: update with #841
-        coord_vec_str = tuple(cv.tobytes() for cv in self.coord_vectors)
-        return hash((type(self), coord_vec_str))
+        return hash(
+            (type(self), tuple(array_hash(cv) for cv in self.coord_vectors))
+        )
 
     def approx_contains(self, other, atol):
         """Test if ``other`` belongs to this grid up to a tolerance.