freealg 0.7.12__py3-none-any.whl → 0.7.15__py3-none-any.whl

freealg/__version__.py

@@ -1 +1 @@
-__version__ = "0.7.12"
+__version__ = "0.7.15"

freealg/_algebraic_form/_cusp.py

@@ -0,0 +1,357 @@
+# 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 scipy.optimize
+from ._decompress import eval_P_partials
+
+__all__ = ["solve_cusp"]
+
+
+# ==========
+# newton 3x3
+# ==========
+
+def _newton_3x3(F, x0, max_iter=60, tol=1e-12, bounds=None, max_step=None):
+    x = numpy.array(x0, dtype=float)
+
+    # bounds: list/tuple of (lo, hi) per component (None means unbounded)
+    if bounds is not None:
+        b = []
+        for lo, hi in bounds:
+            b.append((None if lo is None else float(lo),
+                      None if hi is None else float(hi)))
+        bounds = b
+
+    if max_step is not None:
+        max_step = numpy.asarray(max_step, dtype=float)
+        if max_step.shape != (3,):
+            raise ValueError("max_step must have shape (3,)")
+
+    def _apply_bounds(xv):
+        if bounds is None:
+            return xv
+        for i, (lo, hi) in enumerate(bounds):
+            if lo is not None and xv[i] < lo:
+                xv[i] = lo
+            if hi is not None and xv[i] > hi:
+                xv[i] = hi
+        return xv
+
+    x = _apply_bounds(x.copy())
+
+    fx = F(x)
+    if numpy.linalg.norm(fx) <= tol:
+        return x, True, fx
+
+    for _ in range(max_iter):
+        J = numpy.zeros((3, 3), dtype=float)
+        eps = 1e-6
+        for j in range(3):
+            xp = x.copy()
+            xp[j] += eps
+            xp = _apply_bounds(xp)
+            J[:, j] = (F(xp) - fx) / eps
+
+        try:
+            dx = numpy.linalg.solve(J, -fx)
+        except numpy.linalg.LinAlgError:
+            return x, False, fx
+
+        if max_step is not None:
+            dx = numpy.clip(dx, -max_step, max_step)
+
+        lam = 1.0
+        improved = False
+        for _ls in range(12):
+            x_try = x + lam * dx
+            x_try = _apply_bounds(x_try)
+            f_try = F(x_try)
+            if numpy.linalg.norm(f_try) < numpy.linalg.norm(fx):
+                x, fx = x_try, f_try
+                improved = True
+                break
+            lam *= 0.5
+
+        if not improved:
+            return x, False, fx
+
+        if numpy.linalg.norm(fx) <= tol:
+            return x, True, fx
+
+    return x, False, fx
+
+
+__all__ = ["solve_cusp"]
+
+
+def _second_partials_fd(zeta, y, a_coeffs, eps_z=None, eps_y=None):
+    zeta = float(zeta)
+    y = float(y)
+
+    if eps_z is None:
+        eps_z = 1e-7 * (1.0 + abs(zeta))
+    if eps_y is None:
+        eps_y = 1e-7 * (1.0 + abs(y))
+
+    _, Pz_p, Py_p = eval_P_partials(zeta + eps_z, y, a_coeffs)
+    _, Pz_m, Py_m = eval_P_partials(zeta - eps_z, y, a_coeffs)
+    Pzz = (Pz_p - Pz_m) / (2.0 * eps_z)
+    Pzy1 = (Py_p - Py_m) / (2.0 * eps_z)
+
+    _, Pz_p, Py_p = eval_P_partials(zeta, y + eps_y, a_coeffs)
+    _, Pz_m, Py_m = eval_P_partials(zeta, y - eps_y, a_coeffs)
+    Pzy2 = (Pz_p - Pz_m) / (2.0 * eps_y)
+    Pyy = (Py_p - Py_m) / (2.0 * eps_y)
+
+    Pzy = 0.5 * (Pzy1 + Pzy2)
+    return float(Pzz), float(Pzy), float(Pyy)
+
+
+def _cusp_F_real(zeta, y, s, a_coeffs):
+    # tau = 1 + exp(s)  => c = tau-1 = exp(s) > 0
+    c = float(numpy.exp(float(s)))
+
+    P, Pz, Py = eval_P_partials(float(zeta), float(y), a_coeffs)
+    P = float(numpy.real(P))
+    Pz = float(numpy.real(Pz))
+    Py = float(numpy.real(Py))
+
+    F1 = P
+    F2 = (y * y) * Py - c * Pz
+
+    Pzz, Pzy, Pyy = _second_partials_fd(zeta, y, a_coeffs)
+    F3 = y * (Pzz * (Py * Py) - 2.0 * Pzy * Pz * Py + Pyy * (Pz * Pz)) + \
+        2.0 * (Pz * Pz) * Py
+
+    return numpy.array([F1, F2, F3], dtype=float)
+
+
+# ================
+# poly coeffs in y
+# ================
+
+def _poly_coeffs_in_y(a_coeffs, zeta):
+    a = numpy.asarray(a_coeffs)
+    deg_z = a.shape[0] - 1
+    deg_y = a.shape[1] - 1
+    z_pows = numpy.power(zeta, numpy.arange(deg_z + 1, dtype=numpy.int64))
+    c = numpy.empty((deg_y + 1,), dtype=numpy.complex128)
+    for j in range(deg_y + 1):
+        c[j] = numpy.dot(a[:, j], z_pows)
+    return c  # ascending in y
+
+
+# ===================
+# pick realish root y
+# ===================
+
+def _pick_realish_root_y(a_coeffs, zeta):
+
+    c_asc = _poly_coeffs_in_y(a_coeffs, zeta)
+    c_desc = c_asc[::-1]  # descending for numpy.roots
+
+    k = 0
+    while k < len(c_desc) and abs(c_desc[k]) == 0:
+        k += 1
+    c_desc = c_desc[k:] if k < len(c_desc) else c_desc
+
+    if len(c_desc) <= 1:
+        return 0.0
+
+    roots = numpy.roots(c_desc)
+    j = int(numpy.argmin(numpy.abs(numpy.imag(roots))))
+    return float(numpy.real(roots[j]))
+
+
+# ==========
+# solve cusp
+# ==========
+
+def solve_cusp(
+        a_coeffs,
+        t_init,
+        zeta_init,
+        y_init=None,
+        max_iter=80,
+        tol=1e-12,
+        t_bounds=None,
+        zeta_bounds=None):
+    """
+    Exact-derivative cusp solve for (zeta, y, t) with unknowns (zeta, y, s),
+    where tau = 1 + exp(s), t = log(tau), x = zeta - (tau-1)/y.
+
+    a_coeffs: array shape (deg_z+1, deg_y+1), P(zeta,y)=
+    sum_{i,j} a[i,j]*zeta^i*y^j
+    """
+
+    a = numpy.asarray(a_coeffs, dtype=numpy.complex128)
+    deg_z = a.shape[0] - 1
+    deg_y = a.shape[1] - 1
+
+    def _P_partials_all(zeta, y):
+        # returns (P, Pz, Py, Pzz, Pzy, Pyy) as complex
+        zeta = numpy.complex128(zeta)
+        y = numpy.complex128(y)
+
+        zi = numpy.power(zeta, numpy.arange(deg_z + 1, dtype=numpy.int64))
+        yj = numpy.power(y, numpy.arange(deg_y + 1, dtype=numpy.int64))
+
+        P = numpy.sum(a * zi[:, None] * yj[None, :])
+
+        # Pz
+        if deg_z >= 1:
+            iz = numpy.arange(1, deg_z + 1, dtype=numpy.int64)
+            zi_m1 = numpy.power(zeta, iz - 1)
+            Pz = numpy.sum(
+                    (a[iz, :] * iz[:, None]) * zi_m1[:, None] * yj[None, :])
+        else:
+            Pz = 0.0 + 0.0j
+
+        # Py
+        if deg_y >= 1:
+            jy = numpy.arange(1, deg_y + 1, dtype=numpy.int64)
+            yj_m1 = numpy.power(y, jy - 1)
+            Py = numpy.sum(
+                    (a[:, jy] * jy[None, :]) * zi[:, None] * yj_m1[None, :])
+        else:
+            Py = 0.0 + 0.0j
+
+        # Pzz
+        if deg_z >= 2:
+            iz = numpy.arange(2, deg_z + 1, dtype=numpy.int64)
+            zi_m2 = numpy.power(zeta, iz - 2)
+            Pzz = numpy.sum((a[iz, :] * (iz * (iz - 1))[:, None]) *
+                            zi_m2[:, None] * yj[None, :])
+        else:
+            Pzz = 0.0 + 0.0j
+
+        # Pyy
+        if deg_y >= 2:
+            jy = numpy.arange(2, deg_y + 1, dtype=numpy.int64)
+            yj_m2 = numpy.power(y, jy - 2)
+            Pyy = numpy.sum((a[:, jy] * (jy * (jy - 1))[None, :]) *
+                            zi[:, None] * yj_m2[None, :])
+        else:
+            Pyy = 0.0 + 0.0j
+
+        # Pzy
+        if (deg_z >= 1) and (deg_y >= 1):
+            iz = numpy.arange(1, deg_z + 1, dtype=numpy.int64)
+            jy = numpy.arange(1, deg_y + 1, dtype=numpy.int64)
+            zi_m1 = numpy.power(zeta, iz - 1)
+            yj_m1 = numpy.power(y, jy - 1)
+            coeff = a[numpy.ix_(iz, jy)] * (iz[:, None] * jy[None, :])
+            Pzy = numpy.sum(coeff * zi_m1[:, None] * yj_m1[None, :])
+        else:
+            Pzy = 0.0 + 0.0j
+
+        return P, Pz, Py, Pzz, Pzy, Pyy
+
+    def _F(vec):
+        zeta, y, s = float(vec[0]), float(vec[1]), float(vec[2])
+        c = float(numpy.exp(s))  # c = tau - 1 > 0
+        P, Pz, Py, Pzz, Pzy, Pyy = _P_partials_all(zeta, y)
+
+        # Work in reals: cusp lives on real zeta,y for real cusp
+        P = float(numpy.real(P))
+        Pz = float(numpy.real(Pz))
+        Py = float(numpy.real(Py))
+        Pzz = float(numpy.real(Pzz))
+        Pzy = float(numpy.real(Pzy))
+        Pyy = float(numpy.real(Pyy))
+
+        F1 = P
+        F2 = (y * y) * Py - c * Pz
+        F3 = y * (Pzz * (Py * Py) - 2.0 * Pzy * Pz * Py + Pyy * (Pz * Pz)) + \
+            2.0 * (Pz * Pz) * Py
+        return numpy.array([F1, F2, F3], dtype=float)
+
+    z0 = float(zeta_init)
+
+    # seed y: keep your provided seed; else pick a real-ish root at z0
+    if y_init is None:
+        # build polynomial in y at fixed z0 and pick root with smallest imag
+        zi = numpy.power(z0, numpy.arange(deg_z + 1, dtype=numpy.int64))
+        c_asc = numpy.array([numpy.dot(a[:, j], zi) for j in range(deg_y + 1)],
+                            dtype=numpy.complex128)
+        c_desc = c_asc[::-1]
+        kk = 0
+        while kk < len(c_desc) and abs(c_desc[kk]) == 0:
+            kk += 1
+        c_desc = c_desc[kk:] if kk < len(c_desc) else c_desc
+        roots = numpy.roots(c_desc) if len(c_desc) > 1 else numpy.array([0.0])
+        j = int(numpy.argmin(numpy.abs(numpy.imag(roots))))
+        y0 = float(numpy.real(roots[j]))
+    else:
+        y0 = float(y_init)
+
+    tau0 = float(numpy.exp(float(t_init)))
+    c0 = max(tau0 - 1.0, 1e-14)
+    s0 = float(numpy.log(c0))
+
+    # bounds for zeta, y, s
+    z_lo, z_hi = -numpy.inf, numpy.inf
+    if zeta_bounds is not None:
+        z_lo, z_hi = float(zeta_bounds[0]), float(zeta_bounds[1])
+        if z_hi < z_lo:
+            z_lo, z_hi = z_hi, z_lo
+
+    s_lo, s_hi = -numpy.inf, numpy.inf
+    if t_bounds is not None:
+        t_lo, t_hi = float(t_bounds[0]), float(t_bounds[1])
+        if t_hi < t_lo:
+            t_lo, t_hi = t_hi, t_lo
+        c_lo = max(float(numpy.expm1(t_lo)), 1e-14)
+        c_hi = max(float(numpy.expm1(t_hi)), 1e-14)
+        s_lo, s_hi = float(numpy.log(c_lo)), float(numpy.log(c_hi))
+
+    # keep y on the seeded sheet (this is crucial)
+    y_rad = 4.0 * (1.0 + abs(y0))
+    y_lo, y_hi = float(y0 - y_rad), float(y0 + y_rad)
+
+    lb = numpy.array([z_lo, y_lo, s_lo], dtype=float)
+    ub = numpy.array([z_hi, y_hi, s_hi], dtype=float)
+    x0 = numpy.array([z0, y0, s0], dtype=float)
+    x0 = numpy.minimum(numpy.maximum(x0, lb), ub)
+
+    res = scipy.optimize.least_squares(
+        _F,
+        x0,
+        bounds=(lb, ub),
+        method="trf",
+        max_nfev=int(max_iter) * 100,
+        ftol=tol,
+        xtol=tol,
+        gtol=tol,
+        x_scale="jac")
+
+    zeta, y, s = res.x
+    c = float(numpy.exp(float(s)))
+    tau = 1.0 + c
+    t = float(numpy.log(tau))
+    x = float(zeta - (tau - 1.0) / y)
+
+    F_final = _F(res.x)
+    ok = bool(res.success and
+              (numpy.max(numpy.abs(F_final)) <= max(1e-9, 50.0 * tol)))
+
+    return {
+        "ok": ok,
+        "t": t,
+        "tau": float(tau),
+        "zeta": float(zeta),
+        "y": float(y),
+        "x": x,
+        "F": F_final,
+        "success": bool(res.success)}

freealg/_algebraic_form/_cusp_wrap.py

@@ -0,0 +1,268 @@
+# 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 scipy.optimize as opt
+
+
+# ================
+# poly coeffs in y
+# ================
+
+def _poly_coeffs_in_y(a_coeffs, zeta):
+    """
+    Build coefficients c_j(zeta) so that P(zeta, y) = sum_j c_j(zeta) y^j.
+
+    Assumes a_coeffs[i, j] multiplies z^i y^j (same layout as eval_P in
+    _continuation_algebraic). Returns coefficients in ascending powers of y.
+    """
+
+    a = numpy.asarray(a_coeffs)
+    deg_z = a.shape[0] - 1
+    deg_y = a.shape[1] - 1
+
+    # c_j(zeta) = sum_i a[i,j] zeta^i
+    z_pows = numpy.power(zeta, numpy.arange(deg_z + 1, dtype=numpy.int64))
+    c = numpy.empty((deg_y + 1,), dtype=numpy.complex128)
+    for j in range(deg_y + 1):
+        c[j] = numpy.dot(a[:, j], z_pows)
+
+    return c
+
+
+# ===================
+# pick realish root y
+# ===================
+
+def _pick_realish_root_y(a_coeffs, zeta):
+    """
+    Pick a reasonable real-ish root y of P(zeta, y)=0 to seed Newton.
+
+    Returns a float (real part of the selected root).
+    """
+
+    c_asc = _poly_coeffs_in_y(a_coeffs, zeta)  # ascending in y
+    # numpy.roots wants descending order
+    c_desc = c_asc[::-1]
+    # strip leading ~0 coefficients
+    k = 0
+    while k < len(c_desc) and abs(c_desc[k]) == 0:
+        k += 1
+    c_desc = c_desc[k:] if k < len(c_desc) else c_desc
+
+    if len(c_desc) <= 1:
+        return 0.0
+
+    roots = numpy.roots(c_desc)
+    # choose the root closest to the real axis
+    j = int(numpy.argmin(numpy.abs(numpy.imag(roots))))
+    return float(numpy.real(roots[j]))
+
+
+# =========
+# cusp wrap
+# =========
+
+def cusp_wrap(self, t_grid, edge_kwargs=None, max_iter=80, tol=1e-12,
+              verbose=False):
+
+    if edge_kwargs is None:
+        edge_kwargs = {}
+
+    t_grid = numpy.asarray(t_grid, dtype=float).ravel()
+
+    # allow scalar / len-1 input
+    if t_grid.size == 1:
+        t0 = float(t_grid[0])
+        dt = 0.25
+        t_grid = numpy.linspace(max(0.0, t0 - dt), t0 + dt, 21)
+
+    if t_grid.size < 5:
+        raise ValueError("t_grid too small")
+
+    def gap_at(tt):
+        ce, _, _ = self.edge(numpy.array([float(tt)]), verbose=False,
+                             **edge_kwargs)
+        return float(ce[0, 2].real - ce[0, 1].real)
+
+    # coarse grid gap
+    ce, _, _ = self.edge(t_grid, verbose=False, **edge_kwargs)
+    gap = ce[:, 2].real - ce[:, 1].real
+    m = numpy.isfinite(gap)
+
+    if numpy.count_nonzero(m) < 2:
+        return {"success": False, "reason": "gap is not finite on grid"}
+
+    tg = t_grid[m]
+    gg = gap[m]
+
+    # candidate bracket indices from coarse grid
+    s = numpy.sign(gg)
+    idx = numpy.where(s[:-1] * s[1:] < 0)[0]
+
+    bracketed = False
+    t_star = None
+
+    # robust: verify sign change using the true gap_at before calling brentq
+    if idx.size > 0:
+        for ii in idx[:5]:  # try a few brackets
+            tL, tR = float(tg[ii]), float(tg[ii + 1])
+            gL = gap_at(tL)
+            gR = gap_at(tR)
+            if numpy.isfinite(gL) and numpy.isfinite(gR) and (gL * gR < 0.0):
+                t_star = float(opt.brentq(gap_at, tL, tR, xtol=1e-12,
+                                          rtol=1e-12, maxiter=200))
+                bracketed = True
+                break
+
+    # fallback: minimizer of |gap| on the coarse grid
+    if t_star is None:
+        i0 = int(numpy.argmin(numpy.abs(gg)))
+        t_star = float(tg[i0])
+        bracketed = False
+
+    # --- seed (zeta,y) correctly using zeta = x + (tau-1)/y ---
+    ce_star, _, _ = self.edge(numpy.array([t_star]), verbose=False,
+                              **edge_kwargs)
+    x_seed = float(ce_star[0, 1].real)  # inner edge b1
+    tau = float(numpy.exp(t_star))
+    c = tau - 1.0
+
+    a = numpy.asarray(self.a_coeffs, dtype=numpy.complex128)
+    deg_z = a.shape[0] - 1
+    deg_y = a.shape[1] - 1
+
+    def poly_in_y(zeta):
+        zi = numpy.power(zeta, numpy.arange(deg_z + 1, dtype=numpy.int64))
+        c_asc = numpy.array([numpy.dot(a[:, j], zi) for j in range(deg_y + 1)],
+                            dtype=numpy.complex128)
+        return c_asc
+
+    zeta0 = float(x_seed)
+    c_asc = poly_in_y(zeta0)
+    roots = numpy.roots(c_asc[::-1])
+    j = int(numpy.argmin(numpy.abs(numpy.imag(roots))))
+    y0 = float(numpy.real(roots[j]))
+    if abs(y0) < 1e-12:
+        jj = numpy.argsort(numpy.abs(numpy.imag(roots)))
+        for k in jj:
+            if abs(numpy.real(roots[k])) > 1e-8:
+                y0 = float(numpy.real(roots[k]))
+                break
+
+    zeta_seed = float(x_seed + c / y0)
+    y_seed = float(y0)
+
+    def P_all(zeta, y):
+        zeta = numpy.complex128(zeta)
+        y = numpy.complex128(y)
+        zi = numpy.power(zeta, numpy.arange(deg_z + 1))
+        yj = numpy.power(y, numpy.arange(deg_y + 1))
+        P = numpy.sum(a * zi[:, None] * yj[None, :])
+
+        if deg_z >= 1:
+            iz = numpy.arange(1, deg_z + 1)
+            Pz = numpy.sum((a[iz, :] * iz[:, None]) *
+                           numpy.power(zeta, iz - 1)[:, None] * yj[None, :])
+        else:
+            Pz = 0.0 + 0.0j
+
+        if deg_y >= 1:
+            jy = numpy.arange(1, deg_y + 1)
+            Py = numpy.sum((a[:, jy] * jy[None, :]) * zi[:, None] *
+                           numpy.power(y, jy - 1)[None, :])
+        else:
+            Py = 0.0 + 0.0j
+
+        if deg_z >= 2:
+            iz = numpy.arange(2, deg_z + 1)
+            Pzz = numpy.sum((a[iz, :] * (iz * (iz - 1))[:, None]) *
+                            numpy.power(zeta, iz - 2)[:, None] * yj[None, :])
+        else:
+            Pzz = 0.0 + 0.0j
+
+        if deg_y >= 2:
+            jy = numpy.arange(2, deg_y + 1)
+            Pyy = numpy.sum((a[:, jy] * (jy * (jy - 1))[None, :]) *
+                            zi[:, None] * numpy.power(y, jy - 2)[None, :])
+        else:
+            Pyy = 0.0 + 0.0j
+
+        if (deg_z >= 1) and (deg_y >= 1):
+            iz = numpy.arange(1, deg_z + 1)
+            jy = numpy.arange(1, deg_y + 1)
+            coeff = a[numpy.ix_(iz, jy)] * (iz[:, None] * jy[None, :])
+            Pzy = numpy.sum(coeff * numpy.power(zeta, iz - 1)[:, None] *
+                            numpy.power(y, jy - 1)[None, :])
+        else:
+            Pzy = 0.0 + 0.0j
+
+        return P, Pz, Py, Pzz, Pzy, Pyy
+
+    def G(v):
+        zeta, y = float(v[0]), float(v[1])
+        P, Pz, Py, _, _, _ = P_all(zeta, y)
+        P = float(numpy.real(P))
+        Pz = float(numpy.real(Pz))
+        Py = float(numpy.real(Py))
+        F2 = (y * y) * Py - c * Pz
+        return numpy.array([P, F2], dtype=float)
+
+    z_rad = 0.5
+    y_rad = 5.0 * (1.0 + abs(y_seed))
+    lb = numpy.array([zeta_seed - z_rad, y_seed - y_rad], dtype=float)
+    ub = numpy.array([zeta_seed + z_rad, y_seed + y_rad], dtype=float)
+
+    res = opt.least_squares(
+        G, numpy.array([zeta_seed, y_seed], dtype=float),
+        bounds=(lb, ub), method="trf",
+        max_nfev=8000, ftol=tol, xtol=tol, gtol=tol, x_scale="jac"
+    )
+
+    zeta_star = float(res.x[0])
+    y_star = float(res.x[1])
+    x_star = float(zeta_star - c / y_star)
+
+    P, Pz, Py, Pzz, Pzy, Pyy = P_all(zeta_star, y_star)
+    P = float(numpy.real(P))
+    Pz = float(numpy.real(Pz))
+    Py = float(numpy.real(Py))
+    Pzz = float(numpy.real(Pzz))
+    Pzy = float(numpy.real(Pzy))
+    Pyy = float(numpy.real(Pyy))
+
+    F2 = (y_star * y_star) * Py - c * Pz
+    F3 = y_star * (Pzz * (Py * Py) - 2.0 * Pzy * Pz * Py + Pyy * (Pz * Pz)) + \
+        2.0 * (Pz * Pz) * Py
+    F = numpy.array([P, float(F2), float(F3)], dtype=float)
+
+    ok = bool(numpy.max(numpy.abs(F)) < 1e-8)
+
+    return {
+        "ok": ok,
+        "t": float(t_star),
+        "tau": float(tau),
+        "zeta": float(zeta_star),
+        "y": float(y_star),
+        "x": float(x_star),
+        "F": F,
+        "success": True,
+        "seed": {
+            "t": float(t_star),
+            "x": float(x_seed),
+            "zeta": float(zeta_seed),
+            "y": float(y_seed)
+        },
+        "merge": {"bracketed": bool(bracketed)},
+        "gap_at_t": float(gap_at(t_star)),
+        "lsq_success": bool(res.success)}

freealg/_algebraic_form/_decompress2.py

@@ -35,6 +35,7 @@ def decompress_coeffs(a, t, normalize=True):
             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)
     a[-1, 0] = 0.0
     if a.ndim != 2:
@@ -123,6 +124,7 @@ def plot_candidates(a, x, delta=1e-4, size=None, latex=False, verbose=False):
     ax : matplotlib.axes.Axes
         The axes the scatter plot was drawn on.
     """
+
     if not (isinstance(delta, (float, int)) and delta > 0):
         raise ValueError("delta must be a positive scalar.")