freealg 0.1.2__tar.gz → 0.1.4__tar.gz

{freealg-0.1.2/freealg.egg-info → freealg-0.1.4}/PKG-INFO

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

freealg-0.1.4/freealg/__version__.py

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

{freealg-0.1.2 → freealg-0.1.4}/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
 # =============

{freealg-0.1.2 → freealg-0.1.4}/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,16 +206,21 @@ class FreeForm(object):
         reg : float, default=0.0
             Tikhonov regularization coefficient.
 
-        projection : {``'sample'``, ``'kernel'``}, default= ``'kernel'``
+        projection : {``'sample'``, ``'gaussian'``, ``'beta'``}, \
+                default= ``'beta'``
             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.
-
-        kernel_bw : float, default=None
+            * ``'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=0.001
             Kernel band-wdth. See scipy.stats.gaussian_kde. This argument is
             relevant if ``projection='kernel'`` is set.
 
@@ -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)
@@ -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.2 → freealg-0.1.4/freealg.egg-info}/PKG-INFO

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

freealg-0.1.2/freealg/__version__.py

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