Merge pull request #332 from cako/patch-N-dims

Patch `N`/`dims`

Author: mrava87

MIGRATION_V1_V2.md

@@ -1,12 +1,10 @@
-# Migrating PyLops codes from V1 to V2
+# Migrating PyLops code from v1.x to v2.0
 
 This file is intended to guide users willing to convert their codes from PyLops v1 to PyLops v2.
 
 In the following we provide a detailed description of all the breaking changes introduced in v2, which
 should be used as a checklist when converting a piece of code using PyLops from v1 to v2.
 
-- XX
-- XX
-- XX
-
+- Several operators have deprecated `N` as a keyword. To migrate, pass only `dims` if both `N` and `dims` are currently being passed.
+If only `N` is being passed, ensure it is being passed as a value and not a keyword argument (e.g., change `Flip(N=100)` to `Flip(100)`).
 - `utils.dottest`: The relative tolerance is new set via `rtol` (before `tol`), and absolute tolerance is new supported via the keyword `atol`. When calling it with purely positional arguments, note that after `rtol` comes now first `atol` before `complexflag`. When using `raiseerror=True` it now emits an `AttributeError` instead of a `ValueError`.

examples/plot_causalintegration.py

@@ -112,16 +112,14 @@
 t = np.arange(nt) * dt + ot
 x = np.outer(np.sin(t), np.ones(nx))
 
-Cop = pylops.CausalIntegration(
-    nt * nx, dims=(nt, nx), sampling=dt, dir=0, halfcurrent=True
-)
+Cop = pylops.CausalIntegration((nt, nx), sampling=dt, dir=0, halfcurrent=True)
 
 y = Cop * x.ravel()
 y = y.reshape(nt, nx)
 yn = y + np.random.normal(0, 4e-1, y.shape)
 
 # Numerical derivative
-Dop = pylops.FirstDerivative(nt * nx, dims=(nt, nx), dir=0, sampling=dt)
+Dop = pylops.FirstDerivative((nt, nx), dir=0, sampling=dt)
 xder = Dop * yn.ravel()
 xder = xder.reshape(nt, nx)
 

examples/plot_convolve.py

@@ -92,10 +92,9 @@
 h = np.ones((nh[0], nh[1]))
 
 Cop = pylops.signalprocessing.Convolve2D(
-    nt * nx,
+    (nt, nx),
     h=h,
     offset=(int(nh[0]) / 2, int(nh[1]) / 2),
-    dims=(nt, nx),
     dtype="float32",
 )
 y = Cop * x.ravel()

examples/plot_derivative.py

@@ -83,7 +83,7 @@
 A = np.zeros((nx, ny))
 A[nx // 2, ny // 2] = 1.0
 
-D1op = pylops.FirstDerivative(nx * ny, dims=(nx, ny), dir=0, dtype="float64")
+D1op = pylops.FirstDerivative((nx, ny), dir=0, dtype="float64")
 B = np.reshape(D1op * A.ravel(), (nx, ny))
 
 fig, axs = plt.subplots(1, 2, figsize=(10, 3))
@@ -106,7 +106,7 @@
 A = np.zeros((nx, ny))
 A[nx // 2, ny // 2] = 1.0
 
-D2op = pylops.SecondDerivative(nx * ny, dims=(nx, ny), dir=0, dtype="float64")
+D2op = pylops.SecondDerivative((nx, ny), dir=0, dtype="float64")
 B = np.reshape(D2op * A.ravel(), (nx, ny))
 
 fig, axs = plt.subplots(1, 2, figsize=(10, 3))
@@ -127,7 +127,7 @@
 ###############################################################################
 # We can also apply the second derivative to the second direction of
 # our data (``dir=1``)
-D2op = pylops.SecondDerivative(nx * ny, dims=(nx, ny), dir=1, dtype="float64")
+D2op = pylops.SecondDerivative((nx, ny), dir=1, dtype="float64")
 B = np.reshape(D2op * np.ndarray.flatten(A), (nx, ny))
 
 fig, axs = plt.subplots(1, 2, figsize=(10, 3))

examples/plot_flip.py

@@ -40,7 +40,7 @@
 # first flip the model along the first axis and then along the second axis
 nt, nx = 10, 5
 x = np.outer(np.arange(nt), np.ones(nx))
-Fop = pylops.Flip(nt * nx, dims=(nt, nx), dir=0)
+Fop = pylops.Flip((nt, nx), dir=0)
 y = Fop * x.ravel()
 xadj = Fop.H * y.ravel()
 y = y.reshape(nt, nx)
@@ -64,7 +64,7 @@
 
 
 x = np.outer(np.ones(nt), np.arange(nx))
-Fop = pylops.Flip(nt * nx, dims=(nt, nx), dir=1)
+Fop = pylops.Flip((nt, nx), dir=1)
 y = Fop * x.ravel()
 xadj = Fop.H * y.ravel()
 y = y.reshape(nt, nx)

examples/plot_restriction.py

@@ -95,7 +95,7 @@
 nxsub = int(np.round(nx * perc_subsampling))
 iava = np.sort(np.random.permutation(np.arange(nx))[:nxsub])
 
-Rop = pylops.Restriction(nx * nt, iava, dims=(nx, nt), dir=0, dtype="float64")
+Rop = pylops.Restriction((nx, nt), iava, dir=0, dtype="float64")
 y = (Rop * x.ravel()).reshape(nxsub, nt)
 ymask = Rop.mask(x)
 

examples/plot_roll.py

@@ -37,7 +37,7 @@
 ny, nx = 10, 5
 x = np.arange(ny * nx).reshape(ny, nx)
 
-Rop = pylops.Roll(ny * nx, dims=(ny, nx), dir=1, shift=-2)
+Rop = pylops.Roll((ny, nx), dir=1, shift=-2)
 
 y = Rop * x.ravel()
 xadj = Rop.H * y

examples/plot_stacking.py

@@ -27,8 +27,8 @@
 ###############################################################################
 # Let's start by defining two second derivatives :py:class:`pylops.SecondDerivative`
 # that we will be using in this example.
-D2hop = pylops.SecondDerivative(11 * 21, dims=[11, 21], dir=1, dtype="float32")
-D2vop = pylops.SecondDerivative(11 * 21, dims=[11, 21], dir=0, dtype="float32")
+D2hop = pylops.SecondDerivative((11, 21), dir=1, dtype="float32")
+D2vop = pylops.SecondDerivative((11, 21), dir=0, dtype="float32")
 
 ###############################################################################
 # Chaining of operators represents the simplest concatenation that

examples/plot_symmetrize.py

@@ -49,7 +49,7 @@
 nt, nx = 10, 6
 x = np.outer(np.arange(nt), np.ones(nx))
 
-Sop = pylops.Symmetrize(nt * nx, dims=(nt, nx), dir=0)
+Sop = pylops.Symmetrize((nt, nx), dir=0)
 y = Sop * x.ravel()
 xadj = Sop.H * y.ravel()
 xinv = Sop / y
@@ -75,7 +75,7 @@
 
 
 x = np.outer(np.ones(nt), np.arange(nx))
-Sop = pylops.Symmetrize(nt * nx, dims=(nt, nx), dir=1)
+Sop = pylops.Symmetrize((nt, nx), dir=1)
 
 y = Sop * x.ravel()
 xadj = Sop.H * y.ravel()

examples/plot_tvreg.py

@@ -148,10 +148,10 @@
 
 Dop = [
     pylops.FirstDerivative(
-        ny * nx, dims=(ny, nx), dir=0, edge=False, kind="backward", dtype=np.complex128
+        (ny, nx), dir=0, edge=False, kind="backward", dtype=np.complex128
     ),
     pylops.FirstDerivative(
-        ny * nx, dims=(ny, nx), dir=1, edge=False, kind="backward", dtype=np.complex128
+        (ny, nx), dir=1, edge=False, kind="backward", dtype=np.complex128
     ),
 ]