freealg 0.1.13__py3-none-any.whl → 0.1.15__py3-none-any.whl

freealg/__init__.py

@@ -6,9 +6,10 @@
 # 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, condfree
 from . import distributions
 
-__all__ = ['FreeForm', 'distributions', 'eigfree']
+__all__ = ['FreeForm', 'distributions', 'eigfree', 'condfree']
 
 from .__version__ import __version__                          # noqa: F401 E402

freealg/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.13"
+__version__ = "0.1.15"

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
@@ -225,14 +224,6 @@ def chebyshev_stieltjes(z, psi, support):
     psi_zero = numpy.concatenate([[0], psi])
     S = wynn_pade(psi_zero, J)
 
-    # build powers J^(k+1) for k=0..K
-    #K = len(psi) - 1
-    # shape: (..., K+1)
-    #Jpow = J[..., None] ** numpy.arange(1, K+2)
-
-    # sum psi_k * J^(k+1)
-    #S = numpy.sum(psi * Jpow, axis=-1)
-
     # assemble m(z)
     m_z = -2 / span * numpy.pi * S
 

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=1, 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/_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/_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/_support.py

@@ -1,31 +1,126 @@
+# 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
 
-def detect_support(eigs, method='interior_smooth', k = None, p = 0.001, **kwargs):
+
+@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'``, ``'jackknife'``, ``'regression'``, ``'interior'``, 
-                ``'interior_smooth'``}, \
-            default= ``'jackknife'``
+    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
+        * ``'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.
+            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.
+        * ``'interior_smooth'``: same as ``'interior'`` but using kernel
+            density estimation.
 
     k : int, default = None
-        Number of extreme order statistics to use for ``method='regression'``. 
-    
+        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
@@ -36,28 +131,33 @@ def detect_support(eigs, method='interior_smooth', k = None, p = 0.001, **kwargs
     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.
+    .. [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':
+    if method == 'range':
         lam_m = eigs.min()
         lam_p = eigs.max()
 
-    elif method=='jackknife':
+    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_m = x[0] - (n - 1)/n * (x[1] - x[0])
         lam_p = x[-1] + (n - 1)/n * (x[-1] - x[-2])
 
-    elif method=='regression':
+    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}.
+        # 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
@@ -66,10 +166,10 @@ def detect_support(eigs, method='interior_smooth', k = None, p = 0.001, **kwargs
         # Right edge: regress x_{(n-i+1)} on y
         _, lam_p = numpy.polyfit(y, x[-k:][::-1], 1)
 
-    elif method=='interior':
+    elif method == 'interior':
         lam_m, lam_p = numpy.quantile(eigs, [p, 1-p])
-    
-    elif method=='interior_smooth':
+
+    elif method == 'interior_smooth':
         kde = gaussian_kde(eigs)
         xs = numpy.linspace(eigs.min(), eigs.max(), 1000)
         fs = kde(xs)
@@ -79,6 +179,7 @@ def detect_support(eigs, method='interior_smooth', k = None, p = 0.001, **kwargs
 
         lam_m = numpy.interp(p, cdf, xs)
         lam_p = numpy.interp(1-p, cdf, xs)
+
     else:
         raise NotImplementedError("Unknown method")
 

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 = 'Theoretical'
+            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):
         """

freealg/distributions/_marchenko_pastur.py

@@ -108,7 +108,7 @@ class MarchenkoPastur(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.
 
@@ -135,6 +135,10 @@ class MarchenkoPastur(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
         -------
 
@@ -171,7 +175,11 @@ class MarchenkoPastur(object):
             numpy.sqrt((self.lam_p - x[mask]) * (x[mask] - self.lam_m))
 
         if plot:
-            plot_density(x, rho, label='', latex=latex, save=save)
+            if eig is not None:
+                label = 'Theoretical'
+            else:
+                label = ''
+            plot_density(x, rho, label=label, latex=latex, save=save, eig=eig)
 
         return rho
 

freealg/distributions/_meixner.py

@@ -114,7 +114,7 @@ class Meixner(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.
 
@@ -141,6 +141,10 @@ class Meixner(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
         -------
 
@@ -188,7 +192,11 @@ class Meixner(object):
         rho[mask] = numer[mask] / denom[mask]
 
         if plot:
-            plot_density(x, rho, label='', latex=latex, save=save)
+            if eig is not None:
+                label = 'Theoretical'
+            else:
+                label = ''
+            plot_density(x, rho, label=label, latex=latex, save=save, eig=eig)
 
         return rho
 

freealg/distributions/_wachter.py

@@ -115,7 +115,7 @@ class Wachter(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.
 
@@ -142,6 +142,10 @@ class Wachter(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
         -------
 
@@ -179,7 +183,11 @@ class Wachter(object):
             numpy.sqrt((self.lam_p - x[mask]) * (x[mask] - self.lam_m))
 
         if plot:
-            plot_density(x, rho, label='', latex=latex, save=save)
+            if eig is not None:
+                label = 'Theoretical'
+            else:
+                label = ''
+            plot_density(x, rho, label=label, latex=latex, save=save, eig=eig)
 
         return rho
 

freealg/distributions/_wigner.py

@@ -96,7 +96,7 @@ class Wigner(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.
 
@@ -123,6 +123,10 @@ class Wigner(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
         -------
 
@@ -159,7 +163,11 @@ class Wigner(object):
             numpy.sqrt(self.r**2 - x[mask]**2)
 
         if plot:
-            plot_density(x, rho, label='', latex=latex, save=save)
+            if eig is not None:
+                label = 'Theoretical'
+            else:
+                label = ''
+            plot_density(x, rho, label=label, latex=latex, save=save, eig=eig)
 
         return rho
 

freealg/eigfree.py

@@ -0,0 +1,170 @@
+# SPDX-FileCopyrightText: Copyright 2025, Siavash Ameli <sameli@berkeley.edu>
+# 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
+from ._util import compute_eig
+from .freeform import FreeForm
+
+__all__ = ['eigfree', 'condfree']
+
+
+# ========
+# eig free
+# ========
+
+
+def eigfree(A, N=None, psd=None, plots=False):
+    """
+    Estimate the eigenvalues of a matrix.
+
+    This function estimates the eigenvalues of the matrix :math:`\\mathbf{A}`
+    or a larger matrix containing :math:`\\mathbf{A}` using free decompression.
+
+    Parameters
+    ----------
+
+    A : numpy.ndarray
+        The symmetric real-valued matrix :math:`\\mathbf{A}` whose eigenvalues
+        (or those of a matrix containing :math:`\\mathbf{A}`) are to be
+        computed.
+
+    N : int, default=None
+        The size of the matrix containing :math:`\\mathbf{A}` to estimate
+        eigenvalues of. If None, returns estimates of the eigenvalues of
+        :math:`\\mathbf{A}` itself.
+
+    psd: bool, default=None
+        Determines whether the matrix is positive-semidefinite (PSD; all
+        eigenvalues are non-negative). If None, the matrix is considered PSD if
+        all sampled eigenvalues are positive.
+
+    plots : bool, default=False
+        Print out all relevant plots for diagnosing eigenvalue accuracy.
+
+    Notes
+    -----
+
+    This is a convenience function for the FreeForm class with some effective
+    defaults that work well for common random matrix ensembles. For improved
+    performance and plotting utilites, consider finetuning parameters using
+    the FreeForm class.
+
+    References
+    ----------
+
+    .. [1] Reference.
+
+    Examples
+    --------
+
+    .. code-block:: python
+
+        >>> from freealg import condfree
+        >>> from freealg.distributions import MarchenkoPastur
+        >>> mp = MarchenkoPastur(1/50)
+        >>> A = mp.matrix(3000)
+        >>> eigs = eigfree(A)
+    """
+
+    if A.ndim != 2 or A.shape[0] != A.shape[1]:
+        raise RuntimeError("Only square matrices are permitted.")
+    n = A.shape[0]
+
+    if N is None:
+        N = n
+
+    # Size of sample matrix
+    n_s = int(80*(1 + numpy.log(n)))
+    # If matrix is not large enough, return eigenvalues
+    if n < n_s:
+        return compute_eig(A)
+    # Number of samples
+    num_samples = int(10 * (n / n_s)**0.5)
+
+    # Collect eigenvalue samples
+    samples = []
+    for _ in range(num_samples):
+        indices = numpy.random.choice(n, n_s, replace=False)
+        samples.append(compute_eig(A[numpy.ix_(indices, indices)]))
+    samples = numpy.concatenate(samples).ravel()
+
+    # If all eigenvalues are positive, set PSD flag
+    if psd is None:
+        psd = samples.min() > 0
+
+    ff = FreeForm(samples)
+    # Since we are resampling, we need to provide the correct matrix size
+    ff.n = n_s
+
+    # Perform fit and estimate eigenvalues
+    order = 1 + int(len(samples)**.2)
+    ff.fit(method='chebyshev', K=order, projection='sample',
+           force=True, plot=False, latex=False, save=False)
+
+    if plots:
+        ff.density(plot=True)
+        ff.stieltjes(plot=True)
+
+    _, _, eigs = ff.decompress(N, plot=plots)
+
+    if psd:
+        eigs = numpy.abs(eigs)
+        eigs.sort()
+
+    return eigs
+
+
+# ========
+# cond free
+# ========
+
+def condfree(A, N=None):
+    """
+    Estimate the condition number of a positive-definite matrix.
+
+    This function estimates the condition number of the matrix
+    :math:`\\mathbf{A}` or a larger matrix containing :math:`\\mathbf{A}`
+    using free decompression.
+
+    Parameters
+    ----------
+
+    A : numpy.ndarray
+        The symmetric real-valued matrix :math:`\\mathbf{A}` whose condition
+        number (or that of a matrix containing :math:`\\mathbf{A}`) are to be
+        computed.
+
+    N : int, default=None
+        The size of the matrix containing :math:`\\mathbf{A}` to estimate
+        eigenvalues of. If None, returns estimates of the eigenvalues of
+        :math:`\\mathbf{A}` itself.
+
+    Notes
+    -----
+
+    This is a convenience function using the eigfree procedure.
+
+    Examples
+    --------
+
+    .. code-block:: python
+
+        >>> from freealg import condfree
+        >>> from freealg.distributions import MarchenkoPastur
+        >>> mp = MarchenkoPastur(1/50)
+        >>> A = mp.matrix(3000)
+        >>> condfree(A)
+    """
+
+    eigs = eigfree(A, N)
+    return eigs.max() / eigs.min()

freealg/freeform.py

@@ -28,7 +28,7 @@ from ._decompress import decompress
 from ._sample import qmc_sample
 from ._support import detect_support
 
-__all__ = ['FreeForm', 'eigfree']
+__all__ = ['FreeForm']
 
 
 # =========
@@ -75,15 +75,15 @@ class FreeForm(object):
         Eigenvalues of the matrix
 
     support: tuple
-        The predicted (or given) support :math:`(\lambda_\min, \lambda_\max)` of the 
-        eigenvalue density.
+        The predicted (or given) support :math:`(\\lambda_{\\min},
+        \\lambda_{\\max})` of the eigenvalue density.
 
     psi : numpy.array
         Jacobi coefficients.
 
-    n   : int
-        Initial array size (assuming a square matrix when :math:`\\mathbf{A}`
-        is 2D).
+    n : int
+      Initial array size (assuming a square matrix when :math:`\\mathbf{A}` is
+      2D).
 
     Methods
     -------
@@ -390,10 +390,10 @@ class FreeForm(object):
             x_supp = numpy.linspace(self.lam_m, self.lam_p, 1000)
             g_supp = 2.0 * numpy.pi * self.hilbert(x_supp)
             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,
-                                    pade_reg=pade_reg, safety=1.0, max_outer=40,
-                                    xtol=1e-12, ftol=1e-12, optimizer=optimizer,
-                                    verbose=0)
+                                      p=pade_p, q=pade_q, odd_side=odd_side,
+                                      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, :]
@@ -449,7 +449,8 @@ class FreeForm(object):
         """
 
         if self.psi is None:
-            raise RuntimeError('The spectral density needs to be fit using the .fit() function.')
+            raise RuntimeError('The spectral density needs to be fit using ' +
+                               'the .fit() function.')
 
         # Create x if not given
         if x is None:
@@ -543,7 +544,8 @@ class FreeForm(object):
         """
 
         if self.psi is None:
-            raise RuntimeError('The spectral density needs to be fit using the .fit() function.')
+            raise RuntimeError('The spectral density needs to be fit using ' +
+                               'the .fit() function.')
 
         # Create x if not given
         if x is None:
@@ -605,8 +607,10 @@ class FreeForm(object):
 
     def stieltjes(self, x=None, y=None, plot=False, latex=False, save=False):
         """
-        Compute Stieltjes transform of the spectral density, evaluated on an array
-        of points, or over a 2D Cartesian grid on the complex plane.
+        Compute Stieltjes transform of the spectral density on a grid.
+
+        This function evaluates Stieltjes transform on an array of points, or
+        over a 2D Cartesian grid on the complex plane.
 
         Parameters
         ----------
@@ -665,11 +669,11 @@ class FreeForm(object):
         """
 
         if self.psi is None:
-            raise RuntimeError('The spectral density needs to be fit using the .fit() function.')
-
+            raise RuntimeError('The spectral density needs to be fit using ' +
+                               'the .fit() function.')
 
-        # Determine whether the Stieltjes transform is to be computed on
-        # a Cartesian grid
+        # Determine whether the Stieltjes transform is to be computed on a
+        # Cartesian grid
         cartesian = plot | (y is not None)
 
         # Create x if not given
@@ -693,8 +697,8 @@ class FreeForm(object):
             z = x_grid + 1j * y_grid              # shape (Ny, Nx)
         else:
             z = x
-        
-        m1, m2 = self._eval_stieltjes(z)
+
+        m1, m2 = self._eval_stieltjes(z, branches=True)
 
         if plot:
             plot_stieltjes(x, y, m1, m2, self.support, latex=latex, save=save)
@@ -705,7 +709,7 @@ class FreeForm(object):
     # eval stieltjes
     # ==============
 
-    def _eval_stieltjes(self, z):
+    def _eval_stieltjes(self, z, branches=False):
         """
         Compute Stieltjes transform of the spectral density.
 
@@ -716,12 +720,18 @@ class FreeForm(object):
             The z values in the complex plan where the Stieltjes transform is
             evaluated.
 
+        branches : bool, default = False
+            Return both the principal and secondary branches of the Stieltjes
+            transform. The default ``branches=False`` will return only
+            the secondary branch.
+
 
         Returns
         -------
 
         m_p : numpy.ndarray
-            The Stieltjes transform on the principal branch.
+            The Stieltjes transform on the principal branch if
+            ``branches=True``.
 
         m_m : numpy.ndarray
             The Stieltjes transform continued to the secondary branch.
@@ -737,14 +747,15 @@ class FreeForm(object):
         z = z.reshape(-1, 1)
 
         # # Set the number of bases as the number of x points insides support
-        # mask_sup = numpy.logical_and(z.real >= self.lam_m, z.real <= self.lam_p)
+        # mask_sup = numpy.logical_and(z.real >= self.lam_m,
+        #                              z.real <= self.lam_p)
         # n_base = 2 * numpy.sum(mask_sup)
 
         # Stieltjes function
         if self.method == 'jacobi':
             stieltjes = partial(jacobi_stieltjes, psi=self.psi,
                                 support=self.support, alpha=self.alpha,
-                                beta=self.beta) # n_base = n_base
+                                beta=self.beta)  # n_base = n_base
         elif self.method == 'chebyshev':
             stieltjes = partial(chebyshev_stieltjes, psi=self.psi,
                                 support=self.support)
@@ -760,31 +771,34 @@ class FreeForm(object):
             m1[mask_p] = stieltjes(z[mask_p].reshape(-1, 1)).ravel()
 
             # Lower half-plane, use Schwarz reflection
-            m1[mask_m] = numpy.conjugate(
-                stieltjes(numpy.conjugate(z[mask_m].reshape(-1, 1)))).ravel()
+            z_conj = numpy.conjugate(z[mask_m].reshape(-1, 1))
+            m1[mask_m] = numpy.conjugate(stieltjes(z_conj)).ravel()
 
             # Second Riemann sheet
             m2[mask_p] = m1[mask_p]
             m2[mask_m] = -m1[mask_m] + self._glue(
                 z[mask_m].reshape(-1, 1)).ravel()
-        
-        else:
-            m2[:]      = stieltjes(z.reshape(-1,1)).reshape(*m2.shape)
-            m1[mask_p] = m2[mask_p]
-            m1[mask_m] = numpy.conjugate(
-                stieltjes(numpy.conjugate(z[mask_m].reshape(-1,1)))
-            ).ravel()
 
-        m1, m2 = m1.reshape(*shape), m2.reshape(*shape)
-
-        return m1, m2
+        else:
+            m2[:] = stieltjes(z.reshape(-1, 1)).reshape(*m2.shape)
+            if branches:
+                m1[mask_p] = m2[mask_p]
+                m1[mask_m] = numpy.conjugate(
+                    stieltjes(numpy.conjugate(z[mask_m].reshape(-1, 1)))
+                ).ravel()
+
+        if not branches:
+            return m2.reshape(*shape)
+        else:
+            m1, m2 = m1.reshape(*shape), m2.reshape(*shape)
+            return m1, m2
 
     # ==========
     # decompress
     # ==========
 
     def decompress(self, size, x=None, max_iter=500, eigvals=True,
-                   step_size=0.1, tolerance=1e-9, seed=None, plot=False,
+                   tolerance=1e-9, seed=None, plot=False,
                    latex=False, save=False):
         """
         Free decompression of spectral density.
@@ -805,9 +819,6 @@ class FreeForm(object):
         eigvals: bool, default=True
             Return estimated (sampled) eigenvalues as well as the density.
 
-        step_size: float, default=0.1
-            Step size for Newton iterations.
-
         tolerance: float, default=1e-9
             Tolerance for the solution obtained by the Newton solver. Also
             used for the finite difference approximation to the derivative.
@@ -880,14 +891,15 @@ class FreeForm(object):
         else:
             return x, rho
 
-def eigfree(A, N = None, psd = None):
+
+def eigfree(A, N=None, psd=None, plots=False):
     """
     Estimate the eigenvalues of a matrix :math:`\\mathbf{A}` or a larger matrix
     containing :math:`\\mathbf{A}` using free decompression.
 
     This is a convenience function for the FreeForm class with some effective
     defaults that work well for common random matrix ensembles. For improved
-    performance and plotting utilites, consider finetuning parameters using 
+    performance and plotting utilites, consider finetuning parameters using
     the FreeForm class.
 
     Parameters
@@ -895,18 +907,22 @@ def eigfree(A, N = None, psd = None):
 
     A : numpy.ndarray
         The symmetric real-valued matrix :math:`\\mathbf{A}` whose eigenvalues
-        (or those of a matrix containing :math:`\\mathbf{A}`) are to be computed.
+        (or those of a matrix containing :math:`\\mathbf{A}`) are to be
+        computed.
 
     N : int, default=None
         The size of the matrix containing :math:`\\mathbf{A}` to estimate
         eigenvalues of. If None, returns estimates of the eigenvalues of
         :math:`\\mathbf{A}` itself.
 
-    psd: bool, default=None
-        Determines whether the matrix is positive-semidefinite (PSD; all 
+    psd : bool, default=None
+        Determines whether the matrix is positive-semidefinite (PSD; all
         eigenvalues are non-negative). If None, the matrix is considered PSD if
         all sampled eigenvalues are positive.
 
+    plots : bool, default=False
+        Print out all relevant plots for diagnosing eigenvalue accuracy.
+
     Notes
     -----
 
@@ -924,20 +940,24 @@ def eigfree(A, N = None, psd = None):
 
         >>> from freealg import FreeForm
     """
+    if A.ndim != 2 or A.shape[0] != A.shape[1]:
+        raise RuntimeError("Only square matrices are permitted.")
     n = A.shape[0]
-    
+
+    if N is None:
+        N = n
+
     # Size of sample matrix
     n_s = int(80*(1 + numpy.log(n)))
-
     # If matrix is not large enough, return eigenvalues
     if n < n_s:
         return compute_eig(A)
-    
-    if N is None:
-        N = n
-    
     # Number of samples
     num_samples = int(10 * (n / n_s)**0.5)
+    # else:
+    #     # Use the entire matrix given
+    #     n_s = n
+    #     num_samples = 1
 
     # Collect eigenvalue samples
     samples = []
@@ -956,12 +976,17 @@ def eigfree(A, N = None, psd = None):
 
     # Perform fit and estimate eigenvalues
     order = 1 + int(len(samples)**.2)
-    ff.fit(method='chebyshev', K=order, projection='sample', damp='jackson', 
-           force=True, plot=False, latex=False, save=False, reg=0.05)
-    _, _, eigs = ff.decompress(N)
+    ff.fit(method='chebyshev', K=order, projection='sample',
+           force=True, plot=False, latex=False, save=False)
+
+    if plots:
+        ff.density(plot=True)
+        ff.stieltjes(plot=True)
+
+    _, _, eigs = ff.decompress(N, plot=plots)
 
     if psd:
         eigs = numpy.abs(eigs)
         eigs.sort()
 
-    return eigs
+    return eigs

{freealg-0.1.13.dist-info → freealg-0.1.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.1.13
+Version: 0.1.15
 Summary: Free probability for large matrices
 Keywords: leaderboard bot chat
 Platform: Linux
@@ -50,6 +50,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 
@@ -120,15 +126,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.15.dist-info/RECORD

@@ -0,0 +1,25 @@
+freealg/__init__.py,sha256=oYfXRQgu--OhZAY9cIVdfEHDVz6XQmqzTsIqIFAlPws,570
+freealg/__version__.py,sha256=qb0TalpSt1CbprnFyeLUKqgrqNtmnk9IoQQ7umAoXVY,23
+freealg/_chebyshev.py,sha256=dsAj3YEpmkzB65smluZ0Fi5IZSdpnQXBSIuKMg19grA,5523
+freealg/_damp.py,sha256=k2vtBtWOxQBf4qXaWu_En81lQBXbEO4QbxxWpvuVhdE,1802
+freealg/_decompress.py,sha256=Q19AmpqxBWcrbFSniDOnh9ethOLm5_7bqDLXUNGCxk4,10372
+freealg/_jacobi.py,sha256=AT4ONSHGGDxVKE3MGMLyMR8uDFiO-e9u3x5udYfdJJk,5635
+freealg/_pade.py,sha256=wer31W6c6lDCag4THKGdW69r5d7uimsH_Y53wJih144,15185
+freealg/_plot_util.py,sha256=U4alp7Pzg315_7jJdu1UB0tIUcxUovQgHDHsUYoa2Z0,19728
+freealg/_sample.py,sha256=ckC75eqv-mRP1F5BnhvsjfLTaoAzHK8bebl9bCRZYDo,2561
+freealg/_support.py,sha256=LIM_VWH8TzLJlp_q5A0ql-xawPUNyH2YI9ZKBlHHuzo,6122
+freealg/_util.py,sha256=PWLXcsTb0-FinGWvNiY12D-f4CHQB5bP_W3ThqfY4FY,3681
+freealg/eigfree.py,sha256=ssS6t6b5wSgZNOo3ydA0MxvnhJivbYH8bwdKNmD81FE,4571
+freealg/freeform.py,sha256=j1oECmOyc-v6o7bIrbW844QZqAG6hJm6NjGvLXRMvEo,31263
+freealg/distributions/__init__.py,sha256=t_yZyEkW_W_tSV9IvgYXtVASxD2BEdiNVXcV2ebMy8M,579
+freealg/distributions/_kesten_mckay.py,sha256=210RF2OQEYLZBeLB6wmbdHnZPs_9ldDNHm_FMlg5tis,19881
+freealg/distributions/_marchenko_pastur.py,sha256=kchFccRMuVF2Cus_99vdEwuRimkHzEUV8xt5kZFg7ZI,16994
+freealg/distributions/_meixner.py,sha256=ws7t_EUa7V0s97dgMQIJLv1b6qMLqf9fLLbTJQudf_8,17512
+freealg/distributions/_wachter.py,sha256=Hna_MXqAPjuRkeilLPMf4Xg_3C6tTu5oZLEQnA-RuE4,16897
+freealg/distributions/_wigner.py,sha256=SxgPLtvIVBi9m4De-oBD0x6-2Je_eBqpDrpDYcoLuis,15871
+freealg-0.1.15.dist-info/licenses/AUTHORS.txt,sha256=0b67Nz4_JgIzUupHJTAZxu5QdSUM_HRM_X_w4xCb17o,30
+freealg-0.1.15.dist-info/licenses/LICENSE.txt,sha256=J-EEYEtxb3VVf_Bn1TYfWnpY5lMFIM15iLDDcnaDTPA,1443
+freealg-0.1.15.dist-info/METADATA,sha256=mvdtAxG-4t3-rThaz_lqpG3B_Ca8Z2LrpekEocrxVRk,4497
+freealg-0.1.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+freealg-0.1.15.dist-info/top_level.txt,sha256=eR2wrgYwDdnnJ9Zf5PruPqe4kQav0GMvRsqct6y00Q8,8
+freealg-0.1.15.dist-info/RECORD,,

freealg-0.1.13.dist-info/RECORD

@@ -1,24 +0,0 @@
-freealg/__init__.py,sha256=YqewBd3fq4nm-L3oGcExhEDR2wtVcrtggkSGzfpDqr4,528
-freealg/__version__.py,sha256=khDKUuWafURKVs5EAZkpOMiUHI2-V7axlqrWLPUpuZo,23
-freealg/_chebyshev.py,sha256=oDJtRCwKEHazitzVBDbfdQz1jkyfsJOJfcAfo-PNkNo,5745
-freealg/_damp.py,sha256=k2vtBtWOxQBf4qXaWu_En81lQBXbEO4QbxxWpvuVhdE,1802
-freealg/_decompress.py,sha256=vTnxV_7XPYUVVnWCnALCrZkQT77IAPm_CzrWMgiTiqg,7986
-freealg/_jacobi.py,sha256=AT4ONSHGGDxVKE3MGMLyMR8uDFiO-e9u3x5udYfdJJk,5635
-freealg/_pade.py,sha256=yREJYSmnWaVUNRBNxjuQUqeLe_XSaGa9_VzV6HG5RkA,15164
-freealg/_plot_util.py,sha256=BOYre8FPhrxmW1VRj3I40dCjWTFqUBTInmXc3wFunKQ,19648
-freealg/_sample.py,sha256=ckC75eqv-mRP1F5BnhvsjfLTaoAzHK8bebl9bCRZYDo,2561
-freealg/_support.py,sha256=A8hUjfKnSkHm09KLcEkeEXeTieKjhH-sVPd7I3_p4VE,3100
-freealg/_util.py,sha256=PWLXcsTb0-FinGWvNiY12D-f4CHQB5bP_W3ThqfY4FY,3681
-freealg/freeform.py,sha256=_HDgchJaeryUTgywobSM4Yr8SjXi6pRVG8kQkTKDdMM,30375
-freealg/distributions/__init__.py,sha256=t_yZyEkW_W_tSV9IvgYXtVASxD2BEdiNVXcV2ebMy8M,579
-freealg/distributions/_kesten_mckay.py,sha256=HDMjbM1AcNxlwrpYeGmRqcbP10QsLI5RCeKvjVK3tOk,19566
-freealg/distributions/_marchenko_pastur.py,sha256=th921hlEEtTbnHnRyBgT54a_e-9ZzAl9rB78O9FjorY,16688
-freealg/distributions/_meixner.py,sha256=ItE0zYG2vhyUkObxbx4bDZaJ0BHVQWPzAJGLdMz10l4,17206
-freealg/distributions/_wachter.py,sha256=lw70PT3TZlCf7mHU8IqoygXFUWB4IL57obkng0_ZGeI,16591
-freealg/distributions/_wigner.py,sha256=2ZSPjgmDr9q9qiz6jO6yhXFo4ALHfxK1f0EzolzhRNE,15565
-freealg-0.1.13.dist-info/licenses/AUTHORS.txt,sha256=0b67Nz4_JgIzUupHJTAZxu5QdSUM_HRM_X_w4xCb17o,30
-freealg-0.1.13.dist-info/licenses/LICENSE.txt,sha256=J-EEYEtxb3VVf_Bn1TYfWnpY5lMFIM15iLDDcnaDTPA,1443
-freealg-0.1.13.dist-info/METADATA,sha256=83nEmVJt6xwHPu6o0qlYN0JQ_zYuqgIPgQBvHsAdvkE,4029
-freealg-0.1.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-freealg-0.1.13.dist-info/top_level.txt,sha256=eR2wrgYwDdnnJ9Zf5PruPqe4kQav0GMvRsqct6y00Q8,8
-freealg-0.1.13.dist-info/RECORD,,