foscat 3.4.0__py3-none-any.whl → 3.6.1__py3-none-any.whl

foscat/FoCUS.py

@@ -38,7 +38,7 @@ class FoCUS:
         mpi_rank=0,
     ):
 
-        self.__version__ = "3.4.0"
+        self.__version__ = "3.6.1"
         # P00 coeff for normalization for scat_cov
         self.TMPFILE_VERSION = TMPFILE_VERSION
         self.P1_dic = None

foscat/alm.py

@@ -1,48 +1,137 @@
 import healpy as hp
 import numpy as np
+import time
 
 class alm():
 
     def __init__(self,backend=None,lmax=24,
                  nside=None,limit_range=1E10):
+        
+        if backend is None:
+            import foscat.scat_cov as sc
+            self.sc=sc.funct()
+            self.backend=self.sc.backend
+        else:
+            self.backend=backend.backend
+            
         self._logtab={}
         self.lth={}
+        self.lph={}
+        self.matrix_shift_ph={}
+        self.ratio_mm={}
+        self.P_mm={}
+        self.A={}
+        self.B={}
         if nside is not None:
+            self.maxlog=6*nside+1
             self.lmax=3*nside
-            th,ph=hp.pix2ang(nside,np.arange(12*nside*nside))
-
-            lth=np.unique(th)
-            
-            self.lth[nside]=lth
         else:
             self.lmax=lmax
-
-        for k in range(1,2*self.lmax+1):
-            self._logtab[k]=np.log(k)
+            self.maxlog=2*lmax+1
+        
+        for k in range(1,self.maxlog):
+            self._logtab[k]=self.backend.bk_log(self.backend.bk_cast(k))
         self._logtab[0]=0.0
+
+        if nside is not None:
+            self.ring_th(nside)
+            self.ring_ph(nside)
+            self.shift_ph(nside)
+            
         self._limit_range=1/limit_range
         self._log_limit_range=np.log(limit_range)
         
-        if backend is None:
-            import foscat.scat_cov as sc
-            self.sc=sc.funct()
-            self.backend=self.sc.backend
-        else:
-            self.backend=backend.backend
 
         self.Yp={}
         self.Ym={}
 
     def ring_th(self,nside):
         if nside not in self.lth:
-            th,ph=hp.pix2ang(nside,np.arange(12*nside*nside))
-
-            lth=np.unique(th)
-        
-            self.lth[nside]=lth
+            n=0
+            ith=[]
+            for k in range(nside-1):
+                N=4*(k+1)
+                ith.append(n)
+                n+=N
+                
+            for k in range(2*nside+1):
+                N=4*nside
+                ith.append(n)
+                n+=N
+            for k in range(nside-1):
+                N=4*(nside-1-k)
+                ith.append(n)
+                n+=N
+                
+            th,ph=hp.pix2ang(nside,ith)
+            
+            self.lth[nside]=th
         return self.lth[nside]
+    
+    def ring_ph(self,nside):
+        if nside not in self.lph:
+            n=0
+            iph=[]
+            for k in range(nside-1):
+                N=4*(k+1)
+                iph.append(n)
+                n+=N
+                
+            for k in range(2*nside+1):
+                N=4*nside
+                iph.append(n)
+                n+=N
+            for k in range(nside-1):
+                N=4*(nside-1-k)
+                iph.append(n)
+                n+=N
+                
+            th,ph=hp.pix2ang(nside,iph)
+            
+            self.lph[nside]=ph
         
+    def shift_ph(self,nside):
+        
+        if nside not in self.matrix_shift_ph:
+            self.ring_th(nside)
+            self.ring_ph(nside)
+            x=(-1J*np.arange(3*nside)).reshape(1,3*nside)
+            self.matrix_shift_ph[nside]=self.backend.bk_cast(self.backend.bk_exp(x*self.lph[nside].reshape(4*nside-1,1)))
 
+            self.lmax=3*nside-1
+            
+            ratio_mm={}
+            
+            for m in range(3*nside):
+                val=np.zeros([self.lmax-m+1])
+                aval=np.zeros([self.lmax-m+1])
+                bval=np.zeros([self.lmax-m+1])
+                
+                if m>0:
+                    val[0]=self.double_factorial_log(2*m - 1)-0.5*np.sum(np.log(1+np.arange(2*m)))
+                else:
+                    val[0]=self.double_factorial_log(2*m - 1)
+                if m<self.lmax:
+                    aval[1]=(2*m + 1)
+                    val[1] = val[0]-0.5*self.log(2*m+1)
+
+                    for l in range(m + 2, self.lmax+1):
+                        aval[l-m]=(2*l - 1)/ (l - m)
+                        bval[l-m]=(l + m - 1)/ (l - m)
+                        val[l-m] = val[l-m-1] + 0.5*self.log(l-m) - 0.5*self.log(l+m)
+                        
+                self.A[nside,m]=self.backend.constant((aval))
+                self.B[nside,m]=self.backend.constant((bval))
+                self.ratio_mm[nside,m]=self.backend.constant(np.sqrt(4*np.pi)*np.expand_dims(np.exp(val),1))
+            # Calcul de P_{mm}(x)
+            P_mm=np.ones([3*nside,4*nside-1])
+            x=np.cos(self.lth[nside])
+            if m == 0:
+                P_mm[m] = 1.0
+            for m in range(3*nside-1):
+                P_mm[m] = (0.5-m%2)*2 * (1 - x**2)**(m/2)
+            self.P_mm[nside]=self.backend.constant(P_mm)
+        
     def init_Ys(self,s,nside):
 
         if (s,nside) not in self.Yp:
@@ -52,7 +141,7 @@ class alm():
             ell_max = 3*nside-1  # Use the largest ℓ value you expect to need
             wigner = spherical.Wigner(ell_max)
 
-            th,ph=hp.pix2ang(nside,np.arange(12*nside*nside))
+            #th,ph=hp.pix2ang(nside,np.arange(12*nside*nside))
 
             lth=self.ring_th(nside)
 
@@ -64,21 +153,22 @@ class alm():
             
             for m in range(ell_max+1):
                 idx=np.array([wigner.Yindex(k, m) for k in range(m,ell_max+1)])
-                self.Yp[s,nside][m] = iplus[idx]
-                self.Ym[s,nside][m] = imoins[idx]
+                vnorm=1/np.expand_dims(np.sqrt(2*(np.arange(ell_max-m+1)+m)+1),1)
+                self.Yp[s,nside][m] = iplus[idx]*vnorm
+                self.Ym[s,nside][m] = imoins[idx]*vnorm
                 
             del(iplus)
             del(imoins)
             del(wigner)
             
     def log(self,v):
-        #return np.log(v)
+        return np.log(v)
         if isinstance(v,np.ndarray):
-            return np.array([self.log(k) for k in v])
-        if v<self.lmax*2+1:
+            return np.array([self.backend.bk_log(self.backend.bk_cast(k)) for k in v])
+        if v<self.maxlog:
             return self._logtab[v]
         else:
-            self._logtab[v]=np.log(v)
+            self._logtab[v]=self.backend.bk_log(self.backend.bk_cast(v))
         return self._logtab[v]
 
     # Fonction pour calculer la double factorielle
@@ -87,11 +177,21 @@ class alm():
             return 0.0
         result = 0.0
         for i in range(n, 0, -2):
-            result += self.log(i)
+            result += np.log(i)
         return result
 
-    # Calcul des P_{lm}(x) pour tout l inclus dans [m,lmax]
-    def compute_legendre_m(self,x,m,lmax):
+    def recurrence_fn(self,states, inputs):
+        """
+        Fonction de récurrence pour tf.scan.
+        states: un tuple (U_{n-1}, U_{n-2}) de forme [m]
+        inputs: un tuple (a_n(x), b_n) où a_n(x) est de forme [m]
+        """
+        U_prev, U_prev2 = states
+        a_n, b_n = inputs  # a_n est de forme [m], b_n est un scalaire
+        U_n = a_n * U_prev - b_n * U_prev2
+        return (U_n, U_prev)  # Avancer les états
+# Calcul des P_{lm}(x) pour tout l inclus dans [m,lmax]
+    def compute_legendre_m(self,x,m,lmax,nside):
         result=np.zeros([lmax-m+1,x.shape[0]])
         ratio=np.zeros([lmax-m+1,1])
         
@@ -109,7 +209,7 @@ class alm():
         result[0]  = Pmm
     
         if m == lmax:
-            return result*np.exp(ratio)*np.sqrt(4*np.pi*(2*(np.arange(lmax-m+1)+m)+1)).reshape(lmax+1-m,1)
+            return result*np.exp(ratio)*np.sqrt(4*np.pi)
     
         # Étape 2 : Calcul de P_{l+1, m}(x)
         result[1] = x * (2*m + 1) * result[0]
@@ -126,7 +226,81 @@ class alm():
                 ratio[l-m-1,0]+= self._log_limit_range
                 ratio[l-m,0]+=   self._log_limit_range
                 
-        return result*np.exp(ratio)*(np.sqrt(4*np.pi*(2*(np.arange(lmax-m+1)+m)+1))).reshape(lmax+1-m,1)
+        return result*np.exp(ratio)*np.sqrt(4*np.pi)
+
+    # Calcul des P_{lm}(x) pour tout l inclus dans [m,lmax]
+    def compute_legendre_m_old2(self,x,m,lmax,nside):
+        
+        result={}
+        
+        # Si l == m, c'est directement P_{mm}
+        result[0]  = self.P_mm[nside][m]
+    
+        if m == lmax:
+            v=self.backend.bk_reshape(result[0]*self.ratio_mm[nside,m][0],[1,4*nside-1])
+            return self.backend.bk_complex(v,0*v)
+    
+        # Étape 2 : Calcul de P_{l+1, m}(x)
+        result[1] = x * self.A[nside,m][1] * result[0]
+    
+        # Étape 3 : Récurence pour l > m + 1
+        for l in range(m + 2, lmax+1):
+            result[l-m]  = self.A[nside,m][l-m] * x * result[l-m-1] - self.B[nside,m][l-m] *  result[l-m-2]
+            """
+            if np.max(abs(result[l-m]))>self._limit_range:
+                result[l-m-1]*=  self._limit_range
+                result[l-m]*=    self._limit_range
+                ratio[l-m-1]+= self._log_limit_range
+                ratio[l-m]+=   self._log_limit_range
+            """
+        result=self.backend.bk_reshape(self.backend.bk_concat([result[k] for k in range(lmax+1-m)],axis=0),[lmax+1-m,4*nside-1])
+
+        return self.backend.bk_complex(result*self.ratio_mm[nside,m],0*result)
+
+    
+    def compute_legendre_m_old(self,x,m,lmax,nside):
+        
+        import tensorflow as tf
+        result={}
+        
+        # Si l == m, c'est directement P_{mm}
+        U_0  = self.P_mm[nside][m]
+    
+        if m == lmax:
+            v=self.backend.bk_reshape(U_0*self.ratio_mm[nside,m][0],[1,4*nside-1])
+            return self.backend.bk_complex(v,0*v)
+    
+        # Étape 2 : Calcul de P_{l+1, m}(x)
+        U_1 = x * self.A[nside,m][1] * U_0
+        if m == lmax-1:
+            result = tf.concat([self.backend.bk_expand_dims(U_0,0),
+                                self.backend.bk_expand_dims(U_1,0)],0)
+            return self.backend.bk_complex(result*self.ratio_mm[nside,m],0*result)
+
+        a_values = self.backend.bk_expand_dims(self.A[nside,m],1)*self.backend.bk_expand_dims(x,0)
+        # Initialiser les états avec (U_1, U_0) pour chaque m
+        initial_states = (U_1, U_0)
+        inputs = (a_values[2:], self.B[nside,m][2:])
+        # Appliquer tf.scan
+        result = tf.scan(self.recurrence_fn, inputs, initializer=initial_states)
+        # Le premier élément de result contient les U[n]
+        result = tf.concat([self.backend.bk_expand_dims(U_0,0),
+                            self.backend.bk_expand_dims(U_1,0),
+                            result[0]], axis=0)
+        """
+        # Étape 3 : Récurence pour l > m + 1
+        for l in range(m + 2, lmax+1):
+            result[l-m]  = self.A[nside,m][l-m] * x * result[l-m-1] - self.B[nside,m][l-m] *  result[l-m-2]
+            
+            if np.max(abs(result[l-m]))>self._limit_range:
+                result[l-m-1]*=  self._limit_range
+                result[l-m]*=    self._limit_range
+                ratio[l-m-1]+= self._log_limit_range
+                ratio[l-m]+=   self._log_limit_range
+        result=self.backend.bk_reshape(self.backend.bk_concat([result[k] for k in range(lmax+1-m)],axis=0),[lmax+1-m,4*nside-1])
+         """
+        
+        return self.backend.bk_complex(result*self.ratio_mm[nside,m],0*result)
 
     
     # Calcul des s_P_{lm}(x) pour tout l inclus dans [m,lmax]
@@ -194,45 +368,139 @@ class alm():
         ylm_moins = alpha_moins*ylm[1:] + beta_moins*ylm[:-1]
                 
         return ylm_plus,ylm_moins
+
+    def rfft2fft(self,val,axis=0):
+        r=self.backend.bk_rfft(val)
+        if axis==0:
+            r_inv=self.backend.bk_reverse(self.backend.bk_conjugate(r[1:-1]),axis=axis)
+        else:
+            r_inv=self.backend.bk_reverse(self.backend.bk_conjugate(r[:,1:-1]),axis=axis)
+        return self.backend.bk_concat([r,r_inv],axis=axis)
     
-    def comp_tf(self,im,ph):
-        nside=int(np.sqrt(im.shape[0]//12))
+    def irfft2fft(self,val,N,axis=0):
+        if axis==0:
+            return self.backend.bk_irfft(val[0:N//2+1])
+        else:
+            return self.backend.bk_irfft(val[:,0:N//2+1])
+    
+    def comp_tf(self,im,nside,realfft=False):
+        
+        self.shift_ph(nside)
         n=0
-        ii=0
+        
         ft_im=[]
         for k in range(nside-1):
             N=4*(k+1)
-            l_n=N
-            if l_n>3*nside:
-                l_n=3*nside
-            tmp=self.backend.bk_fft(im[n:n+N])[0:l_n]
-            ft_im.append(tmp*np.exp(-1J*np.arange(l_n)*ph[n]))
-            ft_im.append(self.backend.bk_zeros((3*nside-l_n),dtype=self.backend.all_cbk_type))
-            # if N<3*nside fill the tf with rotational values to mimic alm_tools.F90 of healpix (Minor effect)
-            #for m in range(l_n,3*nside,l_n):
-            #    ft_im.append(tmp[0:np.min([3*nside-m,l_n])])
-            n+=N
-            ii+=1
-        for k in range(2*nside+1):
-            N=4*nside
-            ft_im.append(self.backend.bk_fft(im[n:n+N])[:3*nside]*np.exp(-1J*np.arange(3*nside)*ph[n]))
+            
+            if realfft:
+                tmp=self.rfft2fft(im[n:n+N])
+            else:
+                tmp=self.backend.bk_fft(im[n:n+N])
+
+            l_n=tmp.shape[0]
+            
+            if l_n<3*nside+1:
+                repeat_n=3*nside//l_n+1
+                tmp=self.backend.bk_tile(tmp,repeat_n,axis=0)
+                
+            ft_im.append(tmp[0:3*nside])
+            
             n+=N
-            ii+=1
+        if nside>1:
+            result=self.backend.bk_reshape(self.backend.bk_concat(ft_im,axis=0),[nside-1,3*nside])
+        
+        N=4*nside*(2*nside+1)    
+        v=self.backend.bk_reshape(im[n:n+N],[2*nside+1,4*nside])
+        if realfft:
+            v_fft=self.rfft2fft(v,axis=1)[:,:3*nside]
+        else:
+            v_fft=self.backend.bk_fft(v)[:,:3*nside]
+
+        n+=N
+        if nside>1:
+            result=self.backend.bk_concat([result,v_fft],axis=0)
+        else:
+            result=v_fft
+        
+        if nside>1:
+            ft_im=[]
+            for k in range(nside-1):
+                N=4*(nside-1-k)
+
+                if realfft:
+                    tmp=self.rfft2fft(im[n:n+N])[0:l_n]
+                else:
+                    tmp=self.backend.bk_fft(im[n:n+N])[0:l_n]
+
+                l_n=tmp.shape[0]
+
+                if l_n<3*nside+1:
+                    repeat_n=3*nside//l_n+1
+                    tmp=self.backend.bk_tile(tmp,repeat_n,axis=0)
+
+                ft_im.append(tmp[0:3*nside])
+                n+=N
+
+            lastresult=self.backend.bk_reshape(self.backend.bk_concat(ft_im,axis=0),[nside-1,3*nside])
+            return self.backend.bk_concat([result,lastresult],axis=0)*self.matrix_shift_ph[nside]
+        else:
+            return result*self.matrix_shift_ph[nside]
+
+    
+    def icomp_tf(self,i_im,nside,realfft=False):
+        
+        self.shift_ph(nside)
+        
+        n=0
+        im=[]
+        ft_im=i_im*self.backend.bk_conjugate(self.matrix_shift_ph[nside])
+        
         for k in range(nside-1):
-            N=4*(nside-1-k)
-            l_n=N
-            if l_n>3*nside:
-                l_n=3*nside
-            tmp=self.backend.bk_fft(im[n:n+N])[0:l_n]
-            ft_im.append(tmp*np.exp(-1J*np.arange(l_n)*ph[n]))
-            ft_im.append(self.backend.bk_zeros((3*nside-l_n),dtype=self.backend.all_cbk_type))
-            # if N<3*nside fill the tf with rotational values to mimic alm_tools.F90 of healpix (Minor effect)
-            #for m in range(l_n,3*nside,l_n):
-            #    ft_im.append(tmp[0:np.min([3*nside-m,l_n])])
+            N=4*(k+1)
+            
+            if realfft:
+                tmp=self.irfft2fft(ft_im[k],N)
+            else:
+                tmp=self.backend.bk_ifft(im[k],N)
+                
+            im.append(tmp[0:N])
+            
             n+=N
-            ii+=1
-        return self.backend.bk_reshape(self.backend.bk_concat(ft_im,axis=0),[4*nside-1,3*nside])
+            
+        if nside>1:
+            result=self.backend.bk_concat(im,axis=0)
+        
+        N=4*nside*(2*nside+1)    
+        v=ft_im[nside-1:3*nside,0:2*nside+1]
+        if realfft:
+            v_fft=self.backend.bk_reshape(self.irfft2fft(v,N,axis=1),[4*nside*(2*nside+1)])
+        else:
+            v_fft=self.backend.bk_ifft(v)
+
+        n+=N
+        if nside>1:
+            result=self.backend.bk_concat([result,v_fft],axis=0)
+        else:
+            result=v_fft
+        
+        if nside>1:
+            im=[]
+            for k in range(nside-1):
+                N=4*(nside-1-k)
+            
+                if realfft:
+                    tmp=self.irfft2fft(ft_im[k+3*nside],N)
+                else:
+                    tmp=self.backend.bk_ifft(im[k+3*nside],N)
+                
+                im.append(tmp[0:N])
+            
+                n+=N
 
+            return self.backend.bk_concat([result]+im,axis=0)
+        else:
+            return result
+        
     def anafast(self,im,map2=None,nest=False,spin=2):
         
         """The `anafast` function computes the L1 and L2 norm power spectra. 
@@ -253,38 +521,41 @@ class alm():
         ordered as TT, EE, BB, TE, EB.TBanafast function computes L1 and L2 norm powerspctra.
 
         """
+        i_im=self.backend.bk_cast(im)
+        if map2 is not None:
+            i_map2=self.backend.bk_cast(map2)
+            
         doT=True
-        if len(im.shape)==1: # nopol
-            nside=int(np.sqrt(im.shape[0]//12))
+        if len(i_im.shape)==1: # nopol
+            nside=int(np.sqrt(i_im.shape[0]//12))
         else:
-            if im.shape[0]==2:
+            if i_im.shape[0]==2:
                 doT=False
-                
-            nside=int(np.sqrt(im.shape[1]//12))
+            nside=int(np.sqrt(i_im.shape[1]//12))
             
-        th,ph=hp.pix2ang(nside,np.arange(12*nside*nside))
-        
+        self.shift_ph(nside)
+    
         if doT: # nopol
+            if len(i_im.shape)==2: # pol
+                l_im=i_im[0]
+                if map2 is not None:
+                    l_map2=i_map2[0]
+            else:
+                l_im=i_im
+                if map2 is not None:
+                    l_map2=i_map2
+                    
             if nest:
                 idx=hp.ring2nest(nside,np.arange(12*nside**2))
-                if len(im.shape)==1: # nopol
-                    ft_im=self.comp_tf(self.backend.bk_complex(self.backend.bk_gather(im,idx),0*im),ph)
-                    if map2 is not None:
-                        ft_im2=self.comp_tf(self.backend.bk_complex(self.backend.bk_gather(map2,idx),0*im),ph)
-                else:
-                    ft_im=self.comp_tf(self.backend.bk_complex(self.backend.bk_gather(im[0],idx),0*im[0]),ph)
+                if len(i_im.shape)==1: # nopol
+                    ft_im=self.comp_tf(self.backend.bk_gather(l_im,idx),nside,realfft=True)
                     if map2 is not None:
-                        ft_im2=self.comp_tf(self.backend.bk_complex(self.backend.bk_gather(map2[0],idx),0*im[0]),ph)
+                        ft_im2=self.comp_tf(self.backend.bk_gather(l_map2,idx),nside,realfft=True)
             else:
-                if len(im.shape)==1: # nopol
-                    ft_im=self.comp_tf(self.backend.bk_complex(im,0*im),ph)
-                    if map2 is not None:
-                        ft_im2=self.comp_tf(self.backend.bk_complex(map2,0*im),ph)
-                else:
-                    ft_im=self.comp_tf(self.backend.bk_complex(im[0],0*im[0]),ph)
-                    if map2 is not None:
-                        ft_im2=self.comp_tf(self.backend.bk_complex(map2[0],0*im[0]),ph)
-                    
+                ft_im=self.comp_tf(l_im,nside,realfft=True)
+                if map2 is not None:
+                    ft_im2=self.comp_tf(l_map2,nside,realfft=True)
+
         lth=self.ring_th(nside)
 
         co_th=np.cos(lth)
@@ -293,33 +564,35 @@ class alm():
         
         cl2=None
         cl2_L1=None
-        
-        if len(im.shape)==2: # nopol
+        dt2=0
+        dt3=0
+        dt4=0
+        if len(i_im.shape)==2: # nopol
         
             self.init_Ys(spin,nside)
             
             if nest:
                 idx=hp.ring2nest(nside,np.arange(12*nside**2))
-                l_Q=self.backend.bk_gather(im[int(doT)],idx)
-                l_U=self.backend.bk_gather(im[1+int(doT)],idx)
-                ft_im_Pp=self.comp_tf(self.backend.bk_complex(l_Q,l_U),ph)
-                ft_im_Pm=self.comp_tf(self.backend.bk_complex(l_Q,-l_U),ph)
+                l_Q=self.backend.bk_gather(i_im[int(doT)],idx)
+                l_U=self.backend.bk_gather(i_im[1+int(doT)],idx)
+                ft_im_Pp=self.comp_tf(self.backend.bk_complex(l_Q,l_U),nside)
+                ft_im_Pm=self.comp_tf(self.backend.bk_complex(l_Q,-l_U),nside)
                 if map2 is not None:
-                    l_Q=self.backend.bk_gather(map2[int(doT)],idx)
-                    l_U=self.backend.bk_gather(map2[1+int(doT)],idx)
-                    ft_im2_Pp=self.comp_tf(self.backend.bk_complex(l_Q,l_U),ph)
-                    ft_im2_Pm=self.comp_tf(self.backend.bk_complex(l_Q,-l_U),ph)
+                    l_Q=self.backend.bk_gather(i_map2[int(doT)],idx)
+                    l_U=self.backend.bk_gather(i_map2[1+int(doT)],idx)
+                    ft_im2_Pp=self.comp_tf(self.backend.bk_complex(l_Q,l_U),nside)
+                    ft_im2_Pm=self.comp_tf(self.backend.bk_complex(l_Q,-l_U),nside)
             else:
-                ft_im_Pp=self.comp_tf(self.backend.bk_complex(im[int(doT)],im[1+int(doT)]),ph)
-                ft_im_Pm=self.comp_tf(self.backend.bk_complex(im[int(doT)],-im[1+int(doT)]),ph)
+                ft_im_Pp=self.comp_tf(self.backend.bk_complex(i_im[int(doT)],i_im[1+int(doT)]),nside)
+                ft_im_Pm=self.comp_tf(self.backend.bk_complex(i_im[int(doT)],-i_im[1+int(doT)]),nside)
                 if map2 is not None:
-                    ft_im2_Pp=self.comp_tf(self.backend.bk_complex(map2[int(doT)],map2[1+int(doT)]),ph)
-                    ft_im2_Pm=self.comp_tf(self.backend.bk_complex(map2[int(doT)],-map2[1+int(doT)]),ph)
+                    ft_im2_Pp=self.comp_tf(self.backend.bk_complex(i_map2[int(doT)],i_map2[1+int(doT)]),nside)
+                    ft_im2_Pm=self.comp_tf(self.backend.bk_complex(i_map2[int(doT)],-i_map2[1+int(doT)]),nside)
 
         for m in range(lmax+1):
 
-            plm=self.compute_legendre_m(co_th,m,3*nside-1)/(12*nside**2)
-
+            plm=self.compute_legendre_m(co_th,m,3*nside-1,nside)/(12*nside**2)
+            
             if doT:
                 tmp=self.backend.bk_reduce_sum(plm*ft_im[:,m],1)
 
@@ -327,8 +600,8 @@ class alm():
                     tmp2=self.backend.bk_reduce_sum(plm*ft_im2[:,m],1)
                 else:
                     tmp2=tmp
-                
-            if len(im.shape)==2: # pol
+                    
+            if len(i_im.shape)==2: # pol
                 plmp=self.Yp[spin,nside][m]
                 plmm=self.Ym[spin,nside][m]
             
@@ -398,35 +671,35 @@ class alm():
                     
             if cl2 is None:
                 cl2=l_cl
-                cl2_l1=self.backend.bk_L1(l_cl)
             else:
                 cl2+=2*l_cl
-                cl2_l1+=2*self.backend.bk_L1(l_cl)
-                
-        if len(im.shape)==1: # nopol
-            cl2=cl2/(2*np.arange(cl2.shape[0])+1)
-            cl2_l1=cl2_l1/(2*np.arange(cl2.shape[0])+1)
-        else:
-            cl2=cl2/np.expand_dims(2*np.arange(cl2.shape[1])+1,0)
-            cl2_l1=cl2_l1/np.expand_dims(2*np.arange(cl2.shape[1])+1,0)
+        
+        #cl2=cl2*(4*np.pi) #self.backend.bk_sqrt(self.backend.bk_cast(4*np.pi)) #(2*np.arange(cl2.shape[0])+1)))
+                                         
+        cl2_l1=self.backend.bk_L1(cl2)
+                                         
         return cl2,cl2_l1
 
     def map2alm(self,im,nest=False):
         nside=int(np.sqrt(im.shape[0]//12))
-        th,ph=hp.pix2ang(nside,np.arange(12*nside*nside))
+        
+        ph=self.shift_ph(nside)
+        
         if nest:
             idx=hp.ring2nest(nside,np.arange(12*nside**2))
-            ft_im=self.comp_tf(self.backend.bk_complex(self.backend.bk_gather(im,idx),0*im),ph)
+            ft_im=self.comp_tf(self.backend.bk_cast(self.backend.bk_gather(im,idx)),nside,realfft=True)
         else:
-            ft_im=self.comp_tf(self.backend.bk_complex(im,0*im),ph)
+            ft_im=self.comp_tf(self.backend.bk_cast(im),nside,realfft=True)
             
-        co_th=np.cos(self.ring_th(nside))
+        lth=self.ring_th(nside)
+
+        co_th=np.cos(lth)
 
         lmax=3*nside-1
     
         alm=None
         for m in range(lmax+1):
-            plm=self.compute_legendre_m(co_th,m,3*nside-1)/(12*nside**2)
+            plm=self.compute_legendre_m(co_th,m,3*nside-1,nside)/(12*nside**2)
             
             tmp=self.backend.bk_reduce_sum(plm*ft_im[:,m],1)
             if m==0:
@@ -436,29 +709,71 @@ class alm():
             
         return alm
 
+    
+    def alm2map(self,nside,alm):
+
+        lth=self.ring_th(nside)
+
+        co_th=np.cos(lth)
+        
+        ft_im=[]
+
+        n=0
+
+        lmax=3*nside-1
+        
+        for m in range(lmax+1):
+            plm=self.compute_legendre_m(co_th,m,3*nside-1,nside)/(12*nside**2)
+
+            print(alm[n:n+lmax-m+1].shape,plm.shape)
+            ft_im.append(self.backend.bk_reduce_sum(self.backend.bk_reshape(alm[n:n+lmax-m+1],[lmax-m+1,1])*plm,0))
+
+            n=n+lmax-m+1
+            
+        return self.backend.bk_reshape(self.backend.bk_concat(ft_im,0),[lmax+1,4*nside-1])
+        
+            
+        if nest:
+            idx=hp.ring2nest(nside,np.arange(12*nside**2))
+            ft_im=self.comp_tf(self.backend.bk_cast(self.backend.bk_gather(im,idx)),nside,realfft=True)
+        else:
+            ft_im=self.comp_tf(self.backend.bk_cast(im),nside,realfft=True)
+            
+
+        lmax=3*nside-1
+    
+        alm=None
+        for m in range(lmax+1):
+            plm=self.compute_legendre_m(co_th,m,3*nside-1,nside)/(12*nside**2)
+            
+            tmp=self.backend.bk_reduce_sum(plm*ft_im[:,m],1)
+            if m==0:
+                alm=tmp
+            else:
+                alm=self.backend.bk_concat([alm,tmp],axis=0)
+            
+        return o_map
+
     def map2alm_spin(self,im_Q,im_U,spin=2,nest=False):
         
         if spin==0:
             return self.map2alm(im_Q,nest=nest),self.map2alm(im_U,nest=nest)
 
-        
         nside=int(np.sqrt(im_Q.shape[0]//12))
-        th,ph=hp.pix2ang(nside,np.arange(12*nside*nside))
+
+        lth=self.ring_th(nside)
         
-        self.init_Ys(spin,nside)
+        co_th=np.cos(lth)
         
         if nest:
             idx=hp.ring2nest(nside,np.arange(12*nside**2))
             l_Q=self.backend.bk_gather(im_Q,idx)
             l_U=self.backend.bk_gather(im_U,idx)
-            ft_im_1=self.comp_tf(self.backend.bk_complex(l_Q,l_U),ph)
-            ft_im_2=self.comp_tf(self.backend.bk_complex(l_Q,-l_U),ph)
+            ft_im_1=self.comp_tf(self.backend.bk_complex(l_Q,l_U),nside)
+            ft_im_2=self.comp_tf(self.backend.bk_complex(l_Q,-l_U),nside)
         else:
-            ft_im_1=self.comp_tf(self.backend.bk_complex(im_Q,im_U),ph)
-            ft_im_2=self.comp_tf(self.backend.bk_complex(im_Q,-im_U),ph)
-
-        #co_th=np.cos(self.ring_th[nside])
-        #si_th=np.sin(self.ring_th[nside])
+            ft_im_1=self.comp_tf(self.backend.bk_complex(im_Q,im_U),nside)
+            ft_im_2=self.comp_tf(self.backend.bk_complex(im_Q,-im_U),nside)
 
         lmax=3*nside-1
     

foscat/alm_tools.py

@@ -9,184 +9,3 @@ class alm_tools():
     def __init__(self):
         pass
 
-    @staticmethod
-    def gen_recfac(l_max, m):
-        """
-        Generate recursion factors used to compute the Ylm of degree m for all l in m <= l <= l_max.
-
-        Parameters:
-        l_max (int): Maximum degree l.
-        m (int): Degree m.
-
-        Returns:
-        np.ndarray: Recursion factors as a 2D array of shape (2, l_max + 1).
-        """
-        recfac = np.zeros((2, l_max + 1), dtype=np.float64)
-        fm2 = float(m)**2
-
-        for l in range(m, l_max + 1):
-            fl2 = float(l + 1)**2
-            recfac[0, l] = np.sqrt((4.0 * fl2 - 1.0) / (fl2 - fm2))
-
-        recfac[1, m:l_max + 1] = 1.0 / recfac[0, m:l_max + 1]
-
-        return recfac
-
-    @staticmethod
-    def gen_recfac_spin(l_max, m, spin):
-        """
-        Generate recursion factors for spin-weighted spherical harmonics.
-
-        Parameters:
-        l_max (int): Maximum degree l.
-        m (int): Degree m.
-        spin (int): Spin weight.
-
-        Returns:
-        np.ndarray: Recursion factors as a 2D array of shape (2, l_max + 1).
-        """
-        recfac_spin = np.zeros((2, l_max + 1), dtype=np.float64)
-        fm2 = float(m)**2
-        s2 = float(spin)**2
-
-        for l in range(m, l_max + 1):
-            fl2 = float(l + 1)**2
-            recfac_spin[0, l] = np.sqrt((4.0 * fl2 - 1.0) / (fl2 - fm2))
-
-        recfac_spin[1, m:l_max + 1] = (1.0 - s2 / (float(m) + 1.0)**2) / recfac_spin[0, m:l_max + 1]
-
-        return recfac_spin
-
-    @staticmethod
-    def gen_lamfac(l_max):
-        """
-        Generate lambda factors for spherical harmonics.
-
-        Parameters:
-        l_max (int): Maximum degree l.
-
-        Returns:
-        np.ndarray: Lambda factors as a 1D array of size l_max + 1.
-        """
-        lamfac = np.zeros(l_max + 1, dtype=np.float64)
-
-        for l in range(1, l_max + 1):
-            lamfac[l] = np.sqrt(2.0 * l + 1.0)
-
-        return lamfac
-
-    @staticmethod
-    def gen_lamfac_der(l_max):
-        """
-        Generate the derivatives of lambda factors.
-
-        Parameters:
-        l_max (int): Maximum degree l.
-
-        Returns:
-        np.ndarray: Lambda factor derivatives as a 1D array of size l_max + 1.
-        """
-        lamfac_der = np.zeros(l_max + 1, dtype=np.float64)
-
-        for l in range(1, l_max + 1):
-            lamfac_der[l] = (2.0 * l + 1.0) / np.sqrt(2.0 * l + 1.0)
-
-        return lamfac_der
-
-    @staticmethod
-    def gen_mfac(m_max):
-        """
-        Generate m factors for spherical harmonics.
-
-        Parameters:
-        m_max (int): Maximum degree m.
-
-        Returns:
-        np.ndarray: M factors as a 1D array of size m_max + 1.
-        """
-        mfac = np.zeros(m_max + 1, dtype=np.float64)
-
-        for m in range(1, m_max + 1):
-            mfac[m] = np.sqrt(2.0 * m)
-
-        return mfac
-
-    @staticmethod
-    def gen_mfac_spin(m_max, spin):
-        """
-        Generate m factors for spin-weighted spherical harmonics.
-
-        Parameters:
-        m_max (int): Maximum degree m.
-        spin (int): Spin weight.
-
-        Returns:
-        np.ndarray: Spin-weighted m factors as a 1D array of size m_max + 1.
-        """
-        mfac_spin = np.zeros(m_max + 1, dtype=np.float64)
-
-        for m in range(1, m_max + 1):
-            mfac_spin[m] = np.sqrt(2.0 * m) * (1.0 - spin**2 / (m + 1)**2)
-
-        return mfac_spin
-
-    @staticmethod
-    def compute_lam_mm(l_max, m):
-        """
-        Compute lambda values for specific m.
-
-        Parameters:
-        l_max (int): Maximum degree l.
-        m (int): Degree m.
-
-        Returns:
-        np.ndarray: Lambda values as a 1D array of size l_max + 1.
-        """
-        lam_mm = np.zeros(l_max + 1, dtype=np.float64)
-
-        for l in range(m, l_max + 1):
-            lam_mm[l] = (2.0 * l + 1.0) * (1.0 - (m / (l + 1.0))**2)
-
-        return lam_mm
-
-    @staticmethod
-    def do_lam_lm(l_max, m):
-        """
-        Perform computations for lambda values for all l, m.
-
-        Parameters:
-        l_max (int): Maximum degree l.
-        m (int): Degree m.
-
-        Returns:
-        np.ndarray: Computed lambda values as a 2D array of size (l_max + 1, l_max + 1).
-        """
-        lam_lm = np.zeros((l_max + 1, l_max + 1), dtype=np.float64)
-
-        for l in range(m, l_max + 1):
-            for mp in range(m, l + 1):
-                lam_lm[l, mp] = (2.0 * l + 1.0) * (1.0 - (mp / (l + 1.0))**2)
-
-        return lam_lm
-
-    @staticmethod
-    def do_lam_lm_spin(l_max, m, spin):
-        """
-        Perform computations for spin-weighted lambda values for all l, m.
-
-        Parameters:
-        l_max (int): Maximum degree l.
-        m (int): Degree m.
-        spin (int): Spin weight.
-
-        Returns:
-        np.ndarray: Computed spin-weighted lambda values as a 2D array of size (l_max + 1, l_max + 1).
-        """
-        lam_lm_spin = np.zeros((l_max + 1, l_max + 1), dtype=np.float64)
-
-        for l in range(m, l_max + 1):
-            for mp in range(m, l + 1):
-                lam_lm_spin[l, mp] = (2.0 * l + 1.0) * (1.0 - spin**2 / (mp + 1.0)**2)
-
-        return lam_lm_spin
-

foscat/backend.py

@@ -879,7 +879,10 @@ class foscat_backend:
     def bk_repeat(self, data, nn, axis=0):
         return self.backend.repeat(data, nn, axis=axis)
 
-    def bk_tile(self, data, nn, axis=0):
+    def bk_tile(self, data, nn,axis=0):
+        if self.BACKEND == self.TENSORFLOW:
+            return self.backend.tile(data, [nn])
+        
         return self.backend.tile(data, nn)
 
     def bk_roll(self, data, nn, axis=0):
@@ -952,6 +955,14 @@ class foscat_backend:
         if self.BACKEND == self.NUMPY:
             return data[idx]
         
+    def bk_reverse(self, data,axis=0):
+        if self.BACKEND == self.TENSORFLOW:
+            return self.backend.reverse(data,axis=[axis])
+        if self.BACKEND == self.TORCH:
+            return self.backend.reverse(data,axis=axis)
+        if self.BACKEND == self.NUMPY:
+            return np.reverse(data,axis=axis)
+        
     def bk_fft(self, data):
         if self.BACKEND == self.TENSORFLOW:
             return self.backend.signal.fft(data)
@@ -960,6 +971,23 @@ class foscat_backend:
         if self.BACKEND == self.NUMPY:
             return self.backend.fft.fft(data)
         
+    def bk_rfft(self, data):
+        if self.BACKEND == self.TENSORFLOW:
+            return self.backend.signal.rfft(data)
+        if self.BACKEND == self.TORCH:
+            return self.backend.rfft(data)
+        if self.BACKEND == self.NUMPY:
+            return self.backend.fft.rfft(data)
+
+        
+    def bk_irfft(self, data):
+        if self.BACKEND == self.TENSORFLOW:
+            return self.backend.signal.irfft(data)
+        if self.BACKEND == self.TORCH:
+            return self.backend.irfft(data)
+        if self.BACKEND == self.NUMPY:
+            return self.backend.fft.irfft(data)
+        
     def bk_conjugate(self, data):
 
         if self.BACKEND == self.TENSORFLOW:

foscat/scat_cov.py

@@ -2488,15 +2488,16 @@ class funct(FOC.FoCUS):
         )
 
     def eval(
-        self,
-        image1,
-        image2=None,
-        mask=None,
-        norm=None,
-        Auto=True,
-        calc_var=False,
-        cmat=None,
-        cmat2=None,
+            self,
+            image1,
+            image2=None,
+            mask=None,
+            norm=None,
+            Auto=True,
+            calc_var=False,
+            cmat=None,
+            cmat2=None,
+            out_nside=None
     ):
         """
         Calculates the scattering correlations for a batch of images. Mean are done over pixels.
@@ -2708,6 +2709,8 @@ class funct(FOC.FoCUS):
 
         if return_data:
             s0 = I1
+            if out_nside is not None:
+                s0 = self.backend.bk_reduce_mean(self.backend.bk_reshape(s0,[s0.shape[0],12*out_nside**2,(nside//out_nside)**2]),2)
         else:
             if not cross:
                 s0, l_vs0 = self.masked_mean(I1, vmask, axis=1, calc_var=True)
@@ -2778,6 +2781,12 @@ class funct(FOC.FoCUS):
                 if return_data:
                     if S2 is None:
                         S2 = {}
+                    if out_nside is not None and out_nside<nside_j3:
+                        s2 = self.backend.bk_reduce_mean(
+                            self.backend.bk_reshape(s2,[s2.shape[0],
+                                                        12*out_nside**2,
+                                                        (nside_j3//out_nside)**2,
+                                                        s2.shape[2]]),2)
                     S2[j3] = s2
                 else:
                     if norm == "auto":  # Normalize S2
@@ -2818,6 +2827,12 @@ class funct(FOC.FoCUS):
                 if return_data:
                     if S1 is None:
                         S1 = {}
+                    if out_nside is not None and out_nside<nside_j3:
+                        s1 = self.backend.bk_reduce_mean(
+                            self.backend.bk_reshape(s1,[s1.shape[0],
+                                                        12*out_nside**2,
+                                                        (nside_j3//out_nside)**2,
+                                                        s1.shape[2]]),2)
                     S1[j3] = s1
                 else:
                     ### Normalize S1
@@ -2904,6 +2919,12 @@ class funct(FOC.FoCUS):
                 if return_data:
                     if S2 is None:
                         S2 = {}
+                    if out_nside is not None and out_nside<nside_j3:
+                        s2 = self.backend.bk_reduce_mean(
+                            self.backend.bk_reshape(s2,[s2.shape[0],
+                                                        12*out_nside**2,
+                                                        (nside_j3//out_nside)**2,
+                                                        s2.shape[2]]),2)
                     S2[j3] = s2
                 else:
                     ### Normalize S2_cross
@@ -2949,6 +2970,12 @@ class funct(FOC.FoCUS):
                 if return_data:
                     if S1 is None:
                         S1 = {}
+                    if out_nside is not None and out_nside<nside_j3:
+                        s1 = self.backend.bk_reduce_mean(
+                            self.backend.bk_reshape(s1,[s1.shape[0],
+                                                        12*out_nside**2,
+                                                        (nside_j3//out_nside)**2,
+                                                        s1.shape[2]]),2)
                     S1[j3] = s1
                 else:
                     ### Normalize S1
@@ -2979,6 +3006,7 @@ class funct(FOC.FoCUS):
                 M2convPsi_dic = {}
 
             ###### S3
+            nside_j2=nside_j3
             for j2 in range(0, j3 + 1):  # j2 <= j3
                 if return_data:
                     if S4[j3] is None:
@@ -3013,6 +3041,13 @@ class funct(FOC.FoCUS):
                     if return_data:
                         if S3[j3] is None:
                             S3[j3] = {}
+                        if out_nside is not None and out_nside<nside_j2:
+                            s3 = self.backend.bk_reduce_mean(
+                                self.backend.bk_reshape(s3,[s3.shape[0],
+                                                            12*out_nside**2,
+                                                            (nside_j2//out_nside)**2,
+                                                            s3.shape[2],
+                                                            s3.shape[3]]),2)
                         S3[j3][j2] = s3
                     else:
                         ### Normalize S3 with S2_j [Nbatch, Nmask, Norient_j]
@@ -3095,6 +3130,19 @@ class funct(FOC.FoCUS):
                         if S3[j3] is None:
                             S3[j3] = {}
                             S3P[j3] = {}
+                        if out_nside is not None and out_nside<nside_j2:
+                            s3 = self.backend.bk_reduce_mean(
+                                self.backend.bk_reshape(s3,[s3.shape[0],
+                                                            12*out_nside**2,
+                                                            (nside_j2//out_nside)**2,
+                                                            s3.shape[2],
+                                                            s3.shape[3]]),2)
+                            s3p = self.backend.bk_reduce_mean(
+                                self.backend.bk_reshape(s3p,[s3.shape[0],
+                                                             12*out_nside**2,
+                                                             (nside_j2//out_nside)**2,
+                                                             s3.shape[2],
+                                                             s3.shape[3]]),2)
                         S3[j3][j2] = s3
                         S3P[j3][j2] = s3p
                     else:
@@ -3154,6 +3202,7 @@ class funct(FOC.FoCUS):
                                 )  # Add a dimension for NS3
 
                 ##### S4
+                nside_j1=nside_j2
                 for j1 in range(0, j2 + 1):  # j1 <= j2
                     ### S4_auto = <(|I1 * psi1| * psi3)(|I1 * psi2| * psi3)^*>
                     if not cross:
@@ -3179,6 +3228,14 @@ class funct(FOC.FoCUS):
                         if return_data:
                             if S4[j3][j2] is None:
                                 S4[j3][j2] = {}
+                            if out_nside is not None and out_nside<nside_j1:
+                                s4 = self.backend.bk_reduce_mean(
+                                    self.backend.bk_reshape(s4,[s4.shape[0],
+                                                                12*out_nside**2,
+                                                                (nside_j1//out_nside)**2,
+                                                                s4.shape[2],
+                                                                s4.shape[3],
+                                                                s4.shape[4]]),2)
                             S4[j3][j2][j1] = s4
                         else:
                             ### Normalize S4 with S2_j [Nbatch, Nmask, Norient_j]
@@ -3248,6 +3305,14 @@ class funct(FOC.FoCUS):
                         if return_data:
                             if S4[j3][j2] is None:
                                 S4[j3][j2] = {}
+                            if out_nside is not None and out_nside<nside_j1:
+                                s4 = self.backend.bk_reduce_mean(
+                                    self.backend.bk_reshape(s4,[s4.shape[0],
+                                                                12*out_nside**2,
+                                                                (nside_j1//out_nside)**2,
+                                                                s4.shape[2],
+                                                                s4.shape[3],
+                                                                s4.shape[4]]),2)
                             S4[j3][j2][j1] = s4
                         else:
                             ### Normalize S4 with S2_j [Nbatch, Nmask, Norient_j]
@@ -3292,7 +3357,9 @@ class funct(FOC.FoCUS):
                                         ],
                                         axis=2,
                                     )  # Add a dimension for NS4
-
+                            nside_j1=nside_j1 // 2
+                        nside_j2=nside_j2 // 2
+                        
             ###### Reshape for next iteration on j3
             ### Image I1,
             # downscale the I1 [Nbatch, Npix_j3]
@@ -3659,9 +3726,14 @@ class funct(FOC.FoCUS):
             if x.S3P is not None:
                 nval += self.backend.bk_size(x.S3P)
             result /= self.backend.bk_cast(nval)
+            return result
         else:
-            return self.backend.bk_reduce_sum(x)
-        return result
+            if sigma is None:
+                tmp=x-y
+            else:
+                tmp=(x-y)/sigma
+            # do abs in case of complex values
+            return self.backend.bk_abs(self.backend.bk_reduce_mean(self.backend.bk_square(tmp)))
 
     def reduce_sum(self, x):
 

foscat/scat_cov_map.py

@@ -24,10 +24,10 @@ class funct(scat.funct):
         super().__init__(return_data=True, *args, **kwargs)
 
     def eval(
-        self, image1, image2=None, mask=None, norm=None, Auto=True, calc_var=False
+            self, image1, image2=None, mask=None, norm=None, Auto=True, calc_var=False,out_nside=None
     ):
         r = super().eval(
-            image1, image2=image2, mask=mask, norm=norm, Auto=Auto, calc_var=calc_var
+            image1, image2=image2, mask=mask, norm=norm, Auto=Auto, calc_var=calc_var,out_nside=out_nside
         )
         return scat_cov_map(
             r.S2, r.S0, r.S3, r.S4, S1=r.S1, S3P=r.S3P, backend=r.backend

{foscat-3.4.0.dist-info → foscat-3.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.1
 Name: foscat
-Version: 3.4.0
+Version: 3.6.1
 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.4.0.dist-info → foscat-3.6.1.dist-info}/RECORD

@@ -1,27 +1,27 @@
 foscat/CNN.py,sha256=j0F2a4Xf3LijhyD_WVZ6Eg_IjGuXw3ddH6Iudj1xVaw,4874
 foscat/CircSpline.py,sha256=DjP1gy88cnXu2O21ww_lNnsHAHXc3OAWk_8ey84yicg,4053
-foscat/FoCUS.py,sha256=gq2KcT3GN16Ypcy-9OOHo_OVfjDxfWKV0bU2dvzScWI,101774
+foscat/FoCUS.py,sha256=YoZqPiDLQanUXGgN4RyN6S4_F2rHn273P6QQjq0hlBU,101774
 foscat/GCNN.py,sha256=5RV-FKuvqbD-k99TwiM4CttM2LMZE21WD0IK0j5Mkko,7599
 foscat/Softmax.py,sha256=aBLQauoG0q2SJYPotV6U-cxAhsJcspWHNRWdnA_nAiQ,2854
 foscat/Spline1D.py,sha256=a5Jb8I9tb8y20iM8W-z6iZsIqDFByRp6eZdChpmuI5k,3010
 foscat/Synthesis.py,sha256=3_Lq5-gUM-WmO2h15kajMES8XjRo2BGseoxvTLW_xEc,13626
 foscat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-foscat/alm.py,sha256=Jte3HBEoLahH8sIvEZ-hQKfY1cpRdYKITWcqAe-geBA,19451
-foscat/alm_tools.py,sha256=zI6r7VWt4oCEFoHyK3uEaIsLqazYfDg6MblsQwzozAs,5402
-foscat/backend.py,sha256=Hh4FbjVgzlbyG-HfagULk6StQo5eg-Z_vkHQ9XIVRGE,39182
+foscat/alm.py,sha256=IIvYOz0kAtufhlBzS_QOx891-Y30ARmofyqomOFmJDY,29335
+foscat/alm_tools.py,sha256=BMObyIMF3_v04JdvMWBMMaF2F8s2emvDKmirKDnHWDA,387
+foscat/backend.py,sha256=bN-b0CWcJXVsLCyqMhJACom0JlSStgrMWyD0uB6HqoU,40218
 foscat/backend_tens.py,sha256=9Dp136m9frkclkwifJQLLbIpl3ETI3_txdPUZcKfuMw,1618
 foscat/loss_backend_tens.py,sha256=dCOVN6faDtIpN3VO78HTmYP2i5fnFAf-Ddy5qVBlGrM,1783
 foscat/loss_backend_torch.py,sha256=k3z18Dj3SaLKK6ZIKcm7GO4U_YKYVP6LtHG1aIbxkYk,1627
 foscat/scat.py,sha256=qGYiBIysPt65MdmF07WWA4piVlTfA9-lFDTaicnqC2w,72822
 foscat/scat1D.py,sha256=W5Uu6wdQ4ZsFKXpof0f1OBl-1wjJmW7ruvddRWxe7uM,53726
 foscat/scat2D.py,sha256=boKj0ASqMMSy7uQLK6hPniG87m3hZGJBYBiq5v8F9IQ,532
-foscat/scat_cov.py,sha256=6dItWbxQG7t9_AALDMvaidJ3s0d5ospMR5OS5AFbedY,145576
+foscat/scat_cov.py,sha256=gQvGC2s93oDurBDW0A6mGyzzMETjYAuBsBsDOI-ZqUY,150642
 foscat/scat_cov1D.py,sha256=XOxsZZ5TYq8f34i2tUgIfzyaqaTDlICB3HzD2l_puro,531
 foscat/scat_cov2D.py,sha256=3gn6xjKvfKsyHJoPfYIu8q9LLVAbU3tsiS2l1LAJ0XM,531
-foscat/scat_cov_map.py,sha256=0wTRo4Nc7rYfI09RI2mh2bYixoukt5lrvAXR6wa9kjA,2744
+foscat/scat_cov_map.py,sha256=9Yymbr1MxUNY5nJd9kIEEHt1x2IoOjc0EW4kkJVtmQ4,2783
 foscat/scat_cov_map2D.py,sha256=FqF45FBcoiQbvuVsrLWUIPRUc95GsKsrnH6fKzB3GlE,2841
-foscat-3.4.0.dist-info/LICENCE,sha256=i0ukIr8ZUpkSY2sZaE9XZK-6vuSU5iG6IgX_3pjatP8,1505
-foscat-3.4.0.dist-info/METADATA,sha256=obU7dCa9Mbe6SZ4ptdpHTB3bGtbPeW0GlX0aKIBH9Yg,7216
-foscat-3.4.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-foscat-3.4.0.dist-info/top_level.txt,sha256=AGySXBBAlJgb8Tj8af6m_F-aiNg2zNTcybCUPVOKjAg,7
-foscat-3.4.0.dist-info/RECORD,,
+foscat-3.6.1.dist-info/LICENCE,sha256=i0ukIr8ZUpkSY2sZaE9XZK-6vuSU5iG6IgX_3pjatP8,1505
+foscat-3.6.1.dist-info/METADATA,sha256=6t347EDYxBbM5qhlC5T6pwbJDBwvAnJ5VJnNppblC6A,7216
+foscat-3.6.1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+foscat-3.6.1.dist-info/top_level.txt,sha256=AGySXBBAlJgb8Tj8af6m_F-aiNg2zNTcybCUPVOKjAg,7
+foscat-3.6.1.dist-info/RECORD,,

{foscat-3.4.0.dist-info → foscat-3.6.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: bdist_wheel (0.42.0)
 Root-Is-Purelib: true
 Tag: py3-none-any