minor: small linting

PyLops · Feb 13, 2024 · 42a303a · 42a303a
1 parent 0e880aa
commit 42a303a
Show file tree

Hide file tree

Showing 5 changed files with 29 additions and 31 deletions.
diff --git a/examples/plot_distributed_array.py b/examples/plot_distributed_array.py
@@ -84,7 +84,7 @@
 pylops_mpi.plot_local_arrays(sum_arr, "Addition", vmin=0, vmax=1)
 
 ###############################################################################
-# **Element-wise In-place Addition** - Similar to the previous one but the 
+# **Element-wise In-place Addition** - Similar to the previous one but the
 # addition is performed directly on one of the addends without creating a new
 # distributed array.
 sum_arr += arr2

diff --git a/examples/plot_stacked_array.py b/examples/plot_stacked_array.py
@@ -22,10 +22,10 @@
 
 ###############################################################################
 # Let's start by defining two distributed array
-subarr1 = pylops_mpi.DistributedArray(global_shape=size*10,
+subarr1 = pylops_mpi.DistributedArray(global_shape=size * 10,
                                       partition=pylops_mpi.Partition.SCATTER,
                                       axis=0)
-subarr2 = pylops_mpi.DistributedArray(global_shape=size*4,
+subarr2 = pylops_mpi.DistributedArray(global_shape=size * 4,
                                       partition=pylops_mpi.Partition.SCATTER,
                                       axis=0)
 # Filling the local arrays
@@ -53,10 +53,10 @@
 ###############################################################################
 # Let's now create a second :py:class:`pylops_mpi.StackedDistributedArray` object
 # and perform different mathematical operations on those two objects.
-subarr1_ = pylops_mpi.DistributedArray(global_shape=size*10,
+subarr1_ = pylops_mpi.DistributedArray(global_shape=size * 10,
                                        partition=pylops_mpi.Partition.SCATTER,
                                        axis=0)
-subarr2_ = pylops_mpi.DistributedArray(global_shape=size*4,
+subarr2_ = pylops_mpi.DistributedArray(global_shape=size * 4,
                                        partition=pylops_mpi.Partition.SCATTER,
                                        axis=0)
 # Filling the local arrays
@@ -107,7 +107,7 @@
 
 ###############################################################################
 # **VStack of operators**
-x = pylops_mpi.DistributedArray(global_shape=size*10,
+x = pylops_mpi.DistributedArray(global_shape=size * 10,
                                 partition=pylops_mpi.Partition.SCATTER,
                                 axis=0)
 # Filling the local arrays
@@ -130,7 +130,7 @@
                                 pylops.BlockDiag([pylops.MatrixMult(2 * Mop1),] * size)])
     print('mop.shape', mop.shape, mop_single.shape)
 
-    x_single = np.ones(size*10)
+    x_single = np.ones(size * 10)
     y_single = mop_single @ x_single
     xadj_single = mop_single.H @ y_single
 
@@ -162,4 +162,4 @@
 xinv_array = xinv.asarray()
 
 if rank == 0:
-    print('xinv_array', xinv_array)
+    print('xinv_array', xinv_array)
diff --git a/pylops_mpi/DistributedArray.py b/pylops_mpi/DistributedArray.py
@@ -346,13 +346,13 @@ def __iadd__(self, x):
 
     def __sub__(self, x):
         return self.__add__(-x)
-    
+
     def __isub__(self, x):
         return self.__iadd__(-x)
 
     def __mul__(self, x):
         return self.multiply(x)
-    
+
     def __rmul__(self, x):
         return self.multiply(x)
 
@@ -376,13 +376,12 @@ def iadd(self, dist_array):
         self[:] = self.local_array + dist_array.local_array
         return self
 
-
     def multiply(self, dist_array):
         """Distributed Element-wise multiplication
         """
         if isinstance(dist_array, DistributedArray):
             self._check_partition_shape(dist_array)
-        
+
         ProductArray = DistributedArray(global_shape=self.global_shape,
                                         base_comm=self.base_comm,
                                         dtype=self.dtype,
@@ -616,12 +615,13 @@ def asarray(self):
         -------
         final_array : :obj:`numpy.ndarray`
             Global Array gathered at all ranks
-        
+
         """
         return np.hstack([distarr.asarray().ravel() for distarr in self.distarrays])
 
     def _check_stacked_size(self, stacked_array):
         """Check that arrays have consistent size
+
         """
         if self.narrays != stacked_array.narrays:
             raise ValueError("Stacked arrays must be composed the same number of of distributed arrays")
@@ -632,17 +632,17 @@ def _check_stacked_size(self, stacked_array):
                                  f"{stacked_array[iarr].global_shape}")
 
     def __neg__(self):
-        arr = self.copy() #StackedDistributedArray([distarray.copy() for distarray in self.distarrays])
+        arr = self.copy()
         for iarr in range(self.narrays):
             arr[iarr][:] = -arr[iarr][:]
         return arr
 
     def __add__(self, x):
         return self.add(x)
-    
+
     def __iadd__(self, x):
         return self.iadd(x)
-    
+
     def __sub__(self, x):
         return self.__add__(-x)
 
@@ -651,15 +651,16 @@ def __isub__(self, x):
 
     def __mul__(self, x):
         return self.multiply(x)
-    
+
     def __rmul__(self, x):
         return self.multiply(x)
 
     def add(self, stacked_array):
         """Stacked Distributed Addition of arrays
+
         """
         self._check_stacked_size(stacked_array)
-        SumArray = self.copy() #StackedDistributedArray([distarray.copy() for distarray in self.distarrays])
+        SumArray = self.copy()
         for iarr in range(self.narrays):
             SumArray[iarr][:] = (self[iarr] + stacked_array[iarr])[:]
         return SumArray
@@ -671,11 +672,11 @@ def iadd(self, stacked_array):
         for iarr in range(self.narrays):
             self[iarr][:] = (self[iarr] + stacked_array[iarr])[:]
         return self
-    
+
     def multiply(self, stacked_array):
         if isinstance(stacked_array, StackedDistributedArray):
             self._check_stacked_size(stacked_array)
-        ProductArray = self.copy() #StackedDistributedArray([distarray.copy() for distarray in self.distarrays])
+        ProductArray = self.copy()
 
         if isinstance(stacked_array, StackedDistributedArray):
             # multiply two DistributedArray
@@ -686,7 +687,7 @@ def multiply(self, stacked_array):
             for iarr in range(self.narrays):
                 ProductArray[iarr][:] = (self[iarr] * stacked_array)[:]
         return ProductArray
-    
+
     def dot(self, stacked_array):
         self._check_stacked_size(stacked_array)
         dotprod = 0.

diff --git a/pylops_mpi/basicoperators/VStack.py b/pylops_mpi/basicoperators/VStack.py
@@ -139,7 +139,7 @@ class StackedVStack():
     ----------
     ops : :obj:`list`
         One or more :class:`pylops_mpi.MPILinearOperator` to be vertically stacked.
-    
+
     Attributes
     ----------
     shape : :obj:`tuple`
@@ -152,8 +152,8 @@ class StackedVStack():
 
     Notes
     -----
-    An StackedVStack is composed of N  :class:`pylops_mpi.MPILinearOperator` stacked 
-    vertically. These MPI operators will be applied sequentially, however distributed 
+    An StackedVStack is composed of N  :class:`pylops_mpi.MPILinearOperator` stacked
+    vertically. These MPI operators will be applied sequentially, however distributed
     computations will be performed within each operator.
 
     """

diff --git a/tests/test_stackedarray.py b/tests/test_stackedarray.py
@@ -3,12 +3,10 @@
     $ mpiexec -n 10 pytest test_stackedarray.py --with-mpi
 """
 import numpy as np
-from mpi4py import MPI
 import pytest
 from numpy.testing import assert_allclose
 
 from pylops_mpi import DistributedArray, Partition, StackedDistributedArray
-from pylops_mpi.DistributedArray import local_split
 
 np.random.seed(42)
 
@@ -57,13 +55,13 @@ def test_creation(par):
     assert_allclose(stacked_arrays[1].local_array, 
                     np.ones(shape=distributed_array1.local_shape,
                             dtype=par['dtype']), rtol=1e-14)
-                                                           
+
     # Modify array in place
     distributed_array0[:] = 2
     assert_allclose(stacked_arrays[0].local_array, 
                     2 * np.ones(shape=distributed_array0.local_shape,
                                 dtype=par['dtype']), rtol=1e-14)
-    
+
 
 @pytest.mark.mpi(min_size=2)
 @pytest.mark.parametrize("par", [(par1), (par1j), (par2),
@@ -81,7 +79,7 @@ def test_stacked_math(par):
 
     stacked_array1 = StackedDistributedArray([distributed_array0, distributed_array1])
     stacked_array2 = StackedDistributedArray([distributed_array1, distributed_array0])
-    
+
     # Addition
     sum_array = stacked_array1 + stacked_array2
     assert isinstance(sum_array, StackedDistributedArray)
@@ -115,7 +113,6 @@ def test_stacked_math(par):
     assert_allclose(l1norm, np.linalg.norm(stacked_array1.asarray().flatten(), 1),
                     rtol=1e-14)
     assert_allclose(l2norm, np.linalg.norm(stacked_array1.asarray(), 2),
-                    rtol=1e-10) # needed to raise it due to how partial norms are combined (with power applied)
+                    rtol=1e-10)  # needed to raise it due to how partial norms are combined (with power applied)
     assert_allclose(linfnorm, np.linalg.norm(stacked_array1.asarray().flatten(), np.inf),
                     rtol=1e-14)
-