STY: mainly style updates in bregman functional and corresponding test.

Author: aringh

odl/solvers/functional/default_functionals.py

@@ -2476,11 +2476,11 @@ class BregmanDistance(Functional):
     Notes
     -----
     Given a functional :math:`f`, which has a (sub)gradient :math:`\partial f`,
-    and given a point :math:`y`, the Bregman distance functional :math:`D_f`
-    in a point :math:`x` is given by
+    and given a point :math:`y`, the Bregman distance functional
+    :math:`D_f(\cdot, y)` in a point :math:`x` is given by
 
     .. math::
-        D_f(x) = f(x) - f(y) - \langle \partial f(y), x - y \\rangle.
+        D_f(x, y) = f(x) - f(y) - \langle \partial f(y), x - y \\rangle.
 
 
     References
@@ -2503,7 +2503,7 @@ def __init__(self, functional, point, subgradient_op=None):
             optional argument `subgradient_op` is not given, the functional
             needs to implement `functional.gradient`.
         point : element of ``functional.domain``
-            The point from which to define the Bregman distance
+            The point from which to define the Bregman distance.
         subgradient_op : `Operator`, optional
             The operator that takes an element in `functional.domain` and
             returns a subgradient of the functional in that point.
@@ -2513,15 +2513,16 @@ def __init__(self, functional, point, subgradient_op=None):
         --------
         Example of initializing the Bregman distance functional:
 
-        >>> space = odl.uniform_discr(0, 2, 14)
+        >>> space = odl.uniform_discr(0, 1, 10)
         >>> l2_squared = odl.solvers.L2NormSquared(space)
         >>> point = space.one()
         >>> Bregman_dist = odl.solvers.BregmanDistance(l2_squared, point)
 
-        This is gives the shifted L2 norm squared ||x - 1||:
+        This is gives the shifted L2 norm squared ||x - 1||^2:
 
-        >>> Bregman_dist(space.zero())
-        2.0
+        >>> expected_value = l2_squared(space.one())
+        >>> Bregman_dist(space.zero()) == expected_value
+        True
         """
         if not isinstance(functional, Functional):
             raise TypeError('`functional` {} not an instance of ``Functional``'
@@ -2545,16 +2546,16 @@ def __init__(self, functional, point, subgradient_op=None):
                                           ''.format(functional))
         else:
             # Check that given subgradient is an operator that maps from the
-            # domain of the functional to the domain of the functional
+            # domain of the functional to itself
             if not isinstance(subgradient_op, Operator):
                 raise TypeError('`subgradient_op` {} is not an instance of '
                                 '``Operator``'.format(subgradient_op))
-            if not self.__functional.domain == subgradient_op.domain:
+            if not subgradient_op.domain == self.__functional.domain:
                 raise ValueError('`functional.domain` {} is not the same as '
                                  '`subgradient_op.domain` {}'
                                  ''.format(self.__functional.domain,
                                            subgradient_op.domain))
-            if not self.__functional.domain == subgradient_op.range:
+            if not subgradient_op.range == self.__functional.domain:
                 raise ValueError('`functional.domain` {} is not the same as '
                                  '`subgradient_op.range` {}'
                                  ''.format(self.__functional.domain,
@@ -2568,7 +2569,8 @@ def __init__(self, functional, point, subgradient_op=None):
 
         super(BregmanDistance, self).__init__(
             space=functional.domain, linear=False,
-            grad_lipschitz=self.__functional.grad_lipschitz)
+            grad_lipschitz=(self.__functional.grad_lipschitz +
+                            self.__subgrad_eval.norm()))
 
     @property
     def functional(self):
@@ -2606,11 +2608,9 @@ def gradient(self):
 
     def __repr__(self):
         '''Return ``repr(self)``.'''
-        return '{}({!r}, {!r}, {!r}, {!r})'.format(self.__class__.__name__,
-                                                   self.domain,
-                                                   self.functional,
-                                                   self.point,
-                                                   self.subgradient_op)
+        return '{}({!r}, {!r}, {!r})'.format(self.__class__.__name__,
+                                             self.functional, self.point,
+                                             self.subgradient_op)
 
 
 if __name__ == '__main__':

odl/test/solvers/functional/default_functionals_test.py

@@ -517,9 +517,12 @@ def test_moreau_envelope_l2_sq(space, sigma):
 
 
 def test_bregman_functional_no_gradient(space):
-    """Test that the Bregman distance functional fails if the underlying
+    """Test Bregman distance for functional without gradient.
+
+    Test that the Bregman distance functional fails if the underlying
     functional does not have a gradient and no subgradient operator is
-    given."""
+    given. Also test giving the subgradient operator separately.
+    """
 
     ind_func = odl.solvers.IndicatorNonnegativity(space)
     point = noise_element(space)
@@ -542,14 +545,12 @@ def test_bregman_functional_no_gradient(space):
 
 
 def test_bregman_functional_l2_squared(space, sigma):
-    """Test for the Bregman distance functional, using l2 norm squared as
-    underlying functional."""
+    """Test Bregman distance using l2 norm squared as underlying functional."""
     sigma = float(sigma)
 
     l2_sq = odl.solvers.L2NormSquared(space)
     point = noise_element(space)
-    subgrad_op = odl.ScalingOperator(space, 2.0)
-    bregman_dist = odl.solvers.BregmanDistance(l2_sq, point, subgrad_op)
+    bregman_dist = odl.solvers.BregmanDistance(l2_sq, point)
 
     expected_func = odl.solvers.L2NormSquared(space).translated(point)
 
@@ -559,7 +560,8 @@ def test_bregman_functional_l2_squared(space, sigma):
     assert all_almost_equal(bregman_dist(x), expected_func(x))
 
     # Gradient evaluation
-    assert all_almost_equal(bregman_dist(x), expected_func(x))
+    assert all_almost_equal(bregman_dist.gradient(x),
+                            expected_func.gradient(x))
 
     # Convex conjugate
     cc_bregman_dist = bregman_dist.convex_conj