def __init__(self, alphas, control_points, discr_space, ft_kernel):
"""Initialize a new instance.
Parameters
----------
alphas : `ProductSpaceElement`
Displacement parameters in which the derivative is evaluated
control_points : `TensorGrid` or `array-like`
The points ``x_j`` controlling the deformation. They can
be given either as a tensor grid or as a point array. In
the latter case, its shape must be ``(N, n)``, where
``n`` is the dimension of the template space, and ``N``
the number of ``alpha_j``, i.e. the size of (each
component of) ``par_space``.
discr_space : `DiscreteSpace`
Space of the image grid of the template.
kernel : `callable`
Function to determine the kernel at the control points ``K(y_j)``
The function must accept a real variable and return a real number.
"""
super().__init__(alphas, control_points, discr_space, ft_kernel)
# Switch domain and range
self.discr_space = discr_space
self.range_space = ProductSpace(self.discr_space,
self.discr_space.ndim)
Operator.__init__(self, self.range_space, alphas.space, linear=True)
def __init__(self, space):
"""Operator that extracts the imaginary part of a vector.
Parameters
----------
space : `FnBase`
Space which imaginary part should be taken, needs to implement
``space.real_space``.
Examples
--------
Take the imaginary part of complex vector:
>>> c3 = odl.cn(3)
>>> op = ImagPart(c3)
>>> op([1 + 2j, 2, 3 - 1j])
rn(3).element([2.0, 0.0, -1.0])
The operator is the zero operator on real spaces:
>>> r3 = odl.rn(3)
>>> op = ImagPart(r3)
>>> op([1, 2, 3])
rn(3).element([0.0, 0.0, 0.0])
"""
real_space = space.real_space
linear = (space == real_space)
Operator.__init__(self, space, real_space, linear=linear)
def __init__(self, space):
"""Operator that extracts the imaginary part of a vector.
Parameters
----------
space : `FnBase`
Space which imaginary part should be taken, needs to implement
``space.real_space``.
Examples
--------
Take the imaginary part of complex vector:
>>> c3 = odl.cn(3)
>>> op = ImagPart(c3)
>>> op([1 + 2j, 2, 3 - 1j])
rn(3).element([2.0, 0.0, -1.0])
The operator is the zero operator on real spaces:
>>> r3 = odl.rn(3)
>>> op = ImagPart(r3)
>>> op([1, 2, 3])
rn(3).element([0.0, 0.0, 0.0])
"""
real_space = space.real_space
linear = (space == real_space)
Operator.__init__(self, space, real_space, linear=linear)
def __init__(self, space, linear=False, grad_lipschitz=np.nan):
"""Initialize a new instance.
Parameters
----------
space : `LinearSpace`
The domain of this functional, i.e., the set of elements to
which this functional can be applied.
linear : bool, optional
If `True`, the functional is considered as linear.
grad_lipschitz : float, optional
The Lipschitz constant of the gradient. Default: ``nan``
"""
Operator.__init__(self, domain=space, range=space.field, linear=linear)
self.__grad_lipschitz = float(grad_lipschitz)
def __init__(self, space, linear=False, grad_lipschitz=np.nan):
"""Initialize a new instance.
Parameters
----------
space : `LinearSpace`
The domain of this functional, i.e., the set of elements to
which this functional can be applied.
linear : bool, optional
If `True`, the functional is considered as linear.
grad_lipschitz : float, optional
The Lipschitz constant of the gradient. Default: ``nan``
"""
Operator.__init__(self, domain=space,
range=space.field, linear=linear)
self.__grad_lipschitz = float(grad_lipschitz)
def __init__(self, space, linear=False, grad_lipschitz=np.nan):
"""Initialize a new instance.
Parameters
----------
space : `LinearSpace`
The domain of this functional, i.e., the set of elements to
which this functional can be applied.
linear : bool, optional
If `True`, the functional is considered as linear.
grad_lipschitz : float, optional
The Lipschitz constant of the gradient. Default: ``nan``
"""
# Cannot use `super(Functional, self)` here since that breaks
# subclasses with multiple inheritance (at least those where both
# parents implement `__init__`, e.g., in `ScalingFunctional`)
Operator.__init__(self, domain=space, range=space.field, linear=linear)
self.__grad_lipschitz = float(grad_lipschitz)
def __init__(self, space, scalar=1):
"""Initialize a new instance.
Parameters
----------
space : `FnBase`
Space which real part should be taken, needs to implement
``space.complex_space``.
scalar : ``space.complex_space.field`` element, optional
Scalar which the incomming vectors should be multiplied by in order
to get the complex vector.
Examples
--------
Embed real vector into complex space:
>>> r3 = odl.rn(3)
>>> op = ComplexEmbedding(r3)
>>> op([1, 2, 3])
cn(3).element([(1+0j), (2+0j), (3+0j)])
Embed real vector as imaginary part into complex space:
>>> op = ComplexEmbedding(r3, scalar=1j)
>>> op([1, 2, 3])
cn(3).element([1j, 2j, 3j])
On complex spaces the operator is the same as simple multiplication by
scalar:
>>> c3 = odl.cn(3)
>>> op = ComplexEmbedding(c3, scalar=1 + 2j)
>>> op([1 + 1j, 2 + 2j, 3 + 3j])
cn(3).element([(-1+3j), (-2+6j), (-3+9j)])
"""
complex_space = space.complex_space
self.scalar = complex_space.field.element(scalar)
Operator.__init__(self, space, complex_space, linear=True)
def __init__(self, space, scalar=1):
"""Initialize a new instance.
Parameters
----------
space : `FnBase`
Space which real part should be taken, needs to implement
``space.complex_space``.
scalar : ``space.complex_space.field`` element, optional
Scalar which the incomming vectors should be multiplied by in order
to get the complex vector.
Examples
--------
Embed real vector into complex space:
>>> r3 = odl.rn(3)
>>> op = ComplexEmbedding(r3)
>>> op([1, 2, 3])
cn(3).element([(1+0j), (2+0j), (3+0j)])
Embed real vector as imaginary part into complex space:
>>> op = ComplexEmbedding(r3, scalar=1j)
>>> op([1, 2, 3])
cn(3).element([1j, 2j, 3j])
On complex spaces the operator is the same as simple multiplication by
scalar:
>>> c3 = odl.cn(3)
>>> op = ComplexEmbedding(c3, scalar=1 + 2j)
>>> op([1 + 1j, 2 + 2j, 3 + 3j])
cn(3).element([(-1+3j), (-2+6j), (-3+9j)])
"""
complex_space = space.complex_space
self.scalar = complex_space.field.element(scalar)
Operator.__init__(self, space, complex_space, linear=True)
def __init__(self, space):
"""Initialize a new instance.
Parameters
----------
space : `FnBase`
Space which real part should be taken, needs to implement
``space.real_space``.
Examples
--------
Take the real part of complex vector:
>>> c3 = odl.cn(3)
>>> op = RealPart(c3)
>>> op([1 + 2j, 2, 3 - 1j])
rn(3).element([1.0, 2.0, 3.0])
The operator is the identity on real spaces:
>>> r3 = odl.rn(3)
>>> op = RealPart(r3)
>>> op([1, 2, 3])
rn(3).element([1.0, 2.0, 3.0])
The operator also works on other `FnBase` spaces such as
`DiscreteLp` spaces:
>>> r3 = odl.uniform_discr(0, 1, 3, dtype=complex)
>>> op = RealPart(r3)
>>> op([1, 2, 3])
uniform_discr(0.0, 1.0, 3).element([1.0, 2.0, 3.0])
"""
real_space = space.real_space
linear = (space == real_space)
Operator.__init__(self, space, real_space, linear=linear)
def __init__(self, space):
"""Initialize a new instance.
Parameters
----------
space : `FnBase`
Space which real part should be taken, needs to implement
``space.real_space``.
Examples
--------
Take the real part of complex vector:
>>> c2 = odl.cn(2)
>>> op = odl.ComplexModulus(c2)
>>> op([3 + 4j, 2])
rn(2).element([5.0, 2.0])
The operator is the absolute value on real spaces:
>>> r2 = odl.rn(2)
>>> op = odl.ComplexModulus(r2)
>>> op([1, -2])
rn(2).element([1.0, 2.0])
The operator also works on other `FnBase` spaces such as
`DiscreteLp` spaces:
>>> r2 = odl.uniform_discr(0, 1, 2, dtype=complex)
>>> op = odl.ComplexModulus(r2)
>>> op([3 + 4j, 2])
uniform_discr(0.0, 1.0, 2).element([5.0, 2.0])
"""
real_space = space.real_space
linear = (space == real_space)
Operator.__init__(self, space, real_space, linear=linear)
def __init__(self, space):
"""Initialize a new instance.
Parameters
----------
space : `FnBase`
Space which real part should be taken, needs to implement
``space.real_space``.
Examples
--------
Take the real part of complex vector:
>>> c3 = odl.cn(3)
>>> op = RealPart(c3)
>>> op([1 + 2j, 2, 3 - 1j])
rn(3).element([1.0, 2.0, 3.0])
The operator is the identity on real spaces:
>>> r3 = odl.rn(3)
>>> op = RealPart(r3)
>>> op([1, 2, 3])
rn(3).element([1.0, 2.0, 3.0])
The operator also works on other `FnBase` spaces such as
`DiscreteLp` spaces:
>>> r3 = odl.uniform_discr(0, 1, 3, dtype=complex)
>>> op = RealPart(r3)
>>> op([1, 2, 3])
uniform_discr(0.0, 1.0, 3).element([1.0, 2.0, 3.0])
"""
real_space = space.real_space
linear = (space == real_space)
Operator.__init__(self, space, real_space, linear=linear)
def __init__(self, map_type, fset, partition, dspace, linear=False,
**kwargs):
"""Initialize a new instance.
Parameters
----------
map_type : {'sampling', 'interpolation'}
The type of operator
fset : `FunctionSet`
The non-discretized (abstract) set of functions to be
discretized
partition : `RectPartition`
Partition of (a subset of) ``fset.domain`` based on a
`TensorGrid`
dspace : `NtuplesBase`
Data space providing containers for the values of a
discretized object. Its `NtuplesBase.size` must be equal
to the total number of grid points.
linear : bool
Create a linear operator if `True`, otherwise a non-linear
operator.
order : {'C', 'F'}, optional
Ordering of the axes in the data storage. 'C' means the
first axis varies slowest, the last axis fastest;
vice versa for 'F'.
Default: 'C'
"""
map_type_ = str(map_type).lower()
if map_type_ not in ('sampling', 'interpolation'):
raise ValueError('mapping type {!r} not understood.'
''.format(map_type))
if not isinstance(fset, FunctionSet):
raise TypeError('function set {!r} is not a `FunctionSet` '
'instance.'.format(fset))
if not isinstance(partition, RectPartition):
raise TypeError('grid {!r} is not a `TensorGrid` instance.'
''.format(partition))
if not isinstance(dspace, NtuplesBase):
raise TypeError('data space {!r} is not an `NtuplesBase` instance.'
''.format(dspace))
if not fset.domain.contains_set(partition):
raise ValueError('{} not contained in the domain {} '
'of the function set {}.'
''.format(partition, fset.domain, fset))
if dspace.size != partition.size:
raise ValueError('size {} of the data space {} not equal '
'to the size {} of the partition.'
''.format(dspace.size, dspace, partition.size))
dom = fset if map_type_ == 'sampling' else dspace
ran = dspace if map_type_ == 'sampling' else fset
Operator.__init__(self, dom, ran, linear=linear)
self._partition = partition
if self.is_linear:
if not isinstance(fset, FunctionSpace):
raise TypeError('function space {!r} is not a `FunctionSpace` '
'instance.'.format(fset))
if not isinstance(dspace, FnBase):
raise TypeError('data space {!r} is not an `FnBase` instance.'
''.format(dspace))
if fset.field != dspace.field:
raise ValueError('field {} of the function space and field '
'{} of the data space are not equal.'
''.format(fset.field, dspace.field))
order = str(kwargs.pop('order', 'C'))
if str(order).upper() not in ('C', 'F'):
raise ValueError('order {!r} not recognized.'.format(order))
else:
self._order = str(order).upper()
def __init__(self, space, index):
""" Initialize and instance."""
self.index = int(index)
Operator.__init__(self, space, space.field, True)
def __init__(self, map_type, fset, grid, dspace, order="C", linear=False):
"""Initialize a new instance.
Parameters
----------
map_type : {'restriction', 'extension'}
The type of operator
fset : `FunctionSet`
The undiscretized (abstract) set of functions to be
discretized
grid : `TensorGrid`
The grid on which to evaluate. Must be contained in
the common domain of the function set.
dspace : `NtuplesBase`
Data space providing containers for the values of a
discretized object. Its `NtuplesBase.size` must be equal
to the total number of grid points.
order : {'C', 'F'}, optional
Ordering of the values in the flat data arrays. 'C'
means the first grid axis varies slowest, the last fastest,
'F' vice versa.
linear : bool
Create a linear operator if `True`, otherwise a non-linear
operator.
"""
map_type_ = str(map_type).lower()
if map_type_ not in ("restriction", "extension"):
raise ValueError("mapping type {!r} not understood." "".format(map_type))
if not isinstance(fset, FunctionSet):
raise TypeError("function set {!r} is not a `FunctionSet` " "instance.".format(fset))
if not isinstance(grid, TensorGrid):
raise TypeError("grid {!r} is not a `TensorGrid` instance." "".format(grid))
if not isinstance(dspace, NtuplesBase):
raise TypeError("data space {!r} is not an `NtuplesBase` instance." "".format(dspace))
# TODO: this method is expected to exist, which is the case for
# interval products. It could be a general optional `Set` method
if not fset.domain.contains_set(grid):
raise ValueError(
"grid {} not contained in the domain {} of the " "function set {}.".format(grid, fset.domain, fset)
)
if dspace.size != grid.ntotal:
raise ValueError(
"size {} of the data space {} not equal "
"to the total number {} of grid points."
"".format(dspace.size, dspace, grid.ntotal)
)
self._order = str(order).upper()
if self.order not in ("C", "F"):
raise ValueError("ordering {!r} not understood.".format(order))
dom = fset if map_type_ == "restriction" else dspace
ran = dspace if map_type_ == "restriction" else fset
Operator.__init__(self, dom, ran, linear=linear)
self._grid = grid
if self.is_linear:
if not isinstance(fset, FunctionSpace):
raise TypeError("function space {!r} is not a `FunctionSpace` " "instance.".format(fset))
if not isinstance(dspace, FnBase):
raise TypeError("data space {!r} is not an `FnBase` instance." "".format(dspace))
if fset.field != dspace.field:
raise ValueError(
"field {} of the function space and field "
"{} of the data space are not equal."
"".format(fset.field, dspace.field)
)
