freealg 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

freealg/__version__.py

@@ -1 +1 @@
-__version__ = "0.5.0"
+__version__ = "0.5.2"

freealg/_chebyshev.py

@@ -16,7 +16,7 @@ from scipy.special import eval_chebyu
 from ._series import partial_sum, wynn_epsilon
 
 __all__ = ['chebyshev_sample_proj', 'chebyshev_kernel_proj',
-           'chebyshev_approx', 'chebyshev_stieltjes']
+           'chebyshev_density', 'chebyshev_stieltjes']
 
 
 # =====================
@@ -115,11 +115,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).
 

freealg/_jacobi.py

@@ -14,8 +14,9 @@
 import numpy
 from scipy.special import eval_jacobi, roots_jacobi
 from scipy.special import gammaln, beta as Beta
+from ._series import wynn_epsilon
 
-__all__ = ['jacobi_sample_proj', 'jacobi_kernel_proj', 'jacobi_approx',
+__all__ = ['jacobi_sample_proj', 'jacobi_kernel_proj', 'jacobi_density',
            'jacobi_stieltjes']
 
 
@@ -108,13 +109,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 +145,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 +155,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,
+                     use_wynn_epsilon=False):
     """
     Compute m(z) = sum_k psi_k * m_k(z) where
 
@@ -178,22 +180,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).
 
+    use_wynn_epsilon : bool, default=False
+        Use Wynn epsilon, otherwise assumes Pade is used.
+
     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 use_wynn_epsilon:
+        # 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 +218,43 @@ 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 use_wynn_epsilon:
+
+            # 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 use_wynn_epsilon:
+            m_partial[k, :] = m_total.ravel()
 
-    # We use a negative sign convention
-    m_total = -m_total
+    if use_wynn_epsilon:
+        S = wynn_epsilon(m_partial)
+        m_total = S.reshape(z.shape)
 
     return m_total

freealg/_plot_util.py

@@ -20,7 +20,7 @@ import matplotlib.ticker as ticker
 import matplotlib.gridspec as gridspec
 
 __all__ = ['plot_fit', 'plot_density', 'plot_hilbert', 'plot_stieltjes',
-           'plot_stieltjes_on_disk']
+           'plot_stieltjes_on_disk', 'plot_samples']
 
 
 # ========

freealg/_series.py

@@ -84,18 +84,40 @@ 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+1, N, d), dtype=Sn.dtype)
+    eps = numpy.zeros((N, N, d), dtype=Sn.dtype)
     eps[0, :, :] = Sn
 
     tol = numpy.finfo(float).eps
 
-    # Wynn's epsilon algorithm
-    for k in range(1, N+1):
+    # 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, :]
@@ -117,7 +139,7 @@ def wynn_epsilon(Sn):
         if k > 1:
             eps[k, :Nk, :] += eps[k-2, 1:Nk+1, :]
 
-    k_even = 2 * (N // 2)
-    series = eps[k_even, 0, :]
+    k_even = 2 * ((N - 1) // 2)
+    S = eps[k_even, 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,11 +234,11 @@ 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'``}, default= ``'pade'``
             Method of analytic continuation to construct the second branch of
             Steltjes transform in the lower-half complex plane:
 
-            * ``'pade'``: using Reimann-Hilbert problem witth Pade
+            * ``'pade'``: using Riemann-Hilbert problem with Pade
               approximation.
             * ``'wynn'``: Wynn's epsilon algorithm.
 
@@ -401,15 +401,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
@@ -438,12 +438,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 +533,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.')
 
@@ -821,19 +815,20 @@ 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)  # n_base = n_base
+                                beta=self.beta,
+                                use_wynn_epsilon=use_wynn_epsilon)
+            # 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)

{freealg-0.5.0.dist-info → freealg-0.5.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.5.0
+Version: 0.5.2
 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.0.dist-info → freealg-0.5.2.dist-info}/RECORD

@@ -1,26 +1,26 @@
 freealg/__init__.py,sha256=KfzqG7qig6ZZCKqgHcC2ApTg4rTLkrbJsvVoJd8UFG8,625
-freealg/__version__.py,sha256=LBK46heutvn3KmsCrKIYu8RQikbfnjZaj2xFrXaeCzQ,22
-freealg/_chebyshev.py,sha256=-XiMKPra9pjkvMLjLusPo8n4NfjcJd9K0tAm5TF8PdA,6311
+freealg/__version__.py,sha256=isJrmDBLRag7Zc2UK9ZovWGOv7ji1Oh-zJtJMNJFkXw,22
+freealg/_chebyshev.py,sha256=xtHsSu8_aqGNqfBJfZLvdBZ8F71oVDdOS3JJw1dYxck,6316
 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=Q6LkE84AaL49-FamB_Nj3wVAfE4zqS9EeaJWcc0uGqE,7147
 freealg/_linalg.py,sha256=khfRwdQIDtf45aOIq3QSeihAEtUCL-HgwEYtEs0YELc,13137
 freealg/_pade.py,sha256=Ecm373RvBWznAaf8a5D9qtjcRA8O_8NQsePwto-dsP4,13656
-freealg/_plot_util.py,sha256=mkvOZJDXCxIo8jUZoS8gsSDgieMCL8oZNZEo_-mYreQ,20052
+freealg/_plot_util.py,sha256=GKvmc1wjVGeqoomrULPbzBEt6P86FdoR2idBLYh5EDY,20068
 freealg/_sample.py,sha256=MUY9ZkJbdhbC5thoy5_JMRWOHz_OfqMfaH0g2VhKPhg,2550
-freealg/_series.py,sha256=x0_NNaNjv-_FSAnZzlp8BO5XI5q8ELF_kwnGlAUBZZg,2603
+freealg/_series.py,sha256=_ln_DW_4xrRbwyfQTVunnxUhDFi9N_JLiveFQItVjuE,3393
 freealg/_support.py,sha256=ZfU0T7CCDaTXMdEHSbwOL-rMnCPvJWsRb6JtqUMsrzY,6441
-freealg/_util.py,sha256=yerqBCedkglc9soWmRgxcm7HTnJGKeiDq9xxfKcE9WY,3780
-freealg/freeform.py,sha256=zkjkkMkvCTn25k8QvefrvNBaGYQhIkPLBiV_Ij01l04,42286
+freealg/_util.py,sha256=xKhtPgbW4vHidNAG6F5c5aQhTaG4MmaUqCsxwjBznfU,3786
+freealg/freeform.py,sha256=vvURyf8wd6-73HWRwO3KjdyUozRI4J71ysMfbl29F94,42084
 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.0.dist-info/licenses/AUTHORS.txt,sha256=0b67Nz4_JgIzUupHJTAZxu5QdSUM_HRM_X_w4xCb17o,30
-freealg-0.5.0.dist-info/licenses/LICENSE.txt,sha256=J-EEYEtxb3VVf_Bn1TYfWnpY5lMFIM15iLDDcnaDTPA,1443
-freealg-0.5.0.dist-info/METADATA,sha256=rKSfjasqwCCzpGbqmdfjs4y0jezvH6ylKDv_tEL4xZM,5529
-freealg-0.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-freealg-0.5.0.dist-info/top_level.txt,sha256=eR2wrgYwDdnnJ9Zf5PruPqe4kQav0GMvRsqct6y00Q8,8
-freealg-0.5.0.dist-info/RECORD,,
+freealg-0.5.2.dist-info/licenses/AUTHORS.txt,sha256=0b67Nz4_JgIzUupHJTAZxu5QdSUM_HRM_X_w4xCb17o,30
+freealg-0.5.2.dist-info/licenses/LICENSE.txt,sha256=J-EEYEtxb3VVf_Bn1TYfWnpY5lMFIM15iLDDcnaDTPA,1443
+freealg-0.5.2.dist-info/METADATA,sha256=0Vz7b2mbf5Mf6QLU6Y7X0ajGjs0A83eGBZbMfHkRdTE,5530
+freealg-0.5.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+freealg-0.5.2.dist-info/top_level.txt,sha256=eR2wrgYwDdnnJ9Zf5PruPqe4kQav0GMvRsqct6y00Q8,8
+freealg-0.5.2.dist-info/RECORD,,