freealg 0.1.13__tar.gz → 0.1.14__tar.gz

{freealg-0.1.13 → freealg-0.1.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.1.13
+Version: 0.1.14
 Summary: Free probability for large matrices
 Keywords: leaderboard bot chat
 Platform: Linux
@@ -70,6 +70,12 @@ Dynamic: summary
     :width: 240
     :class: custom-dark
 
+`Paper <https://arxiv.org/abs/2506.11994>`__ |
+`Slides <https://www.dropbox.com/scl/fi/03gjuyz17k9yhsqy0isoz/free_decomporession_slides.pdf?rlkey=8f82mhciyl2ju02l7hv1md5li&st=26xmhjga&dl=0>`__ |
+`Docs <https://ameli.github.io/freealg>`__
+
+.. `Slides <https://ameli.github.io/freealg/_static/data/slides.pdf>`__ |
+
 *freealg* is a Python package that employs **free** probability to evaluate the spectral
 densities of large matrix **form**\ s. The fundamental algorithm employed by *freealg* is
 **free decompression**, which extrapolates from the empirical spectral densities of small 
@@ -140,15 +146,19 @@ requests and bug reports.
 How to Cite
 ===========
 
-If you use this work, please cite the `arXiv paper <https://arxiv.org/abs/2506.11994>`.
+If you use this work, please cite the `arXiv paper <https://arxiv.org/abs/2506.11994>`__.
 
   .. code::
 
-      @article{ameli2025spectral,
-        title={Spectral Estimation with Free Decompression},
-        author={Siavash Ameli and Chris van der Heide and Liam Hodgkinson and Michael W. Mahoney},
-        journal={arXiv preprint arXiv:2506.11994},
-        year={2025}
+      @article{spectral2025,
+          title={Spectral Estimation with Free Decompression},
+          author={Siavash Ameli and Chris van der Heide and Liam Hodgkinson and Michael W. Mahoney},
+          year={2025},
+          eprint={2506.11994},
+          archivePrefix={arXiv},
+          primaryClass={stat.ML},
+          url={https://arxiv.org/abs/2506.11994},
+          journal={arXiv preprint arXiv:2506.11994},
       }
 
 

{freealg-0.1.13 → freealg-0.1.14}/README.rst

@@ -3,6 +3,12 @@
     :width: 240
     :class: custom-dark
 
+`Paper <https://arxiv.org/abs/2506.11994>`__ |
+`Slides <https://www.dropbox.com/scl/fi/03gjuyz17k9yhsqy0isoz/free_decomporession_slides.pdf?rlkey=8f82mhciyl2ju02l7hv1md5li&st=26xmhjga&dl=0>`__ |
+`Docs <https://ameli.github.io/freealg>`__
+
+.. `Slides <https://ameli.github.io/freealg/_static/data/slides.pdf>`__ |
+
 *freealg* is a Python package that employs **free** probability to evaluate the spectral
 densities of large matrix **form**\ s. The fundamental algorithm employed by *freealg* is
 **free decompression**, which extrapolates from the empirical spectral densities of small 
@@ -73,15 +79,19 @@ requests and bug reports.
 How to Cite
 ===========
 
-If you use this work, please cite the `arXiv paper <https://arxiv.org/abs/2506.11994>`.
+If you use this work, please cite the `arXiv paper <https://arxiv.org/abs/2506.11994>`__.
 
   .. code::
 
-      @article{ameli2025spectral,
-        title={Spectral Estimation with Free Decompression},
-        author={Siavash Ameli and Chris van der Heide and Liam Hodgkinson and Michael W. Mahoney},
-        journal={arXiv preprint arXiv:2506.11994},
-        year={2025}
+      @article{spectral2025,
+          title={Spectral Estimation with Free Decompression},
+          author={Siavash Ameli and Chris van der Heide and Liam Hodgkinson and Michael W. Mahoney},
+          year={2025},
+          eprint={2506.11994},
+          archivePrefix={arXiv},
+          primaryClass={stat.ML},
+          url={https://arxiv.org/abs/2506.11994},
+          journal={arXiv preprint arXiv:2506.11994},
       }
 
 

{freealg-0.1.13 → freealg-0.1.14}/freealg/__init__.py

@@ -6,7 +6,8 @@
 # under the terms of the license found in the LICENSE.txt file in the root
 # directory of this source tree.
 
-from .freeform import FreeForm, eigfree
+from .freeform import FreeForm
+from .eigfree import eigfree
 from . import distributions
 
 __all__ = ['FreeForm', 'distributions', 'eigfree']

freealg-0.1.14/freealg/__version__.py

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

{freealg-0.1.13 → freealg-0.1.14}/freealg/_chebyshev.py

@@ -58,7 +58,6 @@ def chebyshev_sample_proj(eig, support, K=10, reg=0.0):
 
     # Map to [–1,1] interval
     t = (2 * eig - (lam_m + lam_p)) / (lam_p - lam_m)
-    N = eig.size
 
     # Inner‐product norm of each U_k under w(t) = sqrt{1–t^2} is \\pi/2
     norm = numpy.pi / 2
@@ -104,7 +103,7 @@ def chebyshev_kernel_proj(xs, pdf, support, K=10, reg=0.0):
 
     for k in range(K + 1):
         Pk = eval_chebyu(k, t)                       # U_k(t) on the grid
-        moment = numpy.trapezoid(Pk * pdf, xs)           # \int U_k(t) \rho(x) dx
+        moment = numpy.trapezoid(Pk * pdf, xs)       # \int U_k(t) \rho(x) dx
 
         if k == 0:
             penalty = 0
@@ -226,12 +225,12 @@ def chebyshev_stieltjes(z, psi, support):
     S = wynn_pade(psi_zero, J)
 
     # build powers J^(k+1) for k=0..K
-    #K = len(psi) - 1
+    # K = len(psi) - 1
     # shape: (..., K+1)
-    #Jpow = J[..., None] ** numpy.arange(1, K+2)
+    # Jpow = J[..., None] ** numpy.arange(1, K+2)
 
     # sum psi_k * J^(k+1)
-    #S = numpy.sum(psi * Jpow, axis=-1)
+    # S = numpy.sum(psi * Jpow, axis=-1)
 
     # assemble m(z)
     m_z = -2 / span * numpy.pi * S

{freealg-0.1.13 → freealg-0.1.14}/freealg/_decompress.py

@@ -11,12 +11,18 @@
 # =======
 
 import numpy
-# from scipy.integrate import solve_ivp
 
 __all__ = ['decompress', 'reverse_characteristics']
 
+
+# =============
+# secant method
+# =============
+
+
 def secant_complex(f, z0, z1, a=0+0j, tol=1e-12, max_iter=100,
-    alpha=0.5, max_bt=12, eps=1e-30, verbose=False):
+                   alpha=0.5, max_bt=2, eps=1e-30, step_factor=5.0,
+                   post_smooth=True, jump_tol=10.0, verbose=False):
     """
     Solves :math:``f(z) = a`` for many starting points simultaneously
     using the secant method in the complex plane.
@@ -42,11 +48,20 @@ def secant_complex(f, z0, z1, a=0+0j, tol=1e-12, max_iter=100,
         Back‑tracking shrink factor (``0 < alpha < 1``). Defaults to ``0.5``.
 
     max_bt : int, optional
-        Maximum back‑tracking trials per iteration. Defaults to ``12``.
+        Maximum back‑tracking trials per iteration. Defaults to ``0``.
 
     eps : float, optional
         Safeguard added to tiny denominators. Defaults to ``1e-30``.
 
+    post_smooth : bool, optional
+        If True (default) run a single vectorised clean-up pass that
+        re-solves points whose final root differs from the *nearest*
+        neighbour by more than ``jump_tol`` times the local median jump.
+
+    jump_tol : float, optional
+        Sensitivity of the clean-up pass; larger tolerance implies fewer
+        re-solves.
+
     verbose : bool, optional
         If *True*, prints progress every 10 iterations.
 
@@ -69,8 +84,8 @@ def secant_complex(f, z0, z1, a=0+0j, tol=1e-12, max_iter=100,
     orig_shape = z0.shape
     z0, z1, a = (x.ravel() for x in (z0, z1, a))
 
-    n_points   = z0.size
-    roots      = z1.copy()
+    n_points = z0.size
+    roots = z1.copy()
     iterations = numpy.zeros(n_points, dtype=int)
 
     f0 = f(z0) - a
@@ -87,9 +102,16 @@ def secant_complex(f, z0, z1, a=0+0j, tol=1e-12, max_iter=100,
         # Secant step
         denom = f1 - f0
         denom = numpy.where(numpy.abs(denom) < eps, denom + eps, denom)
-        dz    = (z1 - z0) * f1 / denom
-        z2    = z1 - dz
-        f2    = f(z2) - a
+        dz = (z1 - z0) * f1 / denom
+
+        # Step-size limiter
+        prev_step = numpy.maximum(numpy.abs(z1 - z0), eps)
+        max_step = step_factor * prev_step
+        big = numpy.abs(dz) > max_step
+        dz[big] *= max_step[big] / numpy.abs(dz[big])
+
+        z2 = z1 - dz
+        f2 = f(z2) - a
 
         # Line search by backtracking
         worse = (numpy.abs(f2) >= numpy.abs(f1)) & active
@@ -130,18 +152,57 @@ def secant_complex(f, z0, z1, a=0+0j, tol=1e-12, max_iter=100,
     residuals[remaining] = numpy.abs(f1[remaining])
     iterations[remaining] = max_iter
 
+    # Optional clean-up pass
+    if post_smooth and n_points > 2:
+        # absolute jump to *nearest* neighbour (left or right)
+        diff_left = numpy.empty_like(roots)
+        diff_right = numpy.empty_like(roots)
+        diff_left[1:] = numpy.abs(roots[1:] - roots[:-1])
+        diff_right[:-1] = numpy.abs(roots[:-1] - roots[1:])
+        jump = numpy.minimum(diff_left, diff_right)
+
+        # ignore unconverged points
+        median_jump = numpy.median(jump[~remaining])
+        bad = (jump > jump_tol * median_jump) & ~remaining
+
+        if bad.any():
+            z_first_all = numpy.where(bad & (diff_left <= diff_right),
+                                      roots - diff_left,
+                                      roots + diff_right)
+
+            # keep only the offending indices
+            z_first = z_first_all[bad]
+            z_second = z_first + (roots[bad] - z_first) * 1e-2
+
+            # re-solve just the outliers in one vector call
+            new_root, new_res, new_iter = secant_complex(
+                f, z_first, z_second, a[bad],
+                tol=tol, max_iter=max_iter,
+                alpha=alpha, max_bt=max_bt,
+                eps=eps, step_factor=step_factor,
+                post_smooth=False,      # avoid recursion
+            )
+            roots[bad] = new_root
+            residuals[bad] = new_res
+            iterations[bad] = iterations[bad] + new_iter
+
+            if verbose:
+                print(f"Clean-up: re-solved {bad.sum()} outliers")
+
     return (
         roots.reshape(orig_shape),
         residuals.reshape(orig_shape),
         iterations.reshape(orig_shape),
     )
 
+
 # ==========
 # decompress
 # ==========
 
-def decompress(freeform, size, x=None, delta=1e-6, max_iter=500,
-               tolerance=1e-12):
+
+def decompress(freeform, size, x=None, delta=1e-4, max_iter=500,
+               tolerance=1e-8):
     """
     Free decompression of spectral density.
 
@@ -201,34 +262,35 @@ def decompress(freeform, size, x=None, delta=1e-6, max_iter=500,
     alpha = size / freeform.n
     m = freeform._eval_stieltjes
     # Lower and upper bound on new support
-    hilb_lb = (1 / m(freeform.lam_m + delta * 1j)[1]).real
-    hilb_ub = (1 / m(freeform.lam_p + delta * 1j)[1]).real
+    hilb_lb = (1 / m(freeform.lam_m + delta * 1j)).real
+    hilb_ub = (1 / m(freeform.lam_p + delta * 1j)).real
     lb = freeform.lam_m - (alpha - 1) * hilb_lb
     ub = freeform.lam_p - (alpha - 1) * hilb_ub
 
     # Create x if not given
-    if x is None:
+    on_grid = (x is None)
+    if on_grid:
         radius = 0.5 * (ub - lb)
         center = 0.5 * (ub + lb)
         scale = 1.25
         x_min = numpy.floor(center - radius * scale)
         x_max = numpy.ceil(center + radius * scale)
         x = numpy.linspace(x_min, x_max, 500)
+    else:
+        x = numpy.asarray(x)
 
-    # Ensure that input is an array
-    x = numpy.asarray(x)
     target = x + delta * 1j
     if numpy.isclose(alpha, 1.0):
         return freeform.density(x), x, freeform.support
 
     # Characteristic curve map
     def _char_z(z):
-        return z + (1 / m(z)[1]) * (1 - alpha)
+        return z + (1 / m(z)) * (1 - alpha)
 
-    z0 = numpy.full(target.shape, numpy.mean(freeform.support) + delta*1j,
+    z0 = numpy.full(target.shape, numpy.mean(freeform.support) + .1j,
                     dtype=numpy.complex128)
-    z1 = z0 - numpy.log(alpha) * 1j
-    
+    z1 = z0 - .2j
+
     roots, _, _ = secant_complex(
         _char_z, z0, z1,
         a=target,
@@ -238,9 +300,15 @@ def decompress(freeform, size, x=None, delta=1e-6, max_iter=500,
 
     # Plemelj's formula
     z = roots
-    char_s = m(z)[1] / alpha
+    char_s = m(z) / alpha
     rho = numpy.maximum(0, char_s.imag / numpy.pi)
     rho[numpy.isnan(rho) | numpy.isinf(rho)] = 0
+    if on_grid:
+        x, rho = x.ravel(), rho.ravel()
+        # dx = x[1] - x[0]
+        # left_idx, right_idx = support_from_density(dx, rho)
+        # x, rho = x[left_idx-1:right_idx+1], rho[left_idx-1:right_idx+1]
+        rho = rho / numpy.trapezoid(rho, x)
 
     return rho.reshape(*x.shape), x, (lb, ub)
 
@@ -260,7 +328,7 @@ def reverse_characteristics(freeform, z_inits, T, iterations=500,
     m = freeform._eval_stieltjes
 
     def _char_z(z, t):
-        return z + (1 / m(z)[1]) * (1 - numpy.exp(t))
+        return z + (1 / m(z)) * (1 - numpy.exp(t))
 
     target_z, target_t = numpy.meshgrid(z_inits, t_eval)
 

{freealg-0.1.13 → freealg-0.1.14}/freealg/_pade.py

@@ -236,9 +236,10 @@ def _eval_rational(z, c, D, poles, resid):
 
     return c + D * z + term
 
-# ========
-# Wynn epsilon algorithm for Pade
-# ========
+
+# =========
+# Wynn pade
+# =========
 
 @numba.jit(nopython=True, parallel=True)
 def wynn_pade(coeffs, x):
@@ -248,48 +249,57 @@ def wynn_pade(coeffs, x):
     returns a function handle that computes the Pade approximant at any x
     using Wynn's epsilon algorithm.
 
-    Parameters:
-        coeffs (list or array): Coefficients [a0, a1, a2, ...] of the power series.
+    Parameters
+    ----------
+
+    coeffs (list or array):
+        Coefficients [a0, a1, a2, ...] of the power series.
 
-    Returns:
-        function: A function approximant(x) that returns the approximated value f(x).
+    Returns
+    -------
+
+    function:
+        A function approximant(x) that returns the approximated value f(x).
     """
+
     # Number of coefficients
     xn = x.ravel()
     d = len(xn)
     N = len(coeffs)
-    
+
     # Compute the partial sums s_n = sum_{i=0}^n a_i * x^i for n=0,...,N-1
     eps = numpy.zeros((N+1, N, d), dtype=numpy.complex128)
     for i in numba.prange(d):
         partial_sum = 0.0
         for n in range(N):
             partial_sum += coeffs[n] * (xn[i] ** n)
-            eps[0,n,i] = partial_sum
+            eps[0, n, i] = partial_sum
 
     for i in numba.prange(d):
         for k in range(1, N+1):
             for j in range(N - k):
-                delta = eps[k-1, j+1,i] - eps[k-1, j,i]
+                delta = eps[k-1, j+1, i] - eps[k-1, j, i]
                 if delta == 0:
                     rec_delta = numpy.inf
                 elif numpy.isinf(delta) or numpy.isnan(delta):
                     rec_delta = 0.0
                 else:
                     rec_delta = 1.0 / delta
-                eps[k,j,i] = rec_delta
+                eps[k, j, i] = rec_delta
                 if k > 1:
-                    eps[k,j,i] += eps[k-2,j+1,i]
+                    eps[k, j, i] += eps[k-2, j+1, i]
 
     if (N % 2) == 0:
         N -= 1
-    
+
     return eps[N-1, 0, :].reshape(x.shape)
 
+
 # ========
 # fit pade
 # ========
 
+
 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):

{freealg-0.1.13 → freealg-0.1.14}/freealg/_plot_util.py

@@ -139,7 +139,7 @@ def _auto_bins(array, method='scott', factor=5):
 # ============
 
 def plot_density(x, rho, eig=None, support=None, label='',
-                 title='Spectral density', latex=False, save=False):
+                 title='Spectral Density', latex=False, save=False):
     """
     """
 
@@ -147,8 +147,11 @@ def plot_density(x, rho, eig=None, support=None, label='',
 
         fig, ax = plt.subplots(figsize=(6, 2.7))
 
-        if (support is not None) and (eig is not None):
-            lam_m, lam_p = support
+        if eig is not None:
+            if support is not None:
+                lam_m, lam_p = support
+            else:
+                lam_m, lam_p = min(eig), max(eig)
             bins = numpy.linspace(lam_m, lam_p, _auto_bins(eig))
             _ = ax.hist(eig, bins, density=True, color='silver',
                         edgecolor='none', label='Histogram')

freealg-0.1.14/freealg/_support.py

@@ -0,0 +1,186 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# SPDX-FileType: SOURCE
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the license found in the LICENSE.txt file in the root directory
+# of this source tree.
+
+
+# =======
+# Imports
+# =======
+
+import numpy
+import numba
+from scipy.stats import gaussian_kde
+
+
+@numba.njit(numba.types.UniTuple(numba.types.int64, 2)(
+    numba.types.float64,
+    numba.types.float64[::1]
+))
+def support_from_density(dx, density):
+    """
+    Estimates the support from a collection of noisy observations of a
+    density over a grid of x-values with mesh spacing dx.
+    """
+    n = density.shape[0]
+    target = 1.0 / dx
+
+    # 1) compute total_sum once
+    total_sum = 0.0
+    for t in range(n):
+        total_sum += density[t]
+
+    # 2) set up our “best‐so‐far” trackers
+    large = 1e300
+    best_nonneg_sum = large
+    best_nonneg_idx = -1
+    best_nonpos_sum = -large
+    best_nonpos_idx = -1
+
+    # 3) seed with first element (i.e. prefix_sum for k=1)
+    prefix_sum = density[0]
+    if prefix_sum >= 0.0:
+        best_nonneg_sum, best_nonneg_idx = prefix_sum, 1
+    else:
+        best_nonpos_sum, best_nonpos_idx = prefix_sum, 1
+
+    # 4) sweep j from 2...n–1, updating prefix_sum on the fly
+    optimal_i, optimal_j = 1, 2
+    minimal_cost = large
+
+    for j in range(2, n):
+        # extend prefix_sum to cover density[0]...density[j-1]
+        prefix_sum += density[j-1]
+
+        # cost for [0...i], [i...j]
+        diff_mid = prefix_sum - target
+        if diff_mid >= 0.0 and best_nonneg_sum <= diff_mid:
+            cost12 = diff_mid
+            i_cand = best_nonneg_idx
+        elif diff_mid < 0.0 and best_nonpos_sum >= diff_mid:
+            cost12 = -diff_mid
+            i_cand = best_nonpos_idx
+        else:
+            cost_using_nonpos = diff_mid - 2.0 * best_nonpos_sum
+            cost_using_nonneg = 2.0 * best_nonneg_sum - diff_mid
+            if cost_using_nonpos < cost_using_nonneg:
+                cost12, i_cand = cost_using_nonpos, best_nonpos_idx
+            else:
+                cost12, i_cand = cost_using_nonneg, best_nonneg_idx
+
+        # cost for [j...n]
+        cost3 = total_sum - prefix_sum
+        if cost3 < 0.0:
+            cost3 = -cost3
+
+        # total and maybe update best split
+        total_cost = cost12 + cost3
+        if total_cost < minimal_cost:
+            minimal_cost = total_cost
+            optimal_i, optimal_j = i_cand, j
+
+        # update our prefix‐sum trackers
+        if prefix_sum >= 0.0:
+            if prefix_sum < best_nonneg_sum:
+                best_nonneg_sum, best_nonneg_idx = prefix_sum, j
+        else:
+            if prefix_sum > best_nonpos_sum:
+                best_nonpos_sum, best_nonpos_idx = prefix_sum, j
+
+    return optimal_i, optimal_j
+
+
+def detect_support(eigs, method='asymp', k=None, p=0.001, **kwargs):
+    """
+    Estimates the support of the eigenvalue density.
+
+    Parameters
+    ----------
+    method : {``'range'``, ``'asymp'``, ``'jackknife'``, ``'regression'``,
+                ``'interior'``, ``'interior_smooth'``}, \
+            default= ``'asymp'``
+        The method of support estimation:
+
+        * ``'range'``: no estimation; the support is the range of the
+            eigenvalues.
+        * ``'asymp'``: assume the relative error in the min/max estimator is
+            1/n.
+        * ``'jackknife'``: estimates the support using Quenouille's [1]
+            jackknife estimator. Fast and simple, more accurate than the
+            range.
+        * ``'regression'``: estimates the support by performing a regression
+            under the assumption that the edge behavior is of square-root
+            type. Often most accurate.
+        * ``'interior'``: estimates a support assuming the range overestimates;
+            uses quantiles (p, 1-p).
+        * ``'interior_smooth'``: same as ``'interior'`` but using kernel
+            density estimation.
+
+    k : int, default = None
+        Number of extreme order statistics to use for ``method='regression'``.
+
+    p : float, default=0.001
+        The edges of the support of the distribution is detected by the
+        :math:`p`-quantile on the left and :math:`(1-p)`-quantile on the right
+        where ``method='interior'`` or ``method='interior_smooth'``.
+        This value should be between 0 and 1, ideally a small number close to
+        zero.
+
+    References
+    ----------
+
+    .. [1] Quenouille, M. H. (1949, July). Approximate tests of correlation in
+           time-series. In Mathematical Proceedings of the Cambridge
+           Philosophical Society (Vol. 45, No. 3, pp. 483-484). Cambridge
+           University Press.
+    """
+
+    if method == 'range':
+        lam_m = eigs.min()
+        lam_p = eigs.max()
+
+    elif method == 'asymp':
+        lam_m = eigs.min() - abs(eigs.min()) / len(eigs)
+        lam_p = eigs.max() + abs(eigs.max()) / len(eigs)
+
+    elif method == 'jackknife':
+        x, n = numpy.sort(eigs), len(eigs)
+        lam_m = x[0] - (n - 1)/n * (x[1] - x[0])
+        lam_p = x[-1] + (n - 1)/n * (x[-1] - x[-2])
+
+    elif method == 'regression':
+        x, n = numpy.sort(eigs), len(eigs)
+        if k is None:
+            k = int(round(n ** (2/3)))
+            k = max(5, min(k, n // 2))
+
+        # The theoretical cdf near the edge behaves like const*(x - a)^{3/2},
+        # so (i/n) ~ (x - a)^{3/2}  ->  x ~ a + const*(i/n)^{2/3}.
+        y = ((numpy.arange(1, k + 1) - 0.5) / n) ** (2 / 3)
+
+        # Left edge: regress x_{(i)} on y
+        _, lam_m = numpy.polyfit(y, x[:k], 1)
+
+        # Right edge: regress x_{(n-i+1)} on y
+        _, lam_p = numpy.polyfit(y, x[-k:][::-1], 1)
+
+    elif method == 'interior':
+        lam_m, lam_p = numpy.quantile(eigs, [p, 1-p])
+
+    elif method == 'interior_smooth':
+        kde = gaussian_kde(eigs)
+        xs = numpy.linspace(eigs.min(), eigs.max(), 1000)
+        fs = kde(xs)
+
+        cdf = numpy.cumsum(fs)
+        cdf /= cdf[-1]
+
+        lam_m = numpy.interp(p, cdf, xs)
+        lam_p = numpy.interp(1-p, cdf, xs)
+
+    else:
+        raise NotImplementedError("Unknown method")
+
+    return lam_m, lam_p

{freealg-0.1.13 → freealg-0.1.14}/freealg/distributions/_kesten_mckay.py

@@ -110,7 +110,7 @@ class KestenMcKay(object):
     # density
     # =======
 
-    def density(self, x=None, plot=False, latex=False, save=False):
+    def density(self, x=None, plot=False, latex=False, save=False, eig=None):
         """
         Density of distribution.
 
@@ -137,6 +137,10 @@ class KestenMcKay(object):
             assumed to the save filename (with the file extension). This option
             is relevant only if ``plot=True``.
 
+        eig : numpy.array, default=None
+            A collection of eigenvalues to compare to via histogram. This
+            option is relevant only if ``plot=True``.
+
         Returns
         -------
 
@@ -173,7 +177,11 @@ class KestenMcKay(object):
             numpy.sqrt(4.0 * (self.d - 1.0) - x[mask]**2)
 
         if plot:
-            plot_density(x, rho, label='', latex=latex, save=save)
+            if eig is not None:
+                label = 'Estimate'
+            else:
+                label = ''
+            plot_density(x, rho, label=label, latex=latex, save=save, eig=eig)
 
         return rho
 
@@ -539,9 +547,9 @@ class KestenMcKay(object):
 
         return samples
 
-    # ============
-    # Haar unitary
-    # ============
+    # ===============
+    # haar orthogonal
+    # ===============
 
     def _haar_orthogonal(self, n, k, seed=None):
         """