feat: dims and dimsd for relevant signalprocessing operators

Author: cako

pylops/signalprocessing/Bilinear.py

@@ -84,8 +84,8 @@ def __init__(self, iava, dims, dtype="float64"):
 
         # define dimension of data
         ndims = len(dims)
-        self.dims = dims
-        self.dimsd = [len(iava[1])] + list(dims[2:])
+        self.dims = tuple(dims)
+        self.dimsd = tuple([len(iava[1])] + list(dims[2:]))
 
         # find indices and weights
         self.iava_t = ncp.floor(iava[0]).astype(int)

pylops/signalprocessing/Convolve1D.py

@@ -1,10 +1,9 @@
 import warnings
 
 import numpy as np
-from numpy.core.multiarray import normalize_axis_index
 
 from pylops import LinearOperator
-from pylops.utils._internal import _value_or_list_like_to_array
+from pylops.utils._internal import _value_or_list_like_to_tuple
 from pylops.utils.backend import (
     get_convolve,
     get_fftconvolve,
@@ -118,7 +117,7 @@ class Convolve1D(LinearOperator):
     """
 
     def __init__(self, dims, h, offset=0, axis=-1, dtype="float64", method=None):
-        self.dims = _value_or_list_like_to_array(dims)
+        self.dims = self.dimsd = _value_or_list_like_to_tuple(dims)
         self.axis = axis
 
         if offset > len(h) - 1:
@@ -149,7 +148,7 @@ def __init__(self, dims, h, offset=0, axis=-1, dtype="float64", method=None):
 
         # choose method and function handle
         self.convfunc, self.method = _choose_convfunc(h, method, self.dimsorig)
-        self.shape = (np.prod(self.dims), np.prod(self.dims))
+        self.shape = (np.prod(self.dimsd), np.prod(self.dims))
         self.dtype = np.dtype(dtype)
         self.explicit = False
 

pylops/signalprocessing/ConvolveND.py

@@ -4,7 +4,7 @@
 from numpy.core.multiarray import normalize_axis_index
 
 from pylops import LinearOperator
-from pylops.utils._internal import _value_or_list_like_to_array
+from pylops.utils._internal import _value_or_list_like_to_tuple
 from pylops.utils.backend import (
     get_array_module,
     get_convolve,
@@ -64,7 +64,7 @@ def __init__(
         dtype="float64",
     ):
         ncp = get_array_module(h)
-        self.dims = _value_or_list_like_to_array(dims)
+        self.dims = self.dimsd = _value_or_list_like_to_tuple(dims)
         self.axes = (
             np.arange(len(self.dims))
             if axes is None
@@ -106,7 +106,7 @@ def __init__(
         self.correlate = get_correlate(h)
         self.method = method
 
-        self.shape = (np.prod(self.dims), np.prod(self.dims))
+        self.shape = (np.prod(self.dimsd), np.prod(self.dims))
         self.dtype = np.dtype(dtype)
         self.explicit = False
 

pylops/signalprocessing/DWT.py

@@ -6,6 +6,7 @@
 
 from pylops import LinearOperator
 from pylops.basicoperators import Pad
+from pylops.utils._internal import _value_or_list_like_to_tuple
 
 try:
     import pywt
@@ -104,15 +105,16 @@ def __init__(self, dims, axis=-1, wavelet="haar", level=1, dtype="float64"):
         if isinstance(dims, int):
             dims = (dims,)
 
+        self.dims = _value_or_list_like_to_tuple(dims)
         # define padding for length to be power of 2
-        ndimpow2 = max(2 ** ceil(log(dims[axis], 2)), 2 ** level)
-        pad = [(0, 0)] * len(dims)
-        pad[axis] = (0, ndimpow2 - dims[axis])
-        self.pad = Pad(dims, pad)
-        self.dims = dims
+        ndimpow2 = max(2 ** ceil(log(self.dims[axis], 2)), 2 ** level)
+        pad = [(0, 0)] * len(self.dims)
+        pad[axis] = (0, ndimpow2 - self.dims[axis])
+        self.pad = Pad(self.dims, pad)
         self.axis = axis
-        self.dimsd = list(dims)
-        self.dimsd[self.axis] = ndimpow2
+        dimsd = list(self.dims)
+        dimsd[self.axis] = ndimpow2
+        self.dimsd = tuple(dimsd)
 
         # apply transform to find out slices
         _, self.sl = pywt.coeffs_to_array(
@@ -130,7 +132,8 @@ def __init__(self, dims, axis=-1, wavelet="haar", level=1, dtype="float64"):
         self.waveletadj = _adjointwavelet(wavelet)
         self.level = level
         self.reshape = True if len(self.dims) > 1 else False
-        self.shape = (int(np.prod(self.dimsd)), int(np.prod(self.dims)))
+
+        self.shape = (np.prod(self.dimsd), np.prod(self.dims))
         self.dtype = np.dtype(dtype)
         self.explicit = False
 

pylops/signalprocessing/DWT2D.py

@@ -80,17 +80,18 @@ def __init__(self, dims, axes=(-2, -1), wavelet="haar", level=1, dtype="float64"
             raise ModuleNotFoundError(pywt_message)
         _checkwavelet(wavelet)
 
+        self.dims = tuple(dims)
         # define padding for length to be power of 2
-        ndimpow2 = [max(2 ** ceil(log(dims[ax], 2)), 2 ** level) for ax in axes]
-        pad = [(0, 0)] * len(dims)
+        ndimpow2 = [max(2 ** ceil(log(self.dims[ax], 2)), 2 ** level) for ax in axes]
+        pad = [(0, 0)] * len(self.dims)
         for i, ax in enumerate(axes):
-            pad[ax] = (0, ndimpow2[i] - dims[ax])
-        self.pad = Pad(dims, pad)
-        self.dims = dims
+            pad[ax] = (0, ndimpow2[i] - self.dims[ax])
+        self.pad = Pad(self.dims, pad)
         self.axes = axes
-        self.dimsd = list(dims)
+        dimsd = list(self.dims)
         for i, ax in enumerate(axes):
-            self.dimsd[ax] = ndimpow2[i]
+            dimsd[ax] = ndimpow2[i]
+        self.dimsd = tuple(dimsd)
 
         # apply transform once again to find out slices
         _, self.sl = pywt.coeffs_to_array(
@@ -106,7 +107,8 @@ def __init__(self, dims, axes=(-2, -1), wavelet="haar", level=1, dtype="float64"
         self.wavelet = wavelet
         self.waveletadj = _adjointwavelet(wavelet)
         self.level = level
-        self.shape = (int(np.prod(self.dimsd)), int(np.prod(self.dims)))
+
+        self.shape = (np.prod(self.dimsd), np.prod(self.dims))
         self.dtype = np.dtype(dtype)
         self.explicit = False
 

pylops/signalprocessing/FFT.py

@@ -84,7 +84,7 @@ def _matvec(self, x):
         return y
 
     def _rmatvec(self, x):
-        x = np.reshape(x, self.dims_fft)
+        x = np.reshape(x, self.dimsd)
         if self.fftshift_after:
             x = np.fft.ifftshift(x, axes=self.axis)
         if self.real:
@@ -175,7 +175,7 @@ def _matvec(self, x):
         return y
 
     def _rmatvec(self, x):
-        x = np.reshape(x, self.dims_fft)
+        x = np.reshape(x, self.dimsd)
         if self.fftshift_after:
             x = scipy.fft.ifftshift(x, axes=self.axis)
         if self.real:
@@ -255,29 +255,30 @@ def __init__(
                 f"fftw backend returns complex128 dtype. To respect the passed dtype, data will be cast to {self.cdtype}."
             )
 
-        self.dims_t = self.dims.copy()
-        self.dims_t[self.axis] = self.nfft
+        dims_t = list(self.dims)
+        dims_t[self.axis] = self.nfft
+        self.dims_t = dims_t
 
         # define padding(fftw requires the user to provide padded input signal)
         self.pad = np.zeros((self.ndim, 2), dtype=int)
         if self.real:
             if self.nfft % 2:
                 self.pad[self.axis, 1] = (
-                    2 * (self.dims_fft[self.axis] - 1) + 1 - self.dims[self.axis]
+                    2 * (self.dimsd[self.axis] - 1) + 1 - self.dims[self.axis]
                 )
             else:
                 self.pad[self.axis, 1] = (
-                    2 * (self.dims_fft[self.axis] - 1) - self.dims[self.axis]
+                    2 * (self.dimsd[self.axis] - 1) - self.dims[self.axis]
                 )
         else:
-            self.pad[self.axis, 1] = self.dims_fft[self.axis] - self.dims[self.axis]
+            self.pad[self.axis, 1] = self.dimsd[self.axis] - self.dims[self.axis]
         self.dopad = True if np.sum(self.pad) > 0 else False
 
         # create empty arrays and plans for fft/ifft
         self.x = pyfftw.empty_aligned(
             self.dims_t, dtype=self.rdtype if real else self.cdtype
         )
-        self.y = pyfftw.empty_aligned(self.dims_fft, dtype=self.cdtype)
+        self.y = pyfftw.empty_aligned(self.dimsd, dtype=self.cdtype)
 
         # Use FFTW without norm-related keywords above. In this case, FFTW standard
         # behavior is to scale with 1/N on the inverse transform. The _scale below
@@ -327,7 +328,7 @@ def _matvec(self, x):
         return y.ravel()
 
     def _rmatvec(self, x):
-        x = np.reshape(x, self.dims_fft)
+        x = np.reshape(x, self.dimsd)
         if self.fftshift_after:
             x = np.fft.ifftshift(x, axes=self.axis)
 
@@ -479,10 +480,14 @@ def FFT(
 
     Attributes
     ----------
-    dims_fft : :obj:`tuple`
+    dimsd : :obj:`tuple`
         Shape of the array after the forward, but before linearization.
 
-        For example, ``y_reshaped = (Op * x.ravel()).reshape(Op.dims_fft)``.
+        For example, ``y_reshaped = (Op * x.ravel()).reshape(Op.dimsd)``.
+    dims_fft : :obj:`tuple`
+
+        .. deprecated:: 2.0.0
+            Use ``dimsd`` instead.
     f : :obj:`numpy.ndarray`
         Discrete Fourier Transform sample frequencies
     real : :obj:`bool`

pylops/signalprocessing/FFT2D.py

@@ -79,7 +79,7 @@ def _matvec(self, x):
         return y.ravel()
 
     def _rmatvec(self, x):
-        x = np.reshape(x, self.dims_fft)
+        x = np.reshape(x, self.dimsd)
         if self.fftshift_after.any():
             x = np.fft.ifftshift(x, axes=self.axes[self.fftshift_after])
         if self.real:
@@ -177,7 +177,7 @@ def _matvec(self, x):
         return y.ravel()
 
     def _rmatvec(self, x):
-        x = np.reshape(x, self.dims_fft)
+        x = np.reshape(x, self.dimsd)
         if self.fftshift_after.any():
             x = scipy.fft.ifftshift(x, axes=self.axes[self.fftshift_after])
         if self.real:
@@ -312,10 +312,14 @@ def FFT2D(
 
     Attributes
     ----------
-    dims_fft : :obj:`tuple`
+    dimsd : :obj:`tuple`
         Shape of the array after the forward, but before linearization.
 
-        For example, ``y_reshaped = (Op * x.ravel()).reshape(Op.dims_fft)``.
+        For example, ``y_reshaped = (Op * x.ravel()).reshape(Op.dimsd)``.
+    dims_fft : :obj:`tuple`
+
+        .. deprecated:: 2.0.0
+            Use ``dimsd`` instead.
     f1 : :obj:`numpy.ndarray`
         Discrete Fourier Transform sample frequencies along ``axes[0]``
     f2 : :obj:`numpy.ndarray`

pylops/signalprocessing/FFTND.py

@@ -70,7 +70,7 @@ def _matvec(self, x):
         return y.ravel()
 
     def _rmatvec(self, x):
-        x = np.reshape(x, self.dims_fft)
+        x = np.reshape(x, self.dimsd)
         if self.fftshift_after.any():
             x = np.fft.ifftshift(x, axes=self.axes[self.fftshift_after])
         if self.real:
@@ -158,7 +158,7 @@ def _matvec(self, x):
         return y.ravel()
 
     def _rmatvec(self, x):
-        x = np.reshape(x, self.dims_fft)
+        x = np.reshape(x, self.dimsd)
         if self.fftshift_after.any():
             x = scipy.fft.ifftshift(x, axes=self.axes[self.fftshift_after])
         if self.real:
@@ -301,10 +301,14 @@ def FFTND(
 
     Attributes
     ----------
-    dims_fft : :obj:`tuple`
+    dimsd : :obj:`tuple`
         Shape of the array after the forward, but before linearization.
 
-        For example, ``y_reshaped = (Op * x.ravel()).reshape(Op.dims_fft)``.
+        For example, ``y_reshaped = (Op * x.ravel()).reshape(Op.dimsd)``.
+    dims_fft : :obj:`tuple`
+
+        .. deprecated:: 2.0.0
+            Use ``dimsd`` instead.
     fs : :obj:`tuple`
         Each element of the tuple corresponds to the Discrete Fourier Transform
         sample frequencies along the respective direction given by ``axes``.

pylops/signalprocessing/Interp.py

@@ -5,7 +5,7 @@
 
 from pylops import LinearOperator
 from pylops.basicoperators import Diagonal, MatrixMult, Restriction, Transpose
-from pylops.utils._internal import _value_or_list_like_to_array
+from pylops.utils._internal import _value_or_list_like_to_tuple
 from pylops.utils.backend import get_array_module
 
 logging.basicConfig(format="%(levelname)s: %(message)s", level=logging.WARNING)
@@ -188,7 +188,7 @@ def Interp(dims, iava, axis=-1, kind="linear", dtype="float64"):
     :math:`i,j` possible combinations.
 
     """
-    dims = _value_or_list_like_to_array(dims)
+    dims = _value_or_list_like_to_tuple(dims)
 
     if kind == "nearest":
         interpop, iava = _nearestinterp(dims, iava, axis=axis, dtype=dtype)
@@ -198,4 +198,4 @@ def Interp(dims, iava, axis=-1, kind="linear", dtype="float64"):
         interpop = _sincinterp(dims, iava, axis=axis, dtype=dtype)
     else:
         raise NotImplementedError("kind is not correct...")
-    return LinearOperator(interpop), iava
+    return interpop, iava

pylops/signalprocessing/Seislet.py

@@ -386,17 +386,18 @@ def __init__(
             raise NotImplementedError("kind should be haar or linear")
 
         # define padding for length to be power of 2
-        dims = slopes.shape
-        ndimpow2 = 2 ** ceil(log(dims[0], 2))
-        pad = [(0, 0)] * len(dims)
-        pad[0] = (0, ndimpow2 - dims[0])
-        self.pad = Pad(dims, pad)
-        self.dims = list(dims)
-        self.dims[0] = ndimpow2
-        self.nx, self.nt = self.dims
+        self.dims = slopes.shape
+        dimsd = list(self.dims)
+        ndimpow2 = 2 ** ceil(log(dimsd[0], 2))
+        pad = [(0, 0)] * len(dimsd)
+        pad[0] = (0, ndimpow2 - dimsd[0])
+        self.pad = Pad(dimsd, pad)
+        dimsd[0] = ndimpow2
+        self.dimsd = dimsd
+        self.nx, self.nt = self.dimsd
 
         # define levels
-        nlevels_max = int(np.log2(self.dims[0]))
+        nlevels_max = int(np.log2(self.dimsd[0]))
         self.levels_size = np.flip(np.array([2 ** i for i in range(nlevels_max)]))
         if level is not None:
             self.levels_size = self.levels_size[:level]
@@ -408,15 +409,15 @@ def __init__(
         self.levels_cum = np.insert(self.levels_cum, 0, 0)
 
         self.dx, self.dt = sampling
-        self.slopes = (self.pad * slopes.ravel()).reshape(self.dims)
+        self.slopes = (self.pad * slopes.ravel()).reshape(self.dimsd)
         self.inv = inv
-        self.shape = (int(np.prod(self.slopes.size)), int(np.prod(slopes.size)))
+        self.shape = (int(np.prod(self.dimsd)), int(np.prod(self.dims)))
         self.dtype = np.dtype(dtype)
         self.explicit = False
 
     def _matvec(self, x):
         x = self.pad.matvec(x)
-        x = np.reshape(x, self.dims)
+        x = np.reshape(x, self.dimsd)
         y = np.zeros((np.sum(self.levels_size) + self.levels_size[-1], self.nt))
         for ilevel in range(self.level):
             odd = x[1::2]
@@ -437,7 +438,7 @@ def _matvec(self, x):
 
     def _rmatvec(self, x):
         if not self.inv:
-            x = np.reshape(x, self.dims)
+            x = np.reshape(x, self.dimsd)
             y = x[self.levels_cum[-1] :]
             for ilevel in range(self.level, 0, -1):
                 res = x[self.levels_cum[ilevel - 1] : self.levels_cum[ilevel]]
@@ -472,7 +473,7 @@ def _rmatvec(self, x):
         return y
 
     def inverse(self, x):
-        x = np.reshape(x, self.dims)
+        x = np.reshape(x, self.dimsd)
         y = x[self.levels_cum[-1] :]
         for ilevel in range(self.level, 0, -1):
             res = x[self.levels_cum[ilevel - 1] : self.levels_cum[ilevel]]