freealg 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

freealg/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.0"
+__version__ = "0.1.2"

freealg/_chebyshev.py

@@ -14,14 +14,15 @@
 import numpy
 from scipy.special import eval_chebyu
 
-__all__ = ['chebyshev_proj', 'chebyshev_approx', 'chebyshev_stieltjes']
+__all__ = ['chebyshev_sample_proj', 'chebyshev_kernel_proj',
+           'chebyshev_approx', 'chebyshev_stieltjes']
 
 
-# ==============
-# chebyshev proj
-# ==============
+# =====================
+# chebyshev sample proj
+# =====================
 
-def chebyshev_proj(eig, support, K=10, reg=0.0):
+def chebyshev_sample_proj(eig, support, K=10, reg=0.0):
     """
     Estimate the coefficients \\psi_k in
 
@@ -81,6 +82,39 @@ def chebyshev_proj(eig, support, K=10, reg=0.0):
     return psi
 
 
+# =====================
+# chebyshev kernel proj
+# =====================
+
+def chebyshev_kernel_proj(xs, pdf, support, K=10, reg=0.0):
+    """
+    Projection of a *continuous* density given on a grid (xs, pdf)
+    onto the Chebyshev-II basis.
+
+    xs  : 1-D numpy array (original x–axis, not the t-variable)
+    pdf : same shape as xs, integrates to 1 on xs
+    """
+
+    lam_m, lam_p = support
+    t = (2.0 * xs - (lam_m + lam_p)) / (lam_p - lam_m)   # map to [−1,1]
+
+    norm = numpy.pi / 2.0
+    psi = numpy.empty(K + 1)
+
+    for k in range(K + 1):
+        Pk = eval_chebyu(k, t)                       # U_k(t) on the grid
+        moment = numpy.trapz(Pk * pdf, xs)           # \int U_k(t) \rho(x) dx
+
+        if k == 0:
+            penalty = 0
+        else:
+            penalty = reg * (k / (K + 1))**2
+
+        psi[k] = moment / (norm + penalty)
+
+    return psi
+
+
 # ================
 # chebyshev approx
 # ================

freealg/_jacobi.py

@@ -15,7 +15,8 @@ import numpy
 from scipy.special import eval_jacobi, roots_jacobi
 from scipy.special import gammaln, beta as Beta
 
-__all__ = ['jacobi_proj', 'jacobi_approx', 'jacobi_stieltjes']
+__all__ = ['jacobi_sample_proj', 'jacobi_kernel_proj', 'jacobi_approx',
+           'jacobi_stieltjes']
 
 
 # ==============
@@ -43,11 +44,11 @@ def jacobi_sq_norm(k, alpha, beta):
     return numpy.exp(lg_num - lg_den)
 
 
-# ===========
-# jacobi pro
-# ===========
+# ==================
+# jacobi sample proj
+# ==================
 
-def jacobi_proj(eig, support, K=10, alpha=0.0, beta=0.0, reg=0.0):
+def jacobi_sample_proj(eig, support, K=10, alpha=0.0, beta=0.0, reg=0.0):
     """
     """
 
@@ -76,6 +77,37 @@ def jacobi_proj(eig, support, K=10, alpha=0.0, beta=0.0, reg=0.0):
     return psi
 
 
+# ==================
+# jacobi kernel proj
+# ==================
+
+def jacobi_kernel_proj(xs, pdf, support, K=10, alpha=0.0, beta=0.0, reg=0.0):
+    """
+    Same moments as `jacobi_proj`, but the target is a *continuous* density
+    given on a grid (xs, pdf).
+    """
+
+    lam_m, lam_p = support
+    t = (2.0 * xs - (lam_p + lam_m)) / (lam_p - lam_m)      # map to [-1,1]
+    psi = numpy.empty(K + 1)
+
+    for k in range(K + 1):
+        Pk = eval_jacobi(k, alpha, beta, t)
+        N_k = jacobi_sq_norm(k, alpha, beta)
+
+        #  \int P_k(t) w(t) \rho(t) dt. w(t) cancels with pdf already being rho
+        moment = numpy.trapz(Pk * pdf, xs)
+
+        if k == 0:
+            penalty = 0
+        else:
+            penalty = reg * (k / (K + 1))**2
+
+        psi[k] = moment / (N_k + penalty)
+
+    return psi
+
+
 # =============
 # jacobi approx
 # =============

freealg/_pade.py

@@ -108,8 +108,7 @@ def _decode_poles(s, lam_m, lam_p):
 # inner ls
 # ========
 
-# def _inner_ls(x, f, poles):  # TEST
-def _inner_ls(x, f, poles, p=1):
+def _inner_ls(x, f, poles, p=1, pade_reg=0.0):
     """
     This is the inner least square (blazing fast).
     """
@@ -169,7 +168,35 @@ def _inner_ls(x, f, poles, p=1):
         cols.append(phi)
 
         A = numpy.column_stack(cols)
-        theta, *_ = lstsq(A, f, rcond=None)
+
+        # theta, *_ = lstsq(A, f, rcond=None) # TEST
+        if pade_reg > 0:
+            ATA = A.T.dot(A)
+
+            # # add pade_reg * I
+            # ATA.flat[:: ATA.shape[1]+1] += pade_reg
+            # ATf = A.T.dot(f)
+            # theta = numpy.linalg.solve(ATA, ATf)
+
+            # figure out how many elements to skip
+            if p == 1:
+                skip = 2     # skip c and D
+            elif p == 0:
+                skip = 1     # skip c only
+            else:
+                skip = 0     # all entries are residues
+
+            # add λ only for the residue positions
+            n = ATA.shape[0]
+            for i in range(skip, n):
+                ATA[i, i] += pade_reg
+
+            # then solve
+            ATf = A.T.dot(f)
+            theta = numpy.linalg.solve(ATA, ATf)
+
+        else:
+            theta, *_ = lstsq(A, f, rcond=None)
 
         if p == -1:
             c, D, resid = 0.0, 0.0, theta
@@ -213,12 +240,11 @@ def _eval_rational(z, c, D, poles, resid):
 # fit pade
 # ========
 
-def fit_pade(x, f, lam_m, lam_p, p=1, q=2, odd_side='left', safety=1.0,
-             max_outer=40, xtol=1e-12, ftol=1e-12, optimizer='ls', verbose=0):
+def fit_pade(x, f, lam_m, lam_p, p=1, q=2, odd_side='left', pade_reg=0.0,
+             safety=1.0, max_outer=40, xtol=1e-12, ftol=1e-12, optimizer='ls',
+             verbose=0):
     """
     This is the outer optimiser.
-
-    Fits  G(x) = (p>=1 ? c : 0) + (p==1 ? D x : 0) + sum r_j/(x - a_j) # TEST
     """
 
     # Checks
@@ -232,10 +258,9 @@ def fit_pade(x, f, lam_m, lam_p, p=1, q=2, odd_side='left', safety=1.0,
     f = numpy.asarray(f, float)
 
     poles0 = _default_poles(q, lam_m, lam_p, safety=safety, odd_side=odd_side)
-    # if q == 0:                               # nothing to optimise
     if q == 0 and p <= 0:
-        # c, D, resid = _inner_ls(x, f, poles0)  # TEST
-        c, D, resid = _inner_ls(x, f, poles0, p)
+        # c, D, resid = _inner_ls(x, f, poles0, pade_reg=pade_reg)  # TEST
+        c, D, resid = _inner_ls(x, f, poles0, p, pade_reg=pade_reg)
         pade_sol = {
             'c': c, 'D': D, 'poles': poles0, 'resid': resid,
             'outer_iters': 0
@@ -249,11 +274,10 @@ def fit_pade(x, f, lam_m, lam_p, p=1, q=2, odd_side='left', safety=1.0,
     # residual
     # --------
 
-    # def residual(s): # TEST
     def residual(s, p=p):
         poles = _decode_poles(s, lam_m, lam_p)
-        # c, D, resid = _inner_ls(x, f, poles) # TEST
-        c, D, resid = _inner_ls(x, f, poles, p)
+        # c, D, resid = _inner_ls(x, f, poles, pade_reg=pade_reg) # TEST
+        c, D, resid = _inner_ls(x, f, poles, p, pade_reg=pade_reg)
         return _eval_rational(x, c, D, poles, resid) - f
 
     # ----------------
@@ -299,8 +323,8 @@ def fit_pade(x, f, lam_m, lam_p, p=1, q=2, odd_side='left', safety=1.0,
         raise RuntimeError('"optimizer" is invalid.')
 
     poles = _decode_poles(res.x, lam_m, lam_p)
-    # c, D, resid = _inner_ls(x, f, poles) # TEST
-    c, D, resid = _inner_ls(x, f, poles, p)
+    # c, D, resid = _inner_ls(x, f, poles, pade_reg=pade_reg) # TEST
+    c, D, resid = _inner_ls(x, f, poles, p, pade_reg=pade_reg)
 
     pade_sol = {
         'c': c, 'D': D, 'poles': poles, 'resid': resid,
@@ -354,8 +378,8 @@ def fit_pade_old(x, f, lam_m, lam_p, p, q, delta=1e-8, B=numpy.inf,
       Q(x) = prod_{j=0..q-1}(x - b_j)
 
     Constraints:
-      a_i ∈ [lam_m, lam_p]
-      b_j ∈ (-infty, lam_m - delta] cup [lam_p + delta, infty)
+      a_i in [lam_m, lam_p]
+      b_j in (-infty, lam_m - delta] cup [lam_p + delta, infty)
 
     Approach:
       - Brute‐force all 2^q left/right assignments for denominator roots

freealg/_util.py

@@ -72,14 +72,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 +89,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/freeform.py

@@ -13,10 +13,13 @@
 
 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 ._jacobi import jacobi_proj, jacobi_approx, jacobi_stieltjes
-from ._chebyshev import chebyshev_proj, chebyshev_approx, chebyshev_stieltjes
+from ._jacobi import jacobi_sample_proj, jacobi_kernel_proj, jacobi_approx, \
+    jacobi_stieltjes
+from ._chebyshev import chebyshev_sample_proj, chebyshev_kernel_proj, \
+    chebyshev_approx, chebyshev_stieltjes
 from ._damp import jackson_damping, lanczos_damping, fejer_damping, \
     exponential_damping, parzen_damping
 from ._plot_util import plot_fit, plot_density, plot_hilbert, plot_stieltjes
@@ -174,8 +177,9 @@ class FreeForm(object):
     # ===
 
     def fit(self, method='jacobi', K=10, alpha=0.0, beta=0.0, reg=0.0,
-            damp=None, force=False, pade_p=0, pade_q=1, odd_side='left',
-            optimizer='ls', plot=False, latex=False, save=False):
+            projection='kernel', 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):
         """
         Fit model to eigenvalues.
 
@@ -202,6 +206,19 @@ class FreeForm(object):
         reg : float, default=0.0
             Tikhonov regularization coefficient.
 
+        projection : {``'sample'``, ``'kernel'``}, default= ``'kernel'``
+            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
+            Kernel band-wdth. See scipy.stats.gaussian_kde. This argument is
+            relevant if ``projection='kernel'`` is set.
+
         damp : {``'jackson'``, ``'lanczos'``, ``'fejer``, ``'exponential'``,\
                 ``'parzen'``}, default=None
             Damping method to eliminate Gibbs oscillation.
@@ -225,6 +242,9 @@ class FreeForm(object):
             optimizer will decide best location by moving them to the left or
             right of the support.
 
+        pade_reg : float, default=0.0
+            Regularization for Pade approximation.
+
         optimizer : {``'ls'``, ``'de'``}, default= ``'ls'``
             Optimizer for Pade approximation, including:
 
@@ -278,12 +298,50 @@ class FreeForm(object):
         if beta <= -1:
             raise ValueError('"beta" should be greater then "-1".')
 
+        if not (method in ['jacobi', 'chebyshev']):
+            raise ValueError('"method" is invalid.')
+
+        if not (projection in ['sample', 'kernel']):
+            raise ValueError('"projection" is invalid.')
+
         # Project eigenvalues to Jacobi polynomials basis
         if method == 'jacobi':
-            psi = jacobi_proj(self.eig, support=self.support, K=K, alpha=alpha,
-                              beta=beta, reg=reg)
+
+            if projection == 'sample':
+                psi = jacobi_sample_proj(self.eig, support=self.support, K=K,
+                                         alpha=alpha, beta=beta, reg=reg)
+            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)
+
+                # Adaptive KDE
+                # k = KDEUnivariate(self.eig)
+                # k.fit(bw="silverman", fft=False, weights=None, gridsize=1024,
+                #       adaptive=True)
+                # pdf = k.evaluate(xs)
+
+                psi = jacobi_kernel_proj(xs, pdf, support=self.support, K=K,
+                                         alpha=alpha, beta=beta, reg=reg)
+
         elif method == 'chebyshev':
-            psi = chebyshev_proj(self.eig, support=self.support, K=K, reg=reg)
+
+            if projection == 'sample':
+                psi = chebyshev_sample_proj(self.eig, support=self.support,
+                                            K=K, reg=reg)
+            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)
+
+                # Adaptive KDE
+                # k = KDEUnivariate(self.eig)
+                # k.fit(bw="silverman", fft=False, weights=None, gridsize=1024,
+                #       adaptive=True)
+                # pdf = k.evaluate(xs)
+
+                psi = chebyshev_kernel_proj(xs, pdf, support=self.support,
+                                            K=K, reg=reg)
         else:
             raise ValueError('"method" is invalid.')
 
@@ -334,8 +392,9 @@ class FreeForm(object):
         #                           B=numpy.inf, S=numpy.inf)
         self._pade_sol = fit_pade(x_supp, g_supp, self.lam_m, self.lam_p,
                                   p=pade_p, q=pade_q, odd_side=odd_side,
-                                  safety=1.0, max_outer=40, xtol=1e-12,
-                                  ftol=1e-12, optimizer=optimizer, verbose=0)
+                                  pade_reg=pade_reg, safety=1.0, max_outer=40,
+                                  xtol=1e-12, ftol=1e-12, optimizer=optimizer,
+                                  verbose=0)
 
         if plot:
             g_supp_approx = eval_pade(x_supp[None, :], self._pade_sol)[0, :]
@@ -418,7 +477,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".')

{freealg-0.1.0.dist-info → freealg-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.1.0
+Version: 0.1.2
 Summary: Free probability for large matrices
 Keywords: leaderboard bot chat
 Platform: Linux
@@ -30,6 +30,7 @@ Requires-Dist: texplot
 Requires-Dist: matplotlib
 Requires-Dist: colorcet
 Requires-Dist: networkx
+Requires-Dist: statsmodels
 Provides-Extra: test
 Provides-Extra: docs
 Dynamic: classifier

{freealg-0.1.0.dist-info → freealg-0.1.2.dist-info}/RECORD

@@ -1,21 +1,21 @@
 freealg/__init__.py,sha256=K92neXJZ9VE1U_j_pj28Qyq1MzlMXhOuYK2ZihgwCaU,463
-freealg/__version__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
-freealg/_chebyshev.py,sha256=Cw48gXF6kd3IAQuLTEWadySeKGnY9TynzX9MNmycMUU,4697
+freealg/__version__.py,sha256=YvuYzWnKtqBb-IqG8HAu-nhIYAsgj9Vmc_b9o7vO-js,22
+freealg/_chebyshev.py,sha256=X6u5pKjR1HPZ-KbCfr7zT6HRwB6pZMADvVS3sT5LTkA,5638
 freealg/_damp.py,sha256=k2vtBtWOxQBf4qXaWu_En81lQBXbEO4QbxxWpvuVhdE,1802
 freealg/_decompress.py,sha256=H7ocq09gQnCY-q_8xHi6qyYj3qp239MCgj406hn0yeE,3344
-freealg/_jacobi.py,sha256=HVnaujwAcaILVFGEgxk26UyIaLdP2FZMY44C8TG3Qcc,4763
-freealg/_pade.py,sha256=wjFH1lfhuaQANNNMLVa8eAlKbP3sz8l8ZMw-P2X3T4A,12867
+freealg/_jacobi.py,sha256=AT4ONSHGGDxVKE3MGMLyMR8uDFiO-e9u3x5udYfdJJk,5635
+freealg/_pade.py,sha256=mP96wEPfIzHLZ6PDB5OyhmSA8N1uVPVUkmJa3ebXXiU,13623
 freealg/_plot_util.py,sha256=aL0u7FHdCwLTj4dZ4SSGA00wab0Voem2nBAsBVvo6XY,18400
 freealg/_sample.py,sha256=K1ZxKoiuPbEKyh-swL5X7gz1kYcQno6Mof0o1xF38tg,2323
-freealg/_util.py,sha256=wJ-t8LMZZFEr2PsZEVqTJP_jQTQ3rHUf0dO27F6L7YQ,2310
-freealg/freeform.py,sha256=nZqGZBEHVT7Cx1UbOe2-cupWBANNdmc44vm9Eyy9I0Q,25390
+freealg/_util.py,sha256=thQpJcfBNniCH4UzTeQ1yRfXPOVa-y9JkGSdE-wjp00,2492
+freealg/freeform.py,sha256=zjEVTqYT2QzxwE5sElpnlr9mdEK03B_4whysAMWN3X4,27910
 freealg/distributions/__init__.py,sha256=Hnk9bJi4Wy8I_1uuskRyrT2DUpPN1YmBY5uK7XI3U_o,644
 freealg/distributions/kesten_mckay.py,sha256=SFYg2_6_MEX9NGfOIW_rRfM9kgF-bdjQiVS0ENJBemQ,15379
 freealg/distributions/marchenko_pastur.py,sha256=0XHhjw1ZDkigGfjU9lmPRgmwecM1-n6VBkGjRJbxpeY,15869
 freealg/distributions/wachter.py,sha256=cG-3XTP5CHSK5o6SQfa3lqQR__ZibeWZ9AoeMxr3Nnk,15602
 freealg/distributions/wigner.py,sha256=gj3XWK4X7wLsB-inoVpn4pHUUM7NOQdgMGw01LEqkcw,14914
-freealg-0.1.0.dist-info/licenses/LICENSE.txt,sha256=J-EEYEtxb3VVf_Bn1TYfWnpY5lMFIM15iLDDcnaDTPA,1443
-freealg-0.1.0.dist-info/METADATA,sha256=hsJ1JS0j2HpMLsplIIdHlQeqOzMZamBkAVRL5xc1pYQ,2912
-freealg-0.1.0.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-freealg-0.1.0.dist-info/top_level.txt,sha256=eR2wrgYwDdnnJ9Zf5PruPqe4kQav0GMvRsqct6y00Q8,8
-freealg-0.1.0.dist-info/RECORD,,
+freealg-0.1.2.dist-info/licenses/LICENSE.txt,sha256=J-EEYEtxb3VVf_Bn1TYfWnpY5lMFIM15iLDDcnaDTPA,1443
+freealg-0.1.2.dist-info/METADATA,sha256=pGmBSVA0sY30xyCZ_gPni177js48SXeFKlm0VNEbu_o,2939
+freealg-0.1.2.dist-info/WHEEL,sha256=A8Eltl-h0W-qZDVezsLjjslosEH_pdYC2lQ0JcbgCzs,91
+freealg-0.1.2.dist-info/top_level.txt,sha256=eR2wrgYwDdnnJ9Zf5PruPqe4kQav0GMvRsqct6y00Q8,8
+freealg-0.1.2.dist-info/RECORD,,

{freealg-0.1.0.dist-info → freealg-0.1.2.dist-info}/WHEEL

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