freealg 0.7.3__tar.gz → 0.7.5__tar.gz

{freealg-0.7.3 → freealg-0.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.7.3
+Version: 0.7.5
 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.5/freealg/__version__.py

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

{freealg-0.7.3 → freealg-0.7.5}/freealg/_algebraic_form/_continuation_algebraic.py

@@ -15,20 +15,22 @@ import numpy
 from .._geometric_form._continuation_genus0 import joukowski_z
 
 __all__ = ['sample_z_joukowski', 'filter_z_away_from_cuts', 'powers',
-           'fit_polynomial_relation', 'eval_P', 'eval_roots',
-           'build_sheets_from_roots']
+           'fit_polynomial_relation', 'sanity_check_stieltjes_branch',
+           'eval_P', 'eval_roots', 'build_sheets_from_roots']
 
 
 # ======================
 # normalize coefficients
 # ======================
 
-def _normalize_coefficients(a):
+def _normalize_coefficients(arr):
     """
     Trim rows and columns on the sides (equivalent to factorizing or reducing
     degree) and normalize so that the sum of the first column is one.
     """
 
+    a = numpy.asarray(arr).copy()
+
     if a.size == 0:
         return a
 
@@ -51,7 +53,7 @@ def _normalize_coefficients(a):
     a = a[:, first_col:last_col]
 
     # --- Normalize so first column sums to 1 ---
-    col_sum = numpy.sum(a[:, 0])
+    col_sum = numpy.sum(numpy.abs(a[:, 0]))
     if col_sum != 0:
         a = a / col_sum
 
@@ -189,12 +191,15 @@ def fit_polynomial_relation(z, m, s, deg_z, ridge_lambda=0.0, weights=None,
     if w is not None:
         A = A * w[:, None]
 
-    s_col = numpy.max(numpy.abs(A), axis=0)
+    # Enforce real coefficients by solving: Re(A) c = 0 and Im(A) c = 0
+    Ar = numpy.vstack([A.real, A.imag])
+
+    s_col = numpy.max(numpy.abs(Ar), axis=0)
     s_col[s_col == 0.0] = 1.0
-    As = A / s_col[None, :]
+    As = Ar / s_col[None, :]
 
     if ridge_lambda > 0.0:
-        L = numpy.sqrt(ridge_lambda) * numpy.eye(n_coef, dtype=complex)
+        L = numpy.sqrt(ridge_lambda) * numpy.eye(n_coef, dtype=float)
         As = numpy.vstack([As, L])
 
     _, _, vh = numpy.linalg.svd(As, full_matrices=False)
@@ -211,6 +216,77 @@ def fit_polynomial_relation(z, m, s, deg_z, ridge_lambda=0.0, weights=None,
     return full
 
 
+# =============================
+# sanity check stieltjes branch
+# =============================
+
+def sanity_check_stieltjes_branch(a_coeffs, x_min, x_max, eta=0.1,
+                                  n_x=64, y0=None, max_bad_frac=0.05):
+    """
+    Quick sanity check: does P(z,m)=0 admit a continuously trackable root with
+    Im(m)>0 along z=x+i*eta.
+    """
+
+    x_min = float(x_min)
+    x_max = float(x_max)
+    eta = float(eta)
+    n_x = int(n_x)
+    if n_x < 4:
+        n_x = 4
+
+    if y0 is None:
+        y0 = 10.0 * max(1.0, abs(x_min), abs(x_max))
+    y0 = float(y0)
+
+    z0 = 1j * y0
+    m0_target = -1.0 / z0
+
+    c0 = _poly_coef_in_m(numpy.array([z0]), a_coeffs)[0]
+    r0 = numpy.roots(c0[::-1])
+    if r0.size == 0:
+        return {'ok': False, 'frac_bad': 1.0, 'n_test': 0, 'n_bad': 0}
+
+    k0 = int(numpy.argmin(numpy.abs(r0 - m0_target)))
+    m_prev = r0[k0]
+
+    xs = numpy.linspace(x_min, x_max, n_x)
+    zs = xs + 1j * eta
+
+    n_bad = 0
+    n_ok = 0
+
+    for z in zs:
+        c = _poly_coef_in_m(numpy.array([z]), a_coeffs)[0]
+        r = numpy.roots(c[::-1])
+        if r.size == 0 or not numpy.all(numpy.isfinite(r)):
+            n_bad += 1
+            continue
+
+        k = int(numpy.argmin(numpy.abs(r - m_prev)))
+        m_sel = r[k]
+        m_prev = m_sel
+        n_ok += 1
+
+        if not numpy.isfinite(m_sel) or (m_sel.imag <= 0.0):
+            n_bad += 1
+
+    n_test = n_ok + (n_bad - (n_x - n_ok))
+    if n_test <= 0:
+        n_test = n_x
+
+    frac_bad = float(n_bad) / float(n_x)
+    ok = frac_bad <= float(max_bad_frac)
+
+    status = {
+        'ok': ok,
+        'frac_bad': frac_bad,
+        'n_test': n_x,
+        'n_bad': n_bad
+    }
+
+    return status
+
+
 # ======
 # eval P
 # ======
@@ -359,6 +435,10 @@ def eval_roots(z, a_coeffs):
 # =======================
 
 def track_one_sheet_on_grid(z, roots, sheet_seed, cuts=None, i0=None, j0=None):
+    """
+    This is mostly used for visualization of the sheets.
+    """
+
     z = numpy.asarray(z)
     n_y, n_x = z.shape
     s = roots.shape[1]
@@ -465,6 +545,7 @@ def track_one_sheet_on_grid(z, roots, sheet_seed, cuts=None, i0=None, j0=None):
 # =======================
 
 def build_sheets_from_roots(z, roots, m1, cuts=None, i0=None, j0=None):
+
     z = numpy.asarray(z)
     m1 = numpy.asarray(m1)
 

freealg-0.7.5/freealg/_algebraic_form/_decompress2.py

@@ -0,0 +1,86 @@
+# =======
+# Imports
+# =======
+
+import numpy
+from scipy.special import comb
+from ._continuation_algebraic import _normalize_coefficients
+
+__all__ = ['decompress_coeffs']
+
+
+# =================
+# decompress_coeffs
+# =================
+
+def decompress_coeffs(a, t, normalize=True):
+    """
+    Compute the decompressed coefficients A[r, s](t) induced by
+    the transform Q_t(z, m) = m^L P(z + (1 - e^{-t}) / m, e^t m).
+
+    Parameters
+    ----------
+    a : array_like of float, shape (L+1, K+1)
+        Coefficients defining P(z, m) in the monomial basis:
+            P(z, m) = sum_{j=0..L} sum_{k=0..K} a[j, k] z^j m^k.
+    t : float
+        Time parameter.
+
+    Returns
+    -------
+    A : ndarray, shape (L+1, L+K+1)
+        Coefficients A[r, s](t) such that
+            sum_{r=0..L} sum_{s=0..L+K} A[r, s](t) z^r m^s = 0,
+        normalized by normalize_coefficients.
+    """
+    a = numpy.asarray(a)
+    if a.ndim != 2:
+        raise ValueError("a must be a 2D array-like of shape (L+1, K+1).")
+
+    l_degree = a.shape[0] - 1
+    k_degree = a.shape[1] - 1
+
+    c = 1.0 - numpy.exp(-t)
+
+    # Scale columns of a by e^{t k}: scaled[j, k] = a[j, k] e^{t k}.
+    exp_factors = numpy.exp(numpy.arange(k_degree + 1) * t)
+    scaled = a * exp_factors
+
+    # Output coefficients.
+    out_dtype = numpy.result_type(a, float)
+    a_out = numpy.zeros((l_degree + 1, l_degree + k_degree + 1),
+                        dtype=out_dtype)
+
+    # Precompute binomial(j, r) * c^{j-r} for all j, r (lower-triangular).
+    j_inds = numpy.arange(l_degree + 1)[:, None]
+    r_inds = numpy.arange(l_degree + 1)[None, :]
+    mask = r_inds <= j_inds
+
+    binom_weights = numpy.zeros((l_degree + 1, l_degree + 1), dtype=float)
+    binom_weights[mask] = comb(j_inds, r_inds, exact=False)[mask]
+    binom_weights[mask] *= (c ** (j_inds - r_inds))[mask]
+
+    # Main accumulation:
+    # For fixed j and r, add:
+    #   A[r, (L - j + r) + k] += binom_weights[j, r] * scaled[j, k],
+    # for k = 0..K.
+    for j in range(l_degree + 1):
+        row_scaled = scaled[j]
+        if numpy.all(row_scaled == 0):
+            continue
+
+        base0 = l_degree - j
+        row_b = binom_weights[j]
+
+        for r in range(j + 1):
+            coeff = row_b[r]
+            if coeff == 0:
+                continue
+
+            start = base0 + r
+            a_out[r, start:start + (k_degree + 1)] += coeff * row_scaled
+
+    if normalize:
+        return _normalize_coefficients(a_out)
+
+    return a_out

freealg-0.7.5/freealg/_algebraic_form/_homotopy.py

@@ -0,0 +1,138 @@
+# =======
+# Imports
+# =======
+
+import numpy
+
+__all__ = ['stieltjes_poly']
+
+
+# =====================
+# stieltjes select root
+# =====================
+
+def stieltjes_select_root(roots, z, w_prev=None):
+    """
+    Select the Stieltjes-branch root among candidates at a given z.
+
+    Parameters
+    ----------
+    roots : array_like of complex
+        Candidate roots for m at the given z.
+    z : complex
+        Evaluation point. The Stieltjes/Herglotz branch satisfies
+        sign(Im(m)) = sign(Im(z)) away from the real axis.
+    w_prev : complex or None, optional
+        Previous continuation value used to enforce continuity. If None,
+        the asymptotic target -1/z is used.
+
+    Returns
+    -------
+    w : complex
+        Selected root corresponding to the Stieltjes branch.
+    """
+
+    z = complex(z)
+    roots = numpy.asarray(roots, dtype=numpy.complex128).ravel()
+
+    if roots.size == 0:
+        raise ValueError("roots must contain at least one candidate root.")
+
+    desired_sign = numpy.sign(z.imag)
+
+    if w_prev is None:
+        target = -1.0 / z
+    else:
+        target = complex(w_prev)
+
+    # Apply a soft Herglotz sign filter: prefer roots with Im(w) having the
+    # same sign as Im(z), allowing tiny numerical violations near the axis.
+    imag_roots = numpy.imag(roots)
+
+    good = roots[numpy.sign(imag_roots) == desired_sign]
+    if good.size == 0:
+        good = roots[(imag_roots * desired_sign) > -1e-12]
+
+    candidates = good if good.size > 0 else roots
+    idx = int(numpy.argmin(numpy.abs(candidates - target)))
+    return candidates[idx]
+
+
+# ==============
+# stieltjes poly
+# ==============
+
+def stieltjes_poly(z, a, eps=None, height=1e+4, steps=100):
+    """
+    Evaluate the Stieltjes-branch solution m(z) of an algebraic equation.
+
+    The coefficients `a` define a polynomial relation
+        P(z, m) = 0,
+    where P is a polynomial in z and m with monomial-basis coefficients
+    arranged so that for fixed z, the coefficients of the polynomial in m
+    can be assembled from powers of z.
+
+    Parameters
+    ----------
+    z : complex
+        Evaluation point. Must be a single value.
+    a : ndarray, shape (L, K)
+        Coefficient matrix defining P(z, m) in the monomial basis.
+    eps : float or None, optional
+        If Im(z) == 0, use z + i*eps as the boundary evaluation point.
+        If None and Im(z) == 0, eps is set to 1e-8 * max(1, |z|).
+    height : float, optional
+        Imaginary height used for the starting point z0 in the same
+        half-plane as the evaluation point.
+    steps : int, optional
+        Number of continuation steps along the homotopy path.
+
+    Returns
+    -------
+    w : complex
+        Value of the Stieltjes-branch solution m(z) (or m(z+i*eps) if z is
+        real).
+    """
+
+    z = complex(z)
+    a = numpy.asarray(a)
+
+    if a.ndim != 2:
+        raise ValueError('a must be a 2D array.')
+
+    if steps < 1:
+        raise ValueError("steps must be a positive integer.")
+
+    a_l, _ = a.shape
+
+    def poly_coeffs_m(z_val):
+        z_powers = z_val ** numpy.arange(a_l)
+        return (z_powers @ a)[::-1]
+
+    def poly_roots(z_val):
+        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 z.imag == 0.0:
+        if eps is None:
+            eps = 1e-8 * max(1.0, abs(z))
+        z_eval = z + 1j * float(eps)
+    else:
+        z_eval = z
+
+    half_sign = numpy.sign(z_eval.imag)
+    if half_sign == 0.0:
+        half_sign = 1.0
+
+    z0 = 1j * float(half_sign) * float(height)
+
+    # Initialize at z0 via asymptotic / Im-sign selection.
+    w_prev = stieltjes_select_root(poly_roots(z0), z0, w_prev=None)
+
+    # Straight-line homotopy from z0 to z_eval.
+    for tau in numpy.linspace(0.0, 1.0, int(steps) + 1)[1:]:
+        z_tau = z0 + tau * (z_eval - z0)
+        w_prev = stieltjes_select_root(poly_roots(z_tau), z_tau, w_prev=w_prev)
+
+    return w_prev

{freealg-0.7.3 → freealg-0.7.5}/freealg/_algebraic_form/algebraic_form.py

@@ -12,12 +12,17 @@
 # =======
 
 import numpy
-from .._util import resolve_complex_dtype
+from .._util import resolve_complex_dtype, compute_eig
 # from .._util import compute_eig
 from ._continuation_algebraic import sample_z_joukowski, \
-        filter_z_away_from_cuts, fit_polynomial_relation, eval_P
+        filter_z_away_from_cuts, fit_polynomial_relation, \
+        sanity_check_stieltjes_branch, eval_P
 from ._edge import evolve_edges, merge_edges
 from ._decompress import decompress_newton
+from ._decompress2 import decompress_coeffs
+from ._homotopy import stieltjes_poly
+from .._free_form._support import supp
+from .._free_form._plot_util import plot_density
 
 # Fallback to previous numpy API
 if not hasattr(numpy, 'trapezoid'):
@@ -129,46 +134,65 @@ class AlgebraicForm(object):
     # def __init__(self, A, support=None, delta=1e-6, dtype='complex128',
     #              **kwargs):
 
-    def __init__(self, stieltjes, support=None, delta=1e-5, dtype='complex128',
+    def __init__(self, A, support=None, delta=1e-5, dtype='complex128',
                  **kwargs):
         """
         Initialization.
         """
 
-        # self.A = None
-        # self.eig = None
-        self.stieltjes = stieltjes
+        self.A = None
+        self.eig = None
+        self.stieltjes = None
         self.support = support
         self.delta = delta    # Offset above real axis to apply Plemelj formula
 
         # Data type for complex arrays
         self.dtype = resolve_complex_dtype(dtype)
 
-        # # Eigenvalues
-        # if A.ndim == 1:
-        #     # When A is a 1D array, it is assumed A is the eigenvalue array.
-        #     self.eig = A
-        #     self.n = len(A)
-        # elif A.ndim == 2:
-        #     # When A is a 2D array, it is assumed A is the actual array,
-        #     # and its eigenvalues will be computed.
-        #     self.A = A
-        #     self.n = A.shape[0]
-        #     assert A.shape[0] == A.shape[1], \
-        #         'Only square matrices are permitted.'
-        #     self.eig = compute_eig(A)
+        if hasattr(A, 'stieltjes') and callable(getattr(A, 'stieltjes', None)):
+            # This is one of the distribution objects, like MarchenkoPastur
+            self.stieltjes = A.stieltjes
+            self.n = 1
+
+        elif callable(A):
+            # This is a custom function
+            self.stieltjes = A
+            self.n = 1
+
+        else:
+            # Eigenvalues
+            if A.ndim == 1:
+                # If A is a 1D array, it is assumed A is the eigenvalues array.
+                self.eig = A
+                self.n = len(A)
+            elif A.ndim == 2:
+                # When A is a 2D array, it is assumed A is the actual array,
+                # and its eigenvalues will be computed.
+                self.A = A
+                self.n = A.shape[0]
+                assert A.shape[0] == A.shape[1], \
+                    'Only square matrices are permitted.'
+                self.eig = compute_eig(A)
+
+            # Use empirical Stieltjes function
+            self.stieltjes = lambda z: \
+                numpy.mean(1.0/(self.eig-z[:, numpy.newaxis]), axis=-1)
 
         # Support
-        # if support is None:
-        #     # Detect support
-        #     self.lam_m, self.lam_p = supp(self.eig, **kwargs)
-        # else:
-        #     self.lam_m = float(support[0])
-        #     self.lam_p = float(support[1])
-        # self.support = (self.lam_m, self.lam_p)
+        if support is None:
+            if self.eig is None:
+                raise RuntimeError("Support must be provided without data")
+            # Detect support
+            self.lam_m, self.lam_p = supp(self.eig, **kwargs)
+            self.support = [(self.lam_m, self.lam_p)]
+            self.broad_support = self.support[0]
+        else:
+            self.support = support
+            self.lam_m = min([s[0] for s in self.support])
+            self.lam_p = max([s[1] for s in self.support])
+            self.broad_support = (self.lam_m, self.lam_p)
 
         # Initialize
-        # self.method = None                 # fitting rho: jacobi, chebyshev
         self.a_coeffs = None               # Polynomial coefficients
         self.cache = {}                    # Cache inner-computations
 
@@ -190,11 +214,9 @@ class AlgebraicForm(object):
         """
 
         # Very important: reset cache whenever this function is called. This
-        # also empties all references holdign a cache copy.
+        # also empties all references holding a cache copy.
         # self.cache.clear()
 
-        # return self.a_coeffs
-
         z_fits = []
         for sup in self.support:
             a, b = sup
@@ -205,12 +227,10 @@ class AlgebraicForm(object):
 
         z_fit = numpy.concatenate(z_fits)
 
-        # Remove points too close to ANY cut
+        # Remove points too close to any cut
         z_fit = filter_z_away_from_cuts(z_fit, self.support, y_eps=y_eps,
                                         x_pad=x_pad)
 
-        # ---------
-
         m1_fit = self.stieltjes(z_fit)
         a_coeffs = fit_polynomial_relation(z_fit, m1_fit, s=deg_m, deg_z=deg_z,
                                            ridge_lambda=reg,
@@ -219,46 +239,66 @@ class AlgebraicForm(object):
 
         self.a_coeffs = a_coeffs
 
+        # Reporting error
+        P_res = numpy.abs(eval_P(z_fit, m1_fit, a_coeffs))
+        res_max = numpy.max(P_res[numpy.isfinite(P_res)])
+        res_99_9 = numpy.quantile(P_res[numpy.isfinite(P_res)], 0.999)
+
+        # Check polynomial has Stieltjes root
+        x_min = self.lam_m - 1.0
+        x_max = self.lam_p + 1.0
+        status = sanity_check_stieltjes_branch(a_coeffs, x_min, x_max,
+                                               eta=max(y_eps, 1e-2), n_x=128,
+                                               max_bad_frac=0.05)
+
+        status['res_max'] = res_max
+        status['res_99_9'] = res_99_9
+
         if verbose:
-            P_res = numpy.abs(eval_P(z_fit, m1_fit, a_coeffs))
-            print("fit residual max:", numpy.max(P_res[numpy.isfinite(P_res)]))
-            print("fit residual 99.9%:",
-                  numpy.quantile(P_res[numpy.isfinite(P_res)], 0.999))
+            print(f'fit residual max  : {res_max:>0.4e}')
+            print(f'fit residual 99.9%: {res_99_9:>0.4e}')
 
-            print('\nCoefficinets')
-            with numpy.printoptions(precision=4, suppress=True):
+            print('\nCoefficients (real)')
+            with numpy.printoptions(precision=8, suppress=True):
                 for i in range(a_coeffs.shape[0]):
                     for j in range(a_coeffs.shape[1]):
                         v = a_coeffs[i, j]
-                        print(f"{v.real:>+0.4f}{v.imag:>+0.4f}j", end=" ")
+                        print(f'{v.real:>+0.8f}', end=' ')
                     print('')
 
-            print('\nCoefficients mangitudes')
-            with numpy.printoptions(precision=6, suppress=True):
-                print(numpy.abs(a_coeffs))
+            a_coeffs_img_norm = numpy.linalg.norm(a_coeffs.imag, ord='fro')
+            print(f'\nCoefficients (imag) norm: {a_coeffs_img_norm:>0.4e}')
 
-        return a_coeffs
+            if not status['ok']:
+                print("\nWARNING: sanity check failed:\n" +
+                      f"\tfrac_bad: {status['frac_bad']:>0.3f}\n" +
+                      f"\tn_bad   : {status['n_bad']}\n" +
+                      f"\tn_test  : {status['n_test']}")
+            else:
+                print('\nStieltjes sanity check: OK')
+
+        return a_coeffs, status
 
     # =============
     # generate grid
     # =============
 
-    # def _generate_grid(self, scale, extend=1.0, N=500):
-    #     """
-    #     Generate a grid of points to evaluate density / Hilbert / Stieltjes
-    #     transforms.
-    #     """
-    #
-    #     radius = 0.5 * (self.lam_p - self.lam_m)
-    #     center = 0.5 * (self.lam_p + self.lam_m)
-    #
-    #     x_min = numpy.floor(extend * (center - extend * radius * scale))
-    #     x_max = numpy.ceil(extend * (center + extend * radius * scale))
-    #
-    #     x_min /= extend
-    #     x_max /= extend
-    #
-    #     return numpy.linspace(x_min, x_max, N)
+    def _generate_grid(self, scale, extend=1.0, N=500):
+        """
+        Generate a grid of points to evaluate density / Hilbert / Stieltjes
+        transforms.
+        """
+
+        radius = 0.5 * (self.lam_p - self.lam_m)
+        center = 0.5 * (self.lam_p + self.lam_m)
+
+        x_min = numpy.floor(extend * (center - extend * radius * scale))
+        x_max = numpy.ceil(extend * (center + extend * radius * scale))
+
+        x_min /= extend
+        x_max /= extend
+
+        return numpy.linspace(x_min, x_max, N)
 
     # =======
     # density
@@ -312,16 +352,19 @@ class AlgebraicForm(object):
             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)
-        #
-        # # Preallocate density to zero
-        # rho = numpy.zeros_like(x)
-        #
-        # # Compute density only inside support
-        # mask = numpy.logical_and(x >= self.lam_m, x <= self.lam_p)
-        #
+        # Create x if not given
+        if x is None:
+            x = self._generate_grid(1.25)
+
+        # Preallocate density to zero
+        rho = numpy.zeros_like(x)
+
+        for idx, x_i in enumerate(x):
+            m_i = stieltjes_poly(x_i, self.a_coeffs)
+            rho[idx] = m_i.imag
+
+        rho = rho / numpy.pi
+
         # if self.method == 'jacobi':
         #     rho[mask] = jacobi_density(x[mask], self.psi, self.support,
         #                                self.alpha, self.beta)
@@ -341,12 +384,12 @@ class AlgebraicForm(object):
         # if min_rho < 0.0 - 1e-3:
         #     print(f'"rho" is not positive. min_rho: {min_rho:>0.3f}. Set ' +
         #           r'"force=True".')
-        #
-        # if plot:
-        #     plot_density(x, rho, eig=self.eig, support=self.support,
-        #                  label='Estimate', latex=latex, save=save)
-        #
-        # return rho
+
+        if plot:
+            plot_density(x, rho, eig=self.eig, support=self.broad_support,
+                         label='Estimate', latex=latex, save=save)
+
+        return rho
 
     # =======
     # hilbert
@@ -568,68 +611,99 @@ class AlgebraicForm(object):
     # decompress
     # ==========
 
-    def decompress(self, x, t,
-                   max_iter=50,
-                   tol=1e-12,
-                   armijo=1e-4,
-                   min_lam=1e-6,
-                   w_min=1e-14,
-                   sweep=True,
-                   verbose=False):
+    def decompress(self, size, x=None, method='one', plot=False, latex=False,
+                   save=False, verbose=False, newton_opt={
+                       'max_iter': 50, 'tol': 1e-12, 'armijo': 1e-4,
+                       'min_lam': 1e-6, 'w_min': 1e-14, 'sweep': True}):
         """
         Free decompression of spectral density.
         """
 
         # Check size argument
-        # if numpy.isscalar(size):
-        #     size = int(size)
-        # else:
-        #     # Check monotonic increment (either all increasing or decreasing)
-        #     diff = numpy.diff(size)
-        #     if not (numpy.all(diff >= 0) or numpy.all(diff <= 0)):
-        #         raise ValueError('"size" increment should be monotonic.')
+        if numpy.isscalar(size):
+            size = int(size)
+        else:
+            # Check monotonic increment (either all increasing or decreasing)
+            diff = numpy.diff(size)
+            if not (numpy.all(diff >= 0) or numpy.all(diff <= 0)):
+                raise ValueError('"size" increment should be monotonic.')
 
         # Decompression ratio equal to e^{t}.
-        # alpha = numpy.atleast_1d(size) / self.n
+        alpha = numpy.atleast_1d(size) / self.n
 
-        # # If the input size was only a scalar, return a 1D rho, otherwise 2D.
-        # if numpy.isscalar(size):
-        #     rho = numpy.squeeze(rho)
-        #
-        # # Plot only the last size
-        # if plot:
-        #     if numpy.isscalar(size):
-        #         rho_last = rho
-        #     else:
-        #         rho_last = rho[-1, :]
-        #     plot_density(x, rho_last, support=(lb, ub),
-        #                  label='Decompression', latex=latex, save=save)
-        #
-        # return rho, x
+        def m_fn(z):
+            return stieltjes_poly(z, self.a_coeffs)
 
-        # Query grid on the real axis + a small imaginary buffer
-        z_query = x + 1j * self.delta
+        # Lower and upper bound on new support
+        hilb_lb = (1.0 / m_fn(self.lam_m + self.delta * 1j).item()).real
+        hilb_ub = (1.0 / m_fn(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
 
-        # Initial condition at t=0 (physical branch)
-        w0_list = self.stieltjes(z_query)
+        # Create x if not given
+        if x is None:
+            radius = 0.5 * (ub - lb)
+            center = 0.5 * (ub + lb)
+            scale = 1.25
+            x_min = numpy.floor(center - radius * scale)
+            x_max = numpy.ceil(center + radius * scale)
+            x = numpy.linspace(x_min, x_max, 200)
+        else:
+            x = numpy.asarray(x)
 
-        # Evolve
-        W, ok = decompress_newton(
-            z_query, t, self.a_coeffs,
-            w0_list=w0_list,
-            max_iter=max_iter,
-            tol=tol,
-            armijo=armijo,
-            min_lam=min_lam,
-            w_min=w_min,
-            sweep=sweep)
+        if method == 'one':
 
-        rho = W.imag / numpy.pi
+            # Query grid on the real axis + a small imaginary buffer
+            z_query = x + 1j * self.delta
 
-        if verbose:
-            print("success rate per t:", ok.mean(axis=1))
+            # Initial condition at t=0 (physical branch)
+            w0_list = self.stieltjes(z_query)
 
-        return rho
+            # Times
+            t = numpy.log(alpha)
+
+            # Evolve
+            W, ok = decompress_newton(
+                z_query, t, self.a_coeffs,
+                w0_list=w0_list, **newton_opt)
+
+            rho = W.imag / numpy.pi
+
+            if verbose:
+                print("success rate per t:", ok.mean(axis=1))
+
+        elif method == 'two':
+
+            # Preallocate density to zero
+            rho = numpy.zeros((alpha.size, x.size), dtype=float)
+
+            # Decompress to each alpha
+            for i in range(alpha.size):
+                coeffs_i = decompress_coeffs(self.a_coeffs,
+                                             numpy.log(alpha[i]))
+                for j, x_j in enumerate(x):
+                    m_j = stieltjes_poly(x_j, coeffs_i)
+                    rho[i, j] = m_j.imag
+
+            rho = rho / numpy.pi
+
+        else:
+            raise ValueError('"method" is invalid.')
+
+        # If the input size was only a scalar, return a 1D rho, otherwise 2D.
+        if numpy.isscalar(size):
+            rho = numpy.squeeze(rho)
+
+        # Plot only the last size
+        if plot:
+            if numpy.isscalar(size):
+                rho_last = rho
+            else:
+                rho_last = rho[-1, :]
+            plot_density(x, rho_last, support=(lb, ub),
+                         label='Decompression', latex=latex, save=save)
+
+        return rho, x
 
     # ====
     # edge

{freealg-0.7.3 → freealg-0.7.5}/freealg/distributions/_deformed_wigner.py

@@ -290,26 +290,14 @@ class DeformedWigner(object):
         A : numpy.ndarray
             A matrix of the size :math:`n \\times n`.
 
-        Parameters
-        ----------
-        size : int
-            Size n of the matrix.
-
-        seed : int, default=None
-            Seed for random number generator.
-
-        Returns
-        -------
-        A : numpy.ndarray
-            Symmetric matrix of shape (n, n).
-
         Notes
         -----
 
-        Generate an :math:`n x n` matrix :math:`\\mathbf{A} = \\mathbf{T} +
-        \\sigma \\mathbf{W}` whose ESD converges to
-        :math:`H \\boxplus SC_{\\sigma^2}`, where
-        :math:`H = w_1 \\delta_{t_1} + (1-w_1) \\delta_{t_2}`.
+        Generate an :math:`n \\times n` matrix
+        :math:`\\mathbf{A} = \\mathbf{T} + \\sigma \\mathbf{W}`
+        whose ESD converges to
+        :math:`H \\boxplus \\mathrm{SC}_{\\sigma^2}`, where
+        :math:`H = w_1 \\delta_{t_1} + (1 - w_1) \\delta_{t_2}`.
 
         Examples
         --------
@@ -317,8 +305,8 @@ class DeformedWigner(object):
         .. code-block::python
 
             >>> from freealg.distributions import DeformedWigner
-            >>> mp = DeformedWigner(1/50)
-            >>> A = mp.matrix(2000)
+            >>> dwg = DeformedWigner(1/50)
+            >>> A = dwg.matrix(2000)
         """
 
         n = int(size)

{freealg-0.7.3 → freealg-0.7.5}/freealg.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.7.3
+Version: 0.7.5
 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.3 → freealg-0.7.5}/freealg.egg-info/SOURCES.txt

@@ -19,7 +19,9 @@ freealg.egg-info/top_level.txt
 freealg/_algebraic_form/__init__.py
 freealg/_algebraic_form/_continuation_algebraic.py
 freealg/_algebraic_form/_decompress.py
+freealg/_algebraic_form/_decompress2.py
 freealg/_algebraic_form/_edge.py
+freealg/_algebraic_form/_homotopy.py
 freealg/_algebraic_form/_sheets_util.py
 freealg/_algebraic_form/algebraic_form.py
 freealg/_free_form/__init__.py

freealg-0.7.3/freealg/__version__.py

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