minor: small improvements to allow adding ABC to LinearOperator

Author: mrava87

examples/plot_sliding.py

@@ -145,7 +145,7 @@
 # This is because we have not inverted our operator but simply applied
 # the adjoint to estimate the representation of the input data in the Radon
 # domain. We can do better if we use the inverse instead.
-radoninv = pylops.aslinearoperator(Slid).div(data.ravel(), niter=10)
+radoninv = Slid.div(data.ravel(), niter=10)
 reconstructed_datainv = Slid * radoninv.ravel()
 
 radoninv = radoninv.reshape(dims)
@@ -288,7 +288,7 @@
 
 reconstructed_data = Slid * radon
 
-radoninv = pylops.aslinearoperator(Slid).div(data.ravel(), niter=10)
+radoninv = Slid.div(data.ravel(), niter=10)
 radoninv = radoninv.reshape(Slid.dims)
 reconstructed_datainv = Slid * radoninv
 

pylops/basicoperators/firstderivative.py

@@ -1,6 +1,6 @@
 __all__ = ["FirstDerivative"]
 
-from typing import Union
+from typing import Callable, Union
 
 import numpy as np
 from numpy.core.multiarray import normalize_axis_index
@@ -100,40 +100,41 @@ def __init__(
         self.kind = kind
         self.edge = edge
         self.order = order
+        self._register_multiplications(self.kind, self.order)
 
-    def _matvec(self, x: NDArray) -> NDArray:
-        if self.kind == "forward":
-            return self._matvec_forward(x)
-        elif self.kind == "backward":
-            return self._matvec_backward(x)
-        elif self.kind == "centered":
-            if self.order == 3:
-                return self._matvec_centered3(x)
-            elif self.order == 5:
-                return self._matvec_centered5(x)
+    def _register_multiplications(
+        self,
+        kind: str,
+        order: int,
+    ) -> None:
+        # choose _matvec and _rmatvec kind
+        self._hmatvec: Callable
+        self._hrmatvec: Callable
+        if kind == "forward":
+            self._hmatvec = self._matvec_forward
+            self._hrmatvec = self._rmatvec_forward
+        elif kind == "centered":
+            if order == 3:
+                self._hmatvec = self._matvec_centered3
+                self._hrmatvec = self._rmatvec_centered3
+            elif order == 5:
+                self._hmatvec = self._matvec_centered5
+                self._hrmatvec = self._rmatvec_centered5
             else:
                 raise NotImplementedError("'order' must be '3, or '5'")
+        elif kind == "backward":
+            self._hmatvec = self._matvec_backward
+            self._hrmatvec = self._rmatvec_backward
         else:
             raise NotImplementedError(
-                "'kind' must be 'forward', 'centered' or 'backward'"
+                "'kind' must be 'forward', 'centered', or 'backward'"
             )
 
+    def _matvec(self, x: NDArray) -> NDArray:
+        return self._hmatvec(x)
+
     def _rmatvec(self, x: NDArray) -> NDArray:
-        if self.kind == "forward":
-            return self._rmatvec_forward(x)
-        elif self.kind == "backward":
-            return self._rmatvec_backward(x)
-        elif self.kind == "centered":
-            if self.order == 3:
-                return self._rmatvec_centered3(x)
-            elif self.order == 5:
-                return self._rmatvec_centered5(x)
-            else:
-                raise NotImplementedError("'order' must be '3, or '5'")
-        else:
-            raise NotImplementedError(
-                "'kind' must be 'forward', 'centered' or 'backward'"
-            )
+        return self._hrmatvec(x)
 
     @reshaped(swapaxis=True)
     def _matvec_forward(self, x: NDArray) -> NDArray:

pylops/basicoperators/secondderivative.py

@@ -1,6 +1,6 @@
 __all__ = ["SecondDerivative"]
 
-from typing import Union
+from typing import Callable, Union
 
 import numpy as np
 from numpy.core.multiarray import normalize_axis_index
@@ -90,30 +90,34 @@ def __init__(
         self.sampling = sampling
         self.kind = kind
         self.edge = edge
+        self._register_multiplications(self.kind)
 
-    def _matvec(self, x: NDArray) -> NDArray:
-        if self.kind == "forward":
-            return self._matvec_forward(x)
-        elif self.kind == "backward":
-            return self._matvec_backward(x)
-        elif self.kind == "centered":
-            return self._matvec_centered(x)
+    def _register_multiplications(
+        self,
+        kind: str,
+    ) -> None:
+        # choose _matvec and _rmatvec kind
+        self._hmatvec: Callable
+        self._hrmatvec: Callable
+        if kind == "forward":
+            self._hmatvec = self._matvec_forward
+            self._hrmatvec = self._rmatvec_forward
+        elif kind == "centered":
+            self._hmatvec = self._matvec_centered
+            self._hrmatvec = self._rmatvec_centered
+        elif kind == "backward":
+            self._hmatvec = self._matvec_backward
+            self._hrmatvec = self._rmatvec_backward
         else:
             raise NotImplementedError(
                 "'kind' must be 'forward', 'centered' or 'backward'"
             )
 
+    def _matvec(self, x: NDArray) -> NDArray:
+        return self._hmatvec(x)
+
     def _rmatvec(self, x: NDArray) -> NDArray:
-        if self.kind == "forward":
-            return self._rmatvec_forward(x)
-        elif self.kind == "backward":
-            return self._rmatvec_backward(x)
-        elif self.kind == "centered":
-            return self._rmatvec_centered(x)
-        else:
-            raise NotImplementedError(
-                "'kind' must be 'forward', 'centered' or 'backward'"
-            )
+        return self._hrmatvec(x)
 
     @reshaped(swapaxis=True)
     def _matvec_forward(self, x: NDArray) -> NDArray:

pylops/linearoperator.py

@@ -5,9 +5,8 @@
     "aslinearoperator",
 ]
 
-from abc import ABCMeta, abstractmethod
-
 import logging
+from abc import ABC, abstractmethod
 
 import numpy as np
 import scipy as sp
@@ -41,7 +40,21 @@
 logging.basicConfig(format="%(levelname)s: %(message)s", level=logging.WARNING)
 
 
-class LinearOperator(metaclass=ABCMeta):
+class _LinearOperator(ABC):
+    """Meta-class for Linear operator"""
+
+    @abstractmethod
+    def _matvec(self, x: NDArray) -> NDArray:
+        """Matrix-vector multiplication handler."""
+        pass
+
+    @abstractmethod
+    def _rmatvec(self, x: NDArray) -> NDArray:
+        """Matrix-vector adjoint multiplication handler."""
+        pass
+
+
+class LinearOperator(_LinearOperator):
     """Common interface for performing matrix-vector products.
 
     This class acts as an abstract interface between matrix-like
@@ -369,13 +382,11 @@ def _copy_attributes(
             if hasattr(self, attr):
                 setattr(dest, attr, getattr(self, attr))
 
-    @abstractmethod
     def _matvec(self, x: NDArray) -> NDArray:
         """Matrix-vector multiplication handler."""
         if self.Op is not None:
             return self.Op._matvec(x)
 
-    @abstractmethod
     def _rmatvec(self, x: NDArray) -> NDArray:
         """Matrix-vector adjoint multiplication handler."""
         if self.Op is not None:
@@ -1482,3 +1493,5 @@ def aslinearoperator(Op: Union[spLinearOperator, LinearOperator]) -> LinearOpera
     """
     if isinstance(Op, LinearOperator):
         return Op
+    else:
+        return LinearOperator(Op)

pylops/signalprocessing/patch2d.py

@@ -264,14 +264,12 @@ def Patch2D(
             for win_in, win_end in zip(dwin0_ins, dwin0_ends)
         ]
     )
-    Pop = aslinearoperator(combining0 * combining1 * OOp)
+    Pop = combining0 * combining1 * OOp
     Pop.dims, Pop.dimsd = (
         nwins0,
         nwins1,
         int(dims[0] // nwins0),
         int(dims[1] // nwins1),
     ), dimsd
-    OOp.dims = Pop.dims
-    combining0.dimsd = Pop.dimsd
     Pop.name = name
     return Pop

pylops/signalprocessing/patch3d.py

@@ -443,7 +443,7 @@ def Patch3D(
         ]
     )
 
-    Pop = aslinearoperator(combining0 * combining1 * combining2 * OOp)
+    Pop = combining0 * combining1 * combining2 * OOp
     Pop.dims, Pop.dimsd = (
         nwins0,
         nwins1,
@@ -452,7 +452,5 @@ def Patch3D(
         int(dims[1] // nwins1),
         int(dims[2] // nwins2),
     ), dimsd
-    OOp.dims = Pop.dims
-    combining0.dimsd = Pop.dimsd
     Pop.name = name
     return Pop

pylops/signalprocessing/sliding1d.py

@@ -180,9 +180,7 @@ def Sliding1D(
             for win_in, win_end in zip(dwin_ins, dwin_ends)
         ]
     )
-    Sop = aslinearoperator(combining * OOp)
+    Sop = combining * OOp
     Sop.dims, Sop.dimsd = (nwins, int(dim[0] // nwins)), dimd
     Sop.name = name
-    OOp.dims = Sop.dims
-    combining.dimsd = Sop.dimsd
     return Sop

pylops/signalprocessing/sliding2d.py

@@ -216,7 +216,5 @@ def Sliding2D(
     )
     Sop = aslinearoperator(combining * OOp)
     Sop.dims, Sop.dimsd = (nwins, int(dims[0] // nwins), dims[1]), dimsd
-    OOp.dims = Sop.dims
-    combining.dimsd = Sop.dimsd
     Sop.name = name
     return Sop

pylops/signalprocessing/sliding3d.py

@@ -215,7 +215,7 @@ def Sliding3D(
             for win_in, win_end in zip(dwin0_ins, dwin0_ends)
         ]
     )
-    Sop = aslinearoperator(combining0 * combining1 * OOp)
+    Sop = combining0 * combining1 * OOp
     Sop.dims, Sop.dimsd = (
         nwins0,
         nwins1,
@@ -224,6 +224,4 @@ def Sliding3D(
         dims[2],
     ), dimsd
     Sop.name = name
-    combining0.dimsd = Sop.dimsd
-    OOp.dims = Sop.dims
     return Sop

pytests/test_linearoperator.py

@@ -71,7 +71,7 @@ def test_scaled(par):
 def test_scipyop(par):
     """Verify interaction between pylops and scipy Linear operators"""
 
-    class spDiag(LinearOperator):
+    class spDiag(spLinearOperator):
         def __init__(self, x):
             self.x = x
             self.shape = (len(x), len(x))