foscat 3.0.18__tar.gz → 3.0.20__tar.gz

{foscat-3.0.18 → foscat-3.0.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foscat
-Version: 3.0.18
+Version: 3.0.20
 Summary: Generate synthetic Healpix or 2D data using Cross Scattering Transform
 Home-page: https://github.com/jmdelouis/FOSCAT
 Author: Jean-Marc DELOUIS

{foscat-3.0.18 → foscat-3.0.20}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='foscat',
-    version='3.0.18',
+    version='3.0.20',
     description='Generate synthetic Healpix or 2D data using Cross Scattering Transform' ,
     long_description='Utilize the Cross Scattering Transform (described in https://arxiv.org/abs/2207.12527) to synthesize Healpix or 2D data that is suitable for component separation purposes, such as denoising. \n A demo package for this process can be found at https://github.com/jmdelouis/FOSCAT_DEMO. \n Complete doc can be found at https://foscat-documentation.readthedocs.io/en/latest/index.html. \n\n List of developers : J.-M. Delouis, T. Foulquier, L. Mousset, T. Odaka, F. Paul, E. Allys ' ,
     license='MIT',

{foscat-3.0.18 → foscat-3.0.20}/src/foscat/FoCUS.py

@@ -5,7 +5,7 @@ import foscat.backend as bk
 from scipy.interpolate import griddata
 
 
-TMPFILE_VERSION='V2_6'
+TMPFILE_VERSION='V3_0'
 
 class FoCUS:
     def __init__(self,
@@ -32,7 +32,7 @@ class FoCUS:
                  mpi_size=1,
                  mpi_rank=0):
 
-        self.__version__ = '3.0.18'
+        self.__version__ = '3.0.20'
         # P00 coeff for normalization for scat_cov
         self.TMPFILE_VERSION=TMPFILE_VERSION
         self.P1_dic = None
@@ -872,7 +872,7 @@ class FoCUS:
         except:
             if self.use_2D==False:
                 if self.KERNELSZ*self.KERNELSZ>12*nside*nside:
-                    l_kernel=2*nside
+                    l_kernel=3
                     
                 aa=np.cos(np.arange(self.NORIENT)/self.NORIENT*np.pi).reshape(1,self.NORIENT)
                 bb=np.sin(np.arange(self.NORIENT)/self.NORIENT*np.pi).reshape(1,self.NORIENT)
@@ -890,14 +890,19 @@ class FoCUS:
                     lidx=np.arange(12*nside*nside)
 
                 pw=np.pi/4.0
-                pw2=1/2.0
-        
+                pw2=1/2
+                amp=1.0
+                
                 if l_kernel==5:
                     pw=np.pi/4.0
-                    pw2=1/2.0
+                    pw2=1/2.25
+                    amp=1.0/9.2038
+                    
                 elif l_kernel==3:
-                    pw=1.0
+                    pw=1.0/np.sqrt(2)
                     pw2=1.0
+                    amp=1/8.45
+                    
                 elif l_kernel==7:
                     pw=np.pi/4.0
                     pw2=1.0/3.0
@@ -920,7 +925,7 @@ class FoCUS:
                     w=np.exp(-pw2*delta[pidx]*(nside**2))
                     pidx=pidx[np.argsort(-w)[0:l_kernel**2]]
                     pidx=pidx[np.argsort(lidx[pidx])]
-                    
+
                     w=np.exp(-pw2*delta[pidx]*(nside**2))
                     iwav[k]=lidx[pidx]
                     wwav[k]=w
@@ -935,7 +940,7 @@ class FoCUS:
                     wav[k,:,:]=(np.cos(xx*aa+yy*bb)+complex(0.0,1.0)*np.sin(xx*aa+yy*bb))*np.expand_dims(w,-1)
     
                 wav=wav-np.expand_dims(np.mean(wav,1),1)
-                wav=wav/np.expand_dims(np.std(wav,1),1)
+                wav=amp*wav/np.expand_dims(np.std(wav,1),1)
                 wwav=wwav/np.expand_dims(np.sum(wwav,1),1)
                 
                 nk=l_kernel*l_kernel

{foscat-3.0.18 → foscat-3.0.20}/src/foscat/Synthesis.py

@@ -160,8 +160,7 @@ class Synthesis:
         self.l_log[self.mpi_rank*self.MAXNUMLOSS:(self.mpi_rank+1)*self.MAXNUMLOSS]=-1.0
         
         for istep in range(nstep):
-            
-        
+                    
             for k in range(self.number_of_loss):
                 if self.loss_class[k].batch is None:
                     l_batch=None

{foscat-3.0.18 → foscat-3.0.20}/src/foscat/scat.py

@@ -3,11 +3,13 @@ import numpy as np
 import pickle
 import foscat.backend as bk
 import healpy as hp
+import sys
   
 # Vérifier si TensorFlow est importé et défini
 tf_defined = 'tensorflow' in sys.modules
 
 if tf_defined:
+    import tensorflow as tf
     tf_function = tf.function  # Facultatif : si vous voulez utiliser TensorFlow dans ce script
 else:
     def tf_function(func):
@@ -63,44 +65,55 @@ class scat:
                     self.j1  , \
                     self.j2  ,backend=self.backend)
 
+        
     def domult(self,x,y):
-        if x.dtype==y.dtype:
+        try:
             return x*y
-        
-        if self.backend.bk_is_complex(x):
-            
-            return self.backend.bk_complex(self.backend.bk_real(x)*y,self.backend.bk_imag(x)*y)
-        else:
-            return self.backend.bk_complex(self.backend.bk_real(y)*x,self.backend.bk_imag(y)*x)
-        
+        except:
+            if x.dtype==y.dtype:
+                return x*y
+            if self.backend.bk_is_complex(x):
+
+                return self.backend.bk_complex(self.backend.bk_real(x)*y,self.backend.bk_imag(x)*y)
+            else:
+                return self.backend.bk_complex(self.backend.bk_real(y)*x,self.backend.bk_imag(y)*x)
+
     def dodiv(self,x,y):
-        if x.dtype==y.dtype:
+        try:
             return x/y
-        if self.backend.bk_is_complex(x):
+        except:
+            if x.dtype==y.dtype:
+                return x/y
+            if self.backend.bk_is_complex(x):
             
-            return self.backend.bk_complex(self.backend.bk_real(x)/y,self.backend.bk_imag(x)/y)
-        else:
-            return self.backend.bk_complex(x/self.backend.bk_real(y),x/self.backend.bk_imag(y))
+                return self.backend.bk_complex(self.backend.bk_real(x)/y,self.backend.bk_imag(x)/y)
+            else:
+                return self.backend.bk_complex(x/self.backend.bk_real(y),x/self.backend.bk_imag(y))
         
     def domin(self,x,y):
-        if x.dtype==y.dtype:
+        try:
             return x-y
-        
-        if self.backend.bk_is_complex(x):
-            
-            return self.backend.bk_complex(self.backend.bk_real(x)-y,self.backend.bk_imag(x)-y)
-        else:
-            return self.backend.bk_complex(x-self.backend.bk_real(y),x-self.backend.bk_imag(y))
+        except:
+            if x.dtype==y.dtype:
+                return x-y
+
+            if self.backend.bk_is_complex(x):
+
+                return self.backend.bk_complex(self.backend.bk_real(x)-y,self.backend.bk_imag(x)-y)
+            else:
+                return self.backend.bk_complex(x-self.backend.bk_real(y),x-self.backend.bk_imag(y))
         
     def doadd(self,x,y):
-        if x.dtype==y.dtype:
+        try:
             return x+y
-        
-        if self.backend.bk_is_complex(x):
-            
-            return self.backend.bk_complex(self.backend.bk_real(x)+y,self.backend.bk_imag(x)+y)
-        else:
-            return self.backend.bk_complex(x+self.backend.bk_real(y),x+self.backend.bk_imag(y))
+        except:
+            if x.dtype==y.dtype:
+                return x+y
+            if self.backend.bk_is_complex(x):
+
+                return self.backend.bk_complex(self.backend.bk_real(x)+y,self.backend.bk_imag(x)+y)
+            else:
+                return self.backend.bk_complex(x+self.backend.bk_real(y),x+self.backend.bk_imag(y))
         
     def relu(self):
         
@@ -336,7 +349,7 @@ class scat:
         if len(tmp.shape)==4:
             for k in range(tmp.shape[3]):
                 for i1 in range(tmp.shape[0]):
-                    for i2 in range(tmp.shape[0]):
+                    for i2 in range(tmp.shape[1]):
                         if test is None:
                             test=1
                             plt.plot(tmp[i1,i2,:,k],color=color, label=r'%s $P_{00}$' % (name), lw=lw)

{foscat-3.0.18 → foscat-3.0.20}/src/foscat/scat1D.py

@@ -8,6 +8,7 @@ import sys
 tf_defined = 'tensorflow' in sys.modules
 
 if tf_defined:
+    import tensorflow as tf
     tf_function = tf.function  # Facultatif : si vous voulez utiliser TensorFlow dans ce script
 else:
     def tf_function(func):
@@ -62,6 +63,7 @@ class scat1D:
     def domult(self,x,y):
         if x.dtype==y.dtype:
             return x*y
+        
         if self.backend.bk_is_complex(x):
             
             return self.backend.bk_complex(self.backend.bk_real(x)*y,self.backend.bk_imag(x)*y)
@@ -80,6 +82,7 @@ class scat1D:
     def domin(self,x,y):
         if x.dtype==y.dtype:
             return x-y
+        
         if self.backend.bk_is_complex(x):
             
             return self.backend.bk_complex(self.backend.bk_real(x)-y,self.backend.bk_imag(x)-y)
@@ -89,6 +92,7 @@ class scat1D:
     def doadd(self,x,y):
         if x.dtype==y.dtype:
             return x+y
+        
         if self.backend.bk_is_complex(x):
             
             return self.backend.bk_complex(self.backend.bk_real(x)+y,self.backend.bk_imag(x)+y)

{foscat-3.0.18 → foscat-3.0.20}/src/foscat/scat_cov.py

@@ -3,11 +3,13 @@ import numpy as np
 import foscat.backend as bk
 import pickle
 import healpy as hp
+import sys
 
 # Vérifier si TensorFlow est importé et défini
 tf_defined = 'tensorflow' in sys.modules
 
 if tf_defined:
+    import tensorflow as tf
     tf_function = tf.function  # Facultatif : si vous voulez utiliser TensorFlow dans ce script
 else:
     def tf_function(func):
@@ -575,41 +577,53 @@ class scat_cov:
                             s1=s1, c10=c10,backend=self.backend)
         
     def domult(self,x,y):
-        if x.dtype==y.dtype:
+        try:
             return x*y
-        if self.backend.bk_is_complex(x):
-            
-            return self.backend.bk_complex(self.backend.bk_real(x)*y,self.backend.bk_imag(x)*y)
-        else:
-            return self.backend.bk_complex(self.backend.bk_real(y)*x,self.backend.bk_imag(y)*x)
+        except:
+            if x.dtype==y.dtype:
+                return x*y
+            if self.backend.bk_is_complex(x):
+
+                return self.backend.bk_complex(self.backend.bk_real(x)*y,self.backend.bk_imag(x)*y)
+            else:
+                return self.backend.bk_complex(self.backend.bk_real(y)*x,self.backend.bk_imag(y)*x)
 
     def dodiv(self,x,y):
-        if x.dtype==y.dtype:
+        try:
             return x/y
-        if self.backend.bk_is_complex(x):
+        except:
+            if x.dtype==y.dtype:
+                return x/y
+            if self.backend.bk_is_complex(x):
             
-            return self.backend.bk_complex(self.backend.bk_real(x)/y,self.backend.bk_imag(x)/y)
-        else:
-            return self.backend.bk_complex(x/self.backend.bk_real(y),x/self.backend.bk_imag(y))
+                return self.backend.bk_complex(self.backend.bk_real(x)/y,self.backend.bk_imag(x)/y)
+            else:
+                return self.backend.bk_complex(x/self.backend.bk_real(y),x/self.backend.bk_imag(y))
         
     def domin(self,x,y):
-        if x.dtype==y.dtype:
+        try:
             return x-y
-        
-        if self.backend.bk_is_complex(x):
-            
-            return self.backend.bk_complex(self.backend.bk_real(x)-y,self.backend.bk_imag(x)-y)
-        else:
-            return self.backend.bk_complex(x-self.backend.bk_real(y),x-self.backend.bk_imag(y))
+        except:
+            if x.dtype==y.dtype:
+                return x-y
+
+            if self.backend.bk_is_complex(x):
+
+                return self.backend.bk_complex(self.backend.bk_real(x)-y,self.backend.bk_imag(x)-y)
+            else:
+                return self.backend.bk_complex(x-self.backend.bk_real(y),x-self.backend.bk_imag(y))
         
     def doadd(self,x,y):
-        if x.dtype==y.dtype:
+        try:
             return x+y
-        if self.backend.bk_is_complex(x):
-            
-            return self.backend.bk_complex(self.backend.bk_real(x)+y,self.backend.bk_imag(x)+y)
-        else:
-            return self.backend.bk_complex(x+self.backend.bk_real(y),x+self.backend.bk_imag(y))
+        except:
+            if x.dtype==y.dtype:
+                return x+y
+            if self.backend.bk_is_complex(x):
+
+                return self.backend.bk_complex(self.backend.bk_real(x)+y,self.backend.bk_imag(x)+y)
+            else:
+                return self.backend.bk_complex(x+self.backend.bk_real(y),x+self.backend.bk_imag(y))
                 
             
     def __mul__(self, other):
@@ -734,7 +748,7 @@ class scat_cov:
         return scat_cov(self.S0,self.backend.constant(p0),self.backend.constant(c01),
                         self.backend.constant(c11),s1=s1,c10=c10,backend=self.backend)
 
-    def plot(self, name=None, hold=True, color='blue', lw=1, legend=True):
+    def plot(self, name=None, hold=True, color='blue', lw=1, legend=True,norm=False):
 
         import matplotlib.pyplot as plt
 
@@ -753,7 +767,7 @@ class scat_cov:
             if len(tmp.shape)>3:
                 for k in range(tmp.shape[3]):
                     for i1 in range(tmp.shape[0]):
-                        for i2 in range(tmp.shape[0]):
+                        for i2 in range(tmp.shape[1]):
                             if test is None:
                                 test=1
                                 plt.plot(tmp[i1,i2,:,k],color=color, label=r'%s $S_1$' % (name), lw=lw)
@@ -761,7 +775,7 @@ class scat_cov:
                                 plt.plot(tmp[i1,i2,:,k],color=color, lw=lw)
             else:
                 for i1 in range(tmp.shape[0]):
-                    for i2 in range(tmp.shape[0]):
+                    for i2 in range(tmp.shape[1]):
                         if test is None:
                             test=1
                             plt.plot(tmp[i1,i2,:],color=color, label=r'%s $S_1$' % (name), lw=lw)
@@ -775,10 +789,11 @@ class scat_cov:
         test=None
         plt.subplot(2, 2, 2)
         tmp=abs(self.get_np(self.P00))
+        ntmp=np.sqrt(tmp)
         if len(tmp.shape)>3:
             for k in range(tmp.shape[3]):
                 for i1 in range(tmp.shape[0]):
-                    for i2 in range(tmp.shape[0]):
+                    for i2 in range(tmp.shape[1]):
                         if test is None:
                             test=1
                             plt.plot(tmp[i1,i2,:,k],color=color, label=r'%s $P_{00}$' % (name), lw=lw)
@@ -786,7 +801,7 @@ class scat_cov:
                             plt.plot(tmp[i1,i2,:,k],color=color, lw=lw)
         else:
             for i1 in range(tmp.shape[0]):
-                for i2 in range(tmp.shape[0]):
+                for i2 in range(tmp.shape[1]):
                     if test is None:
                         test=1
                         plt.plot(tmp[i1,i2,:],color=color, label=r'%s $P_{00}$' % (name), lw=lw)
@@ -818,15 +833,18 @@ class scat_cov:
                     for i2 in range(j1.max()+1):
                         for i3 in range(tmp.shape[3]):
                             for i4 in range(tmp.shape[4]):
+                                dtmp=tmp[i0,i1,j1==i2,i3,i4]
+                                if norm:
+                                    dtmp=dtmp/ntmp[i0,i1,i2,i3]
                                 if j2[j1==i2].shape[0]==1:
-                                    ax1.plot(j2[j1==i2]+n,tmp[i0,i1,j1==i2,i3,i4],'.', \
+                                    ax1.plot(j2[j1==i2]+n,dtmp,'.', \
                                                  color=color, lw=lw)
                                 else:
                                     if legend and test is None:
-                                        ax1.plot(j2[j1==i2]+n,tmp[i0,i1,j1==i2,i3,i4], \
+                                        ax1.plot(j2[j1==i2]+n,dtmp, \
                                                  color=color, label=lname, lw=lw)
                                         test=1
-                                    ax1.plot(j2[j1==i2]+n,tmp[i0,i1,j1==i2,i3,i4], \
+                                    ax1.plot(j2[j1==i2]+n,dtmp, \
                                              color=color, lw=lw)
                         tabnx=tabnx+[r'%d'%(k) for k in j2[j1==i2]]
                         tabx=tabx+[k+n for k in j2[j1==i2]]
@@ -839,15 +857,18 @@ class scat_cov:
                 for i1 in range(tmp.shape[1]):
                     for i2 in range(j1.max()+1):
                         for i3 in range(tmp.shape[3]):
+                            dtmp=tmp[i0,i1,j1==i2,i3]
+                            if norm:
+                                dtmp=dtmp/ntmp[i0,i1,i2]
                             if j2[j1==i2].shape[0]==1:
-                                ax1.plot(j2[j1==i2]+n,tmp[i0,i1,j1==i2,i3],'.', \
+                                ax1.plot(j2[j1==i2]+n,dtmp,'.', \
                                          color=color, lw=lw)
                             else:
                                 if legend and test is None:
-                                    ax1.plot(j2[j1==i2]+n,tmp[i0,i1,j1==i2,i3], \
+                                    ax1.plot(j2[j1==i2]+n,dtmp, \
                                              color=color, label=lname, lw=lw)
                                     test=1
-                                ax1.plot(j2[j1==i2]+n,tmp[i0,i1,j1==i2,i3], \
+                                ax1.plot(j2[j1==i2]+n,dtmp, \
                                          color=color, lw=lw)
                         tabnx=tabnx+[r'%d'%(k) for k in j2[j1==i2]]
                         tabx=tabx+[k+n for k in j2[j1==i2]]
@@ -903,15 +924,18 @@ class scat_cov:
                             for i3 in range(tmp.shape[3]):
                                 for i4 in range(tmp.shape[4]):
                                     for i5 in range(tmp.shape[5]):
+                                        dtmp=tmp[i0,i1,idx,i3,i4,i5]
+                                        if norm:
+                                            dtmp=dtmp/ntmp[i0,i1,i2,i3]
                                         if len(idx)==1:
-                                            ax1.plot(np.arange(len(idx))+n,tmp[i0,i1,idx,i3,i4,i5],'.', \
+                                            ax1.plot(np.arange(len(idx))+n,dtmp,'.', \
                                                      color=color, lw=lw)
                                         else:
                                             if legend and test is None:
-                                                ax1.plot(np.arange(len(idx))+n,tmp[i0,i1,idx,i3,i4,i5], \
+                                                ax1.plot(np.arange(len(idx))+n,dtmp, \
                                                          color=color, label=lname, lw=lw)
                                                 test=1
-                                            ax1.plot(np.arange(len(idx))+n,tmp[i0,i1,idx,i3,i4,i5], \
+                                            ax1.plot(np.arange(len(idx))+n,dtmp, \
                                                      color=color, lw=lw)
                             tabnx=tabnx+[r'%d,%d'%(j2[k],j3[k]) for k in idx]
                             tabx=tabx+[k+n for k in range(len(idx))]
@@ -927,15 +951,18 @@ class scat_cov:
                         for i2b in range(j2[j1==i2].max()+1):
                             idx=np.where((j1==i2)*(j2==i2b))[0]
                             for i3 in range(tmp.shape[3]):
+                                dtmp=tmp[i0,i1,idx,i3]
+                                if norm:
+                                    dtmp=dtmp/ntmp[i0,i1,i2]
                                 if len(idx)==1:
-                                    ax1.plot(np.arange(len(idx))+n,tmp[i0,i1,idx,i3],'.', \
+                                    ax1.plot(np.arange(len(idx))+n,dtmp,'.', \
                                              color=color, lw=lw)
                                 else:
                                     if legend and test is None:
-                                        ax1.plot(np.arange(len(idx))+n,tmp[i0,i1,idx,i3], \
+                                        ax1.plot(np.arange(len(idx))+n,dtmp, \
                                                  color=color, label=lname, lw=lw)
                                         test=1
-                                    ax1.plot(np.arange(len(idx))+n,tmp[i0,i1,idx,i3], \
+                                    ax1.plot(np.arange(len(idx))+n,dtmp, \
                                              color=color, lw=lw)
                             tabnx=tabnx+[r'%d,%d'%(j2[k],j3[k]) for k in idx]
                             tabx=tabx+[k+n for k in range(len(idx))]

{foscat-3.0.18 → foscat-3.0.20}/src/foscat/scat_cov1D.py

@@ -3,12 +3,14 @@ import numpy as np
 import foscat.backend as bk
 import pickle
 import matplotlib.pyplot as plt
+import sys
 
 
 # Vérifier si TensorFlow est importé et défini
 tf_defined = 'tensorflow' in sys.modules
 
 if tf_defined:
+    import tensorflow as tf
     tf_function = tf.function  # Facultatif : si vous voulez utiliser TensorFlow dans ce script
 else:
     def tf_function(func):
@@ -373,42 +375,54 @@ class scat_cov1D:
                             (self.C01 - other),
                             c11,
                             s1=s1, c10=c10,backend=self.backend)
-        
-    def domult(self,x,y):
-        if x.dtype==y.dtype:
+        def domult(self,x,y):
+        try:
             return x*y
-        
-        if self.backend.bk_is_complex(x):
-            return self.backend.bk_complex(self.backend.bk_real(x)*y,self.backend.bk_imag(x)*y)
-        else:
-            return self.backend.bk_complex(self.backend.bk_real(y)*x,self.backend.bk_imag(y)*x)
-        
+        except:
+            if x.dtype==y.dtype:
+                return x*y
+            if self.backend.bk_is_complex(x):
+
+                return self.backend.bk_complex(self.backend.bk_real(x)*y,self.backend.bk_imag(x)*y)
+            else:
+                return self.backend.bk_complex(self.backend.bk_real(y)*x,self.backend.bk_imag(y)*x)
+
     def dodiv(self,x,y):
-        if x.dtype==y.dtype:
+        try:
             return x/y
-        
-        if self.backend.bk_is_complex(x):
-            return self.backend.bk_complex(self.backend.bk_real(x)/y,self.backend.bk_imag(x)/y)
-        else:
-            return self.backend.bk_complex(x/self.backend.bk_real(y),x/self.backend.bk_imag(y))
+        except:
+            if x.dtype==y.dtype:
+                return x/y
+            if self.backend.bk_is_complex(x):
+            
+                return self.backend.bk_complex(self.backend.bk_real(x)/y,self.backend.bk_imag(x)/y)
+            else:
+                return self.backend.bk_complex(x/self.backend.bk_real(y),x/self.backend.bk_imag(y))
         
     def domin(self,x,y):
-        if x.dtype==y.dtype:
+        try:
             return x-y
-            
-        if self.backend.bk_is_complex(x):
-            return self.backend.bk_complex(self.backend.bk_real(x)-y,self.backend.bk_imag(x)-y)
-        else:
-            return self.backend.bk_complex(x-self.backend.bk_real(y),x-self.backend.bk_imag(y))
+        except:
+            if x.dtype==y.dtype:
+                return x-y
+
+            if self.backend.bk_is_complex(x):
+
+                return self.backend.bk_complex(self.backend.bk_real(x)-y,self.backend.bk_imag(x)-y)
+            else:
+                return self.backend.bk_complex(x-self.backend.bk_real(y),x-self.backend.bk_imag(y))
         
     def doadd(self,x,y):
-        if x.dtype==y.dtype:
+        try:
             return x+y
-            
-        if self.backend.bk_is_complex(x):
-            return self.backend.bk_complex(self.backend.bk_real(x)+y,self.backend.bk_imag(x)+y)
-        else:
-            return self.backend.bk_complex(x+self.backend.bk_real(y),x+self.backend.bk_imag(y))
+        except:
+            if x.dtype==y.dtype:
+                return x+y
+            if self.backend.bk_is_complex(x):
+
+                return self.backend.bk_complex(self.backend.bk_real(x)+y,self.backend.bk_imag(x)+y)
+            else:
+                return self.backend.bk_complex(x+self.backend.bk_real(y),x+self.backend.bk_imag(y))
                 
             
     def __mul__(self, other):

{foscat-3.0.18 → foscat-3.0.20}/src/foscat.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foscat
-Version: 3.0.18
+Version: 3.0.20
 Summary: Generate synthetic Healpix or 2D data using Cross Scattering Transform
 Home-page: https://github.com/jmdelouis/FOSCAT
 Author: Jean-Marc DELOUIS