freealg 0.5.2__tar.gz → 0.5.4__tar.gz

{freealg-0.5.2 → freealg-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.5.2
+Version: 0.5.4
 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.4/freealg/__version__.py

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

{freealg-0.5.2 → freealg-0.5.4}/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-0.5.2 → freealg-0.5.4}/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-0.5.2 → freealg-0.5.4}/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-0.5.4/freealg/_series.py

@@ -0,0 +1,454 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# SPDX-FileType: SOURCE
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the license found in the LICENSE.txt file in the root directory
+# of this source tree.
+
+
+# =======
+# Imports
+# =======
+
+import numpy
+
+__all__ = ['partial_sum', 'wynn_epsilon', 'wynn_rho', 'levin_u',
+           'weniger_delta', 'brezinski_theta']
+
+
+# ===========
+# partial sum
+# ===========
+
+def partial_sum(coeffs, x, p=0.0):
+    """
+    Compute partial sum:
+
+    .. math::
+
+        S_n(x) = \\sum_{n=0}^{N-1} coeffs[n] * x^{n+p}.
+
+    Parameters
+    ----------
+
+    coeffs : array_like
+        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
+    -------
+
+    Sn : numpy.ndarray
+        Partial sums of the size (N, d), where the n-th row is the n-th
+        partial sum.
+    """
+
+    x_ = x.ravel()
+    N = len(coeffs)
+    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 *= x_
+
+    return Sn
+
+
+# ============
+# wynn epsilon
+# ============
+
+def wynn_epsilon(Sn):
+    """
+    Accelerate conversion of a series using Wynn's epsilon algorithm.
+
+    Parameters
+    ----------
+
+    Sn : numpy.ndarray
+        A 2D array of the size (N, d), where N is the number of partial sums
+        and d is the vector size.
+
+    Returns
+    -------
+
+    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
+
+    # Epsilons of stage k-1 and k-2
+    eps_prev = Sn.copy()   # row k-1
+    eps_pprev = None       # row k-2
+
+    tol = numpy.finfo(Sn.dtype).eps
+
+    # Wynn's epsilon triangle table
+    for k in range(1, N):
+        Nk = N - k
+
+        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]
+
+        # Current epsilon of row k
+        eps_curr = rec_delta
+        if k > 1:
+            eps_curr += eps_pprev[1:Nk+1, :]
+
+        # Roll rows
+        eps_pprev = eps_prev
+        eps_prev = eps_curr
+
+    # 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, :]
+
+    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
+
+    if (N - 1) % 2 == 0:
+        S = theta_prev[0]
+    else:
+        S = theta_pprev[0]
+
+    return S

{freealg-0.5.2 → freealg-0.5.4}/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 → freealg-0.5.4}/freealg.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.5.2
+Version: 0.5.4
 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/freealg/__version__.py

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

freealg-0.5.2/freealg/_series.py

@@ -1,145 +0,0 @@
-# SPDX-License-Identifier: BSD-3-Clause
-# SPDX-FileType: SOURCE
-#
-# This program is free software: you can redistribute it and/or modify it under
-# the terms of the license found in the LICENSE.txt file in the root directory
-# of this source tree.
-
-
-# =======
-# Imports
-# =======
-
-import numpy
-
-__all__ = ['partial_sum', 'wynn_epsilon']
-
-
-# ===========
-# partial sum
-# ===========
-
-def partial_sum(coeffs, x):
-    """
-    Compute partial sum:
-
-    .. math::
-
-        S_n(x) = \\sum_{n=0}^{N} coeffs[n] * x^n.
-
-    Parameters
-    ----------
-
-    coeffs : array_like
-        Coefficients [a0, a1, a2, ...] of the power series of the size N.
-
-    x : numpy.array
-        A flattened array of the size d.
-
-    Returns
-    -------
-
-    Sn : numpy.ndarray
-        Partial sums of the size (N, d), where the n-th row is the n-th
-        partial sum.
-    """
-
-    xn = x.ravel()
-    N = len(coeffs)
-    d = xn.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)
-
-    for n in range(N):
-        sum_ += coeffs[n] * pow_x
-        Sn[n, :] = sum_
-
-        if n < N-1:
-            pow_x *= xn
-
-    return Sn
-
-
-# ============
-# wynn epsilon
-# ============
-
-def wynn_epsilon(Sn):
-    """
-    Accelerate conversion of a series using Wynn's epsilon algorithm.
-
-    Parameters
-    ----------
-
-    Sn : numpy.ndarray
-        A 2D array of the size (N, d), where N is the number of partial sums
-        and d is the vector size.
-
-    Returns
-    -------
-
-    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
-
-    tol = numpy.finfo(float).eps
-
-    # Wynn's triangle table
-    for k in range(1, N):
-        Nk = N - k
-
-        delta = eps[k-1, 1:N-k+1, :] - eps[k-1, :Nk, :]
-
-        # Reciprocal of delta
-        rec_delta = numpy.empty_like(delta)
-
-        # 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]
-
-        mask_zero = numpy.logical_or(numpy.isinf(delta),
-                                     numpy.isnan(delta))
-        rec_delta[mask_zero] = 0.0
-
-        eps[k, :Nk, :] = rec_delta
-
-        if k > 1:
-            eps[k, :Nk, :] += eps[k-2, 1:Nk+1, :]
-
-    k_even = 2 * ((N - 1) // 2)
-    S = eps[k_even, 0, :]
-
-    return S