WIP: Remove element classes

doc/source/getting_started/code/getting_started_convolution.py

@@ -10,17 +10,18 @@ class Convolution(odl.Operator):
     The operator inherits from ``odl.Operator`` to be able to be used with ODL.
     """
 
-    def __init__(self, kernel):
+    def __init__(self, space, kernel):
         """Initialize a convolution operator with a known kernel."""
 
-        # Store the kernel
-        self.kernel = kernel
-
         # Initialize the Operator class by calling its __init__ method.
         # This sets properties such as domain and range and allows the other
         # operator convenience functions to work.
         super(Convolution, self).__init__(
-            domain=kernel.space, range=kernel.space, linear=True)
+            domain=space, range=space, linear=True
+        )
+
+        # Store the kernel
+        self.kernel = kernel
 
     def _call(self, x):
         """Implement calling the operator by calling scipy."""
@@ -39,7 +40,7 @@ def adjoint(self):
 kernel = odl.phantom.cuboid(space, [-0.05, -0.05], [0.05, 0.05])
 
 # Create convolution operator
-A = Convolution(kernel)
+A = Convolution(space, kernel)
 
 # Create phantom (the "unknown" solution)
 phantom = odl.phantom.shepp_logan(space, modified=True)
@@ -48,9 +49,9 @@ def adjoint(self):
 g = A(phantom)
 
 # Display the results using the show method
-kernel.show('kernel')
-phantom.show('phantom')
-g.show('convolved phantom')
+space.show(kernel, 'kernel')
+space.show(phantom, 'phantom')
+space.show(g, 'convolved phantom')
 
 # Landweber
 
@@ -59,13 +60,13 @@ def adjoint(self):
 
 f = space.zero()
 odl.solvers.landweber(A, f, g, niter=100, omega=1 / opnorm ** 2)
-f.show('landweber')
+space.show(f, 'landweber')
 
 # Conjugate gradient
 
 f = space.zero()
 odl.solvers.conjugate_gradient_normal(A, f, g, niter=100)
-f.show('conjugate gradient')
+space.show(f, 'conjugate gradient')
 
 # Tikhonov with identity
 
@@ -76,7 +77,7 @@ def adjoint(self):
 
 f = space.zero()
 odl.solvers.conjugate_gradient(T, f, b, niter=100)
-f.show('Tikhonov identity conjugate gradient')
+space.show(f, 'Tikhonov identity conjugate gradient')
 
 # Tikhonov with gradient
 
@@ -87,7 +88,7 @@ def adjoint(self):
 
 f = space.zero()
 odl.solvers.conjugate_gradient(T, f, b, niter=100)
-f.show('Tikhonov gradient conjugate gradient')
+space.show(f, 'Tikhonov gradient conjugate gradient')
 
 # Douglas-Rachford
 
@@ -114,4 +115,4 @@ def adjoint(self):
 x = space.zero()
 odl.solvers.douglas_rachford_pd(x, f, g_funcs, lin_ops,
                                 tau=tau, sigma=sigma, niter=100)
-x.show('TV Douglas-Rachford', force_show=True)
+space.show(x, 'TV Douglas-Rachford', force_show=True)

doc/source/getting_started/first_steps.rst

@@ -45,17 +45,19 @@ and create a wrapping `Operator` for it in ODL.
        The operator inherits from ``odl.Operator`` to be able to be used with ODL.
        """
 
-       def __init__(self, kernel):
+       def __init__(self, space, kernel):
            """Initialize a convolution operator with a known kernel."""
 
-           # Store the kernel
-           self.kernel = kernel
-
            # Initialize the Operator class by calling its __init__ method.
            # This sets properties such as domain and range and allows the other
            # operator convenience functions to work.
            super(Convolution, self).__init__(
-               domain=kernel.space, range=kernel.space, linear=True)
+               domain=space, range=space, linear=True
+           )
+
+           # Store the kernel
+           self.kernel = kernel
+
 
        def _call(self, x):
            """Implement calling the operator by calling scipy."""
@@ -75,7 +77,7 @@ ODL also provides a nice range of standard phantoms such as the `cuboid` and `sh
    kernel = odl.phantom.cuboid(space, [-0.05, -0.05], [0.05, 0.05])
 
    # Create convolution operator
-   A = Convolution(kernel)
+   A = Convolution(space, kernel)
 
    # Create phantom (the "unknown" solution)
    phantom = odl.phantom.shepp_logan(space, modified=True)
@@ -84,9 +86,9 @@ ODL also provides a nice range of standard phantoms such as the `cuboid` and `sh
    g = A(phantom)
 
    # Display the results using the show method
-   kernel.show('kernel')
-   phantom.show('phantom')
-   g.show('convolved phantom')
+   space.show(kernel, title='kernel')
+   space.show(phantom, title='phantom')
+   space.show(g, title='convolved phantom')
 
 .. image:: figures/getting_started_kernel.png
 

doc/source/guide/code/functional_indepth_example.py

@@ -27,7 +27,7 @@ def __init__(self, space, y):
     # the functional and always needs to be implemented.
     def _call(self, x):
         """Evaluate the functional."""
-        return x.norm() ** 2 + x.inner(self.y)
+        return self.domain.norm(x) ** + self.domain.inner(x, self.y)
 
     # Next we define the gradient. Note that this is a property.
     @property
@@ -89,7 +89,7 @@ def __init__(self, space, y):
 
     def _call(self, x):
         """Evaluate the functional."""
-        return (x - self.y).norm()**2 / 4.0
+        return self.domain.norm(x - self.y) ** 2 / 4
 
 
 # Create a functional

doc/source/guide/faq.rst

@@ -49,42 +49,6 @@ General errors
       This will yield a specific error message for an erroneous module that helps you debugging your
       changes.
 
-#. **Q:** When adding two space elements, the following error is shown::
-
-      TypeError: unsupported operand type(s) for +: 'DiscretizedSpaceElement' and 'DiscretizedSpaceElement'
-
-   This seems completely illogical since it works in other situations and clearly must be supported.
-   Why is this error shown?
-
-   **P:** The elements you are trying to add are not in the same space.
-   For example, the following code triggers the same error:
-
-      >>> x = odl.uniform_discr(0, 1, 10).one()
-      >>> y = odl.uniform_discr(0, 1, 11).one()
-      >>> x - y
-
-   In this case, the problem is that the elements have a different number of entries.
-   Other possible issues include that they are discretizations of different sets,
-   have different data types (:term:`dtype`), or implementation (for example CUDA/CPU).
-
-   **S:** The elements need to somehow be cast to the same space.
-   How to do this depends on the problem at hand.
-   To find what the issue is, inspect the ``space`` properties of both elements.
-   For the above example, we see that the issue lies in the number of discretization points:
-
-      >>> x.space
-      odl.uniform_discr(0, 1, 10)
-      >>> y.space
-      odl.uniform_discr(0, 1, 11)
-
-   * In the case of spaces being discretizations of different underlying spaces,
-     a transformation of some kind has to be applied (for example by using an operator).
-     In general, errors like this indicates a conceptual issue with the code,
-     for example a "we identify X with Y" step has been omitted.
-
-   * If the ``dtype`` or ``impl`` do not match, they need to be cast to each one of the others.
-     The most simple way to do this is by using the `DiscretizedSpaceElement.astype` method.
-
 #. **Q:** I have installed ODL with the ``pip install --editable`` option, but I still get an
    ``AttributeError`` when I try to use a function/class I just implemented. The use-without-reinstall
    thing does not seem to work. What am I doing wrong?

doc/source/guide/functional_guide.rst

@@ -177,8 +177,7 @@ All available functional arithmetic, including which properties and methods that
 | ``(S * a)(x)``      | ``S(a * x)``    | `FunctionalRightScalarMult`                                                    |
 |                     |                 | - Retains all properties.                                                      |
 +---------------------+-----------------+--------------------------------------------------------------------------------+
-| ``(v * S)(x)``      | ``v * S(x)``    | `FunctionalLeftVectorMult`                                                     |
-|                     |                 | - Results in an operator rather than a functional.                             |
+| ``(v * S)(x)``      | ``v * S(x)``    | Not supported                                                                  |
 +---------------------+-----------------+--------------------------------------------------------------------------------+
 | ``(S * v)(x)``      | ``S(v * x)``    | `FunctionalRightVectorMult`                                                    |
 |                     |                 | - Retains gradient and convex conjugate.                                       |

doc/source/guide/numpy_guide.rst

@@ -123,14 +123,14 @@ The convolution operation, written as ODL operator, could look like this::
    >>> class MyConvolution(odl.Operator):
    ...     """Operator for convolving with a given kernel."""
    ...
-   ...     def __init__(self, kernel):
+   ...     def __init__(self, space, kernel):
    ...         """Initialize the convolution."""
-   ...         self.kernel = kernel
-   ...
    ...         # Initialize operator base class.
    ...         # This operator maps from the space of vector to the same space and is linear
    ...         super(MyConvolution, self).__init__(
-   ...             domain=kernel.space, range=kernel.space, linear=True)
+   ...             domain=space, range=space, linear=True)
+   ...
+   ...         self.kernel = kernel
    ...
    ...     def _call(self, x):
    ...         # The output of an Operator is automatically cast to an ODL object
@@ -139,7 +139,7 @@ The convolution operation, written as ODL operator, could look like this::
 This operator can then be called on its domain elements::
 
    >>> kernel = odl.rn(3).element([1, 2, 1])
-   >>> conv_op = MyConvolution(kernel)
+   >>> conv_op = MyConvolution(r3, kernel)
    >>> conv_op([1, 2, 3])
    rn(3).element([ 4.,  8.,  8.])
 
@@ -149,7 +149,7 @@ It can be also be used with any of the ODL operator functionalities such as mult
    >>> scaled_op([1, 2, 3])
    rn(3).element([  8.,  16.,  16.])
    >>> y = odl.rn(3).element([1, 1, 1])
-   >>> inner_product_op = odl.InnerProductOperator(y)
+   >>> inner_product_op = odl.InnerProductOperator(r3, y)
    >>> # Create composition with inner product operator with [1, 1, 1].
    >>> # When called on a vector, the result should be the sum of the
    >>> # convolved vector.

doc/source/guide/operator_guide.rst

@@ -50,7 +50,7 @@ example::
   class MatrixOperator(odl.Operator):
       ...
       def _call(self, x, out):
-          self.matrix.dot(x, out=out.asarray())
+          self.matrix.dot(x, out=out)
 
 In-place evaluation is usually more efficient and should be used
 *whenever possible*.
@@ -86,8 +86,7 @@ avoided*.
     # In-place evaluation
     operator(x, out=y)
 
-This public calling interface is (duck-)type-checked, so the private methods
-can safely assume that their input data is of the operator domain element type.
+This public calling interface is (duck-)type-checked, so the private methods can safely assume that their input data is of the operator domain element type.
 
 Operator arithmetic
 -------------------
@@ -108,9 +107,7 @@ Another example is matrix multiplication, which corresponds to operator composit
 
 .. _functional: https://en.wikipedia.org/wiki/Functional_(mathematics)
 
-All available operator arithmetic is shown below. ``A``, ``B`` represent arbitrary `Operator`'s,
-``f`` is an `Operator` whose `Operator.range` is a `Field` (sometimes called a functional_), and
-``a`` is a scalar.
+All available operator arithmetic is shown below. ``A``, ``B`` represent arbitrary `Operator`'s, ``f`` is an `Operator` whose `Operator.range` is a `Field` (sometimes called a functional_), and ``a`` is a scalar.
 
 +------------------+-----------------+----------------------------+
 | Code             | Meaning         | Class                      |
@@ -123,7 +120,7 @@ All available operator arithmetic is shown below. ``A``, ``B`` represent arbitra
 +------------------+-----------------+----------------------------+
 | ``(A * a)(x)``   | ``A(a * x)``    | `OperatorRightScalarMult`  |
 +------------------+-----------------+----------------------------+
-| ``(v * f)(x)``   | ``v * f(x)``    | `FunctionalLeftVectorMult` |
+| ``(v * f)(x)``   | ``v * f(x)``    | Not supported (*)          |
 +------------------+-----------------+----------------------------+
 | ``(v * A)(x)``   | ``v * A(x)``    | `OperatorLeftVectorMult`   |
 +------------------+-----------------+----------------------------+
@@ -132,23 +129,24 @@ All available operator arithmetic is shown below. ``A``, ``B`` represent arbitra
 | not available    | ``A(x) * B(x)`` | `OperatorPointwiseProduct` |
 +------------------+-----------------+----------------------------+
 
+(*) The range of such an expression, if interpreted as operator, cannot be inferred.
+
 There are also a few derived expressions using the above:
 
-+------------------+--------------------------------------+
-| Code             | Meaning                              |
-+==================+======================================+
-| ``(+A)(x)``      | ``A(x)``                             |
-+------------------+--------------------------------------+
-| ``(-A)(x)``      | ``(-1) * A(x)``                      |
-+------------------+--------------------------------------+
-| ``(A - B)(x)``   | ``A(x) + (-1) * B(x)``               |
-+------------------+--------------------------------------+
-| ``A**n(x)``      | ``A(A**(n-1)(x))``, ``A^1(x) = A(x)``|
-+------------------+--------------------------------------+
-| ``(A / a)(x)``   | ``A((1/a) * x)``                     |
-+------------------+--------------------------------------+
-| ``(A @ B)(x)``   | ``(A * B)(x)``                       |
-+------------------+--------------------------------------+
-
-Except for composition, operator arithmetic is generally only defined when `Operator.domain` and
-`Operator.range` are either instances of `LinearSpace` or `Field`.
++------------------+-------------------------------------------+
+| Code             | Meaning                                   |
++==================+===========================================+
+| ``(+A)(x)``      | ``A(x)``                                  |
++------------------+-------------------------------------------+
+| ``(-A)(x)``      | ``(-1) * A(x)``                           |
++------------------+-------------------------------------------+
+| ``(A - B)(x)``   | ``A(x) + (-1) * B(x)``                    |
++------------------+-------------------------------------------+
+| ``(A **n)(x)``   | ``A((A ** (n-1))(x))``, ``A^1(x) = A(x)`` |
++------------------+-------------------------------------------+
+| ``(A / a)(x)``   | ``A((1/a) * x)``                          |
++------------------+-------------------------------------------+
+| ``(A @ B)(x)``   | ``(A * B)(x)``                            |
++------------------+-------------------------------------------+
+
+Except for composition, operator arithmetic is generally only defined when `Operator.domain` and `Operator.range` are either instances of `LinearSpace` or `Field`.

examples/deform/linearized_fixed_displacement.py

@@ -44,15 +44,15 @@
 disp_field = disp_field_space.element(disp_func)
 
 # Show template and displacement field
-template.show('Template')
-disp_field.show('Displacement field')
+templ_space.show(template, 'Template')
+disp_field_space.show(disp_field, 'Displacement field')
 
 
 # --- Apply LinDeformFixedDisp and its adjoint --- #
 
 
 # Initialize the deformation operator with fixed displacement
-deform_op = odl.deform.LinDeformFixedDisp(disp_field)
+deform_op = odl.deform.LinDeformFixedDisp(templ_space, disp_field)
 
 # Apply the deformation operator to get the deformed template.
 deformed_template = deform_op(template)
@@ -61,5 +61,7 @@
 adj_result = deform_op.adjoint(template)
 
 # Show results
-deformed_template.show('Deformed template')
-adj_result.show('Adjoint applied to the template', force_show=True)
+templ_space.show(deformed_template, 'Deformed template')
+templ_space.show(
+    adj_result, 'Adjoint applied to the template', force_show=True
+)

examples/deform/linearized_fixed_template.py

@@ -43,15 +43,15 @@
 disp_field = disp_field_space.element(disp_func)
 
 # Show template and displacement field
-template.show('Template')
-disp_field.show('Displacement field')
+templ_space.show(template, 'Template')
+disp_field_space.show(disp_field, 'Displacement field')
 
 
 # --- Apply LinDeformFixedTempl, derivative and its adjoint --- #
 
 
 # Initialize the deformation operator with fixed template
-deform_op = odl.deform.LinDeformFixedTempl(template)
+deform_op = odl.deform.LinDeformFixedTempl(templ_space, template)
 
 # Apply the deformation operator to get the deformed template.
 deformed_template = deform_op(disp_field)
@@ -68,7 +68,10 @@
 deriv_adj_result = deform_op_deriv.adjoint(templ_space.one())
 
 # Show results
-deformed_template.show('Deformed template')
-deriv_result.show('Operator derivative applied to one()')
-deriv_adj_result.show('Adjoint of the derivative applied to one()',
-                      force_show=True)
+templ_space.show(deformed_template, 'Deformed template')
+templ_space.show(deriv_result, 'Operator derivative applied to one()')
+disp_field_space.show(
+    deriv_adj_result,
+    'Adjoint of the derivative applied to one()',
+    force_show=True,
+)