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

freealg/__version__.py

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

freealg/_chebyshev.py

@@ -13,7 +13,8 @@
 
 import numpy
 from scipy.special import eval_chebyu
-from ._series import partial_sum, wynn_epsilon
+from ._series import partial_sum, wynn_epsilon, wynn_rho, levin_u, \
+    weniger_delta, brezinski_theta
 
 __all__ = ['chebyshev_sample_proj', 'chebyshev_kernel_proj',
            'chebyshev_density', 'chebyshev_stieltjes']
@@ -164,7 +165,7 @@ def chebyshev_density(x, psi, support):
 # chebushev stieltjes
 # ===================
 
-def chebyshev_stieltjes(z, psi, support, use_wynn_epsilon=False):
+def chebyshev_stieltjes(z, psi, support, continuation='pade'):
     """
     Compute the Stieltjes transform m(z) for a Chebyshev‐II expansion
 
@@ -197,8 +198,8 @@ def chebyshev_stieltjes(z, psi, support, use_wynn_epsilon=False):
     support : tuple
         The support interval of the original density.
 
-    use_wynn_epsilon : bool, default=False
-        Use Wynn epsilon, otherwise assumes Pade is used.
+    continuation : str, default= ``'pade'``
+        Methof of analytiv continuation.
 
     Returns
     -------
@@ -225,14 +226,7 @@ def chebyshev_stieltjes(z, psi, support, use_wynn_epsilon=False):
     J = numpy.where(Jp.imag > 0, Jm, Jp)
 
     # This depends on the method of analytic continuation
-    if use_wynn_epsilon:
-        # Flatten J before passing to Wynn method.
-        psi_zero = numpy.concatenate([[0], psi])
-        Sn = partial_sum(psi_zero, J.ravel())
-        S = wynn_epsilon(Sn)
-        S = S.reshape(J.shape)
-
-    else:
+    if continuation == 'pade':
         # Build powers J^(k+1) for k = 0, ..., K
         K = len(psi) - 1
         Jpow = J[..., None] ** numpy.arange(1, K+2)  # shape: (..., K+1)
@@ -240,6 +234,26 @@ def chebyshev_stieltjes(z, psi, support, use_wynn_epsilon=False):
         # Summing psi_k * J^(k+1)
         S = numpy.sum(psi * Jpow, axis=-1)
 
+    else:
+        # Flatten J before passing to Wynn method.
+        psi_zero = numpy.concatenate([[0], psi])
+        Sn = partial_sum(psi_zero, J.ravel(), p=0)
+
+        if continuation == 'wynn-eps':
+            S = wynn_epsilon(Sn)
+        elif continuation == 'wynn-rho':
+            S = wynn_rho(Sn)
+        elif continuation == 'levin':
+            S = levin_u(Sn)
+        elif continuation == 'weniger':
+            S = weniger_delta(Sn)
+        elif continuation == 'brezinski':
+            S = brezinski_theta(Sn)
+        else:
+            raise NotImplementedError('"continuation" is invalid.')
+
+        S = S.reshape(J.shape)
+
     # Assemble m(z)
     m_z = -(2.0 / span) * numpy.pi * S
 

freealg/_jacobi.py

@@ -14,7 +14,8 @@
 import numpy
 from scipy.special import eval_jacobi, roots_jacobi
 from scipy.special import gammaln, beta as Beta
-from ._series import wynn_epsilon
+from ._series import wynn_epsilon, wynn_rho, levin_u, weniger_delta, \
+    brezinski_theta
 
 __all__ = ['jacobi_sample_proj', 'jacobi_kernel_proj', 'jacobi_density',
            'jacobi_stieltjes']
@@ -156,7 +157,7 @@ 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,
-                     use_wynn_epsilon=False):
+                     continuation='pade'):
     """
     Compute m(z) = sum_k psi_k * m_k(z) where
 
@@ -180,8 +181,8 @@ def jacobi_stieltjes(z, psi, support, alpha=0.0, beta=0.0, n_base=40,
         Minimum quadrature size.  For degree-k polynomial we use
         n_quad = max(n_base, k+1).
 
-    use_wynn_epsilon : bool, default=False
-        Use Wynn epsilon, otherwise assumes Pade is used.
+    continuation : str, default= ``'pade'``
+        Methof of analytiv continuation.
 
     Returns
     -------
@@ -203,7 +204,7 @@ def jacobi_stieltjes(z, psi, support, alpha=0.0, beta=0.0, n_base=40,
 
     m_total = numpy.zeros_like(z, dtype=numpy.complex128)
 
-    if use_wynn_epsilon:
+    if continuation != 'pade':
         # Stores  m with the ravel size of z.
         m_partial = numpy.zeros((psi.size, z.size), dtype=numpy.complex128)
 
@@ -226,7 +227,7 @@ def jacobi_stieltjes(z, psi, support, alpha=0.0, beta=0.0, n_base=40,
         m_k = (2.0 / span) * Q_k
 
         # Compute secondary branch from the principal branch
-        if use_wynn_epsilon:
+        if continuation != 'pade':
 
             # Compute analytic extension of rho(z) to lower-half plane for
             # when rho is just the k-th Jacobi basis: w(z) P_k(z). FOr this,
@@ -250,11 +251,22 @@ def jacobi_stieltjes(z, psi, support, alpha=0.0, beta=0.0, n_base=40,
         # Accumulate with factor 2/span
         m_total += psi_k * m_k
 
-        if use_wynn_epsilon:
+        if continuation != 'pade':
             m_partial[k, :] = m_total.ravel()
 
-    if use_wynn_epsilon:
-        S = wynn_epsilon(m_partial)
+    if continuation != 'pade':
+
+        if continuation == 'wynn-eps':
+            S = wynn_epsilon(m_partial)
+        elif continuation == 'wynn-rho':
+            S = wynn_rho(m_partial)
+        elif continuation == 'levin':
+            S = levin_u(m_partial)
+        elif continuation == 'weniger':
+            S = weniger_delta(m_partial)
+        elif continuation == 'brezinski':
+            S = brezinski_theta(m_partial)
+
         m_total = S.reshape(z.shape)
 
     return m_total

freealg/_series.py

@@ -12,30 +12,35 @@
 
 import numpy
 
-__all__ = ['partial_sum', 'wynn_epsilon']
+__all__ = ['partial_sum', 'wynn_epsilon', 'wynn_rho', 'levin_u',
+           'weniger_delta', 'brezinski_theta']
 
 
 # ===========
 # partial sum
 # ===========
 
-def partial_sum(coeffs, x):
+def partial_sum(coeffs, x, p=0.0):
     """
     Compute partial sum:
 
     .. math::
 
-        S_n(x) = \\sum_{n=0}^{N} coeffs[n] * x^n.
+        S_n(x) = \\sum_{n=0}^{N-1} coeffs[n] * x^{n+p}.
 
     Parameters
     ----------
 
     coeffs : array_like
-        Coefficients [a0, a1, a2, ...] of the power series of the size N.
+        Coefficients [a_0, a_1, a_2, ..., a_{N-1}] of the power series of the
+        size N.
 
     x : numpy.array
         A flattened array of the size d.
 
+    d : float, default=0.0
+        Offset power.
+
     Returns
     -------
 
@@ -44,21 +49,26 @@ def partial_sum(coeffs, x):
         partial sum.
     """
 
-    xn = x.ravel()
+    x_ = x.ravel()
     N = len(coeffs)
-    d = xn.size
+    d = x_.size
 
     # Forming partial sum via Horner method
     Sn = numpy.zeros((N, d), dtype=x.dtype)
     sum_ = numpy.zeros((d,), dtype=x.dtype)
     pow_x = numpy.ones((d,), dtype=x.dtype)
 
+    if p == 1:
+        pow_x *= x_
+    elif p != 0:
+        pow_x *= x_**p
+
     for n in range(N):
         sum_ += coeffs[n] * pow_x
         Sn[n, :] = sum_
 
         if n < N-1:
-            pow_x *= xn
+            pow_x *= x_
 
     return Sn
 
@@ -111,35 +121,334 @@ def wynn_epsilon(Sn):
     # N: number of partial sums, d: vector size
     N, d = Sn.shape
 
-    eps = numpy.zeros((N, N, d), dtype=Sn.dtype)
-    eps[0, :, :] = Sn
+    # Epsilons of stage k-1 and k-2
+    eps_prev = Sn.copy()   # row k-1
+    eps_pprev = None       # row k-2
 
-    tol = numpy.finfo(float).eps
+    tol = numpy.finfo(Sn.dtype).eps
 
-    # Wynn's triangle table
+    # Wynn's epsilon triangle table
     for k in range(1, N):
         Nk = N - k
 
-        delta = eps[k-1, 1:N-k+1, :] - eps[k-1, :Nk, :]
+        delta = eps_prev[1:Nk+1, :] - eps_prev[:Nk, :]
+        small = numpy.abs(delta) <= \
+            tol * numpy.maximum(1.0, numpy.abs(eps_prev[1:Nk+1, :]))
 
         # Reciprocal of delta
         rec_delta = numpy.empty_like(delta)
+        rec_delta[small] = 0.0j
+        rec_delta[~small] = 1.0 / delta[~small]
 
-        # Avoid division by zero error
-        mask_inf = numpy.abs(delta) < tol
-        rec_delta[mask_inf] = numpy.inf
-        rec_delta[~mask_inf] = 1.0 / delta[~mask_inf]
+        # Current epsilon of row k
+        eps_curr = rec_delta
+        if k > 1:
+            eps_curr += eps_pprev[1:Nk+1, :]
 
-        mask_zero = numpy.logical_or(numpy.isinf(delta),
-                                     numpy.isnan(delta))
-        rec_delta[mask_zero] = 0.0
+        # Roll rows
+        eps_pprev = eps_prev
+        eps_prev = eps_curr
 
-        eps[k, :Nk, :] = rec_delta
+    # Last even row
+    if (N - 1) % 2 == 0:
+        # N is odd, so use step k-1
+        S = eps_prev[0, :]
+    else:
+        # N is even, so use k-2
+        S = eps_pprev[0, :]
 
-        if k > 1:
-            eps[k, :Nk, :] += eps[k-2, 1:Nk+1, :]
+    return S
+
+
+# ========
+# wynn rho
+# ========
+
+def wynn_rho(Sn, beta=0.0):
+    """
+    Accelerate convergence of a series using Wynn's rho algorithm.
+
+    Parameters
+    ----------
+
+    Sn : numpy.ndarray
+        A 2D array of shape ``(N, d)``, where *N* is the number of partial
+        sums and *d* is the vector size.
+
+    beta : float, default=0.0
+        Shift parameter in the rho recursion, usually chosen in the range
+        ``0 < beta <= 1``.
+
+    Returns
+    -------
+
+    S : numpy.ndarray
+        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)
+    sequence.  Wynn's rho algorithm builds a triangular table
+    ``rho[k, n]`` (row *k*, column *n*) as follows:
+
+        rho[-1, n] = 0
+        rho[ 0, n] = S_n
+
+        rho[k, n] = rho[k-2, n+1] +
+                    (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
+    slowly converging component does not stall the others.
+    """
+
+    # N: number of partial sums, d: vector size
+    N, d = Sn.shape
+
+    # Rho of stage k-1 and k-2
+    rho_prev = Sn.copy()   # row k-1
+    rho_pprev = None       # row k-2
+
+    tol = numpy.finfo(Sn.dtype).eps
+
+    # Wynn's rho triangule table
+    for k in range(1, N):
+        Nk = N - k
+
+        delta = rho_prev[1:Nk+1, :] - rho_prev[:Nk, :]
+        small = numpy.abs(delta) <= \
+            tol * numpy.maximum(1.0, numpy.abs(rho_prev[1:Nk+1, :]))
+
+        coef = (beta + (k - 1) + numpy.arange(Nk))[:, None]   # (Nk, 1)
+        coef = numpy.repeat(coef, d, axis=1)                  # (Nk, d)
+
+        # Current rho of row k
+        rho_curr = numpy.empty_like(delta)
+        rho_curr[small] = 0.0j          # treat near-zero denominator
+
+        if k == 1:
+            rho_curr[~small] = coef[~small] / delta[~small]
+        else:
+            rho_curr[~small] = rho_pprev[1:Nk+1][~small] + \
+                coef[~small] / delta[~small]
+
+        # Roll rows
+        rho_pprev = rho_prev
+        rho_prev = rho_curr
+
+    # Last even row
+    if (N - 1) % 2 == 0:
+        # N is odd, so use step k-1
+        S = rho_prev[0, :]
+    else:
+        # N is even, so use k-2
+        S = rho_pprev[0, :]
+
+    return S
+
+
+# ========
+# levin  u
+# ========
+
+def levin_u(Sn, omega=None, beta=0.0):
+    """
+    Levin u‑transform (vector form).
+
+    Parameters
+    ----------
+    Sn : ndarray, shape (N, d)
+        First N partial sums of a vector series.
+    omega : None or ndarray, shape (N-1, d), optional
+        Remainder estimate.  If None, uses omega_n = S_{n+1} - S_n.
+    beta : float, optional
+        Levin shift parameter (default 0.0).
+
+    Returns
+    -------
+    S : ndarray, shape (d,)
+        Accelerated sum / antilimit.
+    """
+
+    Sn = numpy.asarray(Sn)
+    N, d = Sn.shape
+    if N < 3:
+        raise ValueError("Need at least 3 partial sums for Levin u.")
+
+    # default omega_n  = forward difference
+    if omega is None:
+        omega = Sn[1:, :] - Sn[:-1, :]
+    else:
+        omega = numpy.asarray(omega)
+        if omega.shape != (N - 1, d):
+            raise ValueError("omega must have shape (N-1, d).")
+
+    tol = numpy.finfo(Sn.dtype).eps
+    m = N - 2                       # highest possible order
+
+    # binomial coefficients with alternating sign
+    Cmk = numpy.empty(m + 1, dtype=Sn.dtype)
+    Cmk[0] = 1.0
+    for k in range(1, m + 1):
+        Cmk[k] = Cmk[k - 1] * (m - k + 1) / k
+    Cmk *= (-1.0) ** numpy.arange(m + 1)
+
+    # powers (k + beta)^(m-1)
+    if m == 1:
+        Pk = numpy.ones(m + 1, dtype=Sn.dtype)
+    else:
+        Pk = (numpy.arange(m + 1, dtype=Sn.dtype) + beta) ** (m - 1)
+
+    numer = numpy.zeros(d, dtype=Sn.dtype)
+    denom = numpy.zeros(d, dtype=Sn.dtype)
+
+    for k in range(m + 1):
+        idx = k
+        w = omega[idx, :]
+
+        inv_w = numpy.empty_like(w)
+        mask = numpy.abs(w) < tol
+        inv_w[mask] = 0.0
+        inv_w[~mask] = 1.0 / w[~mask]
+
+        coeff = Cmk[k] * Pk[k]
+        numer += coeff * Sn[idx, :] * inv_w
+        denom += coeff * inv_w
+
+    return numer / denom
+
+
+# =============
+# weniger delta
+# =============
+
+def weniger_delta(Sn):
+    """
+    Weniger's nonlinear delta^2 sequence transformation.
+
+    Parameters
+    ----------
+
+    Sn : numpy.ndarray
+        Array of shape (N, d) containing the first N partial sums of the
+        series.
+
+    Returns
+    -------
+
+    S : numpy.ndarray
+        Array of shape (d,) giving the Δ²‑accelerated limit estimate for each
+        component.
+    """
+
+    N, d = Sn.shape
+
+    # Need at least three partial sums to form Δ²
+    if N < 3:
+        return Sn[-1, :].copy()
+
+    # First and second forward differences
+    delta1 = Sn[1:] - Sn[:-1]              # shape (N-1, d)
+    delta2 = delta1[1:] - delta1[:-1]      # shape (N-2, d)
+
+    tol = numpy.finfo(Sn.real.dtype).eps
+
+    # Safe reciprocal of delta2
+    small = numpy.abs(delta2) <= tol * numpy.maximum(
+        1.0, numpy.abs(delta1[:-1]))
+
+    rec_delta2 = numpy.empty_like(delta2)
+    rec_delta2[small] = 0.0j
+    rec_delta2[~small] = 1.0 / delta2[~small]
+
+    # Delta sequence, length N-2
+    delta_sq = Sn[:-2] - (delta1[:-1] ** 2) * rec_delta2
+
+    # Return the last Delta2 term as the accelerated estimate
+    S = delta_sq[-1, :]
+
+    return S
+
+
+# ===============
+# brezinski theta
+# ===============
+
+def brezinski_theta(Sn):
+    """
+    Accelerate convergence of a series using Brezinski's theta algorithm.
+
+    Parameters
+    ----------
+
+    Sn : numpy.ndarray
+        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
+        the series limit in each vector component.
+    """
+
+    N, d = Sn.shape
+
+    theta_prev = Sn.copy()                        # row k-1
+    theta_pprev = numpy.zeros_like(theta_prev)    # row k-2
+
+    tol = numpy.finfo(Sn.dtype).eps
+
+    for k in range(1, N):
+        L_prev = theta_prev.shape[0]              # current row length
+
+        if k % 2 == 1:
+
+            # Odd row 2m+1
+            if L_prev < 2:
+                break
+
+            delta = theta_prev[1:] - theta_prev[:-1]      # len = L
+            theta_pp = theta_pprev[1:L_prev]              # len = L
+
+            small = numpy.abs(delta) <= \
+                tol * numpy.maximum(1.0, numpy.abs(theta_prev[1:]))
+
+            theta_curr = numpy.empty_like(delta)
+            theta_curr[small] = 0.0j
+            theta_curr[~small] = theta_pp[~small] + 1.0 / delta[~small]
+
+        else:
+
+            # Even row 2m+2
+            if L_prev < 3:
+                break
+
+            delta_even = theta_pprev[2:L_prev] - theta_pprev[1:L_prev-1]
+            delta_odd = theta_prev[1:L_prev-1] - theta_prev[:L_prev-2]
+            delta2_odd = (theta_prev[2:L_prev] - 2.0 * theta_prev[1:L_prev-1]
+                          + theta_prev[:L_prev-2])
+
+            small = numpy.abs(delta2_odd) <= tol * numpy.maximum(
+                1.0, numpy.abs(theta_prev[1:L_prev-1]))
+
+            theta_curr = numpy.empty_like(delta_odd)
+            theta_curr[small] = theta_pprev[1:L_prev-1][small]
+            theta_curr[~small] = (
+                theta_pprev[1:L_prev-1][~small] +
+                (delta_even[~small] * delta_odd[~small]) /
+                delta2_odd[~small])
+
+        # roll rows
+        theta_pprev = theta_prev
+        theta_prev = theta_curr
 
-    k_even = 2 * ((N - 1) // 2)
-    S = eps[k_even, 0, :]
+    if (N - 1) % 2 == 0:
+        S = theta_prev[0]
+    else:
+        S = theta_pprev[0]
 
     return S

freealg/freeform.py

@@ -234,13 +234,18 @@ class FreeForm(object):
             If `True`, it forces the density to have unit mass and to be
             strictly positive.
 
-        continuation : {``'pade'``, ``'wynn'``}, default= ``'pade'``
+        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:
 
             * ``'pade'``: using Riemann-Hilbert problem with Pade
               approximation.
-            * ``'wynn'``: Wynn's epsilon algorithm.
+            * ``'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.
 
         pade_p : int, default=0
             Degree of polynomial :math:`P(z)` is :math:`q+p` where :math:`p`
@@ -419,7 +424,8 @@ class FreeForm(object):
         self.beta = beta
 
         # Analytic continuation
-        if continuation not in ['pade', 'wynn']:
+        if continuation not in ['pade', 'wynn-eps', 'wynn-rho', 'levin',
+                                'weniger', 'brezinski']:
             raise NotImplementedError('"continuation" method is invalid.')
 
         self.continuation = continuation
@@ -815,23 +821,17 @@ class FreeForm(object):
         #                              z.real <= self.lam_p)
         # n_base = 2 * numpy.sum(mask_sup)
 
-        if self.continuation == 'wynn':
-            use_wynn_epsilon = True
-        else:
-            use_wynn_epsilon = False
-
         # Stieltjes function
         if self.method == 'jacobi':
             stieltjes = partial(jacobi_stieltjes, psi=self.psi,
                                 support=self.support, alpha=self.alpha,
-                                beta=self.beta,
-                                use_wynn_epsilon=use_wynn_epsilon)
+                                beta=self.beta, continuation=self.continuation)
             # n_base = n_base
 
         elif self.method == 'chebyshev':
             stieltjes = partial(chebyshev_stieltjes, psi=self.psi,
                                 support=self.support,
-                                use_wynn_epsilon=use_wynn_epsilon)
+                                continuation=self.continuation)
 
         mask_p = z.imag >= 0.0
         mask_m = z.imag < 0.0
@@ -852,7 +852,8 @@ class FreeForm(object):
             m2[mask_m] = -m1[mask_m] + self._glue(
                 z[mask_m].reshape(-1, 1)).ravel()
 
-        elif self.continuation == 'wynn':
+        elif self.continuation in ['wynn-eps', 'wynn-rho', 'levin', 'weniger',
+                                   'brezinski']:
             m2[:] = stieltjes(z.reshape(-1, 1)).reshape(*m2.shape)
             if branches:
                 m1[mask_p] = m2[mask_p]

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.5.2
+Version: 0.5.3
 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.5.2.dist-info → freealg-0.5.3.dist-info}/RECORD

@@ -1,26 +1,26 @@
 freealg/__init__.py,sha256=KfzqG7qig6ZZCKqgHcC2ApTg4rTLkrbJsvVoJd8UFG8,625
-freealg/__version__.py,sha256=isJrmDBLRag7Zc2UK9ZovWGOv7ji1Oh-zJtJMNJFkXw,22
-freealg/_chebyshev.py,sha256=xtHsSu8_aqGNqfBJfZLvdBZ8F71oVDdOS3JJw1dYxck,6316
+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=Q6LkE84AaL49-FamB_Nj3wVAfE4zqS9EeaJWcc0uGqE,7147
+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=_ln_DW_4xrRbwyfQTVunnxUhDFi9N_JLiveFQItVjuE,3393
+freealg/_series.py,sha256=MV8yDHentc06aqPuPlqrIQUNgG0-WiviD8ZWMmLWC0I,11490
 freealg/_support.py,sha256=ZfU0T7CCDaTXMdEHSbwOL-rMnCPvJWsRb6JtqUMsrzY,6441
 freealg/_util.py,sha256=xKhtPgbW4vHidNAG6F5c5aQhTaG4MmaUqCsxwjBznfU,3786
-freealg/freeform.py,sha256=vvURyf8wd6-73HWRwO3KjdyUozRI4J71ysMfbl29F94,42084
+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.2.dist-info/licenses/AUTHORS.txt,sha256=0b67Nz4_JgIzUupHJTAZxu5QdSUM_HRM_X_w4xCb17o,30
-freealg-0.5.2.dist-info/licenses/LICENSE.txt,sha256=J-EEYEtxb3VVf_Bn1TYfWnpY5lMFIM15iLDDcnaDTPA,1443
-freealg-0.5.2.dist-info/METADATA,sha256=0Vz7b2mbf5Mf6QLU6Y7X0ajGjs0A83eGBZbMfHkRdTE,5530
-freealg-0.5.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-freealg-0.5.2.dist-info/top_level.txt,sha256=eR2wrgYwDdnnJ9Zf5PruPqe4kQav0GMvRsqct6y00Q8,8
-freealg-0.5.2.dist-info/RECORD,,
+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,,