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

freealg/_algebraic_form/_support.py

@@ -13,16 +13,16 @@
 
 import numpy
 import numpy.polynomial.polynomial as poly
+from ._homotopy5 import StieltjesPoly
 
 __all__ = ['compute_support']
 
 
-# ======================
-# poly coeffs in m and z
-# ======================
+# =====================
+# poly coeffs in m at 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):
@@ -30,48 +30,11 @@ def _poly_coeffs_in_m_at_z(a_coeffs, z):
     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)
@@ -97,7 +60,7 @@ def _P_and_partials(a_coeffs, z, m):
     for j in range(2, s + 1):
         Pmm += j * (j - 1) * a[j] * (m ** (j - 2))
 
-    return P, Pz, Pm, Pzm, Pmm, a
+    return P, Pz, Pm, Pzm, Pmm
 
 
 # ===========
@@ -105,13 +68,12 @@ def _P_and_partials(a_coeffs, z, m):
 # ===========
 
 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)
+        P, Pz, Pm, Pzm, Pmm = _P_and_partials(a_coeffs, z, m)
 
         f0 = float(numpy.real(P))
         f1 = float(numpy.real(Pm))
@@ -142,10 +104,8 @@ def _newton_edge(a_coeffs, x0, m0, tol=1e-12, max_iter=50):
 # =============
 
 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:]:
@@ -154,156 +114,151 @@ def _cluster_edges(edges, x_tol):
     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]
+# ===========
+# bisect edge
+# ===========
 
-    # 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
+def _bisect_edge(stieltjes_poly, x_lo, x_hi, eta, im_thr, max_iter=60):
+    z_lo = x_lo + 1j * eta
+    z_hi = x_hi + 1j * eta
+    f_lo = float(numpy.imag(stieltjes_poly.evaluate_scalar(z_lo)) - im_thr)
+    f_hi = float(numpy.imag(stieltjes_poly.evaluate_scalar(z_hi)) - im_thr)
+
+    if (not numpy.isfinite(f_lo)) or (not numpy.isfinite(f_hi)):
+        return 0.5 * (x_lo + x_hi)
+    if f_lo == 0.0:
+        return float(x_lo)
+    if f_hi == 0.0:
+        return float(x_hi)
+    if f_lo * f_hi > 0.0:
+        return 0.5 * (x_lo + x_hi)
+
+    a = float(x_lo)
+    b = float(x_hi)
+    fa = f_lo
+    # fb = f_hi
 
-    return w
+    for _ in range(max_iter):
+        c = 0.5 * (a + b)
+        z_c = c + 1j * eta
+        fc = float(numpy.imag(stieltjes_poly.evaluate_scalar(z_c)) - im_thr)
+        if not numpy.isfinite(fc):
+            return c
+        if fc == 0.0 or (b - a) < 1e-14 * (1.0 + abs(c)):
+            return c
+        if fa * fc <= 0.0:
+            b = c
+            # fb = fc
+        else:
+            a = c
+            fa = fc
+
+    return 0.5 * (a + b)
 
 
 # ===============
 # 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])))
+def compute_support(a_coeffs, x_min, x_max, n_scan=4000, **kwargs):
 
-    # 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))
+    a_coeffs = numpy.asarray(a_coeffs, dtype=numpy.complex128)
 
-    edges = _cluster_edges(edges, edge_x_cluster_tol)
-    edges.sort()
+    x_min = float(x_min)
+    x_max = float(x_max)
+    n_scan = int(n_scan)
 
-    # Build support by testing midpoints between consecutive real edges
-    support = []
-    m_im_tol = 1e-10
+    scale = max(1.0, abs(x_max - x_min), abs(x_min), abs(x_max))
+    eta = kwargs.get('eta', None)
+    if eta is None:
+        eta = 1e-6 * scale
+    eta = float(eta)
+
+    vopt = {
+        'lam_space': 1.0,
+        'lam_asym': 1.0,
+        'lam_tiny_im': 200.0,
+        'tiny_im': 0.5 * eta,
+        'tol_im': 1e-14,
+    }
+    vopt.update(kwargs.get('viterbi_opt', {}) or {})
+    stieltjes = StieltjesPoly(a_coeffs, viterbi_opt=vopt)
+
+    x_grid = numpy.linspace(x_min, x_max, n_scan)
+    z_grid = x_grid + 1j * eta
+    m_grid = stieltjes(z_grid)
+    im_grid = numpy.imag(m_grid)
+
+    max_im = float(numpy.nanmax(im_grid)) \
+        if numpy.any(numpy.isfinite(im_grid)) else 0.0
 
-    for i in range(edges.size - 1):
-        a = float(edges[i])
-        b = float(edges[i + 1])
-        if b <= a:
+    thr_rel = float(kwargs.get('thr_rel', 1e-3))
+    thr_abs = kwargs.get('thr_abs', None)
+
+    im_thr = thr_rel * max_im
+    im_thr = max(im_thr, 10.0 * eta)
+    if thr_abs is not None:
+        im_thr = max(im_thr, float(thr_abs))
+
+    mask = numpy.isfinite(im_grid) & (im_grid > im_thr)
+
+    runs = []
+    i = 0
+    while i < mask.size:
+        if not mask[i]:
+            i += 1
+            continue
+        j = i
+        while j + 1 < mask.size and mask[j + 1]:
+            j += 1
+        runs.append((i, j))
+        i = j + 1
+
+    edges = []
+    for i0, i1 in runs:
+        if i0 == 0 or i1 == mask.size - 1:
             continue
 
-        xmid = 0.5 * (a + b)
+        xL = _bisect_edge(stieltjes, x_grid[i0 - 1], x_grid[i0], eta, im_thr)
+        xR = _bisect_edge(stieltjes, x_grid[i1], x_grid[i1 + 1], eta, im_thr)
 
-        # 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)
+        edges.append(float(xL))
+        edges.append(float(xR))
 
-        # interval is support iff there exists a non-real root (complex pair)
-        if numpy.any(numpy.abs(numpy.imag(r)) > m_im_tol):
+    edge_x_cluster_tol = float(kwargs.get('edge_x_cluster_tol', 1e-8 * scale))
+    edges = _cluster_edges(edges, edge_x_cluster_tol)
+
+    refine = bool(kwargs.get('refine', True))
+    if refine and edges.size > 0:
+        newton_tol = float(kwargs.get('newton_tol', 1e-12))
+        edges_ref = []
+        for x0 in edges:
+            m0 = float(numpy.real(stieltjes.evaluate_scalar(x0 + 1j * eta)))
+            xe, _, ok = _newton_edge(a_coeffs, x0, m0, tol=newton_tol)
+            edges_ref.append(float(xe)
+                             if ok and numpy.isfinite(xe) else float(x0))
+        edges = _cluster_edges(edges_ref, edge_x_cluster_tol)
+
+    edges.sort()
+    support = []
+    for k in range(0, edges.size - 1, 2):
+        a = float(edges[k])
+        b = float(edges[k + 1])
+        if b > a:
             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),
+        'x_grid': x_grid,
+        'eta': eta,
+        'm_grid': m_grid,
+        'im_grid': im_grid,
+        'im_thr': float(im_thr),
+        'edges': edges,
+        'support': support,
+        'x_min': x_min,
+        'x_max': x_max,
+        'n_scan': n_scan,
+        'scale': scale,
     }
 
     return support, info

freealg/_algebraic_form/algebraic_form.py

@@ -18,12 +18,35 @@ 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 build_time_grid, decompress_newton
-from ._decompress2 import decompress_coeffs
-from ._homotopy import StieltjesPoly
+from ._cusp_wrap import cusp_wrap
+
+# Decompress with Newton
+# from ._decompress import build_time_grid, decompress_newton
+from ._decompress_util import build_time_grid
+# from ._decompress4 import decompress_newton # WORKS (mass issue)
+# from ._decompress5 import build_time_grid, decompress_newton
+# from ._decompress6 import build_time_grid, decompress_newton
+# from ._decompress4_2 import build_time_grid, decompress_newton
+# from ._decompress_new_2 import build_time_grid, decompress_newton
+# from ._decompress_new import build_time_grid, decompress_newton
+# from ._decompress6 import decompress_newton
+# from ._decompress7 import decompress_newton
+# from ._decompress8 import decompress_newton
+from ._decompress9 import decompress_newton  # With Predictor/Corrector
+
+# Decompress with coefficients
+from ._decompress2 import decompress_coeffs, plot_candidates
+
+# Homotopy
+# from ._homotopy import StieltjesPoly
+# from ._homotopy2 import StieltjesPoly
+# from ._homotopy3 import StieltjesPoly  # Viterbi
+# from ._homotopy4 import StieltjesPoly
+from ._homotopy5 import StieltjesPoly
+
 from ._branch_points import compute_branch_points
 from ._support import compute_support
-from ._moments import MomentsESD
+from ._moments import Moments, AlgebraicStieltjesMoments
 from .._free_form._support import supp
 from .._free_form._plot_util import plot_density, plot_hilbert, plot_stieltjes
 
@@ -180,7 +203,7 @@ class AlgebraicForm(object):
             # Use empirical Stieltjes function
             self._stieltjes = lambda z: \
                 numpy.mean(1.0/(self.eig-z[:, numpy.newaxis]), axis=-1)
-            self._moments = MomentsESD(self.eig)  # NOTE (never used)
+            self._moments = Moments(self.eig)  # NOTE (never used)
 
         # broad support
         if self.support is None:
@@ -189,10 +212,10 @@ class AlgebraicForm(object):
 
             # Detect support
             self.lam_m, self.lam_p = supp(self.eig, **kwargs)
-            self.broad_support = (self.lam_m, self.lam_p)
+            self.broad_support = (float(self.lam_m), float(self.lam_p))
         else:
-            self.lam_m = min([s[0] for s in self.support])
-            self.lam_p = max([s[1] for s in self.support])
+            self.lam_m = float(min([s[0] for s in self.support]))
+            self.lam_p = float(max([s[1] for s in self.support]))
             self.broad_support = (self.lam_m, self.lam_p)
 
         # Initialize
@@ -257,7 +280,7 @@ class AlgebraicForm(object):
         if self.support is not None:
             possible_support = self.support
         else:
-            possible_support = self.broad_support
+            possible_support = [self.broad_support]
 
         for sup in possible_support:
             a, b = sup
@@ -300,7 +323,28 @@ 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)  # NOTE overwrite init
+
+        # -----------------
+
+        # Inflate a bit to make sure all points are searched
+        # x_min, x_max = self._inflate_broad_support(inflate=0.2)
+        # scale = float(max(1.0, abs(x_max - x_min), abs(x_min), abs(x_max)))
+        # eta = 1e-6 * scale
+        #
+        # vopt = {
+        #     'lam_space': 1.0,
+        #     'lam_asym': 1.0,
+        #     'lam_tiny_im': 200.0,
+        #     'tiny_im': 0.5 * eta,
+        #     'tol_im': 1e-14,
+        # }
+
+        # NOTE overwrite init
+        self._stieltjes = StieltjesPoly(self.a_coeffs)
+        # self._stieltjes = StieltjesPoly(self.a_coeffs, viterbi_opt=vopt)
+
+        self._moments_base = AlgebraicStieltjesMoments(a_coeffs)
+        self.moments = Moments(self._moments_base)
 
         if verbose:
             print(f'fit residual max  : {res_max:>0.4e}')
@@ -349,7 +393,7 @@ class AlgebraicForm(object):
     # estimate support
     # ================
 
-    def estimate_support(self, a_coeffs=None, n_scan=4000):
+    def estimate_support(self, a_coeffs=None, scan_range=None, n_scan=4000):
         """
         """
 
@@ -360,7 +404,10 @@ class AlgebraicForm(object):
                 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)
+        if scan_range is not None:
+            x_min, x_max = scan_range
+        else:
+            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)
@@ -371,7 +418,7 @@ class AlgebraicForm(object):
     # estimate branch points
     # ======================
 
-    def estimate_branch_points(self):
+    def estimate_branch_points(self, tol=1e-15, real_tol=None):
         """
         Compute global branch points and zeros of leading a_j
         """
@@ -380,7 +427,7 @@ class AlgebraicForm(object):
             raise RuntimeError('Call "fit" first.')
 
         bp, leading_zeros, info = compute_branch_points(
-            self.a_coeffs, tol=1e-12, real_tol=None)
+            self.a_coeffs, tol=tol, real_tol=real_tol)
 
         return bp, leading_zeros, info
 
@@ -460,7 +507,8 @@ class AlgebraicForm(object):
             x = self._generate_grid(1.25)
 
         # Preallocate density to zero
-        rho = self._stieltjes(x).imag / numpy.pi
+        z = x.astype(complex) + 1j * self.delta
+        rho = self._stieltjes(z).imag / numpy.pi
 
         if plot:
             plot_density(x, rho, eig=self.eig, support=self.broad_support,
@@ -654,10 +702,10 @@ class AlgebraicForm(object):
     # ==========
 
     def decompress(self, size, x=None, method='one', plot=False, latex=False,
-                   save=False, verbose=False, newton_opt={
-                       'min_n_times': 10, 'max_iter': 50, 'tol': 1e-12,
-                       'armijo': 1e-4, 'min_lam': 1e-6, 'w_min': 1e-14,
-                       'sweep': True}):
+                   save=False, verbose=False, min_n_times=10,
+                   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.
         """
@@ -704,7 +752,7 @@ class AlgebraicForm(object):
             # 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))
+                size, self.n, min_n_times=min_n_times)
 
             # Evolve
             W, ok = decompress_newton(
@@ -726,9 +774,13 @@ class AlgebraicForm(object):
 
             # Decompress to each alpha
             for i in range(alpha.size):
-                coeffs_i = decompress_coeffs(self.a_coeffs,
-                                             numpy.log(alpha[i]))
-                stieltjes_i = StieltjesPoly(coeffs_i)
+                t_i = numpy.log(alpha[i])
+                coeffs_i = decompress_coeffs(self.a_coeffs, t_i)
+
+                def mom(k):
+                    return self.moments(k, t_i)
+
+                stieltjes_i = StieltjesPoly(coeffs_i, mom)
                 rho[i, :] = stieltjes_i(x).imag
 
             rho = rho / numpy.pi
@@ -751,6 +803,49 @@ class AlgebraicForm(object):
 
         return rho, x
 
+    # ==========
+    # candidates
+    # ==========
+
+    def candidates(self, size, x=None, verbose=False):
+
+        # 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.')
+
+        # Decompression ratio equal to e^{t}.
+        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
+        lb = self.lam_m - (numpy.max(alpha) - 1) * hilb_lb
+        ub = self.lam_p - (numpy.max(alpha) - 1) * hilb_ub
+
+        # 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, 2000)
+        else:
+            x = numpy.asarray(x)
+
+        for i in range(alpha.size):
+            t_i = numpy.log(alpha[i])
+            coeffs_i = decompress_coeffs(self.a_coeffs, t_i)
+            plot_candidates(coeffs_i, x, size=int(alpha[i]*self.n),
+                            verbose=verbose)
+
     # ====
     # edge
     # ====
@@ -759,6 +854,9 @@ class AlgebraicForm(object):
              verbose=False):
         """
         Evolves spectral edges.
+
+        Fix: if t is a scalar or length-1 array, we prepend t=0 internally so
+        evolve_edges actually advances from the initialization at t=0.
         """
 
         if self.support is not None:
@@ -768,18 +866,53 @@ class AlgebraicForm(object):
         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)
+        t = numpy.asarray(t, dtype=float).ravel()
+
+        if t.size == 1:
+            t1 = float(t[0])
+            if t1 == 0.0:
+                t_grid = numpy.array([0.0], dtype=float)
+                complex_edges, ok_edges = evolve_edges(
+                    t_grid, self.a_coeffs, support=known_support, eta=eta,
+                    dt_max=dt_max, max_iter=max_iter, tol=tol
+                )
+            else:
+                # prepend 0 and drop it after evolution
+                t_grid = numpy.array([0.0, t1], dtype=float)
+                complex_edges2, ok_edges2 = evolve_edges(
+                    t_grid, self.a_coeffs, support=known_support, eta=eta,
+                    dt_max=dt_max, max_iter=max_iter, tol=tol
+                )
+                complex_edges = complex_edges2[-1:, :]
+                ok_edges = ok_edges2[-1:, :]
+        else:
+            # For vector t, require it starts at 0 for correct initialization
+            # (you can relax this if you want by prepending 0 similarly).
+            complex_edges, ok_edges = evolve_edges(
+                t, self.a_coeffs, support=known_support, eta=eta,
+                dt_max=dt_max, max_iter=max_iter, tol=tol
+            )
+
+        real_edges = complex_edges.real
 
-        # Remove spurious edges, where two edge cross and are no longer valid.
-        edges2, active_k = merge_edges(edges, tol=1e-4)
+        # Remove spurious edges / merges for plotting
+        real_merged_edges, active_k = merge_edges(real_edges, tol=1e-4)
 
         if verbose:
             print("edge success rate:", ok_edges.mean())
 
-        return edges2, active_k
+        return complex_edges, real_merged_edges, active_k
+
+    # ====
+    # cusp
+    # ====
+
+    def cusp(self, t_grid):
+        """
+        """
+
+        return cusp_wrap(self, t_grid, edge_kwargs=None, max_iter=50,
+                         tol=1.0e-12)
 
     # ========
     # eigvalsh