freealg 0.5.3__py3-none-any.whl → 0.6.0__py3-none-any.whl

freealg/__init__.py

@@ -8,9 +8,12 @@
 
 from .freeform import FreeForm
 from ._linalg import eigvalsh, cond, norm, trace, slogdet
+from ._support import supp
+from ._sample import sample
+from ._util import kde
 from . import distributions
 
 __all__ = ['FreeForm', 'distributions', 'eigvalsh', 'cond', 'norm', 'trace',
-           'slogdet']
+           'slogdet', 'supp', 'sample', 'kde']
 
 from .__version__ import __version__                          # noqa: F401 E402

freealg/__version__.py

@@ -1 +1 @@
-__version__ = "0.5.3"
+__version__ = "0.6.0"

freealg/_chebyshev.py

@@ -43,10 +43,10 @@ def chebyshev_sample_proj(eig, support, K=10, reg=0.0):
         The assumed compact support of rho.
 
     K : int
-        Highest Chebyshev‐II order.
+        Highest Chebyshev-II order.
 
     reg : float
-        Tikhonov‐style ridge on each coefficient (defaults to 0).
+        Tikhonov-style ridge on each coefficient (defaults to 0).
 
     Returns
     -------
@@ -57,10 +57,10 @@ def chebyshev_sample_proj(eig, support, K=10, reg=0.0):
 
     lam_m, lam_p = support
 
-    # Map to [–1,1] interval
+    # Map to [-1,1] interval
     t = (2 * eig - (lam_m + lam_p)) / (lam_p - lam_m)
 
-    # Inner‐product norm of each U_k under w(t) = sqrt{1–t^2} is \\pi/2
+    # Inner-product norm of each U_k under w(t) = sqrt{1-t^2} is \\pi/2
     norm = numpy.pi / 2
 
     psi = numpy.empty(K+1)
@@ -92,12 +92,12 @@ 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)
+    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]
+    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)
@@ -140,15 +140,15 @@ def chebyshev_density(x, psi, support):
     -------
 
     rho_x : ndarray, same shape as x
-        Approximated spectral density on the original x‐axis.
+        Approximated spectral density on the original x-axis.
     """
 
     lam_m, lam_p = support
 
-    # Map to [–1,1] interval
+    # Map to [-1,1] interval
     t = (2 * numpy.asarray(x) - (lam_m + lam_p)) / (lam_p - lam_m)
 
-    # Weight sqrt{1–t^2} (clip for numerical safety)
+    # Weight sqrt{1-t^2} (clip for numerical safety)
     w = numpy.sqrt(numpy.clip(1 - t**2, a_min=0, a_max=None))
 
     # Summation approximation
@@ -165,22 +165,23 @@ def chebyshev_density(x, psi, support):
 # chebushev stieltjes
 # ===================
 
-def chebyshev_stieltjes(z, psi, support, continuation='pade'):
+def chebyshev_stieltjes(z, psi, support, continuation='pade',
+                        dtype=numpy.complex128):
     """
-    Compute the Stieltjes transform m(z) for a Chebyshev‐II expansion
+    Compute the Stieltjes transform m(z) for a Chebyshev-II expansion
 
-    rho(x) = (2/(lam_p - lam_m)) * sqrt(1−t(x)^2) * sum_{k=0}^K psi_k U_k(t(x))
+    rho(x) = (2/(lam_p - lam_m)) * sqrt(1-t(x)^2) * sum_{k=0}^K psi_k U_k(t(x))
 
-    via the closed‐form
+    via the closed-form
 
-      \\int_{-1}^1 U_k(t) sqrt(1−t^2)/(u - t) dt = \\pi J(u)^(k+1),
+      \\int_{-1}^1 U_k(t) sqrt(1-t^2)/(u - t) dt = \\pi J(u)^(k+1),
 
     where
 
-      u = (2(z−center))/span,
+      u = (2(z-center))/span,
       center = (lam_p + lam_m)/2,
       span = lam_p - lam_m,
-      J(u) = u − sqrt(u^2−1)
+      J(u) = u - sqrt(u^2-1)
 
     and then
 
@@ -193,7 +194,7 @@ def chebyshev_stieltjes(z, psi, support, continuation='pade'):
         Points in the complex plane.
 
     psi : array_like, shape (K+1,)
-        Chebyshev‐II coefficients \\psi.
+        Chebyshev-II coefficients \\psi.
 
     support : tuple
         The support interval of the original density.
@@ -201,6 +202,9 @@ def chebyshev_stieltjes(z, psi, support, continuation='pade'):
     continuation : str, default= ``'pade'``
         Methof of analytiv continuation.
 
+    dtype : numpy.type, default=numpy.complex128
+        Data type for compelx arrays. This might enhance series acceleration.
+
     Returns
     -------
 
@@ -208,7 +212,8 @@ def chebyshev_stieltjes(z, psi, support, continuation='pade'):
         The Stieltjes transform m(z) on the same shape as z.
     """
 
-    z = numpy.asarray(z, dtype=numpy.complex128)
+    z = numpy.asarray(z, dtype=dtype)
+
     lam_m, lam_p = support
     span = lam_p - lam_m
     center = 0.5 * (lam_m + lam_p)
@@ -236,7 +241,7 @@ def chebyshev_stieltjes(z, psi, support, continuation='pade'):
 
     else:
         # Flatten J before passing to Wynn method.
-        psi_zero = numpy.concatenate([[0], psi])
+        psi_zero = numpy.concatenate([[0.0], psi])
         Sn = partial_sum(psi_zero, J.ravel(), p=0)
 
         if continuation == 'wynn-eps':

freealg/_decompress.py

@@ -567,7 +567,8 @@ def _newton_method(f, z_init, a, support, enforce_wall=False, tol=1e-4,
 
 def _secant_complex(f, z0, z1, a=0+0j, tol=1e-12, max_iter=100,
                     alpha=0.5, max_bt=1, eps=1e-30, step_factor=5.0,
-                    post_smooth=True, jump_tol=10.0, verbose=False):
+                    post_smooth=True, jump_tol=10.0, dtype=numpy.complex128,
+                    verbose=False):
     """
     Solves :math:``f(z) = a`` for many starting points simultaneously using the
     secant method in the complex plane.
@@ -581,7 +582,7 @@ def _secant_complex(f, z0, z1, a=0+0j, tol=1e-12, max_iter=100,
         Two initial guesses. ``z1`` may be broadcast to ``z0``.
 
     a : complex or array_like, optional
-        Right‑hand‑side targets (broadcasted to ``z0``). Defaults to ``0+0j``.
+        Right-hand-side targets (broadcasted to ``z0``). Defaults to ``0+0j``.
 
     tol : float, optional
         Convergence criterion on ``|f(z) - a|``. Defaults to ``1e-12``.
@@ -590,10 +591,10 @@ def _secant_complex(f, z0, z1, a=0+0j, tol=1e-12, max_iter=100,
         Maximum number of secant iterations. Defaults to ``100``.
 
     alpha : float, optional
-        Back‑tracking shrink factor (``0 < alpha < 1``). Defaults to ``0.5``.
+        Back-tracking shrink factor (``0 < alpha < 1``). Defaults to ``0.5``.
 
     max_bt : int, optional
-        Maximum back‑tracking trials per iteration. Defaults to ``0``.
+        Maximum back-tracking trials per iteration. Defaults to ``0``.
 
     eps : float, optional
         Safeguard added to tiny denominators. Defaults to ``1e-30``.
@@ -607,6 +608,9 @@ def _secant_complex(f, z0, z1, a=0+0j, tol=1e-12, max_iter=100,
         Sensitivity of the clean-up pass; larger tolerance implies fewer
         re-solves.
 
+    dtype : {``'complex128'``, ``'complex256'``}, default = ``'complex128'``
+        Data type for inner computations of complex variables.
+
     verbose : bool, optional
         If *True*, prints progress every 10 iterations.
 
@@ -622,9 +626,9 @@ def _secant_complex(f, z0, z1, a=0+0j, tol=1e-12, max_iter=100,
 
     # Broadcast inputs
     z0, z1, a = numpy.broadcast_arrays(
-        numpy.asarray(z0, numpy.complex128),
-        numpy.asarray(z1, numpy.complex128),
-        numpy.asarray(a,  numpy.complex128),
+        numpy.asarray(z0, dtype=dtype),
+        numpy.asarray(z1, dtype=dtype),
+        numpy.asarray(a, dtype=dtype),
     )
     orig_shape = z0.shape
     z0, z1, a = (x.ravel() for x in (z0, z1, a))
@@ -677,7 +681,7 @@ def _secant_complex(f, z0, z1, a=0+0j, tol=1e-12, max_iter=100,
                 if not worse.any():
                     break
 
-        # Book‑keeping
+        # Book-keeping
         newly_conv = (numpy.abs(f2) < tol) & active
         converged[newly_conv] = True
         iterations[newly_conv] = k + 1
@@ -691,7 +695,7 @@ def _secant_complex(f, z0, z1, a=0+0j, tol=1e-12, max_iter=100,
         if verbose and k % 10 == 0:
             print(f"Iter {k}: {converged.sum()} / {n_points} converged")
 
-    # Non‑converged points
+    # Non-converged points
     remaining = ~converged
     roots[remaining] = z1[remaining]
     residuals[remaining] = numpy.abs(f1[remaining])
@@ -723,7 +727,7 @@ def _secant_complex(f, z0, z1, a=0+0j, tol=1e-12, max_iter=100,
             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
+                dtype=dtype, post_smooth=False,  # avoid recursion
             )
 
             roots[bad] = new_root
@@ -894,7 +898,7 @@ def decompress(freeform, alpha, x, roots_init=None, method='newton',
     # Initialize roots below the real axis
     if roots_init is None:
         roots_init = numpy.full(x.shape, numpy.mean(freeform.support) - 0.1j,
-                                dtype=numpy.complex128)
+                                dtype=freeform.dtype)
 
     # Finding roots
     if method == 'newton':
@@ -925,11 +929,11 @@ def decompress(freeform, alpha, x, roots_init=None, method='newton',
 
     elif method == 'secant':
         z0 = numpy.full(x.shape, numpy.mean(freeform.support) + 0.1j,
-                        dtype=numpy.complex128)
+                        dtype=freeform.dtype)
         z1 = z0 - 0.2j
 
         roots, _, _ = _secant_complex(_char_z, z0, z1, a=target, tol=tolerance,
-                                      max_iter=max_iter)
+                                      max_iter=max_iter, dtype=freeform.dtype)
     else:
         raise NotImplementedError('"method" is invalid.')
 
@@ -960,7 +964,8 @@ def decompress(freeform, alpha, x, roots_init=None, method='newton',
 # =======================
 
 def reverse_characteristics(freeform, z_inits, T, iterations=500,
-                            step_size=0.1, tolerance=1e-8):
+                            step_size=0.1, tolerance=1e-8,
+                            dtype=numpy.complex128):
     """
     """
 
@@ -975,7 +980,7 @@ def reverse_characteristics(freeform, z_inits, T, iterations=500,
     target_z, target_t = numpy.meshgrid(z_inits, t_eval)
 
     z = numpy.full(target_z.shape, numpy.mean(freeform.support) - 0.1j,
-                   dtype=numpy.complex128)
+                   dtype=dtype)
 
     # Broken Newton steps can produce a lot of warnings. Removing them for now.
     with numpy.errstate(all='ignore'):

freealg/_jacobi.py

@@ -144,11 +144,23 @@ def jacobi_density(x, psi, support, alpha=0.0, beta=0.0):
     lam_m, lam_p = support
     t = (2 * x - (lam_p + lam_m)) / (lam_p - lam_m)
     w = (1 - t)**alpha * (1 + t)**beta
+
+    # The function eval_jacobi does not accept complex256 type
+    down_cast = False
+    if numpy.issubdtype(t.dtype, numpy.complexfloating) and \
+            t.itemsize > numpy.dtype(numpy.complex128).itemsize:
+        t = t.astype(numpy.complex128)
+        down_cast = True
+
     P = numpy.vstack([eval_jacobi(k, alpha, beta, t) for k in range(len(psi))])
 
     rho_t = w * (psi @ P)                            # density in t-variable
     rho_x = rho_t * (2.0 / (lam_p - lam_m))          # back to x-variable
 
+    # Case up to complex256
+    if down_cast:
+        rho_x = rho_x.astype(t.dtype)
+
     return rho_x
 
 
@@ -157,13 +169,13 @@ def jacobi_density(x, psi, support, alpha=0.0, beta=0.0):
 # ================
 
 def jacobi_stieltjes(z, psi, support, alpha=0.0, beta=0.0, n_base=40,
-                     continuation='pade'):
+                     continuation='pade', dtype=numpy.complex128):
     """
     Compute m(z) = sum_k psi_k * m_k(z) where
 
     m_k(z) = \\int w^{(alpha, beta)}(t) P_k^{(alpha, beta)}(t) / (u(z)-t) dt
 
-    Each m_k is evaluated *separately* with a Gauss–Jacobi rule sized
+    Each m_k is evaluated *separately* with a Gauss-Jacobi rule sized
     for that k.  This follows the user's request: 1 quadrature rule per P_k.
 
     Parameters
@@ -184,6 +196,9 @@ def jacobi_stieltjes(z, psi, support, alpha=0.0, beta=0.0, n_base=40,
     continuation : str, default= ``'pade'``
         Methof of analytiv continuation.
 
+    dtype : numpy.type, default=numpy.complex128
+        Data type for compelx arrays. This might enhance series acceleration.
+
     Returns
     -------
 
@@ -194,7 +209,7 @@ def jacobi_stieltjes(z, psi, support, alpha=0.0, beta=0.0, n_base=40,
         Same shape as z
     """
 
-    z = numpy.asarray(z, dtype=numpy.complex128)
+    z = numpy.asarray(z, dtype=dtype)
     lam_minus, lam_plus = support
     span = lam_plus - lam_minus
     centre = 0.5 * (lam_plus + lam_minus)
@@ -202,11 +217,11 @@ def jacobi_stieltjes(z, psi, support, alpha=0.0, beta=0.0, n_base=40,
     # Map z -> u in the standard [-1,1] domain
     u = (2.0 / span) * (z - centre)
 
-    m_total = numpy.zeros_like(z, dtype=numpy.complex128)
+    m_total = numpy.zeros_like(z, dtype=dtype)
 
     if continuation != 'pade':
         # Stores  m with the ravel size of z.
-        m_partial = numpy.zeros((psi.size, z.size), dtype=numpy.complex128)
+        m_partial = numpy.zeros((psi.size, z.size), dtype=dtype)
 
     for k, psi_k in enumerate(psi):
         # Select quadrature size tailored to this P_k
@@ -221,7 +236,7 @@ def jacobi_stieltjes(z, psi, support, alpha=0.0, beta=0.0, n_base=40,
 
         # Evaluate jacobi polynomals of the second kind, Q_k using quadrature
         diff = t_nodes[:, None, None] - u[None, ...]         # (n_quad, Ny, Nx)
-        Q_k = (integrand[:, None, None] / diff).sum(axis=0)
+        Q_k = (integrand[:, None, None] / diff).sum(axis=0).astype(dtype)
 
         # Principal branch
         m_k = (2.0 / span) * Q_k

freealg/_linalg.py

@@ -151,7 +151,7 @@ def eigvalsh(A, size=None, psd=None, seed=None, plot=False, **kwargs):
     # Perform fit and estimate eigenvalues
     order = 1 + int(len(samples)**0.2)
     ff.fit(method='chebyshev', K=order, projection='sample',
-           continuation='wynn', force=True, plot=False, latex=False,
+           continuation='wynn-eps', force=True, plot=False, latex=False,
            save=False)
 
     if plot:

freealg/_pade.py

@@ -27,8 +27,8 @@ def _default_poles(q, lam_m, lam_p, safety=1.0, odd_side='left'):
     """
     Generate q real poles outside [lam_m, lam_p].
 
-    • even q  : q/2 on each side (Chebyshev-like layout)
-    • odd  q  : (q+1)/2 on the *left*,  (q–1)/2 on the right
+    * even q  : q/2 on each side (Chebyshev-like layout)
+    * odd  q  : (q+1)/2 on the *left*,  (q-1)/2 on the right
                 so q=1 => single pole on whichever side `odd_side` says.
 
     safety >= 1: 1, then poles start half an interval away; >1 pushes them
@@ -73,13 +73,13 @@ def _default_poles(q, lam_m, lam_p, safety=1.0, odd_side='left'):
 
 def _encode_poles(a, lam_m, lam_p):
     """
-    Map real pole a_j → unconstrained s_j,
+    Map real pole a_j => unconstrained s_j,
     so that the default left-of-interval pole stays left.
     """
 
     # half-width of the interval
     d = 0.5 * (lam_p - lam_m)
-    # if a < lam_m, we want s ≥ 0; if a > lam_p, s < 0
+    # if a < lam_m, we want s >= 0; if a > lam_p, s < 0
     return numpy.where(
         a < lam_m,
         numpy.log((lam_m - a) / d),   # zero at a = lam_m - d
@@ -93,13 +93,13 @@ def _encode_poles(a, lam_m, lam_p):
 
 def _decode_poles(s, lam_m, lam_p):
     """
-    Inverse map s_j → real pole a_j outside the interval.
+    Inverse map s_j => real pole a_j outside the interval.
     """
 
     d = 0.5 * (lam_p - lam_m)
     return numpy.where(
         s >= 0,
-        lam_m - d * numpy.exp(s),     # maps s=0 to a=lam_m−d (left)
+        lam_m - d * numpy.exp(s),     # maps s=0 to a=lam_m-d (left)
         lam_p + d * numpy.exp(-s)     # maps s=0 to a=lam_p+d (right)
     )
 
@@ -186,7 +186,7 @@ def _inner_ls(x, f, poles, p=1, pade_reg=0.0):
             else:
                 skip = 0     # all entries are residues
 
-            # add λ only for the residue positions
+            # add lambda only for the residue positions
             n = ATA.shape[0]
             for i in range(skip, n):
                 ATA[i, i] += pade_reg
@@ -343,7 +343,7 @@ def eval_pade(z, pade_sol):
     """
 
     # z_arr = numpy.asanyarray(z)                   # shape=(M,N)
-    # flat = z_arr.ravel()                          # shape=(M·N,)
+    # flat = z_arr.ravel()                          # shape=(M*N,)
     # c, D = pade_sol['c'], pade_sol['D']
     # poles = pade_sol['poles']
     # resid = pade_sol['resid']
@@ -362,7 +362,7 @@ def eval_pade(z, pade_sol):
 
     out = c + D*z
     for bj, rj in zip(poles, resid):
-        out += rj/(z - bj)       # each is an (N,) op, no N×q temp
+        out += rj/(z - bj)       # each is an (N,) op, no N*q temp
     return out
 
 
@@ -384,7 +384,7 @@ def fit_pade_old(x, f, lam_m, lam_p, p, q, delta=1e-8, B=numpy.inf,
       b_j in (-infty, lam_m - delta] cup [lam_p + delta, infty)
 
     Approach:
-      - Brute‐force all 2^q left/right assignments for denominator roots
+      - Brute-force all 2^q left/right assignments for denominator roots
       - Global search with differential_evolution, fallback to zeros if needed
       - Local refinement with least_squares
 

freealg/_sample.py

@@ -15,7 +15,7 @@ from scipy.integrate import cumulative_trapezoid
 from scipy.interpolate import PchipInterpolator
 from scipy.stats import qmc
 
-__all__ = ['qmc_sample']
+__all__ = ['sample']
 
 
 # =============
@@ -32,60 +32,75 @@ def _quantile_func(x, rho, clamp=1e-4, eps=1e-8):
     rho_clamp[rho < clamp] = eps
     cdf = cumulative_trapezoid(rho_clamp, x, initial=0)
     cdf /= cdf[-1]
+    cdf_inv = PchipInterpolator(cdf, x, extrapolate=False)
 
-    return PchipInterpolator(cdf, x, extrapolate=False)
+    return cdf_inv
 
 
-# ==========
-# qmc sample
-# ==========
+# ======
+# sample
+# ======
 
-def qmc_sample(x, rho, num_pts, seed=None):
+def sample(x, rho, num_pts, method='qmc', seed=None):
     """
-    Low-discrepancy sampling from a univariate density estimate using
-    Quasi-Monte Carlo.
+    Low-discrepancy sampling from density estimate.
 
     Parameters
     ----------
 
-    x : numpy.array, shape (n,)
-        Sorted abscissae at which the density has been evaluated.
+    x : numpy.array
+        Sorted abscissae at which the density has been evaluated. Shape `(n,)`.
 
-    rho : numpy.array, shape (n,)
+    rho : numpy.array
         Density values corresponding to `x`. Must be non-negative and define
         a valid probability density (i.e., integrate to 1 over the support).
+        Shape `(n,)`.
 
     num_pts : int
         Number of sample points to generate from the density estimate.
 
+    method : {``'mc'``, ``'qmc'``}, default= ``'qmc'``
+        Method of drawing samples from uniform distribution:
+
+        * ``'mc'``: Monte Carlo
+        * ``'qmc'``: Quasi Monte Carlo
+
     seed : int, default=None
         Seed for random number generator
 
     Returns
     -------
+
     samples : numpy.array, shape (num_pts,)
         Samples drawn from the estimated density using a one-dimensional Halton
         sequence mapped through the estimated quantile function.
 
     See Also
     --------
-    scipy.stats.qmc.Halton
-        Underlying Quasi-Monte Carlo engine used for generating low-discrepancy
-        points.
+
+    freealg.supp
+    freealg.kde
+
+    Notes
+    -----
+
+    The underlying Quasi-Monte Carlo engine uses ``scipy.stats.qmc.Halton``
+    function for generating low-discrepancy points.
 
     Examples
     --------
 
     .. code-block:: python
+        :emphasize-lines: 8
 
         >>> import numpy
-        >>> from freealg import qmc_sample
+        >>> from freealg import sample
 
         >>> # density of Beta(3,1) on [0,1]
         >>> x = numpy.linspace(0, 1, 200)
         >>> rho = 3 * x**2
 
-        >>> samples = qmc_sample(x, rho, num_pts=1000)
+        >>> samples = sample(x, rho, num_pts=1000, method='qmc')
         >>> assert samples.shape == (1000,)
 
         >>> # Empirical mean should be close to 3/4
@@ -94,8 +109,17 @@ def qmc_sample(x, rho, num_pts, seed=None):
 
     rng = numpy.random.default_rng(seed)
     quantile = _quantile_func(x, rho)
-    engine = qmc.Halton(d=1, rng=rng)
-    u = engine.random(num_pts)
+
+    # Draw from uniform distribution
+    if method == 'mc':
+        u = rng.random(num_pts)
+    elif method == 'qmc':
+        engine = qmc.Halton(d=1, rng=rng)
+        u = engine.random(num_pts)
+    else:
+        raise NotImplementedError('"method" is invalid.')
+
+    # Draw from distribution by mapping from inverse CDF
     samples = quantile(u)
 
     return samples.ravel()

freealg/_series.py

@@ -183,13 +183,13 @@ def wynn_rho(Sn, beta=0.0):
     -------
 
     S : numpy.ndarray
-        A 1D array of shape ``(d,)`` giving the rho‑accelerated estimate
+        A 1D array of shape ``(d,)`` giving the rho-accelerated estimate
         of the series limit for each component.
 
     Notes
     -----
 
-    Let ``S_n`` be the *n*‑th partial sum of the (possibly divergent)
+    Let ``S_n`` be the *n*-th partial sum of the (possibly divergent)
     sequence.  Wynn's rho algorithm builds a triangular table
     ``rho[k, n]`` (row *k*, column *n*) as follows:
 
@@ -200,7 +200,7 @@ def wynn_rho(Sn, beta=0.0):
                     (n + beta + k - 1) / (rho[k-1, n+1] - rho[k-1, n])
 
     Only even rows (k even) provide improved approximants.  As with
-    ``wynn_epsilon``, we apply the scalar recursion component‑wise so that a
+    ``wynn_epsilon``, we apply the scalar recursion component-wise so that a
     slowly converging component does not stall the others.
     """
 
@@ -255,7 +255,7 @@ def wynn_rho(Sn, beta=0.0):
 
 def levin_u(Sn, omega=None, beta=0.0):
     """
-    Levin u‑transform (vector form).
+    Levin u-transform (vector form).
 
     Parameters
     ----------
@@ -339,13 +339,13 @@ def weniger_delta(Sn):
     -------
 
     S : numpy.ndarray
-        Array of shape (d,) giving the Δ²‑accelerated limit estimate for each
-        component.
+        Array of shape (d,) giving the delta2 accelerated limit estimate for
+        each component.
     """
 
     N, d = Sn.shape
 
-    # Need at least three partial sums to form Δ²
+    # Need at least three partial sums to form delta2
     if N < 3:
         return Sn[-1, :].copy()
 
@@ -384,14 +384,14 @@ def brezinski_theta(Sn):
     ----------
 
     Sn : numpy.ndarray
-        A 2‑D array of the size ``(N, d)``, where `N` is the number of partial
+        A 2-D array of the size ``(N, d)``, where `N` is the number of partial
         sums and `d` is the vector size.
 
     Returns
     -------
 
     S : numpy.ndarray
-        A 1‑D array of the size ``(d,)`` – the theta‑accelerated estimate of
+        A 1-D array of the size ``(d,)``. The theta-accelerated estimate of
         the series limit in each vector component.
     """
 

freealg/_support.py

@@ -14,7 +14,7 @@ import numpy
 import numba
 from scipy.stats import gaussian_kde
 
-__all__ = ['support_from_density', 'detect_support']
+__all__ = ['support_from_density', 'supp']
 
 
 # ====================
@@ -34,26 +34,26 @@ def support_from_density(dx, density):
     n = density.shape[0]
     target = 1.0 / dx
 
-    # 1) compute total_sum once
+    # 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
+    # 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)
+    # 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
+    # sweep j from 2, ..., n-1, updating prefix_sum on the fly
     optimal_i, optimal_j = 1, 2
     minimal_cost = large
 
@@ -88,7 +88,7 @@ def support_from_density(dx, density):
             minimal_cost = total_cost
             optimal_i, optimal_j = i_cand, j
 
-        # update our prefix‐sum trackers
+        # 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
@@ -99,36 +99,34 @@ def support_from_density(dx, density):
     return optimal_i, optimal_j
 
 
-# ==============
-# detect support
-# ==============
+# ====
+# supp
+# ====
 
-def detect_support(eigs, method='asymp', k=None, p=0.001, **kwargs):
+def supp(eigs, method='asymp', k=None, p=0.001):
     """
     Estimates the support of the eigenvalue density.
 
     Parameters
     ----------
 
-    method : {``'range'``, ``'asymp'``, ``'jackknife'``, ``'regression'``,
-                ``'interior'``, ``'interior_smooth'``}, \
-            default= ``'asymp'``
+    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.
+          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.
+          :math:`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.
+          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).
+          uses quantiles :math:`(p, 1-p)`.
         * ``'interior_smooth'``: same as ``'interior'`` but using kernel
-            density estimation, from [2]_.
+          density estimation, from [2]_.
 
     k : int, default = None
         Number of extreme order statistics to use for ``method='regression'``.
@@ -140,6 +138,21 @@ def detect_support(eigs, method='asymp', k=None, p=0.001, **kwargs):
         This value should be between 0 and 1, ideally a small number close to
         zero.
 
+    Returns
+    -------
+
+    lam_m : float
+        Lower end of support interval :math:`[\\lambda_{-}, \\lambda_{+}]`.
+
+    lam_p : float
+        Upper end of support interval :math:`[\\lambda_{-}, \\lambda_{+}]`.
+
+    See Also
+    --------
+
+    freealg.sample
+    freealg.kde
+
     References
     ----------
 

freealg/_util.py

@@ -13,14 +13,60 @@
 
 import numpy
 import scipy
+from scipy.stats import gaussian_kde
 from scipy.stats import beta
+# from statsmodels.nonparametric.kde import KDEUnivariate
 from scipy.optimize import minimize
+import matplotlib.pyplot as plt
+import texplot
+from ._plot_util import _auto_bins
 
 # Fallback to previous API
 if not hasattr(numpy, 'trapezoid'):
     numpy.trapezoid = numpy.trapz
 
-__all__ = ['compute_eig', 'beta_kde', 'force_density']
+__all__ = ['resolve_complex_dtype', 'compute_eig', 'kde', 'force_density']
+
+
+# =====================
+# resolve complex dtype
+# =====================
+
+def resolve_complex_dtype(dtype):
+    """
+    Convert a user-supplied dtype name to a NumPy dtype object and fall back
+    safely if the requested precision is unavailable.
+    """
+
+    # Normalise the string
+    dtype = str(dtype).lower()
+
+    if not isinstance(numpy.dtype(dtype), numpy.dtype):
+        raise ValueError(f'{dtype} is not a recognized numpy dtype.')
+    elif not numpy.issubdtype(numpy.dtype(dtype), numpy.complexfloating):
+        raise ValueError(f'{dtype} is not a complex dtype.')
+
+    if dtype in {'complex128', '128'}:
+        cdtype = numpy.complex128
+
+    elif dtype in ['complex256', '256', 'longcomplex', 'clongcomplex']:
+
+        complex256_found = False
+        for name in ['complex256', 'clongcomplex']:
+            if hasattr(numpy, name):
+                cdtype = getattr(numpy, name)
+                complex256_found = True
+
+        if not complex256_found:
+            raise RuntimeWarning(
+                'NumPy on this platform has no 256-bit complex type. ' +
+                'Falling back to complex128.')
+            cdtype = numpy.complex128
+
+    else:
+        raise ValueError('Unsupported dtype.')
+
+    return cdtype
 
 
 # ===========
@@ -37,50 +83,107 @@ def compute_eig(A, lower=False):
     return eig
 
 
-# ========
-# beta kde
-# ========
+# ===
+# kde
+# ===
 
-def beta_kde(eig, xs, lam_m, lam_p, h):
+def kde(eig, xs, lam_m, lam_p, h, kernel='beta', plot=False):
     """
-    Beta-kernel KDE with automatic guards against NaNs.
+    Kernel density estimation of eigenvalues.
 
     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
-    """
+    eig : numpy.array
+        1D array of samples of size `n`.
+
+    xs : numpy.array
+        1D array of evaluation grid (must lie within ``[lam_m, lam_p]``)
+
+    lam_m : float
+        Lower end of the support endpoints  with ``lam_m < lam_p``.
 
-    span = lam_p - lam_m
-    if span <= 0:
-        raise ValueError("lam_p must be larger than lam_m")
+    lam_p : float
+        Upper end of the support endpoints  with ``lam_m < lam_p``.
 
-    # map samples and grid to [0, 1]
-    u = (eig - lam_m) / span
-    t = (xs - lam_m) / span
+    h : float
+        Kernel bandwidth in rescaled units where ``0 < h < 1``.
 
-    if u.min() < 0 or u.max() > 1:
-        mask = (u > 0) & (u < 1)
-        u = u[mask]
+    kernel : {``'gaussian'``, ``'beta'``}, default= ``'beta'``
+        Kernel function using either Gaussian or Beta distribution.
 
-    pdf = numpy.zeros_like(xs, dtype=float)
-    n = len(u)
+    plot : bool, default=False
+        If `True`, the KDE is plotted.
 
-    # 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)
+    Returns
+    -------
+
+    pdf : numpy.ndarray
+        Probability distribution function with the same length as ``xs``.
+
+    See Also
+    --------
+
+    freealg.supp
+    freealg.sample
+    """
 
-    pdf /= n * span                        # renormalise
-    pdf[(t < 0) | (t > 1)] = 0.0           # exact zeros outside
+    if kernel == 'gaussian':
+        pdf = gaussian_kde(eig, bw_method=h)(xs)
+
+        # Adaptive KDE
+        # k = KDEUnivariate(eig)
+        # k.fit(kernel='gau', bw='silverman', fft=False, weights=None,
+        #       gridsize=1024, adaptive=True)
+        # pdf = k.evaluate(xs)
+
+    elif kernel == 'beta':
+
+        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
+
+    else:
+        raise NotImplementedError('"kernel" is invalid.')
+
+    if plot:
+        with texplot.theme(use_latex=False):
+            fig, ax = plt.subplots(figsize=(6, 4))
+
+            x_min = numpy.min(xs)
+            x_max = numpy.max(xs)
+            bins = numpy.linspace(x_min, x_max, _auto_bins(eig))
+            _ = ax.hist(eig, bins, density=True, color='silver',
+                        edgecolor='none', label='Samples histogram')
+            ax.plot(xs, pdf, color='black', label='KDE')
+            ax.set_xlabel(r'$x$')
+            ax.set_ylabel(r'$\\rho(x)$')
+            ax.set_xlim([xs[0], xs[-1]])
+            ax.set_ylim(bottom=0)
+            ax.set_title('Kernel Density Estimation')
+            ax.legend(fontsize='x-small')
+            plt.show()
 
     return pdf
 
@@ -95,8 +198,8 @@ def force_density(psi0, support, density, grid, alpha=0.0, beta=0.0):
       min  0.5 ||psi - psi0||^2
       s.t. F_pos psi >= 0           (positivity on grid)
            psi[0] = psi0[0]         (mass)
-           f(lam_m)·psi = 0         (zero at left edge)
-           f(lam_p)·psi = 0         (zero at right edge)
+           f(lam_m) psi = 0         (zero at left edge)
+           f(lam_p) psi = 0         (zero at right edge)
     """
 
     lam_m, lam_p = support

freealg/distributions/_kesten_mckay.py

@@ -78,7 +78,7 @@ class KestenMcKay(object):
     ----------
 
     .. [1] Kesten, H. (1959). Symmetric random walks on groups. Transactions of
-           the American Mathematical Society, 92(2), 336–354.
+           the American Mathematical Society, 92(2), 336-354.
 
     .. [2] McKay, B. D. (1981). The expected eigenvalue distribution of a large
            regular graph. Linear Algebra and its Applications, 40, 203-216

freealg/distributions/_marchenko_pastur.py

@@ -290,7 +290,7 @@ class MarchenkoPastur(object):
             m1 = (-B + sqrtD) / (2 * A)
             m2 = (-B - sqrtD) / (2 * A)
 
-            # pick correct branch only for non‑masked entries
+            # pick correct branch only for non-masked entries
             upper = z[not_mask].imag >= 0
             branch = numpy.empty_like(m1)
             branch[upper] = numpy.where(sign*m1[upper].imag > 0, m1[upper],

freealg/distributions/_meixner.py

@@ -83,7 +83,7 @@ class Meixner(object):
 
     .. [1] Saitoh, N. & Yosnida, M. (2001). The infinite divisibility and
            orthogonal polynomials with a constant recursion formula in free
-           probability theory. Probab. Math. Statist., 21, 159–170.
+           probability theory. Probab. Math. Statist., 21, 159-170.
 
     Examples
     --------
@@ -315,7 +315,7 @@ class Meixner(object):
         m1 = (-B + sqrtD) / (2 * A)
         m2 = (-B - sqrtD) / (2 * A)
 
-        # pick correct branch only for non‑masked entries
+        # pick correct branch only for non-masked entries
         upper = z.imag >= 0
         branch = numpy.empty_like(m1)
         branch[upper] = numpy.where(

freealg/distributions/_wachter.py

@@ -290,7 +290,7 @@ class Wachter(object):
         m1 = (-B + sqrtD) / (2 * A)
         m2 = (-B - sqrtD) / (2 * A)
 
-        # pick correct branch only for non‑masked entries
+        # pick correct branch only for non-masked entries
         upper = z.imag >= 0
         branch = numpy.empty_like(m1)
         branch[upper] = numpy.where(sign*m1[upper].imag > 0, m1[upper],

freealg/freeform.py

@@ -12,10 +12,8 @@
 # =======
 
 import numpy
-from scipy.stats import gaussian_kde
-# from statsmodels.nonparametric.kde import KDEUnivariate
 from functools import partial
-from ._util import compute_eig, beta_kde, force_density
+from ._util import resolve_complex_dtype, compute_eig, kde, force_density
 from ._jacobi import jacobi_sample_proj, jacobi_kernel_proj, jacobi_density, \
     jacobi_stieltjes
 from ._chebyshev import chebyshev_sample_proj, chebyshev_kernel_proj, \
@@ -25,8 +23,8 @@ from ._damp import jackson_damping, lanczos_damping, fejer_damping, \
 from ._plot_util import plot_fit, plot_density, plot_hilbert, plot_stieltjes
 from ._pade import fit_pade, eval_pade
 from ._decompress import decompress
-from ._sample import qmc_sample
-from ._support import detect_support
+from ._sample import sample
+from ._support import supp
 
 # Fallback to previous numpy API
 if not hasattr(numpy, 'trapezoid'):
@@ -59,8 +57,21 @@ class FreeForm(object):
         Size of perturbations into the upper half plane for Plemelj's
         formula.
 
+    dtype : {``'complex128'``, ``'complex256'``}, default = ``'complex128'``
+        Data type for inner computations of complex variables:
+
+        * ``'complex128'``: 128-bit complex numbers, equivalent of two double
+          precision floating point.
+        * ``'complex256'``: 256-bit complex numbers, equivalent of two long
+          double precision floating point. This optino is only available on
+          Linux machines.
+
+        When using series acceleration methods (such as setting
+        ``continuation`` in :func:`fit` function to ``wynn-eps``), setting a
+        higher precision floating point arithmetics might improve conference.
+
     **kwargs : dict, optional
-        Parameters for the ``detect_support`` function can also be prescribed
+        Parameters for the :func:`supp` function can also be prescribed
         here when ``support=None``.
 
     Notes
@@ -135,7 +146,8 @@ class FreeForm(object):
     # init
     # ====
 
-    def __init__(self, A, support=None, delta=1e-6, **kwargs):
+    def __init__(self, A, support=None, delta=1e-6, dtype='complex128',
+                 **kwargs):
         """
         Initialization.
         """
@@ -144,6 +156,9 @@ class FreeForm(object):
         self.eig = None
         self.delta = delta    # Offset above real axis to apply Plemelj formula
 
+        # Data type for complex arrays
+        self.dtype = resolve_complex_dtype(dtype)
+
         # Eigenvalues
         if A.ndim == 1:
             # When A is a 1D array, it is assumed A is the eigenvalue array.
@@ -160,7 +175,8 @@ class FreeForm(object):
 
         # Support
         if support is None:
-            self.lam_m, self.lam_p = detect_support(self.eig, **kwargs)
+            # Detect support
+            self.lam_m, self.lam_p = supp(self.eig, **kwargs)
         else:
             self.lam_m = support[0]
             self.lam_p = support[1]
@@ -234,7 +250,7 @@ class FreeForm(object):
             If `True`, it forces the density to have unit mass and to be
             strictly positive.
 
-        continuation : {``'pade'``, ``'wynn-eps'``, ``'wynn-rho'``,
+        continuation : {``'pade'``, ``'wynn-eps'``, ``'wynn-rho'``, \
             ``'levin'``, ``'weniger'``, ``'brezinski'``}, default= ``'pade'``
             Method of analytic continuation to construct the second branch of
             Steltjes transform in the lower-half complex plane:
@@ -242,10 +258,12 @@ class FreeForm(object):
             * ``'pade'``: using Riemann-Hilbert problem with Pade
               approximation.
             * ``'wynn-eps'``: Wynn's :math:`\\epsilon` algorithm.
-            * ``'wynn-rho'``: Wynn's :math:`\\rho` algorithm.
-            * ``'levin'``: Levin's :math:`u` transform.
-            * ``'weniger'``: Weniger's :math:`\\delta^2` algorithm.
-            * ``'brezinski'``: Brezinski's :math:`\\theta` algorithm.
+            * ``'wynn-rho'``: Wynn's :math:`\\rho` algorithm (`experimental`).
+            * ``'levin'``: Levin's :math:`u` transform (`experimental`).
+            * ``'weniger'``: Weniger's :math:`\\delta^2` algorithm
+              (`experimental`).
+            * ``'brezinski'``: Brezinski's :math:`\\theta` algorithm
+              (`experimental`).
 
         pade_p : int, default=0
             Degree of polynomial :math:`P(z)` is :math:`q+p` where :math:`p`
@@ -336,53 +354,35 @@ class FreeForm(object):
             if projection == 'sample':
                 psi = jacobi_sample_proj(self.eig, support=self.support, K=K,
                                          alpha=alpha, beta=beta, reg=reg)
-            else:
+            elif projection in ['gaussian', 'beta']:
                 # smooth KDE on a fixed grid
                 xs = numpy.linspace(self.lam_m, self.lam_p, 2000)
 
-                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)
-                # k.fit(bw="silverman", fft=False, weights=None, gridsize=1024,
-                #       adaptive=True)
-                # pdf = k.evaluate(xs)
-
-                # import matplotlib.pyplot as plt
-                # plt.plot(xs, pdf)
-                # plt.grid(True)
-                # plt.show()
+                pdf = kde(self.eig, xs, self.lam_m, self.lam_p, kernel_bw,
+                          kernel=projection)
 
                 psi = jacobi_kernel_proj(xs, pdf, support=self.support, K=K,
                                          alpha=alpha, beta=beta, reg=reg)
+            else:
+                raise NotImplementedError('"projection" is invalid.')
 
         elif method == 'chebyshev':
 
             if projection == 'sample':
                 psi = chebyshev_sample_proj(self.eig, support=self.support,
                                             K=K, reg=reg)
-            else:
+            elif projection in ['gaussian', 'beta']:
                 # smooth KDE on a fixed grid
                 xs = numpy.linspace(self.lam_m, self.lam_p, 2000)
 
-                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)
-                # k.fit(bw="silverman", fft=False, weights=None, gridsize=1024,
-                #       adaptive=True)
-                # pdf = k.evaluate(xs)
+                pdf = kde(self.eig, xs, self.lam_m, self.lam_p, kernel_bw,
+                          kernel=projection)
 
                 psi = chebyshev_kernel_proj(xs, pdf, support=self.support,
                                             K=K, reg=reg)
+            else:
+                raise NotImplementedError('"projection" is invalid.')
+
         else:
             raise NotImplementedError('"method" is invalid.')
 
@@ -639,8 +639,8 @@ class FreeForm(object):
         diff = x[:, None] - x_s[None, :]
         D = rho_s[None, :] / diff
 
-        # Principal‐value: wherever t == x_i, then diff == 0, zero that entry
-        # (numpy.isclose handles floating‐point exactly)
+        # Principal-value: wherever t == x_i, then diff == 0, zero that entry
+        # (numpy.isclose handles floating-point exactly)
         D[numpy.isclose(diff, 0.0)] = 0.0
 
         # Integrate each row over t using trapezoid rule on x_s
@@ -825,13 +825,15 @@ class FreeForm(object):
         if self.method == 'jacobi':
             stieltjes = partial(jacobi_stieltjes, psi=self.psi,
                                 support=self.support, alpha=self.alpha,
-                                beta=self.beta, continuation=self.continuation)
+                                beta=self.beta, continuation=self.continuation,
+                                dtype=self.dtype)
             # n_base = n_base
 
         elif self.method == 'chebyshev':
             stieltjes = partial(chebyshev_stieltjes, psi=self.psi,
                                 support=self.support,
-                                continuation=self.continuation)
+                                continuation=self.continuation,
+                                dtype=self.dtype)
 
         mask_p = z.imag >= 0.0
         mask_m = z.imag < 0.0
@@ -1002,7 +1004,7 @@ class FreeForm(object):
             # Initial guess for roots (only for the first iteration)
             # if i == 0:
             #     roots = numpy.full(x.shape, numpy.mean(self.support) - 0.1j,
-            #                        dtype=numpy.complex128)
+            #                        dtype=self.dtype)
             roots = None
 
             rho[i, :], roots = decompress(
@@ -1081,7 +1083,7 @@ class FreeForm(object):
             size = self.n
 
         rho, x = self.decompress(size, **kwargs)
-        eigs = numpy.sort(qmc_sample(x, rho, size, seed=seed))
+        eigs = numpy.sort(sample(x, rho, size, method='qmc', seed=seed))
 
         return eigs
 

{freealg-0.5.3.dist-info → freealg-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.5.3
+Version: 0.6.0
 Summary: Free probability for large matrices
 Home-page: https://github.com/ameli/freealg
 Download-URL: https://github.com/ameli/freealg/archive/main.zip

freealg-0.6.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+freealg/__init__.py,sha256=muuYCvlsXjuX1W67YGFca9nFxprFsALLyB3CrJpXFnY,728
+freealg/__version__.py,sha256=cID1jLnC_vj48GgMN6Yb1FA3JsQ95zNmCHmRYE8TFhY,22
+freealg/_chebyshev.py,sha256=1RqSKHgm6WPWbflBk4O0xaQbgven5MiucUnjuAMyUcs,6912
+freealg/_damp.py,sha256=k2vtBtWOxQBf4qXaWu_En81lQBXbEO4QbxxWpvuVhdE,1802
+freealg/_decompress.py,sha256=bFhQx--uptWJ7OjVwEs_tWYT6mLijBKJ9EbrD24Sbl0,32199
+freealg/_jacobi.py,sha256=6oFY6aZpuosozP2PNEWd3zcWJIGHfeEF5ElFgtxT6z0,8064
+freealg/_linalg.py,sha256=0BzJNTXiY1VH3OKrCFgbE0QHLgRoKyiILsBWtnygFGc,13141
+freealg/_pade.py,sha256=BthDHScn2lILTTU2hlGNP-8YqddU3Uyxe0n0FkprwDs,13645
+freealg/_plot_util.py,sha256=GKvmc1wjVGeqoomrULPbzBEt6P86FdoR2idBLYh5EDY,20068
+freealg/_sample.py,sha256=yLJSGlq27j8tA-kDntRwfHIUU8Oo2IOmOTxS8yTRGRU,3075
+freealg/_series.py,sha256=33LLCUe4svmV0eWyzhP_XClfDzccQHTW9WBJlYlLfHY,11475
+freealg/_support.py,sha256=nxDa2OFlWBgjD0_1qoSMWG7kub6-GIuxIA04n5bdaYw,6614
+freealg/_util.py,sha256=NaEhcOxbue44l_xAhefnNZYTy3pBBGBFyk9HdaRjQKo,6899
+freealg/freeform.py,sha256=Grp1sdEy2QPagtkZunBixxykY8nTMdbV68t3B8WU-bQ,42679
+freealg/distributions/__init__.py,sha256=t_yZyEkW_W_tSV9IvgYXtVASxD2BEdiNVXcV2ebMy8M,579
+freealg/distributions/_kesten_mckay.py,sha256=BM_U8cX3eRstbAA4IZRK4qA_6S9zcogaXeuHyKXen14,19897
+freealg/distributions/_marchenko_pastur.py,sha256=xwk40GwpLvEm9--FN7-T2NWtHTkfzcvOS4tFyrm71ww,16990
+freealg/distributions/_meixner.py,sha256=8zmDnoCp-GOMnd6T2rKLQaMfn6uFmSnd-i5PLlfGOUM,17526
+freealg/distributions/_wachter.py,sha256=d601xAaFSVGeK13SSDavjsJ5a-MJnI2mgzWiplX0Quk,16898
+freealg/distributions/_wigner.py,sha256=w8OlZL9pSfGnXVSSB6A4KBiImr0Zz4iH2PDLCHFfpaY,15877
+freealg-0.6.0.dist-info/licenses/AUTHORS.txt,sha256=0b67Nz4_JgIzUupHJTAZxu5QdSUM_HRM_X_w4xCb17o,30
+freealg-0.6.0.dist-info/licenses/LICENSE.txt,sha256=J-EEYEtxb3VVf_Bn1TYfWnpY5lMFIM15iLDDcnaDTPA,1443
+freealg-0.6.0.dist-info/METADATA,sha256=5iMEjHYzw0gEmpxLhLRBZMXW39OSIS-bwVK46ZtcmqY,5530
+freealg-0.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+freealg-0.6.0.dist-info/top_level.txt,sha256=eR2wrgYwDdnnJ9Zf5PruPqe4kQav0GMvRsqct6y00Q8,8
+freealg-0.6.0.dist-info/RECORD,,

freealg-0.5.3.dist-info/RECORD

@@ -1,26 +0,0 @@
-freealg/__init__.py,sha256=KfzqG7qig6ZZCKqgHcC2ApTg4rTLkrbJsvVoJd8UFG8,625
-freealg/__version__.py,sha256=tgzuqHKcEdKBaP57F5oXxq4XlW2n9J4Fj8ZGu7nGOZg,22
-freealg/_chebyshev.py,sha256=UHU9e9LyiTJcs_01h3oIbX8_QQ9wH0P8GRmA3phvWhU,6780
-freealg/_damp.py,sha256=k2vtBtWOxQBf4qXaWu_En81lQBXbEO4QbxxWpvuVhdE,1802
-freealg/_decompress.py,sha256=RKYnuLKMx1V6-XrFjYX1UkGMRbUD9Gmf9XTyS4ffPSc,31970
-freealg/_jacobi.py,sha256=k1zYZtvoA3_gcanqepIVSoA0RJrExtluQzDamkRz_Uk,7570
-freealg/_linalg.py,sha256=khfRwdQIDtf45aOIq3QSeihAEtUCL-HgwEYtEs0YELc,13137
-freealg/_pade.py,sha256=Ecm373RvBWznAaf8a5D9qtjcRA8O_8NQsePwto-dsP4,13656
-freealg/_plot_util.py,sha256=GKvmc1wjVGeqoomrULPbzBEt6P86FdoR2idBLYh5EDY,20068
-freealg/_sample.py,sha256=MUY9ZkJbdhbC5thoy5_JMRWOHz_OfqMfaH0g2VhKPhg,2550
-freealg/_series.py,sha256=MV8yDHentc06aqPuPlqrIQUNgG0-WiviD8ZWMmLWC0I,11490
-freealg/_support.py,sha256=ZfU0T7CCDaTXMdEHSbwOL-rMnCPvJWsRb6JtqUMsrzY,6441
-freealg/_util.py,sha256=xKhtPgbW4vHidNAG6F5c5aQhTaG4MmaUqCsxwjBznfU,3786
-freealg/freeform.py,sha256=i09DcRikLL6dlsu4JzoC1AQ7EHTyacx2fgyEz3hFakI,42432
-freealg/distributions/__init__.py,sha256=t_yZyEkW_W_tSV9IvgYXtVASxD2BEdiNVXcV2ebMy8M,579
-freealg/distributions/_kesten_mckay.py,sha256=4EvW0seBZUv-cZjuLzfVCredmrCiOJcQ_hJM0mJDl6g,19899
-freealg/distributions/_marchenko_pastur.py,sha256=r-jmz8Wq5vG0-x7rB0qvVemqvu0Oq6S-BN67pqH0uiw,16992
-freealg/distributions/_meixner.py,sha256=bZv-x4mwS4yjisKoYSZAffHXtvDEKEis-74BeAjK4_s,17530
-freealg/distributions/_wachter.py,sha256=rkAmrBLqD2zvpBh0F32aQBscjXv8earXDH9_BITgFF0,16900
-freealg/distributions/_wigner.py,sha256=w8OlZL9pSfGnXVSSB6A4KBiImr0Zz4iH2PDLCHFfpaY,15877
-freealg-0.5.3.dist-info/licenses/AUTHORS.txt,sha256=0b67Nz4_JgIzUupHJTAZxu5QdSUM_HRM_X_w4xCb17o,30
-freealg-0.5.3.dist-info/licenses/LICENSE.txt,sha256=J-EEYEtxb3VVf_Bn1TYfWnpY5lMFIM15iLDDcnaDTPA,1443
-freealg-0.5.3.dist-info/METADATA,sha256=p8NU7kItll4WbsBnavnrJQDOdvE5SxKsoQtEHLOL_1w,5530
-freealg-0.5.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-freealg-0.5.3.dist-info/top_level.txt,sha256=eR2wrgYwDdnnJ9Zf5PruPqe4kQav0GMvRsqct6y00Q8,8
-freealg-0.5.3.dist-info/RECORD,,