freealg 0.5.4__py3-none-any.whl → 0.6.1__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.4"
+__version__ = "0.6.1"

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 complex arrays. This might enhance series acceleration.
+
     Returns
     -------
 
@@ -208,12 +212,13 @@ 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)
 
-    # Map z -> u in the standard [-1,1] domain
+    # Map z to u in the standard [-1,1] domain
     u = (2.0 * (z - center)) / span
 
     # Inverse-Joukowski: pick branch sqrt with +Im
@@ -227,16 +232,16 @@ def chebyshev_stieltjes(z, psi, support, continuation='pade'):
 
     # This depends on the method of analytic continuation
     if continuation == 'pade':
-        # Build powers J^(k+1) for k = 0, ..., K
+        # Horner summation for S0(J) = sum_{k=0}^K psi_k * J**k
         K = len(psi) - 1
-        Jpow = J[..., None] ** numpy.arange(1, K+2)  # shape: (..., K+1)
-
-        # Summing psi_k * J^(k+1)
-        S = numpy.sum(psi * Jpow, axis=-1)
+        S0 = numpy.zeros_like(J)
+        for k in range(K, -1, -1):
+            S0 = psi[k] + J * S0
+        S = J * S0
 
     else:
-        # Flatten J before passing to Wynn method.
-        psi_zero = numpy.concatenate([[0], psi])
+        # Flatten J before passing to any of the acceleration methods.
+        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

@@ -97,7 +97,7 @@ def jacobi_kernel_proj(xs, pdf, support, K=10, alpha=0.0, beta=0.0, reg=0.0):
         Pk = eval_jacobi(k, alpha, beta, t)
         N_k = jacobi_sq_norm(k, alpha, beta)
 
-        #  \int P_k(t) w(t) \rho(t) dt. w(t) cancels with pdf already being rho
+        # \int P_k(t) w(t) \rho(t) dt. w(t) cancels with pdf already being rho
         moment = numpy.trapz(Pk * pdf, xs)
 
         if k == 0:
@@ -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
 
 
@@ -156,33 +168,41 @@ def jacobi_density(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,
-                     continuation='pade'):
+def jacobi_stieltjes(z, cache, psi, support, alpha=0.0, beta=0.0, n_quad=None,
+                     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
+    .. math::
 
-    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.
+        m_k(z) = \\int \\frac{w^{(alpha, beta)}(t) P_k^{(alpha, beta)}(t)}{
+        (u(z)-t)} \\mathrm{d} t
+
+    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
     ----------
 
     z : complex or ndarray
 
+    cache : dict
+        Pass a dict to enable cross-call caching.
+
     psi : (K+1,) array_like
 
     support : (lambda_minus, lambda_plus)
 
     alpha, beta : float
 
-    n_base : int
-        Minimum quadrature size.  For degree-k polynomial we use
-        n_quad = max(n_base, k+1).
+    n_quad : int, default=None
+        Number of Gauss-Jacobi quadrature points.
 
     continuation : str, default= ``'pade'``
-        Methof of analytiv continuation.
+        Method of analytic continuation.
+
+    dtype : numpy.type, default=numpy.complex128
+        Data type for complex arrays. This might enhance series acceleration.
 
     Returns
     -------
@@ -194,67 +214,132 @@ 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)
+    if not isinstance(cache, dict):
+        raise TypeError('"cache" must be a dict; pass a persistent dict '
+                        '(e.g., self.cache).')
+
+    # Number of quadratures
+    if 'n_quad' not in cache:
+        if n_quad is None:
+            # Set number of quadratures based on Bernstein ellipse. Here using
+            # an evaluation point a with distance delta from support, to
+            # achieve the quadrature error below tol.
+            tol = 1e-16
+            delta = 1e-2
+            n_quad = int(-numpy.log(tol) / (2.0 * numpy.sqrt(delta)))
+        n_quad = max(n_quad, psi.size)
+        cache['n_quad'] = n_quad
+    else:
+        n_quad = cache['n_quad']
+
+    # Quadrature nodes and weights
+    if ('t_nodes' not in cache) or ('w_nodes' not in cache):
+        t_nodes, w_nodes = roots_jacobi(n_quad, alpha, beta)   # (n_quad,)
+        cache['t_nodes'] = t_nodes
+        cache['w_nodes'] = w_nodes
+    else:
+        t_nodes = cache['t_nodes']
+        w_nodes = cache['w_nodes']
+
+    z = numpy.asarray(z, dtype=dtype)
     lam_minus, lam_plus = support
     span = lam_plus - lam_minus
     centre = 0.5 * (lam_plus + lam_minus)
 
-    # Map z -> u in the standard [-1,1] domain
+    # Map z to u in the standard [-1,1] domain
     u = (2.0 / span) * (z - centre)
 
-    m_total = numpy.zeros_like(z, dtype=numpy.complex128)
+    # Cauchy Kernel (flattened for all z)
+    u_flat = u.ravel()
+    ker = (1.0 / (t_nodes[:, None] - u_flat[None, :])).astype(
+        dtype, copy=False)  # (n_quad, Ny*Nx)
+
+    if continuation == 'pade':
 
-    if continuation != 'pade':
-        # Stores  m with the ravel size of z.
-        m_partial = numpy.zeros((psi.size, z.size), dtype=numpy.complex128)
+        if 'integrand_nodes' not in cache:
 
-    for k, psi_k in enumerate(psi):
-        # Select quadrature size tailored to this P_k
-        n_quad = max(n_base, k + 1)
-        t_nodes, w_nodes = roots_jacobi(n_quad, alpha, beta)  # (n_quad,)
+            # Compute sum_k psi_k P_k (call it s_node)
+            s_nodes = numpy.zeros_like(t_nodes, dtype=dtype)
+            for k, psi_k in enumerate(psi):
 
-        # Evaluate P_k at the quadrature nodes
-        P_k_nodes = eval_jacobi(k, alpha, beta, t_nodes)     # (n_quad,)
+                # Evaluate P_k at the quadrature nodes
+                P_k_nodes = eval_jacobi(k, alpha, beta, t_nodes)   # (n_quad,)
+                s_nodes += psi_k * P_k_nodes
 
-        # Integrand values at nodes: w_nodes already include the weight
-        integrand = w_nodes * P_k_nodes                      # (n_quad,)
+            integrand_nodes = (2.0 / span) * (w_nodes * s_nodes).astype(dtype)
+            cache['integrand_nodes'] = integrand_nodes
 
-        # 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)
+        else:
+            integrand_nodes = cache['integrand_nodes']
 
-        # Principal branch
-        m_k = (2.0 / span) * Q_k
+        Q_flat = (integrand_nodes[:, None] * ker).sum(axis=0)
+        m_total = Q_flat.reshape(z.shape)
 
-        # Compute secondary branch from the principal branch
-        if continuation != 'pade':
+        return m_total
 
-            # 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
+    else:
 
-            # Only lower-half plane
-            mask_m = z.imag <= 0
-            z_m = z[mask_m]
+        # Continuation is not Pade. This is one of Wynn, Levin, etc. These
+        # methods need the series for m for 1, ..., k.
 
-            # 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)
+        if 'B' not in cache:
+            # All P_k at quadrature nodes (real), row-scale by weights
+            P_nodes = numpy.empty((psi.size, n_quad), dtype=w_nodes.dtype)
+            for k in range(psi.size):
+                P_nodes[k, :] = eval_jacobi(k, alpha, beta, t_nodes)
 
-            # 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
+            # All P_k * w shape (K+1, n_quad)
+            B = (2.0 / span) * (P_nodes * w_nodes[None, :]).astype(
+                dtype, copy=False)
+            cache['B'] = B
+
+        else:
+            B = cache['B']
 
-        # Accumulate with factor 2/span
-        m_total += psi_k * m_k
+        # Principal branch. 2D matrix for all k
+        m_k_all = B @ ker
 
-        if continuation != 'pade':
-            m_partial[k, :] = m_total.ravel()
+        # Compute m on secondary branch from the principal branch, which is
+        # m_k = m_k + 2 \pi i rho_k(z), and rho(z) is the analytic extension of
+        # rho_k(x) using the k-th basis. Basically, rho_k(z) is w * P_k(z).
 
-    if continuation != 'pade':
+        # Lower-half-plane jump for ALL k at once (vectorized)
+        mask_m = (z.imag <= 0)
+        if numpy.any(mask_m):
+            idx = numpy.flatnonzero(mask_m.ravel())
+            u_m = u_flat[idx].astype(dtype, copy=False)  # complex
+
+            # Scipy's eval_jacobi tops out at complex128 type. If u_m is
+            # complex256, downcast to complex128.
+            if u_m.dtype.itemsize > numpy.dtype(numpy.complex128).itemsize:
+                u_m_eval = u_m.astype(numpy.complex128, copy=False)
+                down_cast = True
+            else:
+                u_m_eval = u_m
+                down_cast = False
+
+            # P_k at complex u_m (all means for all k = 1,...,K)
+            P_all_m = numpy.empty((psi.size, u_m.size), dtype=dtype)
+            for k in range(psi.size):
+                P_all_m[k, :] = eval_jacobi(k, alpha, beta, u_m_eval)
+
+            # Jacobi weight. Must match jacobi_density's branch
+            w_m = numpy.power(1.0 - u_m, alpha) * numpy.power(1.0 + u_m, beta)
+
+            # rho_k(z) in x-units is (2/span) * w(u) * P_k(u)
+            rho_all = ((2.0 / span) * w_m[None, :] * P_all_m).astype(
+                dtype, copy=False)
+
+            if down_cast:
+                rho_all = rho_all.astype(dtype)
+
+            # 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
+            m_k_all[:, idx] = m_k_all[:, idx] + (2.0 * numpy.pi * 1j) * rho_all
+
+        # Partial sums S_k = sum_{j<=k} psi_j * m_j
+        WQ = (psi[:, None].astype(dtype, copy=False) * m_k_all)
+        m_partial = numpy.cumsum(WQ, axis=0)
 
         if continuation == 'wynn-eps':
             S = wynn_epsilon(m_partial)
@@ -266,7 +351,9 @@ def jacobi_stieltjes(z, psi, support, alpha=0.0, beta=0.0, n_base=40,
             S = weniger_delta(m_partial)
         elif continuation == 'brezinski':
             S = brezinski_theta(m_partial)
+        else:
+            # No acceleration (likely diverges in the lower-half plane)
+            S = m_partial[-1, :]
 
         m_total = S.reshape(z.shape)
-
-    return m_total
+        return m_total

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