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

freealg/__version__.py

@@ -1 +1 @@
-__version__ = "0.7.9"
+__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
 
 
 # ===============
@@ -504,6 +547,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/_algebraic_form/_homotopy.py

@@ -6,12 +6,12 @@ import numpy
 from ._moments import AlgebraicStieltjesMoments
 from tqdm import tqdm
 
-__all__ = ['stieltjes_poly']
+__all__ = ['StieltjesPoly']
 
 
-# =====================
+# ===========
 # select root
-# =====================
+# ===========
 
 def select_root(roots, z, target):
     """
@@ -202,7 +202,7 @@ class StieltjesPoly(object):
 
         # Iterate over indices so we can pass Python scalars into evaluate()
         if progress:
-            indices = tqdm(numpy.ndindex(z_arr.shape),total=z_arr.size)
+            indices = tqdm(numpy.ndindex(z_arr.shape), total=z_arr.size)
         else:
             indices = numpy.ndindex(z_arr.shape)
         for idx in indices:
@@ -265,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/_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