Fix doctests in discr_ops.py

Author: kohr-h

odl/discr/discr_ops.py

@@ -64,14 +64,14 @@ def __init__(self, domain, range, interp):
 
         Apply the corresponding resampling operator to an element:
 
-        >>> print(resampling([0, 1, 0]))
-        [ 0.,  0.,  1.,  1.,  0.,  0.]
+        >>> resampling([0, 1, 0])
+        array([ 0.,  0.,  1.,  1.,  0.,  0.])
 
         With linear interpolation:
 
         >>> resampling = odl.Resampling(coarse_discr, fine_discr, 'linear')
-        >>> print(resampling([0, 1, 0]))
-        [ 0.  ,  0.25,  0.75,  0.75,  0.25,  0.  ]
+        >>> resampling([0, 1, 0])
+        array([ 0.  ,  0.25,  0.75,  0.75,  0.25,  0.  ])
         """
         if domain.domain != range.domain:
             raise ValueError(
@@ -107,11 +107,9 @@ def _call(self, x, out=None):
             x, self.domain.grid.coord_vectors, self.interp
         )
 
-        context = none_context if out is None else writable_array
-        with context(out) as out_arr:
-            return point_collocation(
-                interpolator, self.range.meshgrid, out=out_arr
-            )
+        return point_collocation(
+            interpolator, self.range.meshgrid, out=out
+        )
 
     @property
     def inverse(self):
@@ -151,14 +149,14 @@ def adjoint(self):
         coarser to a finer sampling:
 
         >>> x = [0, 1, 0]
-        >>> print(resampling_inv(resampling(x)))
-        [ 0.,  1.,  0.]
+        >>> resampling_inv(resampling(x))
+        array([ 0.,  1.,  0.])
 
         However, it can fail in the other direction:
 
         >>> y = [0, 0, 0, 1, 0, 0]
-        >>> print(resampling(resampling_inv(y)))
-        [ 0.,  0.,  0.,  0.,  0.,  0.]
+        >>> resampling(resampling_inv(y))
+        array([ 0.,  0.,  0.,  0.,  0.,  0.])
         """
         return self.inverse
 
@@ -251,29 +249,29 @@ def __init__(self, domain, range=None, ran_shp=None, **kwargs):
         >>> x = [[1, 2, 3, 4],
         ...      [5, 6, 7, 8]]
         >>> resize_op = odl.ResizingOperator(space, ran_shp=(4, 4))
-        >>> print(resize_op(x))
-        [[ 0.,  0.,  0.,  0.],
-         [ 1.,  2.,  3.,  4.],
-         [ 5.,  6.,  7.,  8.],
-         [ 0.,  0.,  0.,  0.]]
+        >>> resize_op(x)
+        array([[ 0.,  0.,  0.,  0.],
+               [ 1.,  2.,  3.,  4.],
+               [ 5.,  6.,  7.,  8.],
+               [ 0.,  0.,  0.,  0.]])
         >>>
         >>> resize_op = odl.ResizingOperator(space, ran_shp=(4, 4),
         ...                                  offset=(0, 0),
         ...                                  pad_mode='periodic')
-        >>> print(resize_op(x))
-        [[ 1.,  2.,  3.,  4.],
-         [ 5.,  6.,  7.,  8.],
-         [ 1.,  2.,  3.,  4.],
-         [ 5.,  6.,  7.,  8.]]
+        >>> resize_op(x)
+        array([[ 1.,  2.,  3.,  4.],
+               [ 5.,  6.,  7.,  8.],
+               [ 1.,  2.,  3.,  4.],
+               [ 5.,  6.,  7.,  8.]])
         >>>
         >>> resize_op = odl.ResizingOperator(space, ran_shp=(4, 4),
         ...                                  offset=(0, 0),
         ...                                  pad_mode='order0')
-        >>> print(resize_op(x))
-        [[ 1.,  2.,  3.,  4.],
-         [ 5.,  6.,  7.,  8.],
-         [ 5.,  6.,  7.,  8.],
-         [ 5.,  6.,  7.,  8.]]
+        >>> resize_op(x)
+        array([[ 1.,  2.,  3.,  4.],
+               [ 5.,  6.,  7.,  8.],
+               [ 5.,  6.,  7.,  8.],
+               [ 5.,  6.,  7.,  8.]])
 
         Alternatively, the range of the operator can be provided directly.
         This requires that the partitions match, i.e. that the cell sizes
@@ -283,11 +281,11 @@ def __init__(self, domain, range=None, ran_shp=None, **kwargs):
         >>> large_spc = odl.uniform_discr([-0.5, 0], [1.5, 1], (4, 4))
         >>> resize_op = odl.ResizingOperator(space, large_spc,
         ...                                  pad_mode='periodic')
-        >>> print(resize_op(x))
-        [[ 5.,  6.,  7.,  8.],
-         [ 1.,  2.,  3.,  4.],
-         [ 5.,  6.,  7.,  8.],
-         [ 1.,  2.,  3.,  4.]]
+        >>> resize_op(x)
+        array([[ 5.,  6.,  7.,  8.],
+               [ 1.,  2.,  3.,  4.],
+               [ 5.,  6.,  7.,  8.],
+               [ 1.,  2.,  3.,  4.]])
         """
         # Swap names to be able to use the range iterator without worries
         import builtins
@@ -371,10 +369,9 @@ def axes(self):
 
     def _call(self, x, out):
         """Implement ``self(x, out)``."""
-        with writable_array(out) as out_arr:
-            resize_array(x.asarray(), self.range.shape, offset=self.offset,
-                         pad_mode=self.pad_mode, pad_const=self.pad_const,
-                         direction='forward', out=out_arr)
+        resize_array(x, self.range.shape, offset=self.offset,
+                     pad_mode=self.pad_mode, pad_const=self.pad_const,
+                     direction='forward', out=out)
 
     def derivative(self, point):
         """Derivative of this operator at ``point``.
@@ -411,11 +408,9 @@ class ResizingOperatorAdjoint(Operator):
 
             def _call(self, x, out):
                 """Implement ``self(x, out)``."""
-                with writable_array(out) as out_arr:
-                    resize_array(x.asarray(), op.domain.shape,
-                                 offset=op.offset, pad_mode=op.pad_mode,
-                                 pad_const=0, direction='adjoint',
-                                 out=out_arr)
+                resize_array(x, op.domain.shape,
+                             offset=op.offset, pad_mode=op.pad_mode,
+                             pad_const=0, direction='adjoint', out=out)
 
             @property
             def adjoint(self):