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

freealg/__version__.py

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

freealg/_chebyshev.py

@@ -13,10 +13,11 @@
 
 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_approx', 'chebyshev_stieltjes']
+           'chebyshev_density', 'chebyshev_stieltjes']
 
 
 # =====================
@@ -115,11 +116,11 @@ def chebyshev_kernel_proj(xs, pdf, support, K=10, reg=0.0):
     return psi
 
 
-# ================
-# chebyshev approx
-# ================
+# =================
+# chebyshev density
+# =================
 
-def chebyshev_approx(x, psi, support):
+def chebyshev_density(x, psi, support):
     """
     Given \\psi_k, evaluate the approximate density \\rho(x).
 
@@ -164,7 +165,7 @@ def chebyshev_approx(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,8 +14,10 @@
 import numpy
 from scipy.special import eval_jacobi, roots_jacobi
 from scipy.special import gammaln, beta as Beta
+from ._series import wynn_epsilon, wynn_rho, levin_u, weniger_delta, \
+    brezinski_theta
 
-__all__ = ['jacobi_sample_proj', 'jacobi_kernel_proj', 'jacobi_approx',
+__all__ = ['jacobi_sample_proj', 'jacobi_kernel_proj', 'jacobi_density',
            'jacobi_stieltjes']
 
 
@@ -108,13 +110,13 @@ def jacobi_kernel_proj(xs, pdf, support, K=10, alpha=0.0, beta=0.0, reg=0.0):
     return psi
 
 
-# =============
-# jacobi approx
-# =============
+# ==============
+# jacobi density
+# ==============
 
-def jacobi_approx(x, psi, support, alpha=0.0, beta=0.0):
+def jacobi_density(x, psi, support, alpha=0.0, beta=0.0):
     """
-    Reconstruct Jacobi approximation.
+    Reconstruct Jacobi approximation of density.
 
     Parameters
     ----------
@@ -144,8 +146,8 @@ def jacobi_approx(x, psi, support, alpha=0.0, beta=0.0):
     w = (1 - t)**alpha * (1 + t)**beta
     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
+    rho_t = w * (psi @ P)                            # density in t-variable
+    rho_x = rho_t * (2.0 / (lam_p - lam_m))          # back to x-variable
 
     return rho_x
 
@@ -154,7 +156,8 @@ def jacobi_approx(x, psi, support, alpha=0.0, beta=0.0):
 # jacobi stieltjes
 # ================
 
-def jacobi_stieltjes(z, psi, support, alpha=0.0, beta=0.0, n_base=40):
+def jacobi_stieltjes(z, psi, support, alpha=0.0, beta=0.0, n_base=40,
+                     continuation='pade'):
     """
     Compute m(z) = sum_k psi_k * m_k(z) where
 
@@ -178,22 +181,33 @@ 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).
 
+    continuation : str, default= ``'pade'``
+        Methof of analytiv continuation.
+
     Returns
     -------
 
-    m1 : ndarray  (same shape as z)
+    m1 : ndarray
+        Same shape as z
 
-    m12 : ndarray  (same shape as z)
+    m2 : ndarray
+        Same shape as z
     """
 
     z = numpy.asarray(z, dtype=numpy.complex128)
     lam_minus, lam_plus = support
     span = lam_plus - lam_minus
     centre = 0.5 * (lam_plus + lam_minus)
-    u_z = (2.0 / span) * (z - centre)          # map z -> u
+
+    # Map z -> u in the standard [-1,1] domain
+    u = (2.0 / span) * (z - centre)
 
     m_total = numpy.zeros_like(z, dtype=numpy.complex128)
 
+    if continuation != 'pade':
+        # Stores  m with the ravel size of z.
+        m_partial = numpy.zeros((psi.size, z.size), dtype=numpy.complex128)
+
     for k, psi_k in enumerate(psi):
         # Select quadrature size tailored to this P_k
         n_quad = max(n_base, k + 1)
@@ -205,14 +219,54 @@ def jacobi_stieltjes(z, psi, support, alpha=0.0, beta=0.0, n_base=40):
         # Integrand values at nodes: w_nodes already include the weight
         integrand = w_nodes * P_k_nodes                      # (n_quad,)
 
-        # Broadcast over z: shape (n_quad, ...) / ...
-        diff = u_z[None, ...] - t_nodes[:, None, None]       # (n_quad, Ny, Nx)
-        m_k = (integrand[:, None, None] / diff).sum(axis=0)
+        # 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)
+
+        # Principal branch
+        m_k = (2.0 / span) * Q_k
+
+        # Compute secondary branch from the principal branch
+        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,
+            # we create a psi array (called unit_psi_j), with all zeros, except
+            # its k-th element is one. Ten we call jacobi_density.
+            unit_psi_k = numpy.zeros_like(psi)
+            unit_psi_k[k] = 1.0
+
+            # Only lower-half plane
+            mask_m = z.imag <= 0
+            z_m = z[mask_m]
+
+            # Dnesity here is rho = w(z) P_k
+            rho_k = jacobi_density(z_m.ravel(), unit_psi_k, support,
+                                   alpha=alpha, beta=beta).reshape(z_m.shape)
+
+            # Secondary branch is principal branch + 2 \pi i rho, using Plemelj
+            # (in fact, Riemann-Hirbert jump).
+            m_k[mask_m] = m_k[mask_m] + 2.0 * numpy.pi * 1j * rho_k
 
         # Accumulate with factor 2/span
-        m_total += psi_k * (2.0 / span) * m_k
+        m_total += psi_k * m_k
+
+        if continuation != 'pade':
+            m_partial[k, :] = m_total.ravel()
+
+    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)
 
-    # We use a negative sign convention
-    m_total = -m_total
+        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
 
@@ -84,40 +94,361 @@ def wynn_epsilon(Sn):
     S : numpy.array
         A 1D array of the size (d,) which is the accelerated value of the
         series at each vector element.
+
+    Notes
+    -----
+
+    Given a series of vectors:
+
+    .. math::
+
+        (S_n)_{n=1}^N = (S1, \\dots, S_n)
+
+    this function finds the limit S = \\lim_{n \\to infty} S_n.
+
+    Each :math:`S_i \\in \\mathbb{C}^d` is a vector. However, instead of using
+    the vector version of the Wynn's epsilon algorithm, we use the scalar
+    version on each component of the vector. The reason for this is that in our
+    dataset, each component has its own convergence rate. The convergence rate
+    of vector version of the algorithm is bounded by the worse point, and this
+    potentially stall convergence for all points. As such, vector version is
+    avoided.
+
+    In our dataset, the series is indeed divergent. The Wynn's accelerated
+    method computes the principal value of the convergence series.
     """
 
     # 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 epsilon algorithm
+    # 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)
-    series = eps[k_even, 0, :]
+    if (N - 1) % 2 == 0:
+        S = theta_prev[0]
+    else:
+        S = theta_pprev[0]
 
-    return series
+    return S

freealg/_util.py

@@ -89,7 +89,7 @@ def beta_kde(eig, xs, lam_m, lam_p, h):
 # force density
 # =============
 
-def force_density(psi0, support, approx, grid, alpha=0.0, beta=0.0):
+def force_density(psi0, support, density, grid, alpha=0.0, beta=0.0):
     """
     Starting from psi0 (raw projection), solve
       min  0.5 ||psi - psi0||^2
@@ -113,26 +113,26 @@ def force_density(psi0, support, approx, grid, alpha=0.0, beta=0.0):
 
     # Enforce positivity
     constraints.append({'type': 'ineq',
-                        'fun': lambda psi: approx(grid, psi)})
+                        'fun': lambda psi: density(grid, psi)})
 
     # Enforce unit mass
     constraints.append({
         'type': 'eq',
-        'fun': lambda psi: numpy.trapz(approx(grid, psi), grid) - 1.0
+        'fun': lambda psi: numpy.trapz(density(grid, psi), grid) - 1.0
     })
 
     # Enforce zero at left edge
     if beta <= 0.0 and beta > -0.5:
         constraints.append({
             'type': 'eq',
-            'fun': lambda psi: approx(numpy.array([lam_m]), psi)[0]
+            'fun': lambda psi: density(numpy.array([lam_m]), psi)[0]
         })
 
     # Enforce zero at right edge
     if alpha <= 0.0 and alpha > -0.5:
         constraints.append({
             'type': 'eq',
-            'fun': lambda psi: approx(numpy.array([lam_p]), psi)[0]
+            'fun': lambda psi: density(numpy.array([lam_p]), psi)[0]
         })
 
     # Solve a small quadratic programming
@@ -146,7 +146,7 @@ def force_density(psi0, support, approx, grid, alpha=0.0, beta=0.0):
 
     # Normalize first mode to unit mass
     x = numpy.linspace(lam_m, lam_p, 1000)
-    rho = approx(x, psi)
+    rho = density(x, psi)
     mass = numpy.trapezoid(rho, x)
     psi[0] = psi[0] / mass
 

freealg/freeform.py

@@ -16,10 +16,10 @@ 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 ._jacobi import jacobi_sample_proj, jacobi_kernel_proj, jacobi_approx, \
+from ._jacobi import jacobi_sample_proj, jacobi_kernel_proj, jacobi_density, \
     jacobi_stieltjes
 from ._chebyshev import chebyshev_sample_proj, chebyshev_kernel_proj, \
-    chebyshev_approx, chebyshev_stieltjes
+    chebyshev_density, chebyshev_stieltjes
 from ._damp import jackson_damping, lanczos_damping, fejer_damping, \
     exponential_damping, parzen_damping
 from ._plot_util import plot_fit, plot_density, plot_hilbert, plot_stieltjes
@@ -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`
@@ -401,15 +406,15 @@ class FreeForm(object):
             grid = numpy.linspace(self.lam_m, self.lam_p, 500)
 
             if method == 'jacobi':
-                approx = partial(jacobi_approx, support=self.support,
-                                 alpha=alpha, beta=beta)
+                density = partial(jacobi_density, support=self.support,
+                                  alpha=alpha, beta=beta)
             elif method == 'chebyshev':
-                approx = partial(chebyshev_approx, support=self.support)
+                density = partial(chebyshev_density, support=self.support)
             else:
                 raise RuntimeError('"method" is invalid.')
 
             # Enforce positivity, unit mass, and zero at edges
-            psi = force_density(psi, support=self.support, approx=approx,
+            psi = force_density(psi, support=self.support, density=density,
                                 grid=grid, alpha=alpha, beta=beta)
 
         # Update attributes
@@ -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
@@ -438,12 +444,6 @@ class FreeForm(object):
             # Do nothing. Make sure _pade_sol is still None
             self._pade_sol = None
 
-            if method != 'chebyshev':
-                raise NotImplementedError(
-                    'Up to the current version, the analytic continuation ' +
-                    'using "wynn" is only implemented for "chebyshev" ' +
-                    'estimation method.')
-
         if plot:
             if self._pade_sol is not None:
                 g_supp_approx = eval_pade(x_supp[None, :],
@@ -539,10 +539,10 @@ class FreeForm(object):
         mask = numpy.logical_and(x >= self.lam_m, x <= self.lam_p)
 
         if self.method == 'jacobi':
-            rho[mask] = jacobi_approx(x[mask], self.psi, self.support,
-                                      self.alpha, self.beta)
+            rho[mask] = jacobi_density(x[mask], self.psi, self.support,
+                                       self.alpha, self.beta)
         elif self.method == 'chebyshev':
-            rho[mask] = chebyshev_approx(x[mask], self.psi, self.support)
+            rho[mask] = chebyshev_density(x[mask], self.psi, self.support)
         else:
             raise RuntimeError('"method" is invalid.')
 
@@ -825,18 +825,13 @@ class FreeForm(object):
         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, continuation=self.continuation)
+            # n_base = n_base
 
         elif self.method == 'chebyshev':
-
-            if self.continuation == 'wynn':
-                use_wynn_epsilon = True
-            else:
-                use_wynn_epsilon = False
-
             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
@@ -857,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.1.dist-info → freealg-0.5.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.5.1
+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
@@ -26,7 +26,7 @@ Classifier: Intended Audience :: Science/Research
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 License-File: AUTHORS.txt

{freealg-0.5.1.dist-info → freealg-0.5.3.dist-info}/RECORD

@@ -1,26 +1,26 @@
 freealg/__init__.py,sha256=KfzqG7qig6ZZCKqgHcC2ApTg4rTLkrbJsvVoJd8UFG8,625
-freealg/__version__.py,sha256=eZ1bOun1DDVV0YLOBW4wj2FP1ajReLjbIrGmzN7ASBw,22
-freealg/_chebyshev.py,sha256=-XiMKPra9pjkvMLjLusPo8n4NfjcJd9K0tAm5TF8PdA,6311
+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=AT4ONSHGGDxVKE3MGMLyMR8uDFiO-e9u3x5udYfdJJk,5635
+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=yCDPct6SQsGQ7ku9lBBRf_esuz_XdoTiwE9x9nZ8uLY,2605
+freealg/_series.py,sha256=MV8yDHentc06aqPuPlqrIQUNgG0-WiviD8ZWMmLWC0I,11490
 freealg/_support.py,sha256=ZfU0T7CCDaTXMdEHSbwOL-rMnCPvJWsRb6JtqUMsrzY,6441
-freealg/_util.py,sha256=yerqBCedkglc9soWmRgxcm7HTnJGKeiDq9xxfKcE9WY,3780
-freealg/freeform.py,sha256=7uXc_y-wy4qDVfD3HgJcYaQmO7jzkWj_s4MPwpoDJf0,42287
+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.1.dist-info/licenses/AUTHORS.txt,sha256=0b67Nz4_JgIzUupHJTAZxu5QdSUM_HRM_X_w4xCb17o,30
-freealg-0.5.1.dist-info/licenses/LICENSE.txt,sha256=J-EEYEtxb3VVf_Bn1TYfWnpY5lMFIM15iLDDcnaDTPA,1443
-freealg-0.5.1.dist-info/METADATA,sha256=dxEIFw2EgtZzak_XLxVW6HPfB3IZt-XFUdcn2ozzXPI,5529
-freealg-0.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-freealg-0.5.1.dist-info/top_level.txt,sha256=eR2wrgYwDdnnJ9Zf5PruPqe4kQav0GMvRsqct6y00Q8,8
-freealg-0.5.1.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,,