Issue 59 coerce

odl/__init__.py

@@ -33,26 +33,23 @@
 # Propagate names defined in __all__ of all submodules into the top-level
 # module
 
-from . import diagnostics
-
-from . import discr
-from .discr import *
-__all__ += discr.__all__
+# Import modules in order of dependency
+from . import set
+from .set import *
+__all__ += set.__all__
 
 from . import operator
 from .operator import *
 __all__ += operator.__all__
 
-from . import set
-from .set import *
-__all__ += set.__all__
-
 from . import space
 from .space import *
 __all__ += space.__all__
 
-from . import trafos
-from .trafos import *
-__all__ += trafos.__all__
+from . import discr
+from .discr import *
+__all__ += discr.__all__
 
+from . import trafos
+from . import diagnostics
 from . import solvers

odl/discr/discretization.py

@@ -270,7 +270,7 @@ def copy(self):
         """Create an identical (deep) copy of this vector."""
         return self.space.element(self.ntuple.copy())
 
-    def asarray(self, out=None):
+    def asarray(self, *args, **kwargs):
         """Extract the data of this array as a numpy array.
 
         Parameters
@@ -279,7 +279,7 @@ def asarray(self, out=None):
             Array in which the result should be written in-place.
             Has to be contiguous and of the correct dtype.
         """
-        return self.ntuple.asarray(out=out)
+        return self.ntuple.asarray(*args, **kwargs)
 
     def __eq__(self, other):
         """``vec.__eq__(other) <==> vec == other``.

odl/discr/lp_discr.py

@@ -149,7 +149,7 @@ def element(self, inp=None):
             if arr.ndim > 1 and arr.shape != self.grid.shape:
                 raise ValueError('input shape {} does not match grid shape {}'
                                  ''.format(arr.shape, self.grid.shape))
-            arr = arr.flatten(order=self.order)
+            arr = arr.ravel(order=self.order)
             return self.element_type(self, self.dspace.element(arr))
 
     @property
@@ -229,14 +229,25 @@ class DiscreteLpVector(DiscretizationVector):
     """Representation of a `DiscreteLp` element."""
 
     def asarray(self, out=None):
-        """Extract the data of this array as a numpy array.
+        """Extract the data of this vector as a numpy array.
 
         Parameters
         ----------
         out : `numpy.ndarray`, optional
             Array in which the result should be written in-place.
             Has to be contiguous and of the correct dtype and
             shape.
+
+        Returns
+        -------
+        out : `numpy.ndarray`
+            This vector as an array, if ``out`` parameter was given, they are
+            equal.
+
+        See also
+        --------
+        asflatarray
+        FnBaseVector.asarray
         """
         if out is None:
             return super().asarray().reshape(self.space.grid.shape,
@@ -266,14 +277,49 @@ def asarray(self, out=None):
             super().asarray(out=out.ravel(order=self.space.order))
             return out
 
+    def asflatarray(self, *args, **kwargs):
+        """Extract the data of this vector as a 1d numpy array.
+
+        Parameters
+        ----------
+        out : `numpy.ndarray`, optional
+            Array in which the result should be written in-place.
+            Has to be contiguous and of the correct dtype.
+
+        Returns
+        -------
+        out : `numpy.ndarray`
+            This vector as an array, if ``out`` parameter was given, they are
+            equal.
+
+        See also
+        --------
+        asarray
+        FnBaseVector.asflatarray
+        """
+        return super().asarray(*args, **kwargs)
+
     @property
     def ndim(self):
-        """Number of dimensions."""
+        """Number of dimensions.
+
+        See also
+        --------
+        TensorGrid.ndim
+        """
         return self.space.grid.ndim
 
     @property
     def shape(self):
-        # override shape
+        """Size in each dimension
+
+        For example, a 3d space can have size (3, 5, 10), indicating that it
+        is 3 elements big in the "x" direction, 5 in the "y" and "10" in the z.
+
+        See also
+        --------
+        TensorGrid.shape
+        """
         return self.space.grid.shape
 
     def __setitem__(self, indices, values):

odl/operator/__init__.py

@@ -33,3 +33,7 @@
 from . import pspace_ops
 from .pspace_ops import *
 __all__ += pspace_ops.__all__
+
+from . import embedding
+from .embedding import *
+__all__ += embedding.__all__

odl/operator/embedding.py

@@ -0,0 +1,133 @@
+# Copyright 2014, 2015 Jonas Adler
+#
+# This file is part of ODL.
+#
+# ODL is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ODL is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with ODL.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Operators to cast between spaces."""
+
+# Imports for common Python 2/3 codebase
+from __future__ import print_function, division, absolute_import
+from future import standard_library
+standard_library.install_aliases()
+from builtins import super
+
+from odl.space.base_ntuples import FnBase
+from odl.discr.lp_discr import DiscreteLp
+from odl.set.pspace import ProductSpace
+from odl.operator.operator import Operator
+
+__all__ = ('Embedding', 'EmbeddingFnInFn', 'EmbeddingPowerSpaceInFn',
+           'EmbeddingFnInPowerSpace')
+
+
+class Embedding(Operator):
+    """An operators to cast between spaces."""
+
+    # TODO: is this needed?
+
+    def __init__(self, origin, target):
+        super().__init__(origin, target)
+
+
+class EmbeddingFnInFn(Embedding):
+    """ Embed a `FnBase` space into another """
+
+    def __init__(self, origin, target):
+        assert isinstance(origin, FnBase)
+        assert isinstance(target, FnBase)
+
+        super().__init__(origin, target)
+
+    def _apply(self, x, out):
+        out[:] = x.asflatarray()
+
+    def _call(self, x):
+        return self.range.element(x.asflatarray())
+
+    @property
+    def adjoint(self):
+        return EmbeddingFnInFn(self.range, self.domain)
+
+
+class EmbeddingDiscreteLpInDiscreteLp(Embedding):
+    """ Embed a `DiscreteLp` space into another """
+
+    def __init__(self, origin, target):
+        assert isinstance(origin, DiscreteLp)
+        assert isinstance(target, DiscreteLp)
+        assert origin.grid.shape == target.grid.shape
+
+        super().__init__(origin, target)
+
+    def _apply(self, x, out):
+        out[:] = x.asarray()
+
+    def _call(self, x):
+        return self.range.element(x.asarray())
+
+    @property
+    def adjoint(self):
+        return EmbeddingDiscreteLpInDiscreteLp(self.range, self.domain)
+
+
+class EmbeddingPowerSpaceInFn(Embedding):
+    """ Embed a `PowerSpace` of `FnBase` space into a `FnBase` """
+
+    def __init__(self, origin, target):
+        # TODO: tests goes here
+
+        super().__init__(origin, target)
+
+    def _apply(self, x, out):
+        out[:] = x.asflatarray()
+
+    def _call(self, x):
+        return self.range.element(x.asflatarray())
+
+    @property
+    def adjoint(self):
+        return EmbeddingFnInPowerSpace(self.range, self.domain)
+
+
+class EmbeddingFnInPowerSpace(Embedding):
+    """ Embed a `FnBase` into `PowerSpace` of `FnBase`'s"""
+
+    def __init__(self, origin, target):
+        # TODO: tests goes here
+
+        super().__init__(origin, target)
+
+    def _apply(self, x, out):
+        index = 0
+        for sub_vec in out:
+            sub_vec[:] = x.asflatarray(index, index + sub_vec.size)
+            index += sub_vec.size
+
+    def _call(self, x):
+        out = self.range.element()
+        index = 0
+        for sub_vec in out:
+            sub_vec[:] = x.asflatarray(index, index + sub_vec.size)
+            index += sub_vec.size
+        return out
+
+    @property
+    def adjoint(self):
+        return EmbeddingPowerSpaceInFn(self.range, self.domain)
+
+
+if __name__ == '__main__':
+    from doctest import testmod, NORMALIZE_WHITESPACE
+    testmod(optionflags=NORMALIZE_WHITESPACE)