freealg 0.5.3__tar.gz → 0.6.0__tar.gz

{freealg-0.5.3 → freealg-0.6.0}/PKG-INFO

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

{freealg-0.5.3 → freealg-0.6.0}/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-0.6.0/freealg/__version__.py

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

{freealg-0.5.3 → freealg-0.6.0}/freealg/_chebyshev.py

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

{freealg-0.5.3 → freealg-0.6.0}/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-0.5.3 → freealg-0.6.0}/freealg/_jacobi.py

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

{freealg-0.5.3 → freealg-0.6.0}/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.3 → freealg-0.6.0}/freealg/_pade.py

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

{freealg-0.5.3 → freealg-0.6.0}/freealg/_sample.py

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

{freealg-0.5.3 → freealg-0.6.0}/freealg/_series.py

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