foscat 3.1.6__py3-none-any.whl → 3.3.0__py3-none-any.whl

foscat/CNN.py

@@ -1,112 +1,151 @@
-import numpy as np
 import pickle
+
+import numpy as np
+
 import foscat.scat_cov as sc
-  
+
 
 class CNN:
-        
-    def __init__(self,
-                 scat_operator=None,
-                 nparam=1,
-                 nscale=1,
-                 chanlist=[],
-                 in_nside=1,
-                 n_chan_in=1,
-                 nbatch=1,
-                 SEED=1234,
-                 filename=None):
+
+    def __init__(
+        self,
+        scat_operator=None,
+        nparam=1,
+        nscale=1,
+        chanlist=[],
+        in_nside=1,
+        n_chan_in=1,
+        nbatch=1,
+        SEED=1234,
+        filename=None,
+    ):
 
         if filename is not None:
-            outlist=pickle.load(open("%s.pkl"%(filename),"rb"))
-            self.scat_operator=sc.funct(KERNELSZ=outlist[3],all_type=outlist[7])
-            self.KERNELSZ= self.scat_operator.KERNELSZ
-            self.all_type= self.scat_operator.all_type
-            self.npar=outlist[2]
-            self.nscale=outlist[5]
-            self.chanlist=outlist[0]
-            self.in_nside=outlist[4] 
-            self.nbatch=outlist[1]
-            self.n_chan_in=outlist[8]
-            self.x=self.scat_operator.backend.bk_cast(outlist[6])
-            self.out_nside=self.in_nside//(2**self.nscale)
+            outlist = pickle.load(open("%s.pkl" % (filename), "rb"))
+            self.scat_operator = sc.funct(KERNELSZ=outlist[3], all_type=outlist[7])
+            self.KERNELSZ = self.scat_operator.KERNELSZ
+            self.all_type = self.scat_operator.all_type
+            self.npar = outlist[2]
+            self.nscale = outlist[5]
+            self.chanlist = outlist[0]
+            self.in_nside = outlist[4]
+            self.nbatch = outlist[1]
+            self.n_chan_in = outlist[8]
+            self.x = self.scat_operator.backend.bk_cast(outlist[6])
+            self.out_nside = self.in_nside // (2**self.nscale)
         else:
-            self.nscale=nscale
-            self.nbatch=nbatch
-            self.npar=nparam
-            self.n_chan_in=n_chan_in
-            self.scat_operator=scat_operator
-            if len(chanlist)!=nscale+1:
-                print('len of chanlist (here %d) should of nscale+1 (here %d)'%(len(chanlist),nscale+1))
+            self.nscale = nscale
+            self.nbatch = nbatch
+            self.npar = nparam
+            self.n_chan_in = n_chan_in
+            self.scat_operator = scat_operator
+            if len(chanlist) != nscale + 1:
+                print(
+                    "len of chanlist (here %d) should of nscale+1 (here %d)"
+                    % (len(chanlist), nscale + 1)
+                )
                 return None
-            
-            self.chanlist=chanlist
-            self.KERNELSZ= scat_operator.KERNELSZ
-            self.all_type= scat_operator.all_type
-            self.in_nside=in_nside
-            self.out_nside=self.in_nside//(2**self.nscale)
+
+            self.chanlist = chanlist
+            self.KERNELSZ = scat_operator.KERNELSZ
+            self.all_type = scat_operator.all_type
+            self.in_nside = in_nside
+            self.out_nside = self.in_nside // (2**self.nscale)
 
             np.random.seed(SEED)
-            self.x=scat_operator.backend.bk_cast(np.random.randn(self.get_number_of_weights())/(self.KERNELSZ*self.KERNELSZ))
-            
-        
-
-    def save(self,filename):
-        
-        outlist=[self.chanlist, \
-                 self.nbatch, \
-                 self.npar, \
-                 self.KERNELSZ, \
-                 self.in_nside, \
-                 self.nscale, \
-                 self.get_weights().numpy(), \
-                 self.all_type, \
-                 self.n_chan_in]
-        
-        myout=open("%s.pkl"%(filename),"wb")
-        pickle.dump(outlist,myout)
+            self.x = scat_operator.backend.bk_cast(
+                np.random.randn(self.get_number_of_weights())
+                / (self.KERNELSZ * self.KERNELSZ)
+            )
+
+    def save(self, filename):
+
+        outlist = [
+            self.chanlist,
+            self.nbatch,
+            self.npar,
+            self.KERNELSZ,
+            self.in_nside,
+            self.nscale,
+            self.get_weights().numpy(),
+            self.all_type,
+            self.n_chan_in,
+        ]
+
+        myout = open("%s.pkl" % (filename), "wb")
+        pickle.dump(outlist, myout)
         myout.close()
-    
+
     def get_number_of_weights(self):
-        totnchan=0
+        totnchan = 0
         for i in range(self.nscale):
-            totnchan=totnchan+self.chanlist[i]*self.chanlist[i+1]
-        return self.npar*12*self.out_nside**2*self.chanlist[self.nscale] \
-            +totnchan*self.KERNELSZ*self.KERNELSZ+self.KERNELSZ*self.KERNELSZ*self.n_chan_in*self.chanlist[0]
+            totnchan = totnchan + self.chanlist[i] * self.chanlist[i + 1]
+        return (
+            self.npar * 12 * self.out_nside**2 * self.chanlist[self.nscale]
+            + totnchan * self.KERNELSZ * self.KERNELSZ
+            + self.KERNELSZ * self.KERNELSZ * self.n_chan_in * self.chanlist[0]
+        )
+
+    def set_weights(self, x):
+        self.x = x
 
-    def set_weights(self,x):
-        self.x=x
-        
     def get_weights(self):
         return self.x
-        
-    def eval(self,im,indices=None,weights=None):
 
-        x=self.x
-        ww=self.scat_operator.backend.bk_reshape(x[0:self.KERNELSZ*self.KERNELSZ*self.n_chan_in*self.chanlist[0]],
-                                                 [self.KERNELSZ*self.KERNELSZ,self.n_chan_in,self.chanlist[0]])
-        nn=self.KERNELSZ*self.KERNELSZ*self.n_chan_in*self.chanlist[0]
+    def eval(self, im, indices=None, weights=None):
+
+        x = self.x
+        ww = self.scat_operator.backend.bk_reshape(
+            x[0 : self.KERNELSZ * self.KERNELSZ * self.n_chan_in * self.chanlist[0]],
+            [self.KERNELSZ * self.KERNELSZ, self.n_chan_in, self.chanlist[0]],
+        )
+        nn = self.KERNELSZ * self.KERNELSZ * self.n_chan_in * self.chanlist[0]
+
+        im = self.scat_operator.healpix_layer(im, ww)
+        im = self.scat_operator.backend.bk_relu(im)
 
-        im=self.scat_operator.healpix_layer(im,ww)
-        im=self.scat_operator.backend.bk_relu(im)
-        
         for k in range(self.nscale):
-            ww=self.scat_operator.backend.bk_reshape(x[nn:nn+self.KERNELSZ*self.KERNELSZ*self.chanlist[k]*self.chanlist[k+1]],
-                                                [self.KERNELSZ*self.KERNELSZ,self.chanlist[k],self.chanlist[k+1]])
-            nn=nn+self.KERNELSZ*self.KERNELSZ*self.chanlist[k]*self.chanlist[k+1]
+            ww = self.scat_operator.backend.bk_reshape(
+                x[
+                    nn : nn
+                    + self.KERNELSZ
+                    * self.KERNELSZ
+                    * self.chanlist[k]
+                    * self.chanlist[k + 1]
+                ],
+                [self.KERNELSZ * self.KERNELSZ, self.chanlist[k], self.chanlist[k + 1]],
+            )
+            nn = (
+                nn
+                + self.KERNELSZ
+                * self.KERNELSZ
+                * self.chanlist[k]
+                * self.chanlist[k + 1]
+            )
             if indices is None:
-                im=self.scat_operator.healpix_layer(im,ww)
+                im = self.scat_operator.healpix_layer(im, ww)
             else:
-                im=self.scat_operator.healpix_layer(im,ww,indices=indices[k],weights=weights[k])
-            im=self.scat_operator.backend.bk_relu(im)
-            im=self.scat_operator.ud_grade_2(im,axis=0)
-
-            
-        ww=self.scat_operator.backend.bk_reshape(x[nn:nn+self.npar*12*self.out_nside**2*self.chanlist[self.nscale]], \
-                                            [12*self.out_nside**2*self.chanlist[self.nscale],self.npar])
-        
-        im=self.scat_operator.backend.bk_matmul(self.scat_operator.backend.bk_reshape(im,[1,12*self.out_nside**2*self.chanlist[self.nscale]]),ww)
-        im=self.scat_operator.backend.bk_reshape(im,[self.npar])
-        im=self.scat_operator.backend.bk_relu(im)
-        
+                im = self.scat_operator.healpix_layer(
+                    im, ww, indices=indices[k], weights=weights[k]
+                )
+            im = self.scat_operator.backend.bk_relu(im)
+            im = self.scat_operator.ud_grade_2(im, axis=0)
+
+        ww = self.scat_operator.backend.bk_reshape(
+            x[
+                nn : nn
+                + self.npar * 12 * self.out_nside**2 * self.chanlist[self.nscale]
+            ],
+            [12 * self.out_nside**2 * self.chanlist[self.nscale], self.npar],
+        )
+
+        im = self.scat_operator.backend.bk_matmul(
+            self.scat_operator.backend.bk_reshape(
+                im, [1, 12 * self.out_nside**2 * self.chanlist[self.nscale]]
+            ),
+            ww,
+        )
+        im = self.scat_operator.backend.bk_reshape(im, [self.npar])
+        im = self.scat_operator.backend.bk_relu(im)
+
         return im
-     

foscat/CircSpline.py

@@ -1,51 +1,75 @@
+import numpy as np
 
-import math
 
 class CircSpline:
     def __init__(self, nodes, degree=3):
         """
-        Initialize the circular spline with the given number of nodes and degree.
+        Initializes the Spline1D instance.
+
+        Parameters:
+        - nodes (int): The number of nodes in the spline.
+        - degree (int): The degree of the spline. Default is 3.
         """
         self.degree = degree
         self.nodes = nodes
-        self.norm = [self._compute_norm(i) for i in range(degree + 1)]
-
-    def _compute_norm(self, i):
+        
+        
+    def cubic_spline_function(self,x):
         """
-        Compute normalization factor for the ith element.
+        Evaluate the cubic spline basis function.
+    
+        Args:
+            x (float or array): Input value(s) to evaluate the spline basis function.
+    
+        Returns:
+            float or array: Result of the cubic spline basis function.
         """
-        return pow(-1, i) * (self.degree + 1) / (math.factorial(self.degree + 1 - i) * math.factorial(i))
+        return -2 * x**3 + 3 * x**2
 
-    def yplus(self, x):
-        """
-        Compute yplus value for a given x based on the spline's degree.
-        """
-        if x < 0.0:
-            return 0.0
-        if self.degree == 0:
-            return 0.5 if x == 0.0 else 1.0
-        return pow(x, self.degree)
 
-    def calculate(self, x):
+    def eval(self,x):
         """
-        Calculate circular spline values for a given x.
+        Compute a 3rd-degree cubic spline with 4-point support.
+    
+        Args:
+            x (float or array): Input value(s) to compute the spline.
+
+        Returns:
+            indices (array): Indices of the spline support points.
+            coefficients (array): Normalized spline coefficients.
         """
-        y = [0] * self.nodes
-        for i in range(self.nodes + self.degree // 2 + 1):
-            tmp = 0
-            tx = self.nodes * math.fmod(x, 2 * math.pi) / (math.pi * 2) - i
-            for j in range(self.degree + 1):
-                tmp += self.norm[j] * self.yplus(tx - j + (self.degree + 1) // 2)
-            if tmp < 0:
-                tmp = 0.0
-            y[i % self.nodes] += tmp
-        for i in range(self.degree // 2):
-            tmp = 0
-            tx = self.nodes * math.fmod(x, 2 * math.pi) / (math.pi * 2) + 1 + i
-            for j in range(self.degree + 1):
-                tmp += self.norm[j] * self.yplus(tx - j + (self.degree + 1) // 2)
-            if tmp < 0:
-                tmp = 0.0
-            y[self.nodes - 1 - i] += tmp
-        return y
+        N=self.nodes
+        
+        if isinstance(x, float):
+            # Single scalar input
+            base_idx = int(x * (N))
+            indices = np.zeros([4], dtype="int")
+            coefficients = np.zeros([4])
+        else:
+            # Array input
+            base_idx = (x * (N)).astype("int")
+            indices = np.zeros([4, x.shape[0]], dtype="int")
+            coefficients = np.zeros([4, x.shape[0]])
+
+        # Compute the fractional part of the input
+        fractional_part = x * (N) - base_idx
+
+        # Compute spline coefficients for 4 support points
+        coefficients[3] = self.cubic_spline_function(fractional_part / 2) / 2
+        coefficients[2] = self.cubic_spline_function(0.5 + fractional_part / 2) / 2
+        coefficients[1] = self.cubic_spline_function(1 - fractional_part / 2) / 2
+        coefficients[0] = self.cubic_spline_function(0.5 - fractional_part / 2) / 2
+
+        # Assign indices for the support points
+        indices[3] = (base_idx + 3)%N
+        indices[2] = (base_idx + 2)%N
+        indices[1] = (base_idx + 1)%N
+        indices[0] = base_idx
+
+        # Adjust indices to start from 0
+        indices = indices - 1
+        # Square coefficients and normalize
+        coefficients = coefficients * coefficients
+        coefficients /= np.sum(coefficients, axis=0)
 
+        return indices, coefficients