foscat 3.8.2__tar.gz → 3.9.0__tar.gz

{foscat-3.8.2/src/foscat.egg-info → foscat-3.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: foscat
-Version: 3.8.2
+Version: 3.9.0
 Summary: Generate synthetic Healpix or 2D data using Cross Scattering Transform
 Author-email: Jean-Marc DELOUIS <jean.marc.delouis@ifremer.fr>
 Maintainer-email: Theo Foulquier <theo.foulquier@ifremer.fr>

{foscat-3.8.2 → foscat-3.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "foscat"
-version = "3.8.2"
+version = "3.9.0"
 description = "Generate synthetic Healpix or 2D data using Cross Scattering Transform"
 readme = "README.md"
 license = { text = "BSD-3-Clause" }

{foscat-3.8.2 → foscat-3.9.0}/src/foscat/BkBase.py

@@ -1,14 +1,15 @@
 import numpy as np
 
+
 class BackendBase:
-    
+
     def __init__(self, name, mpi_rank=0, all_type="float64", gpupos=0, silent=False):
-        
-        self.BACKEND=name
-        self.mpi_rank=mpi_rank
-        self.all_type=all_type
-        self.gpupos=gpupos
-        self.silent=silent
+
+        self.BACKEND = name
+        self.mpi_rank = mpi_rank
+        self.all_type = all_type
+        self.gpupos = gpupos
+        self.silent = silent
         # ---------------------------------------------−---------
         # table use to compute the iso orientation rotation
         self._iso_orient = {}
@@ -101,6 +102,7 @@ class BackendBase:
         return self.bk_reshape(
             self.backend.matmul(self.bk_reshape(x, oshape), lmat), oshape2
         )
+
     def calc_iso_orient(self, norient):
         tmp = np.zeros([norient * norient, norient])
         for i in range(norient):
@@ -188,7 +190,9 @@ class BackendBase:
                     tmp[:, :, k, l_orient] = np.cos(x * k) * np.cos((x.T) * l_orient)
 
             self._fft_2_orient[(norient, nharm, imaginary)] = self.bk_cast(
-                self.bk_constant(tmp.reshape(norient * norient, (1 + nharm) * (1 + nharm)))
+                self.bk_constant(
+                    tmp.reshape(norient * norient, (1 + nharm) * (1 + nharm))
+                )
             )
             self._fft_2_orient_C[(norient, nharm, imaginary)] = self.bk_complex(
                 self._fft_2_orient[(norient, nharm, imaginary)],
@@ -343,7 +347,7 @@ class BackendBase:
                 self._fft_3_orient[(norient, nharm, imaginary)],
                 0 * self._fft_3_orient[(norient, nharm, imaginary)],
             )
-            
+
     # ---------------------------------------------−---------
     # --             BACKEND DEFINITION                    --
     # ---------------------------------------------−---------
@@ -355,7 +359,7 @@ class BackendBase:
 
     def bk_sparse_dense_matmul(self, smat, mat):
         raise NotImplementedError("This is an abstract class.")
-    
+
     def conv2d(self, x, w, strides=[1, 1, 1, 1], padding="SAME"):
         raise NotImplementedError("This is an abstract class.")
 
@@ -379,9 +383,6 @@ class BackendBase:
 
     def bk_flattenR(self, x):
         raise NotImplementedError("This is an abstract class.")
-               
-    def bk_flatten(self, x):
-        raise NotImplementedError("This is an abstract class.")
 
     def bk_flatten(self, x):
         raise NotImplementedError("This is an abstract class.")
@@ -442,7 +443,7 @@ class BackendBase:
 
     def bk_tensor(self, data):
         raise NotImplementedError("This is an abstract class.")
-        
+
     def bk_shape_tensor(self, shape):
         raise NotImplementedError("This is an abstract class.")
 
@@ -460,7 +461,7 @@ class BackendBase:
 
     def bk_tanh(self, data):
         raise NotImplementedError("This is an abstract class.")
-        
+
     def bk_max(self, data):
         raise NotImplementedError("This is an abstract class.")
 
@@ -499,11 +500,11 @@ class BackendBase:
 
     def bk_fft(self, data):
         raise NotImplementedError("This is an abstract class.")
-            
-    def bk_fftn(self, data,dim=None):
+
+    def bk_fftn(self, data, dim=None):
         raise NotImplementedError("This is an abstract class.")
 
-    def bk_ifftn(self, data,dim=None,norm=None):
+    def bk_ifftn(self, data, dim=None, norm=None):
         raise NotImplementedError("This is an abstract class.")
 
     def bk_rfft(self, data):
@@ -524,32 +525,32 @@ class BackendBase:
     def bk_relu(self, x):
         raise NotImplementedError("This is an abstract class.")
 
-    def bk_clip_by_value(self, x,xmin,xmax):
+    def bk_clip_by_value(self, x, xmin, xmax):
         raise NotImplementedError("This is an abstract class.")
 
     def bk_cast(self, x):
         raise NotImplementedError("This is an abstract class.")
-            
-    def bk_variable(self,x):
+
+    def bk_variable(self, x):
         raise NotImplementedError("This is an abstract class.")
-        
-    def bk_assign(self,x,y):
+
+    def bk_assign(self, x, y):
         raise NotImplementedError("This is an abstract class.")
-            
-    def bk_constant(self,x):
+
+    def bk_constant(self, x):
         raise NotImplementedError("This is an abstract class.")
-            
-    def bk_cos(self,x):
+
+    def bk_cos(self, x):
         raise NotImplementedError("This is an abstract class.")
-        
-    def bk_sin(self,x):
+
+    def bk_sin(self, x):
         raise NotImplementedError("This is an abstract class.")
-        
-    def bk_arctan2(self,c,s):
+
+    def bk_arctan2(self, c, s):
         raise NotImplementedError("This is an abstract class.")
-        
-    def bk_empty(self,list):
+
+    def bk_empty(self, list):
         raise NotImplementedError("This is an abstract class.")
-        
-    def to_numpy(self,x):
+
+    def to_numpy(self, x):
         raise NotImplementedError("This is an abstract class.")

{foscat-3.8.2 → foscat-3.9.0}/src/foscat/BkNumpy.py

@@ -1,11 +1,13 @@
-import foscat.BkBase as BackendBase
 import numpy as np
 
+import foscat.BkBase as BackendBase
+
+
 class BkNumpy(BackendBase.BackendBase):
-    
+
     def __init__(self, *args, **kwargs):
         # Impose que use_2D=True pour la classe scat
-        super().__init__(name='tensorflow', *args, **kwargs)
+        super().__init__(name="tensorflow", *args, **kwargs)
 
         # ===========================================================================
         # INIT
@@ -31,13 +33,14 @@ class BkNumpy(BackendBase.BackendBase):
                 self.all_bk_type = self.backend.float64
                 self.all_cbk_type = self.backend.complex128
             else:
-                print("ERROR INIT FOCUS ", all_type, " should be float32 or float64")
+                print(
+                    "ERROR INIT FOCUS ", self.all_type, " should be float32 or float64"
+                )
                 return None
-                
+
         # ===========================================================================
         # INIT
 
-        gpus = []
         gpuname = "CPU:0"
         self.gpulist = {}
         self.gpulist[0] = gpuname
@@ -49,27 +52,25 @@ class BkNumpy(BackendBase.BackendBase):
     def bk_SparseTensor(self, indice, w, dense_shape=[]):
         return self.scipy.sparse.coo_matrix(
             (w, (indice[:, 0], indice[:, 1])), shape=dense_shape
-            )
+        )
 
     def bk_stack(self, list, axis=0):
         return self.backend.stack(list, axis=axis)
 
     def bk_sparse_dense_matmul(self, smat, mat):
         return smat.dot(mat)
-    
+
     def conv2d(self, x, w, strides=[1, 1, 1, 1], padding="SAME"):
-        res = np.zeros(
-                [x.shape[0], x.shape[1], x.shape[2], w.shape[3]], dtype=x.dtype
-            )
+        res = np.zeros([x.shape[0], x.shape[1], x.shape[2], w.shape[3]], dtype=x.dtype)
         for k in range(w.shape[2]):
             for l_orient in range(w.shape[3]):
                 for j in range(res.shape[0]):
                     tmp = self.scipy.signal.convolve2d(
-                            x[j, :, :, k],
-                            w[:, :, k, l_orient],
-                            mode="same",
-                            boundary="symm",
-                        )
+                        x[j, :, :, k],
+                        w[:, :, k, l_orient],
+                        mode="same",
+                        boundary="symm",
+                    )
                     res[j, :, :, l_orient] += tmp
                     del tmp
         return res
@@ -79,8 +80,8 @@ class BkNumpy(BackendBase.BackendBase):
         for k in range(w.shape[2]):
             for j in range(res.shape[0]):
                 tmp = self.scipy.signal.convolve1d(
-                        x[j, :, k], w[:, k], mode="same", boundary="symm"
-                 )
+                    x[j, :, k], w[:, k], mode="same", boundary="symm"
+                )
                 res[j, :, :] += tmp
                 del tmp
         return res
@@ -114,10 +115,6 @@ class BkNumpy(BackendBase.BackendBase):
             return np.concatenate([x.real.flatten(), x.imag.flatten()], 0)
         else:
             return x.flatten()
-                
-    
-    def bk_flatten(self, x):
-        return x.flatten()
 
     def bk_flatten(self, x):
         return x.flatten()
@@ -144,10 +141,6 @@ class BkNumpy(BackendBase.BackendBase):
     # ---------------------------------------------−---------
     # return a tensor size
 
-    def bk_size(self, data):
-        return data.size
-
-
     def bk_reduce_mean(self, data, axis=None):
 
         if axis is None:
@@ -223,7 +216,7 @@ class BkNumpy(BackendBase.BackendBase):
 
     def bk_tensor(self, data):
         return data
-        
+
     def bk_shape_tensor(self, shape):
         return np.zeros(shape)
 
@@ -284,28 +277,27 @@ class BkNumpy(BackendBase.BackendBase):
     def bk_zeros(self, shape, dtype=None):
         return np.zeros(shape, dtype=dtype)
 
-    def bk_gather(self, data, idx,axis=0):
-        if axis==0:
+    def bk_gather(self, data, idx, axis=0):
+        if axis == 0:
             return data[idx]
-        elif axis==1:
-            return data[:,idx]
-        elif axis==2:
-            return data[:,:,idx]
-        elif axis==3:
-            return data[:,:,:,idx]
-        return data[:,:,:,:,idx]
-        
+        elif axis == 1:
+            return data[:, idx]
+        elif axis == 2:
+            return data[:, :, idx]
+        elif axis == 3:
+            return data[:, :, :, idx]
+        return data[:, :, :, :, idx]
 
     def bk_reverse(self, data, axis=0):
         return np.reverse(data, axis=axis)
 
     def bk_fft(self, data):
         return self.backend.fft.fft(data)
-            
-    def bk_fftn(self, data,dim=None):
+
+    def bk_fftn(self, data, dim=None):
         return self.backend.fft.fftn(data)
 
-    def bk_ifftn(self, data,dim=None,norm=None):
+    def bk_ifftn(self, data, dim=None, norm=None):
         return self.backend.fft.ifftn(data)
 
     def bk_rfft(self, data):
@@ -327,8 +319,8 @@ class BkNumpy(BackendBase.BackendBase):
     def bk_relu(self, x):
         return (x > 0) * x
 
-    def bk_clip_by_value(self, x,xmin,xmax):
-        return self.backend.clip(x,xmin,xmax)
+    def bk_clip_by_value(self, x, xmin, xmax):
+        return self.backend.clip(x, xmin, xmax)
 
     def bk_cast(self, x):
         if isinstance(x, np.float64):
@@ -364,29 +356,28 @@ class BkNumpy(BackendBase.BackendBase):
             out_type = self.all_bk_type
 
         return x.astype(out_type)
-            
-    def bk_variable(self,x):
-            
+
+    def bk_variable(self, x):
+
         return self.bk_cast(x)
-        
-    def bk_assign(self,x,y):
-        x=y
-            
-    def bk_constant(self,x):
-            
+
+    def bk_assign(self, x, y):
+        return y
+
+    def bk_constant(self, x):
         return self.bk_cast(x)
-        
-    def bk_cos(self,x):
+
+    def bk_cos(self, x):
         return self.backend.cos(x)
-        
-    def bk_sin(self,x):
+
+    def bk_sin(self, x):
         return self.backend.sin(x)
-        
-    def bk_arctan2(self,c,s):
-        return self.backend.arctan2(c,s)
-        
-    def bk_empty(self,list):
+
+    def bk_arctan2(self, c, s):
+        return self.backend.arctan2(c, s)
+
+    def bk_empty(self, list):
         return self.backend.empty(list)
-        
-    def to_numpy(self,x):
+
+    def to_numpy(self, x):
         return x