Refactor proximal application function name

Signed-off-by: Nicola VIGANÒ <nicola.vigano@cea.fr>

Author: Obi-Wan

src/corrct/data_terms.py

@@ -234,7 +234,7 @@ def update_dual(self, dual: NDArrayFloat, proj_primal: NDArrayFloat) -> None:
             dual += (proj_primal + self.background) * self.sigma
 
     @abstractmethod
-    def apply_proximal(self, dual: NDArrayFloat) -> None:
+    def apply_proximal_dual(self, dual: NDArrayFloat) -> None:
         """Apply the proximal in the dual domain.
 
         Parameters
@@ -283,7 +283,7 @@ def assign_data(self, data: float | NDArrayFloat | None = None, sigma: float | N
     def compute_residual_norm(self, dual: NDArrayFloat) -> float:
         return float(np.linalg.norm(dual.flatten(), ord=2) ** 2)
 
-    def apply_proximal(self, dual: NDArrayFloat) -> None:
+    def apply_proximal_dual(self, dual: NDArrayFloat) -> None:
         if self.data is not None and self.sigma_data is not None:
             dual -= self.sigma_data
         dual *= self.sigma1
@@ -364,7 +364,7 @@ def compute_residual(self, proj_primal: NDArrayFloat, mask: NDArrayFloat | None
         _soft_threshold(residual, self.sigma_sqrt_error)
         return residual
 
-    def apply_proximal(self, dual: NDArrayFloat) -> None:
+    def apply_proximal_dual(self, dual: NDArrayFloat) -> None:
         if self.data is not None and self.sigma_data is not None:
             dual -= self.sigma_data
         _soft_threshold(dual, self.sigma_sqrt_error)
@@ -401,7 +401,7 @@ def compute_residual_norm(self, dual):
         l1_points = 1 - l2_points
         return np.linalg.norm(dual[l2_points].flatten(), ord=2) ** 2 + np.linalg.norm(dual[l1_points].flatten(), ord=1)
 
-    def apply_proximal(self, dual):
+    def apply_proximal_dual(self, dual):
         if self.data is not None and self.sigma_data is not None:
             dual -= self.sigma_data
 
@@ -437,7 +437,7 @@ def _get_inner_norm(self, dual):
     def _apply_threshold(self, dual):
         pass
 
-    def apply_proximal(self, dual, weight=1.0):
+    def apply_proximal_dual(self, dual, weight=1.0):
         if self.data is not None:
             dual -= self.sigma_data
         self._apply_threshold(dual)
@@ -505,7 +505,7 @@ def _compute_sigma_data(self):
         else:
             return 4 * self.sigma * np.fmax(self.data, 0.0)
 
-    def apply_proximal(self, dual):
+    def apply_proximal_dual(self, dual):
         if self.sigma_data is not None:
             dual[:] = (1 + dual[:] - np.sqrt((dual[:] - 1) ** 2 + self.sigma_data[:])) / 2
         else:
@@ -517,7 +517,7 @@ def compute_residual(self, proj_primal, mask=None):
         # we take the Moreau envelope here, and apply the proximal to it
         residual = np.fmax(proj_primal, eps) * self.sigma
 
-        self.apply_proximal(residual)
+        self.apply_proximal_dual(residual)
 
         if mask is not None:
             residual *= mask
@@ -553,7 +553,7 @@ def __init__(self, background=None, ln_axes: Sequence[int] = (1, -1), spectral_n
         self.spectral_norm = spectral_norm
         self.use_fallback = False
 
-    def apply_proximal(self, dual):
+    def apply_proximal_dual(self, dual):
         dual_tmp = dual.copy()
 
         if self.sigma_data is not None:
@@ -569,15 +569,15 @@ def apply_proximal(self, dual):
 
             U, s_p, Vt = np.linalg.svd(dual_tmp, full_matrices=False)
 
-            self.spectral_norm.apply_proximal(s_p)
+            self.spectral_norm.apply_proximal_dual(s_p)
 
             dual_tmp = np.matmul(U, s_p[..., None] * Vt)
             dual_tmp = np.transpose(dual_tmp, np.argsort(t_range))
         else:
             op_svd = operators.TransformSVD(dual_tmp.shape, axes_rows=self.ln_axes[0], axes_cols=self.ln_axes[1])
             s_p = op_svd(dual_tmp)
 
-            self.spectral_norm.apply_proximal(s_p)
+            self.spectral_norm.apply_proximal_dual(s_p)
 
             dual_tmp = op_svd.T(s_p)
 

src/corrct/regularizers.py

@@ -147,7 +147,7 @@ def update_dual(self, dual: NDArray, primal: NDArray) -> None:
 
         dual += self.sigma * self.op(primal)
 
-    def apply_proximal(self, dual: NDArray) -> None:
+    def apply_proximal_dual(self, dual: NDArray) -> None:
         """
         Apply the proximal operator to the dual in-place.
 
@@ -157,9 +157,9 @@ def apply_proximal(self, dual: NDArray) -> None:
             The dual to be applied the proximal on.
         """
         if isinstance(self.norm, dt.DataFidelity_l1):
-            self.norm.apply_proximal(dual, self.weight)
+            self.norm.apply_proximal_dual(dual, self.weight)
         else:
-            self.norm.apply_proximal(dual)
+            self.norm.apply_proximal_dual(dual)
 
     def compute_update_primal(self, dual: NDArray) -> NDArray:
         """
@@ -612,15 +612,15 @@ def update_dual(self, dual: NDArray, primal: NDArray) -> None:
         if not self.min_approx:
             dual[0, ...] = 0
 
-    def apply_proximal(self, dual: NDArray) -> None:
+    def apply_proximal_dual(self, dual: NDArray) -> None:
         if isinstance(self.norm, dt.DataFidelity_l12):
             tmp_dual = dual[1:]
             tmp_dual = tmp_dual.reshape([-1, self.level, *dual.shape[1:]])
-            self.norm.apply_proximal(tmp_dual, self.weight)
+            self.norm.apply_proximal_dual(tmp_dual, self.weight)
             tmp_dual = dual[0:1:]
-            self.norm.apply_proximal(tmp_dual, self.weight)
+            self.norm.apply_proximal_dual(tmp_dual, self.weight)
         else:
-            super().apply_proximal(dual)
+            super().apply_proximal_dual(dual)
 
 
 class Regularizer_l1swl(Regularizer_swl):
@@ -818,7 +818,7 @@ def update_dual(self, dual: NDArray, primal: NDArray) -> None:
             slices = [slice(0, x) for x in op_wl.sub_band_shapes[0]]
             dual[tuple(slices)] = 0
 
-    def apply_proximal(self, dual: NDArray) -> None:
+    def apply_proximal_dual(self, dual: NDArray) -> None:
         if isinstance(self.norm, dt.DataFidelity_l12):
             op_wl: operators.TransformDecimatedWavelet = self.op
             coeffs = pywt.array_to_coeffs(dual, op_wl.slicing_info)
@@ -830,14 +830,14 @@ def apply_proximal(self, dual: NDArray) -> None:
                     labels.append(lab)
                     details.append(det)
                 c_ll = np.stack(details, axis=0)
-                self.norm.apply_proximal(c_ll, self.weight)
+                self.norm.apply_proximal_dual(c_ll, self.weight)
                 for ii, lab in enumerate(labels):
                     c_l[lab] = c_ll[ii]
                 coeffs[ii_l] = c_l
-            self.norm.apply_proximal(coeffs[0], self.weight)
+            self.norm.apply_proximal_dual(coeffs[0], self.weight)
             dual[:] = pywt.coeffs_to_array(coeffs)[0]
         else:
-            super().apply_proximal(dual)
+            super().apply_proximal_dual(dual)
 
 
 class Regularizer_l1dwl(Regularizer_dwl):
@@ -1130,7 +1130,7 @@ def _raise_pwise_norm_error(self):
             + f" Provided the following instead: derivatives={self.pwise_der_norm}, channel={self.pwise_chan_norm}"
         )
 
-    def apply_proximal(self, dual: NDArray) -> None:
+    def apply_proximal_dual(self, dual: NDArray) -> None:
         # Following assignments will detach the local array from the original one
         dual_tmp = dual.copy()
 
@@ -1281,7 +1281,7 @@ def initialize_sigma_tau(self, primal: NDArray) -> float | NDArray:
 
         return tau
 
-    def apply_proximal(self, dual: NDArray) -> None:
+    def apply_proximal_dual(self, dual: NDArray) -> None:
         dual_tmp = dual.copy()
 
         if self.q_ref is not None:
@@ -1405,9 +1405,9 @@ def initialize_sigma_tau(self, primal: NDArray) -> float | NDArray:
     def update_dual(self, dual: NDArray, primal: NDArray) -> None:
         dual += primal - self.limit
 
-    def apply_proximal(self, dual: NDArray) -> None:
+    def apply_proximal_dual(self, dual: NDArray) -> None:
         dual[dual > 0.0] = 0.0
-        self.norm.apply_proximal(dual)
+        self.norm.apply_proximal_dual(dual)
 
 
 class Constraint_UpperLimit(BaseRegularizer):
@@ -1453,6 +1453,6 @@ def initialize_sigma_tau(self, primal: NDArray) -> float | NDArray:
     def update_dual(self, dual: NDArray, primal: NDArray) -> None:
         dual += primal - self.limit
 
-    def apply_proximal(self, dual: NDArray) -> None:
+    def apply_proximal_dual(self, dual: NDArray) -> None:
         dual[dual < 0.0] = 0.0
-        self.norm.apply_proximal(dual)
+        self.norm.apply_proximal_dual(dual)

src/corrct/solvers.py

@@ -840,7 +840,7 @@ def __call__(  # noqa: C901
             q = [reg.initialize_dual() for reg in self.regularizer]
             for q_r, reg in zip(q, self.regularizer):
                 reg.update_dual(q_r, x)
-                reg.apply_proximal(q_r)
+                reg.apply_proximal_dual(q_r)
 
             upd = A.T(res * sigma)
             for q_r, reg in zip(q, self.regularizer):
@@ -1093,14 +1093,14 @@ def __call__(  # noqa: C901
 
             Ax_rlx = A(x_relax)
             self.data_term.update_dual(p, Ax_rlx)
-            self.data_term.apply_proximal(p)
+            self.data_term.apply_proximal_dual(p)
 
             if b_mask is not None:
                 p *= b_mask
 
             for q_r, reg in zip(q, self.regularizer):
                 reg.update_dual(q_r, x_relax)
-                reg.apply_proximal(q_r)
+                reg.apply_proximal_dual(q_r)
 
             upd = A.T(p)
             for q_r, reg in zip(q, self.regularizer):

tests/test_regularizers.py

@@ -45,12 +45,12 @@ def _test_Regularizer_l1(self, vol):
 
         dual += weight / 2
         copy_dual = dual.copy()
-        reg.apply_proximal(dual)
+        reg.apply_proximal_dual(dual)
         assert np.all(np.isclose(dual, np.fmin(weight, copy_dual)))
 
         dual = copy_dual - weight * 2
         copy_dual = dual.copy()
-        reg.apply_proximal(dual)
+        reg.apply_proximal_dual(dual)
         assert np.all(np.isclose(dual, np.fmax(-weight, copy_dual)))
 
         upd = reg.compute_update_primal(dual)
@@ -78,7 +78,7 @@ def _test_Regularizer_l1swl(self, vol):
         assert np.all(np.isclose(upd, reg.op.T(dual)))
 
         copy_dual = dual.copy()
-        reg.apply_proximal(dual)
+        reg.apply_proximal_dual(dual)
         assert np.all(np.isclose(dual, np.fmax(np.fmin(weight, copy_dual), -weight)))
 
     def _test_Regularizer_TV(self, vol):