freealg 0.7.10__py3-none-any.whl → 0.7.11__py3-none-any.whl

freealg/__version__.py

@@ -1 +1 @@
-__version__ = "0.7.10"
+__version__ = "0.7.11"

freealg/_algebraic_form/_branch_points.py

@@ -0,0 +1,288 @@
+# SPDX-FileCopyrightText: Copyright 2026, 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.
+
+
+# =======
+# Imports
+# =======
+
+import numpy
+
+__all__ = ['compute_branch_points']
+
+
+# =========
+# poly trim
+# =========
+
+def _poly_trim(p, tol):
+    p = numpy.asarray(p, dtype=float)
+    if p.size == 0:
+        return p
+    k = p.size - 1
+    while k > 0 and abs(p[k]) <= tol:
+        k -= 1
+    return p[: k + 1]
+
+
+# ========
+# poly add
+# ========
+
+def _poly_add(a, b, tol):
+
+    n = max(len(a), len(b))
+    out = numpy.zeros(n, dtype=float)
+    out[: len(a)] += a
+    out[: len(b)] += b
+
+    return _poly_trim(out, tol)
+
+
+# ========
+# poly sub
+# ========
+
+def _poly_sub(a, b, tol):
+
+    n = max(len(a), len(b))
+    out = numpy.zeros(n, dtype=float)
+    out[: len(a)] += a
+    out[: len(b)] -= b
+
+    return _poly_trim(out, tol)
+
+
+# ========
+# poly mul
+# ========
+
+def _poly_mul(a, b, tol):
+
+    a = _poly_trim(a, tol)
+    b = _poly_trim(b, tol)
+    if a.size == 0 or b.size == 0:
+        return numpy.zeros(1, dtype=float)
+    out = numpy.convolve(a, b)
+    return _poly_trim(out, tol)
+
+
+# ===============
+# poly div approx
+# ===============
+
+def _poly_div_approx(a, b, tol):
+    """
+    Polynomial division q,r = a/b in ascending powers (numpy.polynomial
+    convention). Returns q (ascending). Remainder is ignored if it is
+    small-ish.
+    """
+
+    a = _poly_trim(a, tol)
+    b = _poly_trim(b, tol)
+    if b.size == 0 or (b.size == 1 and abs(b[0]) <= tol):
+        raise RuntimeError(
+            "division by (near) zero polynomial in branch point resultant")
+    # numpy.polydiv uses descending powers, so flip.
+    qd, rd = numpy.polydiv(a[::-1], b[::-1])
+    q = qd[::-1]
+    r = rd[::-1]
+    # Accept small remainder (Bareiss should be exact in exact arithmetic).
+    # If not small, we still proceed with the quotient (robustness over
+    # exactness).
+    scale = max(1.0, numpy.linalg.norm(a))
+    if numpy.linalg.norm(_poly_trim(r, tol)) > 1e6 * tol * scale:
+        pass
+    return _poly_trim(q, tol)
+
+
+# =================
+# det baresiss poly
+# =================
+
+def _det_bareiss_poly(M, tol):
+    """
+    Fraction-free determinant for a matrix with polynomial entries in z.
+    Polynomials are stored as 1D arrays of ascending coefficients.
+    Returns det as ascending coefficients.
+    """
+
+    n = len(M)
+    A = [[_poly_trim(M[i][j], tol) for j in range(n)] for i in range(n)]
+    denom = numpy.array([1.0], dtype=float)
+
+    for k in range(n - 1):
+        pivot = A[k][k]
+        if pivot.size == 1 and abs(pivot[0]) <= tol:
+            swap = None
+            for i in range(k + 1, n):
+                if not (A[i][k].size == 1 and abs(A[i][k][0]) <= tol):
+                    swap = i
+                    break
+            if swap is None:
+                return numpy.zeros(1, dtype=float)
+            A[k], A[swap] = A[swap], A[k]
+            pivot = A[k][k]
+
+        for i in range(k + 1, n):
+            for j in range(k + 1, n):
+                num = _poly_sub(
+                    _poly_mul(A[i][j], pivot, tol),
+                    _poly_mul(A[i][k], A[k][j], tol),
+                    tol,
+                )
+                if k > 0:
+                    A[i][j] = _poly_div_approx(num, denom, tol)
+                else:
+                    A[i][j] = _poly_trim(num, tol)
+
+        denom = pivot
+
+        for i in range(k + 1, n):
+            A[i][k] = numpy.array([0.0], dtype=float)
+            A[k][i] = numpy.array([0.0], dtype=float)
+
+    return _poly_trim(A[n - 1][n - 1], tol)
+
+
+# ======================
+# resultant discriminant
+# ======================
+
+def _resultant_discriminant(a_coeffs, tol):
+    """
+    Numerically compute Disc_m(P)(z) as a polynomial in z (ascending coeffs),
+    via Sylvester determinant evaluation on a circle + interpolation.
+
+    a_coeffs[i,j] is coeff of z^i m^j, shape (deg_z+1, s+1).
+    """
+
+    import numpy
+
+    a_coeffs = numpy.asarray(a_coeffs, dtype=numpy.complex128)
+    deg_z = a_coeffs.shape[0] - 1
+    s = a_coeffs.shape[1] - 1
+    if s < 1 or deg_z < 0:
+        return numpy.zeros(1, dtype=numpy.complex128)
+
+    # Degree bound: deg_z(Disc) <= (2s-1)*deg_z
+    D = (2 * s - 1) * deg_z
+    if D <= 0:
+        return numpy.zeros(1, dtype=numpy.complex128)
+
+    def eval_disc(z):
+        # Build P(m) coeffs in descending powers of m: p_desc[k] = coeff of
+        # m^(s-k)
+        p_asc = numpy.zeros(s + 1, dtype=numpy.complex128)
+        for j in range(s + 1):
+            p_asc[j] = numpy.polyval(a_coeffs[:, j][::-1], z)  # a_j(z)
+        p_desc = p_asc[::-1]
+
+        # Q(m) = dP/dm, descending
+        q_asc = numpy.zeros(s, dtype=numpy.complex128)
+        for j in range(1, s + 1):
+            q_asc[j - 1] = j * p_asc[j]
+        q_desc = q_asc[::-1]
+
+        # Sylvester matrix of P (deg s) and Q (deg s-1): size (2s-1)x(2s-1)
+        n = 2 * s - 1
+        S = numpy.zeros((n, n), dtype=numpy.complex128)
+
+        # First (s-1) rows: shifts of P
+        for r in range(s - 1):
+            S[r, r:r + (s + 1)] = p_desc
+
+        # Next s rows: shifts of Q
+        for r in range(s):
+            rr = (s - 1) + r
+            S[rr, r:r + s] = q_desc
+
+        return numpy.linalg.det(S)
+
+    # Sample points on a circle; scale radius using coefficient magnitude
+    # (simple heuristic) (This only affects conditioning of interpolation, not
+    # correctness.)
+    scale = float(numpy.max(numpy.abs(a_coeffs))) \
+        if numpy.max(numpy.abs(a_coeffs)) > 0 else 1.0
+    R = 1.0 + 0.1 * scale
+
+    N = D + 1
+    k = numpy.arange(N, dtype=float)
+    z_samp = R * numpy.exp(2.0j * numpy.pi * k / float(N))
+    d_samp = numpy.array([eval_disc(z) for z in z_samp],
+                         dtype=numpy.complex128)
+
+    # Interpolate disc(z) = sum_{j=0}^D c[j] z^j  (ascending)
+    V = (z_samp[:, None] ** numpy.arange(D + 1)[None, :]).astype(
+        numpy.complex128)
+    c, _, _, _ = numpy.linalg.lstsq(V, d_samp, rcond=None)
+
+    # Trim tiny coefficients
+    c = _poly_trim(c, tol)
+    if c.size == 0:
+        c = numpy.zeros(1, dtype=numpy.complex128)
+
+    # If numerics leave small imag, kill it (disc should be real-coeff if
+    # a_coeffs real)
+    if numpy.linalg.norm(c.imag) <= \
+            1e3 * tol * max(1.0, numpy.linalg.norm(c.real)):
+        c = c.real.astype(numpy.float64)
+
+    return c
+
+
+# =====================
+# compute branch points
+# =====================
+
+def compute_branch_points(a_coeffs, tol=1e-12, real_tol=None):
+    """
+    Compute global branch points of the affine curve P(z,m)=0 by
+    z-roots of Disc_m(P)(z) = Res_m(P, dP/dm).
+
+    Returns
+    -------
+    z_bp : complex ndarray
+    a_s_zero : complex ndarray
+    info : dict
+    """
+
+    a_coeffs = numpy.asarray(a_coeffs, dtype=float)
+    s = a_coeffs.shape[1] - 1
+    if s < 1:
+        if real_tol is None:
+            real_tol = 1e3 * tol
+        return \
+            numpy.array([], dtype=complex), \
+            numpy.array([], dtype=complex), \
+            {
+                "disc": numpy.zeros(1, dtype=float),
+                "tol": float(tol),
+                "real_tol": float(real_tol),
+            }
+
+    if real_tol is None:
+        real_tol = 1e3 * tol
+
+    a_s = _poly_trim(a_coeffs[:, s], tol)
+    a_s_zero = numpy.roots(a_s[::-1]) if a_s.size > 1 else \
+        numpy.array([], dtype=complex)
+
+    disc = _resultant_discriminant(a_coeffs, tol)
+    if disc.size <= 1:
+        z_bp = numpy.array([], dtype=complex)
+    else:
+        z_bp = numpy.roots(disc[::-1])
+
+    info = {
+        "disc": disc,
+        "tol": float(tol),
+        "real_tol": float(real_tol),
+    }
+
+    return z_bp, a_s_zero, info

freealg/_algebraic_form/_continuation_algebraic.py

@@ -289,7 +289,7 @@ def fit_polynomial_relation(z, m, s, deg_z, ridge_lambda=0.0, weights=None,
 
     # Diagnostic metrics
     fit_metrics = {
-        's_min': svals[-1],
+        's_min': float(svals[-1]),
         'gap_ratio': float(svals[-2] / svals[-1]),
         'n_small': float(int(numpy.sum(svals <= svals[0] * 1e-12))),
     }

freealg/_algebraic_form/_decompress.py

@@ -14,7 +14,50 @@
 import numpy
 from ._continuation_algebraic import powers
 
-__all__ = ['decompress_newton_old', 'decompress_newton']
+__all__ = ['build_time_grid', 'decompress_newton_old', 'decompress_newton']
+
+
+# ===============
+# build time grid
+# ===============
+
+def build_time_grid(sizes, n0, min_n_time=0):
+    """
+    sizes: list/array of requested matrix sizes (e.g. [2000,3000,4000,8000])
+    n0:    initial size (self.n)
+    min_n_time: minimum number of time points to run Newton sweep on
+
+    Returns
+    -------
+    t_all: sorted time grid to run solver on
+    idx_req: indices of requested times inside t_all (same order as sizes)
+    """
+
+    sizes = numpy.asarray(sizes, dtype=float)
+    alpha = sizes / float(n0)
+    t_req = numpy.log(alpha)
+
+    # Always include t=0 and T=max(t_req)
+    T = float(numpy.max(t_req)) if t_req.size else 0.0
+    base = numpy.unique(numpy.r_[0.0, t_req, T])
+    t_all = numpy.sort(base)
+
+    # Add points only if needed: split largest gaps
+    N = int(min_n_time) if min_n_time is not None else 0
+    while t_all.size < N and t_all.size >= 2:
+        gaps = numpy.diff(t_all)
+        k = int(numpy.argmax(gaps))
+        mid = 0.5 * (t_all[k] + t_all[k+1])
+        t_all = numpy.sort(numpy.unique(numpy.r_[t_all, mid]))
+
+    # Map each requested time to an index in t_all (stable, no float drama)
+    # (t_req values came from same construction, so they should match exactly;
+    # still: use searchsorted + assert)
+    idx_req = numpy.searchsorted(t_all, t_req)
+    # optional sanity:
+    # assert numpy.allclose(t_all[idx_req], t_req, rtol=0, atol=0)
+
+    return t_all, idx_req
 
 
 # ===============

freealg/_algebraic_form/_support.py

@@ -0,0 +1,309 @@
+# SPDX-FileCopyrightText: Copyright 2026, 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.
+
+
+# =======
+# Imports
+# =======
+
+import numpy
+import numpy.polynomial.polynomial as poly
+
+__all__ = ['compute_support']
+
+
+# ======================
+# poly coeffs in m and z
+# ======================
+
+def _poly_coeffs_in_m_at_z(a_coeffs, z):
+
+    s = a_coeffs.shape[1] - 1
+    a = numpy.empty(s + 1, dtype=numpy.complex128)
+    for j in range(s + 1):
+        a[j] = poly.polyval(z, a_coeffs[:, j])
+    return a
+
+
+# ===============
+# roots poly in m
+# ===============
+
+def _roots_poly_in_m(c_asc, tol=0.0):
+
+    c = numpy.asarray(c_asc, dtype=numpy.complex128).ravel()
+    if c.size <= 1:
+        return numpy.array([], dtype=numpy.complex128)
+
+    k = c.size - 1
+    while k > 0 and abs(c[k]) <= tol:
+        k -= 1
+    c = c[:k + 1]
+    if c.size <= 1:
+        return numpy.array([], dtype=numpy.complex128)
+
+    return numpy.roots(c[::-1])
+
+
+# ================
+# dPdm coeffs at z
+# ================
+
+def _dPdm_coeffs_at_z(a_coeffs, z):
+
+    a = _poly_coeffs_in_m_at_z(a_coeffs, z)
+    s = a.size - 1
+    if s <= 0:
+        return numpy.array([0.0 + 0.0j], dtype=numpy.complex128)
+    d = numpy.empty(s, dtype=numpy.complex128)
+    for j in range(1, s + 1):
+        d[j - 1] = j * a[j]
+    return d
+
+
+# ==============
+# P and partials
+# ==============
+
+def _P_and_partials(a_coeffs, z, m):
+
+    s = a_coeffs.shape[1] - 1
+
+    a = numpy.empty(s + 1, dtype=numpy.complex128)
+    da = numpy.empty(s + 1, dtype=numpy.complex128)
+    for j in range(s + 1):
+        a[j] = poly.polyval(z, a_coeffs[:, j])
+        da[j] = poly.polyval(z, poly.polyder(a_coeffs[:, j]))
+
+    mpow = 1.0 + 0.0j
+    P = 0.0 + 0.0j
+    Pz = 0.0 + 0.0j
+    for j in range(s + 1):
+        P += a[j] * mpow
+        Pz += da[j] * mpow
+        mpow *= m
+
+    Pm = 0.0 + 0.0j
+    Pmm = 0.0 + 0.0j
+    Pzm = 0.0 + 0.0j
+    for j in range(1, s + 1):
+        Pm += j * a[j] * (m ** (j - 1))
+        Pzm += j * da[j] * (m ** (j - 1))
+    for j in range(2, s + 1):
+        Pmm += j * (j - 1) * a[j] * (m ** (j - 2))
+
+    return P, Pz, Pm, Pzm, Pmm, a
+
+
+# ===========
+# newton edge
+# ===========
+
+def _newton_edge(a_coeffs, x0, m0, tol=1e-12, max_iter=50):
+
+    x = float(x0)
+    m = float(m0)
+
+    for _ in range(max_iter):
+        z = x + 0.0j
+        P, Pz, Pm, Pzm, Pmm, _ = _P_and_partials(a_coeffs, z, m)
+
+        f0 = float(numpy.real(P))
+        f1 = float(numpy.real(Pm))
+
+        j00 = float(numpy.real(Pz))
+        j01 = float(numpy.real(Pm))
+        j10 = float(numpy.real(Pzm))
+        j11 = float(numpy.real(Pmm))
+
+        det = j00 * j11 - j01 * j10
+        if det == 0.0 or (not numpy.isfinite(det)):
+            return x, m, False
+
+        dx = (-f0 * j11 + f1 * j01) / det
+        dm = (-j00 * f1 + j10 * f0) / det
+
+        x += dx
+        m += dm
+
+        if abs(dx) + abs(dm) < tol:
+            return x, m, True
+
+    return x, m, False
+
+
+# =============
+# cluster edges
+# =============
+
+def _cluster_edges(edges, x_tol):
+
+    if len(edges) == 0:
+        return numpy.array([], dtype=float)
+
+    edges = numpy.array(sorted(edges), dtype=float)
+    out = [edges[0]]
+    for e in edges[1:]:
+        if abs(e - out[-1]) > x_tol:
+            out.append(e)
+    return numpy.array(out, dtype=float)
+
+
+# =======================
+# pick physical root at z
+# =======================
+
+def _pick_physical_root_at_z(a_coeffs, z, im_sign=+1):
+
+    a = _poly_coeffs_in_m_at_z(a_coeffs, z)
+    r = _roots_poly_in_m(a)
+    if r.size == 0:
+        return numpy.nan + 1j * numpy.nan
+
+    w_ref = -1.0 / z
+    idx = int(numpy.argmin(numpy.abs(r - w_ref)))
+    w = r[idx]
+
+    # optional strictness: if it violates Herglotz, declare failure
+    if not numpy.isfinite(w.real) or not numpy.isfinite(w.imag):
+        return w
+    if (im_sign * w.imag) <= 0.0:
+        return w
+
+    return w
+
+
+# ===============
+# compute support
+# ===============
+
+def compute_support(a_coeffs,
+                    x_min,
+                    x_max,
+                    n_scan=4000,
+                    y_eps=1e-3,
+                    im_sign=+1,
+                    root_tol=0.0,
+                    edge_rel_tol=1e-6,
+                    edge_x_cluster_tol=1e-3,
+                    newton_tol=1e-12):
+    """
+    Fast support from fitted polynomial using branch-point system P=0, Pm=0.
+
+    Returns
+    -------
+    support : list of (a,b)
+    info    : dict (edges, rel_res_curve, etc.)
+    """
+
+    a_coeffs = numpy.asarray(a_coeffs)
+    x_grid = numpy.linspace(float(x_min), float(x_max), int(n_scan))
+
+    # For each x, find best real critical point m (Pm=0) minimizing rel
+    # residual.
+    rel = numpy.full(x_grid.size, numpy.inf, dtype=float)
+    m_star = numpy.full(x_grid.size, numpy.nan, dtype=float)
+
+    for i, x in enumerate(x_grid):
+        z = x + 0.0j
+        dcoef = _dPdm_coeffs_at_z(a_coeffs, z)
+        mr = _roots_poly_in_m(dcoef, tol=root_tol)
+
+        best = numpy.inf
+        best_m = numpy.nan
+
+        for w in mr:
+            # accept nearly-real roots; numerical roots can have small imag
+            # part
+            if abs(w.imag) > 1e-6 * (1.0 + abs(w.real)):
+                continue
+            m = float(w.real)
+            P, _, _, _, _, a = _P_and_partials(a_coeffs, z, m)
+
+            denom = 1.0
+            am = 1.0
+            for j in range(a.size):
+                denom += abs(a[j]) * abs(am)
+                am *= m
+
+            r = abs(numpy.real(P)) / denom
+            if numpy.isfinite(r) and r < best:
+                best = float(r)
+                best_m = m
+
+        rel[i] = best
+        m_star[i] = best_m
+
+    # Pick candidate edges as local minima of rel(x), below an automatic scale.
+    rel_f = rel[numpy.isfinite(rel)]
+    if rel_f.size == 0:
+        return [], {"edges": numpy.array([], dtype=float), "n_edges": 0}
+
+    med = float(numpy.median(rel_f))
+    min_rel = float(numpy.min(rel_f))
+
+    # accept local minima up to a factor above the best one, but never abov
+    # background scale
+    thr = min(0.1 * med, max(float(edge_rel_tol), 1e4 * min_rel))
+
+    edges0 = []
+    seeds = []
+
+    for i in range(1, x_grid.size - 1):
+        if not numpy.isfinite(rel[i]):
+            continue
+        if rel[i] <= rel[i - 1] and rel[i] <= rel[i + 1] and rel[i] < thr and \
+                numpy.isfinite(m_star[i]):
+            edges0.append(float(x_grid[i]))
+            seeds.append((float(x_grid[i]), float(m_star[i])))
+
+    # Refine each seed by 2D Newton (x,m)
+    edges = []
+    for x0, m0 in seeds:
+        xe, me, ok = _newton_edge(a_coeffs, x0, m0, tol=newton_tol)
+        if ok and numpy.isfinite(xe) and numpy.isfinite(me):
+            edges.append(float(xe))
+
+    edges = _cluster_edges(edges, edge_x_cluster_tol)
+    edges.sort()
+
+    # Build support by testing midpoints between consecutive real edges
+    support = []
+    m_im_tol = 1e-10
+
+    for i in range(edges.size - 1):
+        a = float(edges[i])
+        b = float(edges[i + 1])
+        if b <= a:
+            continue
+
+        xmid = 0.5 * (a + b)
+
+        # roots of P(xmid, m) with real coefficients
+        a_m = _poly_coeffs_in_m_at_z(a_coeffs, xmid + 0.0j)
+        r = _roots_poly_in_m(a_m, tol=root_tol)
+
+        # interval is support iff there exists a non-real root (complex pair)
+        if numpy.any(numpy.abs(numpy.imag(r)) > m_im_tol):
+            support.append((a, b))
+
+    info = {
+        "edges": edges,
+        "n_edges": int(edges.size),
+        "support": support,
+        "n_support": int(len(support)),
+        "x_grid": x_grid,
+        "rel": rel,
+        "thr": float(thr),
+        "x_min": float(x_min),
+        "x_max": float(x_max),
+        "n_scan": int(n_scan),
+        "y_eps": float(y_eps),
+    }
+
+    return support, info

freealg/_algebraic_form/algebraic_form.py

@@ -18,10 +18,11 @@ from ._continuation_algebraic import sample_z_joukowski, \
         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 ._decompress import build_time_grid, decompress_newton
 from ._decompress2 import decompress_coeffs
 from ._homotopy import StieltjesPoly
-from ._discriminant import compute_singular_points
+from ._branch_points import compute_branch_points
+from ._support import compute_support
 from ._moments import MomentsESD
 from .._free_form._support import supp
 from .._free_form._plot_util import plot_density, plot_hilbert, plot_stieltjes
@@ -133,9 +134,6 @@ class AlgebraicForm(object):
     # init
     # ====
 
-    # def __init__(self, A, support=None, delta=1e-6, dtype='complex128',
-    #              **kwargs):
-
     def __init__(self, A, support=None, delta=1e-5, dtype='complex128',
                  **kwargs):
         """
@@ -147,6 +145,7 @@ class AlgebraicForm(object):
         self._stieltjes = None
         self._moments = None
         self.support = support
+        self.est_support = None  # Estimated from polynmial after fitting
         self.delta = delta    # Offset above real axis to apply Plemelj formula
 
         # Data type for complex arrays
@@ -155,6 +154,7 @@ 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.support = A.support()
             self.n = 1
 
         elif callable(A):
@@ -182,16 +182,15 @@ class AlgebraicForm(object):
                 numpy.mean(1.0/(self.eig-z[:, numpy.newaxis]), axis=-1)
             self._moments = MomentsESD(self.eig)  # NOTE (never used)
 
-        # Support
-        if support is None:
+        # broad support
+        if self.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]
+            self.broad_support = (self.lam_m, self.lam_p)
         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)
@@ -251,7 +250,16 @@ class AlgebraicForm(object):
         # self.cache.clear()
 
         z_fits = []
-        for sup in self.support:
+
+        # Sampling around support, or broad_support. This is only needed to
+        # ensure sampled points are not hiting the support itself is not used
+        # in any computation. If support is not known, use broad support.
+        if self.support is not None:
+            possible_support = self.support
+        else:
+            possible_support = self.broad_support
+
+        for sup in possible_support:
             a, b = sup
 
             for i in range(len(r)):
@@ -261,7 +269,7 @@ class AlgebraicForm(object):
         z_fit = numpy.concatenate(z_fits)
 
         # Remove points too close to any cut
-        z_fit = filter_z_away_from_cuts(z_fit, self.support, y_eps=y_eps,
+        z_fit = filter_z_away_from_cuts(z_fit, possible_support, y_eps=y_eps,
                                         x_pad=x_pad)
 
         # Fitting (w_inf = None means adaptive weight selection)
@@ -271,11 +279,11 @@ class AlgebraicForm(object):
                 triangular=triangular, normalize=normalize, mu=mu,
                 mu_reg=mu_reg)
 
-        # 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
 
+        # Estimate support from the fitted polynomial
+        self.est_support, _ = self.estimate_support(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)])
@@ -288,8 +296,6 @@ class AlgebraicForm(object):
                                                eta=max(y_eps, 1e-2), n_x=128,
                                                max_bad_frac=0.05)
 
-        status['branch_points'] = branch_points
-        status['a_s_zero'] = a_s_zero
         status['res_max'] = float(res_max)
         status['res_99_9'] = float(res_99_9)
         status['fit_metrics'] = fit_metrics
@@ -319,7 +325,64 @@ class AlgebraicForm(object):
             else:
                 print('\nStieltjes sanity check: OK')
 
-        return a_coeffs, support, status
+        return a_coeffs, self.est_support, status
+
+    # =====================
+    # inflate broad support
+    # =====================
+
+    def _inflate_broad_support(self, inflate=0.0):
+        """
+        """
+
+        min_supp, max_supp = self.broad_support
+
+        c_supp = 0.5 * (max_supp + min_supp)
+        r_supp = 0.5 * (max_supp - min_supp)
+
+        x_min = c_supp - r_supp * (1.0 + inflate)
+        x_max = c_supp + r_supp * (1.0 + inflate)
+
+        return x_min, x_max
+
+    # ================
+    # estimate support
+    # ================
+
+    def estimate_support(self, a_coeffs=None, n_scan=4000):
+        """
+        """
+
+        if a_coeffs is None:
+            if self.a_coeffs is None:
+                raise RuntimeError('Call "fit" first.')
+            else:
+                a_coeffs = self.a_coeffs
+
+        # Inflate a bit to make sure all points are searched
+        x_min, x_max = self._inflate_broad_support(inflate=0.2)
+
+        est_support, info = compute_support(a_coeffs, x_min=x_min, x_max=x_max,
+                                            n_scan=n_scan)
+
+        return est_support, info
+
+    # ======================
+    # estimate branch points
+    # ======================
+
+    def estimate_branch_points(self):
+        """
+        Compute global branch points and zeros of leading a_j
+        """
+
+        if self.a_coeffs is None:
+            raise RuntimeError('Call "fit" first.')
+
+        bp, leading_zeros, info = compute_branch_points(
+            self.a_coeffs, tol=1e-12, real_tol=None)
+
+        return bp, leading_zeros, info
 
     # =============
     # generate grid
@@ -464,7 +527,7 @@ class AlgebraicForm(object):
         hilb = -self._stieltjes(x).real / numpy.pi
 
         if plot:
-            plot_hilbert(x, hilb, support=self.support, latex=latex,
+            plot_hilbert(x, hilb, support=self.broad_support, latex=latex,
                          save=save)
 
         return hilb
@@ -592,8 +655,9 @@ class AlgebraicForm(object):
 
     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}):
+                       'min_n_times': 10, 'max_iter': 50, 'tol': 1e-12,
+                       'armijo': 1e-4, 'min_lam': 1e-6, 'w_min': 1e-14,
+                       'sweep': True}):
         """
         Free decompression of spectral density.
         """
@@ -634,25 +698,23 @@ class AlgebraicForm(object):
             # Query grid on the real axis + a small imaginary buffer
             z_query = x + 1j * self.delta
 
-            # Initial condition at t=0 (physical branch)
+            # Initial condition at t = 0 (physical branch)
             w0_list = self._stieltjes(z_query)
 
-            # Times
-            t = numpy.log(alpha)
-
-            # Ensure it starts from t = 0
-            if t[0] > 1.0:
-                t = numpy.concatenate([numpy.zeros(1), t])
+            # Ensure there are at least min_n_times time t, including requested
+            # times, and especially time t = 0
+            t_all, idx_req = build_time_grid(
+                size, self.n, min_n_time=newton_opt.get("min_n_time", 0))
 
             # Evolve
             W, ok = decompress_newton(
-                z_query, t, self.a_coeffs,
+                z_query, t_all, self.a_coeffs,
                 w0_list=w0_list, **newton_opt)
 
-            rho = W.imag / numpy.pi
+            rho_all = W.imag / numpy.pi
 
-            # Remove time zero
-            rho = rho[1:, :]
+            # return only the user-requested ones
+            rho = rho_all[idx_req]
 
             if verbose:
                 print("success rate per t:", ok.mean(axis=1))
@@ -699,10 +761,19 @@ class AlgebraicForm(object):
         Evolves spectral edges.
         """
 
-        edges, ok_edges = evolve_edges(t, self.a_coeffs, support=self.support,
-                                       eta=eta, dt_max=dt_max,
-                                       max_iter=max_iter, tol=tol)
+        if self.support is not None:
+            known_support = self.support
+        elif self.est_support is not None:
+            known_support = self.est_support
+        else:
+            raise RuntimeError('Call "fit" first.')
+
+        edges, ok_edges = evolve_edges(t, self.a_coeffs,
+                                       support=known_support, eta=eta,
+                                       dt_max=dt_max, max_iter=max_iter,
+                                       tol=tol)
 
+        # Remove spurious edges, where two edge cross and are no longer valid.
         edges2, active_k = merge_edges(edges, tol=1e-4)
 
         if verbose:

{freealg-0.7.10.dist-info → freealg-0.7.11.dist-info}/METADATA

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

@@ -1,17 +1,18 @@
 freealg/__init__.py,sha256=SjcYb6HWmaclnnM-m1eC1honZRyfNBWYDYBx23kSdjo,833
-freealg/__version__.py,sha256=-wENBv06wDArd9jlfvr1fdogsjPVMgMwskP7VuEz-2A,23
+freealg/__version__.py,sha256=wcKNUm4uZK839U_xaeQFOEaUVqbjHp-EU_6MMaml4qk,23
 freealg/_util.py,sha256=RzccUCORgzrI9NdNqwMVugiHU0uDKkJFcIyjFMUOnv8,2518
 freealg/_algebraic_form/__init__.py,sha256=MIB_jVgw2qI-JW_ypqaFSeNAB6c4GvpjNySnap_a6hg,398
+freealg/_algebraic_form/_branch_points.py,sha256=jzvHszw7xFe9B15a5RZV3pGfCGtndvrKJ4GIX6F3qhc,7814
 freealg/_algebraic_form/_constraints.py,sha256=37U7nvtCTocuS7l_nfUznkPi195PY7eXFzeiikrv3B0,2448
-freealg/_algebraic_form/_continuation_algebraic.py,sha256=KundB9VfX61a35VRxLFyuvB5A51QdT4PD2ffAMjrKR0,19383
-freealg/_algebraic_form/_decompress.py,sha256=EZ005k_a8wXFsyQZie_N-_hoOvQxj2eV8aUlsNNH7UQ,21102
+freealg/_algebraic_form/_continuation_algebraic.py,sha256=vVHFlMJYeXm97pgwEceJB2rGJeGOVhk_Ywg6mjoIA-g,19390
+freealg/_algebraic_form/_decompress.py,sha256=uKiq5jlwmOvGriptIDz97fQiKs_F10uH6eMX1Ix43PQ,22538
 freealg/_algebraic_form/_decompress2.py,sha256=Ng9w9xmGe9M-DApp35IeNeQlvszfzT4NZx5BQn0lQ3I,2459
-freealg/_algebraic_form/_discriminant.py,sha256=755pproom6-xThFARaH20m4GuBwwZS2rc0Y80Yg6NzY,5331
 freealg/_algebraic_form/_edge.py,sha256=7l9QyLJDxaEY4WB6MCUFtfEZSf04wyHwH7YPHFJXSbM,10690
 freealg/_algebraic_form/_homotopy.py,sha256=q5z8YmrT_8m7L3qw_4FD1Sd5eELIvAiAHr2ucOLW258,9508
 freealg/_algebraic_form/_moments.py,sha256=u55RpvQhIMJFGsq8LZ3IlnTKxNgQPhwnPuYUS34YEyw,12400
 freealg/_algebraic_form/_sheets_util.py,sha256=6OLzWQKu-gN8rxM2rbpbN8TjNZFmD8UJ-8t9kcZdkCo,4174
-freealg/_algebraic_form/algebraic_form.py,sha256=TXGgTPexOUx_uXhMF9dPA8kk_uNKXoOWn32TYvmCcO8,30677
+freealg/_algebraic_form/_support.py,sha256=9go_3NjmesSW1e08CiDu8oflpGmAbsh9iZRidMvlARI,7951
+freealg/_algebraic_form/algebraic_form.py,sha256=L5qJFYOX5Qm8LlrBv6YwyuTxROUdn6cCjfXoDklmrlQ,32962
 freealg/_free_form/__init__.py,sha256=5cnSX7kHci3wKx6-BEFhmVY_NjjmQAq1JjWPTEqETTg,611
 freealg/_free_form/_chebyshev.py,sha256=zkyVA8NLf7uUKlJdLz4ijd_SurdsqUgkA5nHGWSybaE,6916
 freealg/_free_form/_damp.py,sha256=k2vtBtWOxQBf4qXaWu_En81lQBXbEO4QbxxWpvuVhdE,1802
@@ -44,9 +45,9 @@ freealg/distributions/_wigner.py,sha256=epgx6ne6R_7to5j6-QsWIAVFJQFquWMmYgnZYMN4
 freealg/visualization/__init__.py,sha256=NLq_zwueF7ytZ8sl8zLPqm-AODxxXNvfMozHGmmklcE,435
 freealg/visualization/_glue_util.py,sha256=2oKnEYjUOS4OZfivmciVLauVr53kyHMwi6c2zRKilTQ,693
 freealg/visualization/_rgb_hsv.py,sha256=rEskxXxSlKKxIrHRslVkgxHtD010L3ge9YtcVsOPl8E,3650
-freealg-0.7.10.dist-info/licenses/AUTHORS.txt,sha256=0b67Nz4_JgIzUupHJTAZxu5QdSUM_HRM_X_w4xCb17o,30
-freealg-0.7.10.dist-info/licenses/LICENSE.txt,sha256=J-EEYEtxb3VVf_Bn1TYfWnpY5lMFIM15iLDDcnaDTPA,1443
-freealg-0.7.10.dist-info/METADATA,sha256=zQjA9ZEsQiqu7ooVnkTrWqcMD7Hg29_Ig0xSxFEG3-Y,5517
-freealg-0.7.10.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-freealg-0.7.10.dist-info/top_level.txt,sha256=eR2wrgYwDdnnJ9Zf5PruPqe4kQav0GMvRsqct6y00Q8,8
-freealg-0.7.10.dist-info/RECORD,,
+freealg-0.7.11.dist-info/licenses/AUTHORS.txt,sha256=0b67Nz4_JgIzUupHJTAZxu5QdSUM_HRM_X_w4xCb17o,30
+freealg-0.7.11.dist-info/licenses/LICENSE.txt,sha256=J-EEYEtxb3VVf_Bn1TYfWnpY5lMFIM15iLDDcnaDTPA,1443
+freealg-0.7.11.dist-info/METADATA,sha256=Cinwx4ei_4R4aY743wVBq_DreuX8KPlwARHCWT--AWo,5517
+freealg-0.7.11.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+freealg-0.7.11.dist-info/top_level.txt,sha256=eR2wrgYwDdnnJ9Zf5PruPqe4kQav0GMvRsqct6y00Q8,8
+freealg-0.7.11.dist-info/RECORD,,

freealg/_algebraic_form/_discriminant.py

@@ -1,226 +0,0 @@
-# SPDX-FileCopyrightText: Copyright 2026, 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.
-
-
-# =======
-# Imports
-# =======
-
-import numpy as np
-import numpy.polynomial.polynomial as poly
-
-__all__ = ['compute_singular_points']
-
-
-# =========
-# ploy trim
-# =========
-
-def _poly_trim(p, tol):
-
-    p = np.asarray(p, dtype=complex).ravel()
-    if p.size == 0:
-        return np.zeros(1, dtype=complex)
-    k = p.size - 1
-    while k > 0 and abs(p[k]) <= tol:
-        k -= 1
-    return p[:k + 1].copy()
-
-
-# ============
-# poly is zero
-# ============
-
-def _poly_is_zero(p, tol):
-
-    p = _poly_trim(p, tol)
-    return (p.size == 1) and (abs(p[0]) <= tol)
-
-
-# ========
-# poly add
-# ========
-
-def _poly_add(a, b, tol):
-
-    return _poly_trim(poly.polyadd(a, b), tol)
-
-
-# ========
-# poly sub
-# ========
-
-def _poly_sub(a, b, tol):
-
-    return _poly_trim(poly.polysub(a, b), tol)
-
-
-# =======
-# ply mul
-# =======
-
-def _poly_mul(a, b, tol):
-
-    return _poly_trim(poly.polymul(a, b), tol)
-
-
-# ==============
-# poly div exact
-# ==============
-
-def _poly_div_exact(a, b, tol):
-
-    a = _poly_trim(a, tol)
-    b = _poly_trim(b, tol)
-    if _poly_is_zero(b, tol):
-        raise ZeroDivisionError("poly division by zero")
-
-    q, r = poly.polydiv(a, b)
-    r = _poly_trim(r, tol)
-
-    # Bareiss expects exact division; with floats it's only approximate.
-    # If the remainder is small, drop it.
-    scale = max(1.0, np.linalg.norm(a))
-    if np.linalg.norm(r) > 1e3 * tol * scale:
-        # Fallback: still drop remainder (keeps algorithm running).
-        # This is acceptable because we only need the resultant roots
-        # robustly, not exact symbolic coefficients.
-        pass
-
-    return _poly_trim(q, tol)
-
-
-# ================
-# det bareiss poly
-# ================
-
-def _det_bareiss_poly(M, tol):
-
-    n = len(M)
-    A = [[_poly_trim(M[i][j], tol) for j in range(n)] for i in range(n)]
-
-    denom = np.array([1.0], dtype=complex)
-    sign = 1.0
-
-    for k in range(n - 1):
-        if _poly_is_zero(A[k][k], tol):
-            piv = -1
-            for i in range(k + 1, n):
-                if not _poly_is_zero(A[i][k], tol):
-                    piv = i
-                    break
-            if piv == -1:
-                return np.array([0.0], dtype=complex)
-            A[k], A[piv] = A[piv], A[k]
-            sign *= -1.0
-
-        pivot = A[k][k]
-        for i in range(k + 1, n):
-            for j in range(k + 1, n):
-                num = _poly_sub(_poly_mul(A[i][j], pivot, tol),
-                                _poly_mul(A[i][k], A[k][j], tol),
-                                tol)
-                if k > 0:
-                    A[i][j] = _poly_div_exact(num, denom, tol)
-                else:
-                    A[i][j] = _poly_trim(num, tol)
-
-        denom = pivot
-
-    return _poly_trim(sign * A[n - 1][n - 1], tol)
-
-
-# ===================
-# cluster real points
-# ===================
-
-def _cluster_real_points(x, eps):
-
-    x = np.asarray(x, dtype=float).ravel()
-    if x.size == 0:
-        return x
-    x = np.sort(x)
-    uniq = []
-    for v in x:
-        if (len(uniq) == 0) or (abs(v - uniq[-1]) > eps):
-            uniq.append(float(v))
-        else:
-            uniq[-1] = 0.5 * (uniq[-1] + float(v))
-    return np.asarray(uniq, dtype=float)
-
-
-# =======================
-# compute singular points
-# =======================
-
-def compute_singular_points(a_coeffs, tol=1e-12, real_tol=None):
-    """
-    a_coeffs[i,j] is coefficient of z^i m^j, shape (deg_z+1, s+1).
-
-    Returns
-    -------
-
-    z_bp     : complex array, roots of Disc_m(P)(z)
-    a_s_zero : complex array, roots of leading coefficient a_s(z)
-    support  : list of (a,b) from real-ish branch points paired consecutively
-    """
-
-    a_coeffs = np.asarray(a_coeffs)
-    s = a_coeffs.shape[1] - 1
-    if s < 1:
-        return (np.array([], dtype=complex),
-                np.array([], dtype=complex),
-                [])
-
-    if real_tol is None:
-        real_tol = 1e3 * tol
-
-    a = [_poly_trim(a_coeffs[:, j], tol) for j in range(s + 1)]
-
-    a_s = a[s]
-    a_s_zero = np.roots(a_s[::-1]) if a_s.size > 1 else \
-        np.array([], dtype=complex)
-
-    b = []
-    for j in range(s):
-        b.append(_poly_trim((j + 1) * a[j + 1], tol))
-
-    mdeg = s
-    ndeg = s - 1
-    N = mdeg + ndeg  # 2s-1
-
-    z0 = np.array([0.0], dtype=complex)
-    M = [[z0 for _ in range(N)] for __ in range(N)]
-
-    for r in range(ndeg):
-        for j in range(mdeg + 1):
-            M[r][r + j] = a[j]
-
-    for r in range(mdeg):
-        rr = ndeg + r
-        for j in range(ndeg + 1):
-            M[rr][r + j] = b[j]
-
-    res = _det_bareiss_poly(M, tol)
-    if res.size <= 1:
-        z_bp = np.array([], dtype=complex)
-    else:
-        z_bp = np.roots(res[::-1])
-
-    support = []
-    if z_bp.size > 0:
-        zr = z_bp[np.abs(z_bp.imag) <= real_tol].real
-        zr = _cluster_real_points(zr, eps=1e2 * real_tol)
-        m2 = (zr.size // 2) * 2
-        for k in range(0, m2, 2):
-            a0 = float(zr[k])
-            b0 = float(zr[k + 1])
-            if b0 > a0:
-                support.append((a0, b0))
-
-    return z_bp, a_s_zero, support