freealg 0.1.1__tar.gz → 0.1.3__tar.gz

{freealg-0.1.1/freealg.egg-info → freealg-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.1.1
+Version: 0.1.3
 Summary: Free probability for large matrices
 Keywords: leaderboard bot chat
 Platform: Linux

freealg-0.1.3/freealg/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.1.3"

{freealg-0.1.1 → freealg-0.1.3}/freealg/_util.py

@@ -13,9 +13,10 @@
 
 import numpy
 import scipy
+from scipy.stats import beta
 from scipy.optimize import minimize
 
-__all__ = ['compute_eig', 'force_density']
+__all__ = ['compute_eig', 'beta_kde', 'force_density']
 
 
 # ===========
@@ -32,6 +33,54 @@ def compute_eig(A, lower=False):
     return eig
 
 
+# ========
+# beta kde
+# ========
+
+def beta_kde(eig, xs, lam_m, lam_p, h):
+    """
+    Beta-kernel KDE with automatic guards against NaNs.
+
+    Parameters
+    ----------
+    eig    : (n,) 1-D array of samples
+    xs     : evaluation grid (must lie within [lam_m, lam_p])
+    lam_m, lam_p : float, support endpoints  (lam_m < lam_p)
+    h      : bandwidth in rescaled units (0 < h < 1)
+
+    Returns
+    -------
+    pdf    : ndarray  same length as xs
+    """
+
+    span = lam_p - lam_m
+    if span <= 0:
+        raise ValueError("lam_p must be larger than lam_m")
+
+    # map samples and grid to [0,1]
+    u = (eig - lam_m) / span
+    t = (xs - lam_m) / span
+
+    if u.min() < 0 or u.max() > 1:
+        mask = (u > 0) & (u < 1)
+        u = u[mask]
+
+    pdf = numpy.zeros_like(xs, dtype=float)
+    n = len(u)
+
+    # tiny positive number to keep shape parameters >0
+    eps = 1e-6
+    for ui in u:
+        a = max(ui / h + 1.0, eps)
+        b = max((1.0 - ui) / h + 1.0, eps)
+        pdf += beta.pdf(t, a, b)
+
+    pdf /= n * span                        # renormalise
+    pdf[(t < 0) | (t > 1)] = 0.0           # exact zeros outside
+
+    return pdf
+
+
 # =============
 # force density
 # =============
@@ -72,14 +121,14 @@ def force_density(psi0, support, approx, grid, alpha=0.0, beta=0.0):
     if beta <= 0.0 and beta > -0.5:
         constraints.append({
             'type': 'eq',
-            'fun': lambda psi: approx(numpy.array([lam_m], psi))[0]
+            'fun': lambda psi: approx(numpy.array([lam_m]), psi)[0]
         })
 
     # Enforce zero at right edge
     if alpha <= 0.0 and alpha > -0.5:
         constraints.append({
             'type': 'eq',
-            'fun': lambda psi: approx(numpy.array([lam_p], psi))[0]
+            'fun': lambda psi: approx(numpy.array([lam_p]), psi)[0]
         })
 
     # Solve a small quadratic programming
@@ -89,4 +138,12 @@ def force_density(psi0, support, approx, grid, alpha=0.0, beta=0.0):
                    method='SLSQP',
                    options={'maxiter': 1000, 'ftol': 1e-9, 'eps': 1e-8})
 
-    return res.x
+    psi = res.x
+
+    # Normalize first mode to unit mass
+    x = numpy.linspace(lam_m, lam_p, 1000)
+    rho = approx(x, psi)
+    mass = numpy.trapz(rho, x)
+    psi[0] = psi[0] / mass
+
+    return psi

{freealg-0.1.1 → freealg-0.1.3}/freealg/freeform.py

@@ -15,7 +15,7 @@ import numpy
 from scipy.stats import gaussian_kde
 # from statsmodels.nonparametric.kde import KDEUnivariate
 from functools import partial
-from ._util import compute_eig, force_density
+from ._util import compute_eig, beta_kde, force_density
 from ._jacobi import jacobi_sample_proj, jacobi_kernel_proj, jacobi_approx, \
     jacobi_stieltjes
 from ._chebyshev import chebyshev_sample_proj, chebyshev_kernel_proj, \
@@ -177,7 +177,7 @@ class FreeForm(object):
     # ===
 
     def fit(self, method='jacobi', K=10, alpha=0.0, beta=0.0, reg=0.0,
-            projection='kernel', kernel_bw=None, damp=None, force=False,
+            projection='gaussian', kernel_bw=None, damp=None, force=False,
             pade_p=0, pade_q=1, odd_side='left', pade_reg=0.0, optimizer='ls',
             plot=False, latex=False, save=False):
         """
@@ -206,14 +206,19 @@ class FreeForm(object):
         reg : float, default=0.0
             Tikhonov regularization coefficient.
 
-        projection : {``'sample'``, ``'kernel'``}, default= ``'kernel'``
+        projection : {``'sample'``, ``'gaussian'``, ``'beta'``}, \
+                default= ``'gaussian'``
             The method of Galerkin projection:
 
             * ``'sample'``: directly project samples (eigenvalues) to the
               orthogonal polynomials. This method is highly unstable as it
               treats each sample as a delta Dirac function.
-            * ``'kernel'``: computes KDE from the samples and project a
-              smooth KDE to the orthogonal polynomials. This method is stable.
+            * ``'gaussian'``: computes Gaussian-Kernel KDE from the samples and
+              project a smooth KDE to the orthogonal polynomials. This method
+              is stable.
+            * ``'beta'``: computes Beta-Kernel KDE from the samples and
+              project a smooth KDE to the orthogonal polynomials. This method
+              is stable.
 
         kernel_bw : float, default=None
             Kernel band-wdth. See scipy.stats.gaussian_kde. This argument is
@@ -301,7 +306,7 @@ class FreeForm(object):
         if not (method in ['jacobi', 'chebyshev']):
             raise ValueError('"method" is invalid.')
 
-        if not (projection in ['sample', 'kernel']):
+        if not (projection in ['sample', 'gaussian', 'beta']):
             raise ValueError('"projection" is invalid.')
 
         # Project eigenvalues to Jacobi polynomials basis
@@ -313,7 +318,12 @@ class FreeForm(object):
             else:
                 # smooth KDE on a fixed grid
                 xs = numpy.linspace(self.lam_m, self.lam_p, 2000)
-                pdf = gaussian_kde(self.eig, bw_method=kernel_bw)(xs)
+
+                if projection == 'gaussian':
+                    pdf = gaussian_kde(self.eig, bw_method=kernel_bw)(xs)
+                else:
+                    pdf = beta_kde(self.eig, xs, self.lam_m, self.lam_p,
+                                   kernel_bw)
 
                 # Adaptive KDE
                 # k = KDEUnivariate(self.eig)
@@ -321,6 +331,12 @@ class FreeForm(object):
                 #       adaptive=True)
                 # pdf = k.evaluate(xs)
 
+                # TEST
+                # import matplotlib.pyplot as plt
+                # plt.plot(xs, pdf)
+                # plt.grid(True)
+                # plt.show()
+
                 psi = jacobi_kernel_proj(xs, pdf, support=self.support, K=K,
                                          alpha=alpha, beta=beta, reg=reg)
 
@@ -332,7 +348,12 @@ class FreeForm(object):
             else:
                 # smooth KDE on a fixed grid
                 xs = numpy.linspace(self.lam_m, self.lam_p, 2000)
-                pdf = gaussian_kde(self.eig, bw_method=kernel_bw)(xs)
+
+                if projection == 'gaussian':
+                    pdf = gaussian_kde(self.eig, bw_method=kernel_bw)(xs)
+                else:
+                    pdf = beta_kde(self.eig, xs, self.lam_m, self.lam_p,
+                                   kernel_bw)
 
                 # Adaptive KDE
                 # k = KDEUnivariate(self.eig)
@@ -477,7 +498,7 @@ class FreeForm(object):
 
         # Check density is unit mass
         mass = numpy.trapz(rho, x)
-        if not numpy.isclose(mass, 1.0, atol=1e-3):
+        if not numpy.isclose(mass, 1.0, atol=1e-2):
             # raise RuntimeWarning(f'"rho" is not unit mass. mass: {mass}. ' +
             #                      r'Set "force=True".')
             print(f'"rho" is not unit mass. mass: {mass}. Set "force=True".')
@@ -893,6 +914,8 @@ class FreeForm(object):
             >>> from freealg import FreeForm
         """
 
+        size = int(size)
+
         rho, x, (lb, ub) = decompress(self, size, x=x, delta=delta,
                                       iterations=iterations,
                                       step_size=step_size, tolerance=tolerance)

{freealg-0.1.1 → freealg-0.1.3/freealg.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.1.1
+Version: 0.1.3
 Summary: Free probability for large matrices
 Keywords: leaderboard bot chat
 Platform: Linux

freealg-0.1.1/freealg/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.1.1"