freealg 0.7.8__tar.gz → 0.7.10__tar.gz

{freealg-0.7.8 → freealg-0.7.10}/PKG-INFO

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

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

{freealg-0.7.8 → freealg-0.7.10}/freealg/_algebraic_form/_decompress.py

@@ -504,6 +504,7 @@ def decompress_newton(z_list, t_grid, a_coeffs, w0_list=None,
     ok : ndarray of bool, same shape as W
         Convergence flags from the accepted solve at each point.
     """
+
     z_list = numpy.asarray(z_list, dtype=complex).ravel()
     t_grid = numpy.asarray(t_grid, dtype=float).ravel()
     nt = t_grid.size

{freealg-0.7.8 → freealg-0.7.10}/freealg/_algebraic_form/_homotopy.py

@@ -4,13 +4,14 @@
 
 import numpy
 from ._moments import AlgebraicStieltjesMoments
+from tqdm import tqdm
 
-__all__ = ['stieltjes_poly']
+__all__ = ['StieltjesPoly']
 
 
-# =====================
+# ===========
 # select root
-# =====================
+# ===========
 
 def select_root(roots, z, target):
     """
@@ -125,13 +126,15 @@ class StieltjesPoly(object):
         self.steps = steps
         self.order = order
 
-        # Objects depending only on a
         self.mom = AlgebraicStieltjesMoments(a)
-        self._zpows_exp = numpy.arange(self.a_l)
         self.rad = 1.0 + self.height * self.mom.radius(self.order)
+        self.z0_p = 1j * self.rad
+        self.m0_p = self.mom.stieltjes(self.z0_p, self.order)
+        self.z0_m = -1j * self.rad
+        self.m0_m = self.mom.stieltjes(self.z0_m, self.order)
 
     def _poly_coeffs_m(self, z_val):
-        z_powers = z_val ** self._zpows_exp
+        z_powers = z_val ** numpy.arange(self.a_l)
         return (z_powers @ self.a)[::-1]
 
     def _poly_roots(self, z_val):
@@ -165,14 +168,18 @@ class StieltjesPoly(object):
         if half_sign == 0.0:
             half_sign = 1.0
 
-        # If z is outside radius of convergence, no homotopy
-        # necessary
-        if numpy.abs(z) > self.rad:
-            target = self.mom.stieltjes(z, self.order)
-            return select_root(self._poly_roots(z), z, target)
+        # # If z is outside radius of convergence, no homotopy
+        # # necessary
+        # if numpy.abs(z) > self.rad:
+        #     target = self.mom.stieltjes(z, self.order)
+        #     return select_root(self._poly_roots(z), z, target)
 
-        z0 = 1j * float(half_sign) * self.rad
-        target = self.mom.stieltjes(z0, self.order)
+        if half_sign > 0.0:
+            z0 = self.z0_p
+            target = self.m0_p
+        else:
+            z0 = self.z0_m
+            target = self.m0_m
 
         # Initialize at z0
         w_prev = select_root(self._poly_roots(z0), z0, target)
@@ -184,7 +191,7 @@ class StieltjesPoly(object):
 
         return w_prev
 
-    def __call__(self, z):
+    def __call__(self, z, progress=False):
         # Scalar fast-path
         if numpy.isscalar(z):
             return self.evaluate(z)
@@ -194,7 +201,11 @@ class StieltjesPoly(object):
         out = numpy.empty(z_arr.shape, dtype=numpy.complex128)
 
         # Iterate over indices so we can pass Python scalars into evaluate()
-        for idx in numpy.ndindex(z_arr.shape):
+        if progress:
+            indices = tqdm(numpy.ndindex(z_arr.shape), total=z_arr.size)
+        else:
+            indices = numpy.ndindex(z_arr.shape)
+        for idx in indices:
             out[idx] = self.evaluate(z_arr[idx])
 
         return out
@@ -254,7 +265,7 @@ class StieltjesPoly(object):
 #         coeffs = numpy.asarray(poly_coeffs_m(z_val), dtype=numpy.complex128)
 #         return numpy.roots(coeffs)
 
-#     # If user asked for a real-axis value, interpret as boundary value from C+.
+#     # If user asked a real-axis value, interpret as boundary value from C+.
 #     if z.imag == 0.0:
 #         if eps is None:
 #             eps = 1e-8 * max(1.0, abs(z))

{freealg-0.7.8 → freealg-0.7.10}/freealg/_algebraic_form/_moments.py

@@ -1,9 +1,13 @@
+# =======
+# Imports
+# =======
+
 import numpy
 
 
-# =========
+# =======
 # Moments
-# =========
+# =======
 
 class MomentsESD(object):
     """
@@ -85,9 +89,9 @@ class MomentsESD(object):
         # (a_{n,0},...,a_{n,n-1})
         self._a = {0: numpy.array([1.0])}
 
-    # ----------
-    # moments
-    # ----------
+    # =
+    # m
+    # =
 
     def m(self, n):
         """
@@ -111,9 +115,9 @@ class MomentsESD(object):
             self._m[n] = numpy.mean(self.eig ** n)
         return self._m[n]
 
-    # -------------
-    # coefficients
-    # -------------
+    # ======
+    # coeffs
+    # ======
 
     def coeffs(self, n):
         """
@@ -129,7 +133,8 @@ class MomentsESD(object):
         -------
 
         a_n : numpy.ndarray
-            Array of shape ``(n,)`` containing :math:`(a_{n,0}, \\dots, a_{n,n-1})`.
+            Array of shape ``(n,)`` containing :math:`(a_{n,0},
+            \\dots, a_{n,n-1})`.
         """
 
         if n in self._a:
@@ -143,6 +148,10 @@ class MomentsESD(object):
         self._compute_row(n)
         return self._a[n]
 
+    # ===========
+    # compute row
+    # ===========
+
     def _compute_row(self, n):
         """
         Compute and memoize the coefficient row :math:`a_n`.
@@ -212,9 +221,9 @@ class MomentsESD(object):
 
         self._a[n] = a_n
 
-    # ----------
+    # --------
     # evaluate
-    # ----------
+    # --------
 
     def __call__(self, n, t=0.0):
         """
@@ -254,18 +263,18 @@ class MomentsESD(object):
         k = numpy.arange(n, dtype=float)
         return numpy.dot(a_n, numpy.exp(k * t))
 
+
 # ===========================
 # Algebraic Stieltjes Moments
 # ===========================
 
-
 class AlgebraicStieltjesMoments(object):
     """
     Given coefficients a[i,j] for P(z,m)=sum_{i,j} a[i,j] z^i m^j,
     compute the large-|z| branch
         m(z) = sum_{k>=0} mu_series[k] / z^{k+1}.
 
-    Convention here: choose mu0 (the leading coefficient) by solving the 
+    Convention here: choose mu0 (the leading coefficient) by solving the
     leading-diagonal equation and (by default) picking the root closest
     to -1, i.e. m(z) ~ -1/z.
 
@@ -281,7 +290,7 @@ class AlgebraicStieltjesMoments(object):
         if self.a.ndim != 2:
             raise ValueError("a must be a 2D NumPy array with a[i,j]=a_{ij}.")
 
-        self.I = self.a.shape[0] - 1
+        self.I = self.a.shape[0] - 1                               # noqa: E741
         self.J = self.a.shape[1] - 1
 
         nz = numpy.argwhere(self.a != 0)
@@ -320,7 +329,8 @@ class AlgebraicStieltjesMoments(object):
             if j > 0:
                 self.A0 += j * coeff * self.mu0pow[j - 1]
         if self.A0 == 0:
-            raise ValueError("A0 is zero for this mu0; the sequential recursion is degenerate.")
+            raise ValueError("A0 is zero for this mu0; the sequential " +
+                             "recursion is degenerate.")
 
         # Stored series moments mu_series[0..]
         self._mu = [self.mu0]
@@ -344,14 +354,17 @@ class AlgebraicStieltjesMoments(object):
                 coeffs[j] = self.a[i, j]
 
         if not numpy.any(coeffs != 0):
-            raise ValueError("Leading diagonal polynomial is identically zero; cannot determine mu0.")
+            raise ValueError("Leading diagonal polynomial is identically " +
+                             "zero; cannot determine mu0.")
 
         deg = int(numpy.max(numpy.nonzero(coeffs)[0]))
-        roots = numpy.roots(coeffs[:deg + 1][::-1])  # descending powers for numpy.roots
+
+        # descending powers for numpy.roots
+        roots = numpy.roots(coeffs[:deg + 1][::-1])
 
         # Targetting mu0 = -1 for ~ -1/z asymptotics
         mu0 = roots[numpy.argmin(numpy.abs(roots + 1))]
-        
+
         if abs(mu0.imag) < 1e-12:
             mu0 = mu0.real
         return mu0
@@ -363,7 +376,8 @@ class AlgebraicStieltjesMoments(object):
 
             # Compute f[j] = coefficient of w^k in (S_trunc(w))^j,
             # where S_trunc uses mu_0..mu_{k-1} only (i.e. mu_k treated as 0).
-            # Key fact: in the true c[j,k], mu_k can only appear linearly as j*mu_k*mu0^{j-1}.
+            # Key fact: in the true c[j,k], mu_k can only appear linearly as
+            # j*mu_k*mu0^{j-1}.
             f = [0] * (self.J + 1)
             f[0] = 0
             for j in range(1, self.J + 1):
@@ -371,8 +385,9 @@ class AlgebraicStieltjesMoments(object):
                 # sum_{t=1..k-1} mu_t * c[j-1, k-t]
                 for t in range(1, k):
                     ssum += self._mu[t] * self._c[j - 1][k - t]
-                # recurrence: c[j,k] = mu0*c[j-1,k] + sum_{t=1..k-1} mu_t*c[j-1,k-t] + mu_k*c[j-1,0]
-                # with mu_k=0 for f, and c[j-1,k]=f[j-1]
+                # recurrence: c[j,k] = mu0*c[j-1,k] + sum_{t=1..k-1}
+                # mu_t*c[j-1,k-t] + mu_k*c[j-1,0] with mu_k=0 for f,
+                # and c[j-1,k]=f[j-1]
                 f[j] = self.mu0 * f[j - 1] + ssum
 
             # Build the linear equation for mu_k:
@@ -386,7 +401,8 @@ class AlgebraicStieltjesMoments(object):
                     continue
                 rest += coeff * f[j]
 
-            # lower diagonals s=1..k contribute coeff*c[j,k-s] (already known since k-s < k)
+            # lower diagonals s=1..k contribute coeff*c[j,k-s] (already known
+            # since k-s < k)
             for s in range(1, k + 1):
                 entries = self.diag.get(s)
                 if not entries:
@@ -402,7 +418,8 @@ class AlgebraicStieltjesMoments(object):
             mu_k = -rest / self.A0
             self._mu.append(mu_k)
 
-            # Now append the new column k to c using the full convolution recurrence:
+            # Now append the new column k to c using the full convolution
+            # recurrence:
             # c[j,k] = sum_{t=0..k} mu_t * c[j-1,k-t]
             for j in range(self.J + 1):
                 self._c[j].append(0)
@@ -430,9 +447,10 @@ class AlgebraicStieltjesMoments(object):
         # Estimate the radius of convergence of the Stieltjes
         # series
         if N < 3:
-            raise RuntimeError("Order is too small, choose a larger value of N")
+            raise RuntimeError("N is too small, choose a larger value.")
         self._ensure(N)
-        return max([numpy.abs(self._mu[j] / self._mu[j-1]) for j in range(2,N+1)])
+        return max([numpy.abs(self._mu[j] / self._mu[j-1])
+                    for j in range(2, N+1)])
 
     def stieltjes(self, z, N):
         # Estimate Stieltjes transform (root) using moment
@@ -441,10 +459,3 @@ class AlgebraicStieltjesMoments(object):
         mu = self.moments(N)
         return -numpy.sum(z[..., numpy.newaxis]**(-numpy.arange(N+1)-1) * mu,
                           axis=-1)
-
-    def target_pt(self, N=15):
-        # Obtain an estimate of the Stieltjes transform at a
-        # single point z where the estimate is likely reliable
-        z = 1j + 2j * self.radius(N)
-        return z, self.stieltjes(z, N)
-

{freealg-0.7.8 → freealg-0.7.10}/freealg/_algebraic_form/algebraic_form.py

@@ -24,7 +24,7 @@ from ._homotopy import StieltjesPoly
 from ._discriminant import compute_singular_points
 from ._moments import MomentsESD
 from .._free_form._support import supp
-from .._free_form._plot_util import plot_density
+from .._free_form._plot_util import plot_density, plot_hilbert, plot_stieltjes
 
 # Fallback to previous numpy API
 if not hasattr(numpy, 'trapezoid'):
@@ -63,7 +63,7 @@ class AlgebraicForm(object):
         * ``'complex128'``: 128-bit complex numbers, equivalent of two double
           precision floating point.
         * ``'complex256'``: 256-bit complex numbers, equivalent of two long
-          double precision floating point. This optino is only available on
+          double precision floating point. This option is only available on
           Linux machines.
 
         When using series acceleration methods (such as setting
@@ -144,8 +144,8 @@ class AlgebraicForm(object):
 
         self.A = None
         self.eig = None
-        self.stieltjes = None
-        self.moments = None
+        self._stieltjes = None
+        self._moments = None
         self.support = support
         self.delta = delta    # Offset above real axis to apply Plemelj formula
 
@@ -154,12 +154,12 @@ class AlgebraicForm(object):
 
         if hasattr(A, 'stieltjes') and callable(getattr(A, 'stieltjes', None)):
             # This is one of the distribution objects, like MarchenkoPastur
-            self.stieltjes = A.stieltjes
+            self._stieltjes = A.stieltjes
             self.n = 1
 
         elif callable(A):
             # This is a custom function
-            self.stieltjes = A
+            self._stieltjes = A
             self.n = 1
 
         else:
@@ -178,9 +178,9 @@ class AlgebraicForm(object):
                 self.eig = compute_eig(A)
 
             # Use empirical Stieltjes function
-            self.stieltjes = lambda z: \
+            self._stieltjes = lambda z: \
                 numpy.mean(1.0/(self.eig-z[:, numpy.newaxis]), axis=-1)
-            self.moments = MomentsESD(self.eig)
+            self._moments = MomentsESD(self.eig)  # NOTE (never used)
 
         # Support
         if support is None:
@@ -265,13 +265,13 @@ class AlgebraicForm(object):
                                         x_pad=x_pad)
 
         # Fitting (w_inf = None means adaptive weight selection)
-        m1_fit = self.stieltjes(z_fit)
+        m1_fit = self._stieltjes(z_fit)
         a_coeffs, fit_metrics = fit_polynomial_relation(
                 z_fit, m1_fit, s=deg_m, deg_z=deg_z, ridge_lambda=reg,
                 triangular=triangular, normalize=normalize, mu=mu,
                 mu_reg=mu_reg)
 
-        # Compute global branhc points, zeros of leading a_j, and support
+        # Compute global branch points, zeros of leading a_j, and support
         branch_points, a_s_zero, support = compute_singular_points(a_coeffs)
 
         self.a_coeffs = a_coeffs
@@ -294,7 +294,7 @@ class AlgebraicForm(object):
         status['res_99_9'] = float(res_99_9)
         status['fit_metrics'] = fit_metrics
         self.status = status
-        self.stieltjes = StieltjesPoly(self.a_coeffs)
+        self._stieltjes = StieltjesPoly(self.a_coeffs)  # NOTE overwrite init
 
         if verbose:
             print(f'fit residual max  : {res_max:>0.4e}')
@@ -388,8 +388,6 @@ class AlgebraicForm(object):
             >>> from freealg import FreeForm
         """
 
-        pass
-
         if self.a_coeffs is None:
             raise RuntimeError('The model needs to be fit using the .fit() ' +
                                'function.')
@@ -399,27 +397,7 @@ class AlgebraicForm(object):
             x = self._generate_grid(1.25)
 
         # Preallocate density to zero
-        rho = self.stieltjes(x).imag / numpy.pi
-
-        # if self.method == 'jacobi':
-        #     rho[mask] = jacobi_density(x[mask], self.psi, self.support,
-        #                                self.alpha, self.beta)
-        # elif self.method == 'chebyshev':
-        #     rho[mask] = chebyshev_density(x[mask], self.psi, self.support)
-        # else:
-        #     raise RuntimeError('"method" is invalid.')
-        #
-        # # Check density is unit mass
-        # mass = numpy.trapezoid(rho, x)
-        # if not numpy.isclose(mass, 1.0, atol=1e-2):
-        #     print(f'"rho" is not unit mass. mass: {mass:>0.3f}. Set ' +
-        #           r'"force=True".')
-        #
-        # # Check density is positive
-        # min_rho = numpy.min(rho)
-        # if min_rho < 0.0 - 1e-3:
-        #     print(f'"rho" is not positive. min_rho: {min_rho:>0.3f}. Set ' +
-        #           r'"force=True".')
+        rho = self._stieltjes(x).imag / numpy.pi
 
         if plot:
             plot_density(x, rho, eig=self.eig, support=self.broad_support,
@@ -431,7 +409,7 @@ class AlgebraicForm(object):
     # hilbert
     # =======
 
-    def hilbert(self, x=None, rho=None, plot=False, latex=False, save=False):
+    def hilbert(self, x=None, plot=False, latex=False, save=False):
         """
         Compute Hilbert transform of the spectral density.
 
@@ -443,9 +421,6 @@ class AlgebraicForm(object):
             an interval slightly larger than the support interval of the
             spectral density is used.
 
-        rho : numpy.array, default=None
-            Density. If `None`, it will be computed.
-
         plot : bool, default=False
             If `True`, density is plotted.
 
@@ -477,49 +452,22 @@ class AlgebraicForm(object):
             >>> from freealg import FreeForm
         """
 
-        pass
-
         if self.a_coeffs is None:
             raise RuntimeError('The model needs to be fit using the .fit() ' +
                                'function.')
 
-        # # Create x if not given
-        # if x is None:
-        #     x = self._generate_grid(1.25)
-        #
-        # # if (numpy.min(x) > self.lam_m) or (numpy.max(x) < self.lam_p):
-        # #     raise ValueError('"x" does not encompass support interval.')
-        #
-        # # Preallocate density to zero
-        # if rho is None:
-        #     rho = self.density(x)
-        #
-        # # mask of support [lam_m, lam_p]
-        # mask = numpy.logical_and(x >= self.lam_m, x <= self.lam_p)
-        # x_s = x[mask]
-        # rho_s = rho[mask]
-        #
-        # # Form the matrix of integrands: rho_s / (t - x_i)
-        # # Here, we have diff[i,j] = x[i] - x_s[j]
-        # diff = x[:, None] - x_s[None, :]
-        # D = rho_s[None, :] / diff
-        #
-        # # Principal-value: wherever t == x_i, then diff == 0, zero that entry
-        # # (numpy.isclose handles floating-point exactly)
-        # D[numpy.isclose(diff, 0.0)] = 0.0
-        #
-        # # Integrate each row over t using trapezoid rule on x_s
-        # # Namely, hilb[i] = int rho_s(t)/(t - x[i]) dt
-        # hilb = numpy.trapezoid(D, x_s, axis=1) / numpy.pi
-        #
-        # # We use negative sign convention
-        # hilb = -hilb
-        #
-        # if plot:
-        #     plot_hilbert(x, hilb, support=self.support, latex=latex,
-        #                  save=save)
-        #
-        # return hilb
+        # Create x if not given
+        if x is None:
+            x = self._generate_grid(1.25)
+
+        # Preallocate density to zero
+        hilb = -self._stieltjes(x).real / numpy.pi
+
+        if plot:
+            plot_hilbert(x, hilb, support=self.support, latex=latex,
+                         save=save)
+
+        return hilb
 
     # =========
     # stieltjes
@@ -559,12 +507,9 @@ class AlgebraicForm(object):
         Returns
         -------
 
-        m_p : numpy.ndarray
+        m : numpy.ndarray
             The Stieltjes transform on the principal branch.
 
-        m_m : numpy.ndarray
-            The Stieltjes transform continued to the secondary branch.
-
         See Also
         --------
 
@@ -579,36 +524,34 @@ class AlgebraicForm(object):
             >>> from freealg import FreeForm
         """
 
-        pass
-
         if self.a_coeffs is None:
             raise RuntimeError('The model needs to be fit using the .fit() ' +
                                'function.')
 
-        # # Create x if not given
-        # if x is None:
-        #     x = self._generate_grid(2.0, extend=2.0)
-        #
-        # # Create y if not given
-        # if (plot is False) and (y is None):
-        #     # Do not use a Cartesian grid. Create a 1D array z slightly above
-        #     # the real line.
-        #     y = self.delta * 1j
-        #     z = x.astype(complex) + y             # shape (Nx,)
-        # else:
-        #     # Use a Cartesian grid
-        #     if y is None:
-        #         y = numpy.linspace(-1, 1, 400)
-        #     x_grid, y_grid = numpy.meshgrid(x.real, y.real)
-        #     z = x_grid + 1j * y_grid              # shape (Ny, Nx)
-        #
-        # m1, m2 = self._eval_stieltjes(z, branches=True)
-        #
-        # if plot:
-        #     plot_stieltjes(x, y, m1, m2, self.support, latex=latex,
-        #                    save=save)
-        #
-        # return m1, m2
+        # Create x if not given
+        if x is None:
+            x = self._generate_grid(2.0, extend=2.0)[::2]
+
+        # Create y if not given
+        if (plot is False) and (y is None):
+            # Do not use a Cartesian grid. Create a 1D array z slightly above
+            # the real line.
+            y = self.delta * 1j
+            z = x.astype(complex) + y             # shape (Nx,)
+        else:
+            # Use a Cartesian grid
+            if y is None:
+                y = numpy.linspace(-1, 1, 200)
+            x_grid, y_grid = numpy.meshgrid(x.real, y.real)
+            z = x_grid + 1j * y_grid              # shape (Ny, Nx)
+
+        m = self._stieltjes(z, progress=True)
+
+        if plot:
+            plot_stieltjes(x, y, m, m, self.broad_support, latex=latex,
+                           save=save)
+
+        return m
 
     # ==============
     # eval stieltjes
@@ -668,8 +611,10 @@ class AlgebraicForm(object):
         alpha = numpy.atleast_1d(size) / self.n
 
         # Lower and upper bound on new support
-        hilb_lb = (1.0 / self.stieltjes(self.lam_m + self.delta * 1j).item()).real
-        hilb_ub = (1.0 / self.stieltjes(self.lam_p + self.delta * 1j).item()).real
+        hilb_lb = \
+            (1.0 / self._stieltjes(self.lam_m + self.delta * 1j).item()).real
+        hilb_ub = \
+            (1.0 / self._stieltjes(self.lam_p + self.delta * 1j).item()).real
         lb = self.lam_m - (numpy.max(alpha) - 1) * hilb_lb
         ub = self.lam_p - (numpy.max(alpha) - 1) * hilb_ub
 
@@ -690,13 +635,14 @@ class AlgebraicForm(object):
             z_query = x + 1j * self.delta
 
             # Initial condition at t=0 (physical branch)
-            w0_list = self.stieltjes(z_query)
+            w0_list = self._stieltjes(z_query)
 
             # Times
             t = numpy.log(alpha)
 
             # Ensure it starts from t = 0
-            t = numpy.concatenate([numpy.zeros(1), t])
+            if t[0] > 1.0:
+                t = numpy.concatenate([numpy.zeros(1), t])
 
             # Evolve
             W, ok = decompress_newton(
@@ -721,7 +667,7 @@ class AlgebraicForm(object):
                 coeffs_i = decompress_coeffs(self.a_coeffs,
                                              numpy.log(alpha[i]))
                 stieltjes_i = StieltjesPoly(coeffs_i)
-                rho[i, :] = stieltjes_i.imag
+                rho[i, :] = stieltjes_i(x).imag
 
             rho = rho / numpy.pi
 

{freealg-0.7.8 → freealg-0.7.10}/freealg.egg-info/PKG-INFO

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

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