def __init__(self, func, scalar):
"""Initialize a new instance.
Parameters
----------
func : `Functional`
Functional to which the scalar is added.
scalar : `element` in the `field` of the ``domain``
The scalar to be added to the functional. The `field` of the
``domain`` is the range of the functional.
"""
from odl.solvers.functional.default_functionals import (
ConstantFunctional)
if not isinstance(func, Functional):
raise TypeError('`fun` {!r} is not a `Functional` instance'
''.format(func))
if scalar not in func.range:
raise TypeError('`scalar` {} is not in the range of '
'`func` {!r}'.format(scalar, func))
FunctionalSum.__init__(self,
left=func,
right=ConstantFunctional(space=func.domain,
constant=scalar))
def __mul__(self, other):
"""Return ``self * other``.
If ``other`` is an `Operator`, this corresponds to composition with the
operator:
``(func * op)(x) == func(op(x))``
If ``other`` is a scalar, this corresponds to right multiplication of
scalars with functionals:
``(func * scalar)(x) == func(scalar * x)``
If ``other`` is a vector, this corresponds to right multiplication of
vectors with functionals:
``(func * vector) == func(vector * x)``
Note that left and right multiplications are generally different.
Parameters
----------
other : `Operator`, `domain` element or scalar
`Operator`:
The `Operator.range` of ``other`` must match this functional's
`domain`.
`domain` element:
``other`` must be an element of this functionals's
`Functional.domain`.
scalar:
The `domain` of this functional must be a
`LinearSpace` and ``other`` must be an element of the `field`
of this functional's `domain`. Note that this `field` is also this
functional's `range`.
Returns
-------
mul : `Functional`
Multiplication result.
If ``other`` is an `Operator`, ``mul`` is a
`FunctionalComp`.
If ``other`` is a scalar, ``mul`` is a
`FunctionalRightScalarMult`.
If ``other`` is a vector, ``mul`` is a
`FunctionalRightVectorMult`.
"""
if isinstance(other, Operator):
return FunctionalComp(self, other)
elif other in self.range:
# Left multiplication is more efficient, so we can use this in the
# case of linear functional.
if other == 0:
from odl.solvers.functional.default_functionals import (
ConstantFunctional)
return ConstantFunctional(self.domain,
self(self.domain.zero()))
elif self.is_linear:
return FunctionalLeftScalarMult(self, other)
else:
return FunctionalRightScalarMult(self, other)
elif other in self.domain:
return FunctionalRightVectorMult(self, other)
else:
return super().__mul__(other)