freealg 0.1.11__py3-none-any.whl → 0.7.12__py3-none-any.whl

freealg/_free_form/__init__.py

@@ -0,0 +1,16 @@
+# SPDX-FileCopyrightText: Copyright 2025, Siavash Ameli <sameli@berkeley.edu>
+# 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.
+
+from .free_form import FreeForm
+from ._linalg import eigvalsh, cond, norm, trace, slogdet
+from ._support import supp
+from ._sample import sample
+from ._density_util import kde
+
+__all__ = ['FreeForm', 'eigvalsh', 'cond', 'norm', 'trace', 'slogdet', 'supp',
+           'sample', 'kde']

freealg/{_chebyshev.py → _free_form/_chebyshev.py}

@@ -13,10 +13,11 @@
 
 import numpy
 from scipy.special import eval_chebyu
-from ._pade import wynn_pade
+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']
 
 
 # =====================
@@ -29,7 +30,7 @@ def chebyshev_sample_proj(eig, support, K=10, reg=0.0):
 
         \\rho(x) = w(t) \\sum_{k=0}^K \\psi_k U_k(t),
 
-    where t = (2x–(\\lambda_{-} + \\lambda_{+}))/ (\\lambda_{+} - \\lambda_{-})
+    where t = (2x-(\\lambda_{-} + \\lambda_{+}))/ (\\lambda_{+} - \\lambda_{-})
     in [-1, 1] and w(t) = \\sqrt{(1 - t^2}.
 
     Parameters
@@ -42,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
     -------
@@ -56,11 +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)
-    N = eig.size
 
-    # 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,19 +92,19 @@ 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)
 
     for k in range(K + 1):
         Pk = eval_chebyu(k, t)                       # U_k(t) on the grid
-        moment = numpy.trapezoid(Pk * pdf, xs)           # \int U_k(t) \rho(x) dx
+        moment = numpy.trapezoid(Pk * pdf, xs)       # \int U_k(t) \rho(x) dx
 
         if k == 0:
             penalty = 0
@@ -116,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).
 
@@ -140,15 +140,15 @@ def chebyshev_approx(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_approx(x, psi, support):
 # chebushev stieltjes
 # ===================
 
-def chebyshev_stieltjes(z, psi, support):
+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,11 +194,17 @@ def chebyshev_stieltjes(z, psi, support):
         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.
 
+    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
     -------
 
@@ -205,35 +212,60 @@ def chebyshev_stieltjes(z, psi, support):
         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
-    root = numpy.sqrt(u*u - 1)
+    # Inverse-Joukowski: pick branch sqrt with +Im
+    root = numpy.sqrt(u*u - 1.0)
     Jm = u - root
     Jp = u + root
 
     # Make sure J is Herglotz
-    J = numpy.zeros_like(Jm)
-    J = numpy.where(root.imag < 0, Jp, Jm)
-
-    psi_zero = numpy.concatenate([[0], psi])
-    S = wynn_pade(psi_zero, J)
+    J = numpy.zeros_like(Jp)
+    J = numpy.where(Jp.imag > 0, Jm, Jp)
+
+    # This depends on the method of analytic continuation
+    if continuation == 'pade':
+        # Horner summation for S0(J) = sum_{k=0}^K psi_k * J**k
+        K = len(psi) - 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 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':
+            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.')
 
-    # build powers J^(k+1) for k=0..K
-    #K = len(psi) - 1
-    # shape: (..., K+1)
-    #Jpow = J[..., None] ** numpy.arange(1, K+2)
+        S = S.reshape(J.shape)
 
-    # sum psi_k * J^(k+1)
-    #S = numpy.sum(psi * Jpow, axis=-1)
+    # Assemble m(z)
+    m_z = -(2.0 / span) * numpy.pi * S
 
-    # assemble m(z)
-    m_z = -2 / span * numpy.pi * S
+    # Check nan or inf
+    if numpy.any(numpy.isinf(m_z)):
+        raise RuntimeError('"m" is nan.')
+    elif numpy.any(numpy.isnan(numpy.abs(m_z))):
+        raise RuntimeError('"m" is inf.')
 
     return m_z