freealg 0.7.16__py3-none-any.whl → 0.7.18__py3-none-any.whl

freealg/_algebraic_form/_decompress4.py

@@ -22,14 +22,14 @@ __all__ = ['decompress_newton']
 # eval P partials
 # ===============
 
-def eval_P_partials(z, m, a_coeffs):
+def eval_P_partials(z, m, coeffs):
     """
     Evaluate P(z,m) and its partial derivatives dP/dz and dP/dm.
 
-    This assumes P is represented by `a_coeffs` in the monomial basis
+    This assumes P is represented by `coeffs` in the monomial basis
 
         P(z, m) = sum_{j=0..s} a_j(z) * m^j,
-        a_j(z) = sum_{i=0..deg_z} a_coeffs[i, j] * z^i.
+        a_j(z) = sum_{i=0..deg_z} coeffs[i, j] * z^i.
 
     The function returns P, dP/dz, dP/dm with broadcasting over z and m.
 
@@ -39,7 +39,7 @@ def eval_P_partials(z, m, a_coeffs):
         First argument to P.
     m : complex or array_like of complex
         Second argument to P. Must be broadcast-compatible with `z`.
-    a_coeffs : ndarray, shape (deg_z+1, s+1)
+    coeffs : ndarray, shape (deg_z+1, s+1)
         Coefficient matrix for P in the monomial basis.
 
     Returns
@@ -61,14 +61,14 @@ def eval_P_partials(z, m, a_coeffs):
     --------
     .. code-block:: python
 
-        P, Pz, Pm = eval_P_partials(1.0 + 1j, 0.2 + 0.3j, a_coeffs)
+        P, Pz, Pm = eval_P_partials(1.0 + 1j, 0.2 + 0.3j, coeffs)
     """
 
     z = numpy.asarray(z, dtype=complex)
     m = numpy.asarray(m, dtype=complex)
 
-    deg_z = int(a_coeffs.shape[0] - 1)
-    s = int(a_coeffs.shape[1] - 1)
+    deg_z = int(coeffs.shape[0] - 1)
+    s = int(coeffs.shape[1] - 1)
 
     if (z.ndim == 0) and (m.ndim == 0):
         zz = complex(z)
@@ -78,7 +78,7 @@ def eval_P_partials(z, m, a_coeffs):
         ap = numpy.empty(s + 1, dtype=complex)
 
         for j in range(s + 1):
-            c = a_coeffs[:, j]
+            c = coeffs[:, j]
 
             val = 0.0 + 0.0j
             for i in range(deg_z, -1, -1):
@@ -118,10 +118,10 @@ def eval_P_partials(z, m, a_coeffs):
     Pm = numpy.zeros(zz.size, dtype=complex)
 
     for j in range(s + 1):
-        aj = zp @ a_coeffs[:, j]
+        aj = zp @ coeffs[:, j]
         P += aj * mp[:, j]
 
-        ajp = dzp @ a_coeffs[:, j]
+        ajp = dzp @ coeffs[:, j]
         Pz += ajp * mp[:, j]
 
         if j >= 1:
@@ -134,7 +134,7 @@ def eval_P_partials(z, m, a_coeffs):
 # fd solve w
 # ==========
 
-# def fd_solve_w(z, t, a_coeffs, w_init, max_iter=50, tol=1e-12,
+# def fd_solve_w(z, t, coeffs, w_init, max_iter=50, tol=1e-12,
 #                armijo=1e-4, min_lam=1e-6, w_min=1e-14):
 #     """
 #     Solve for w = m(t,z) from the implicit FD equation using damped Newton.
@@ -155,7 +155,7 @@ def eval_P_partials(z, m, a_coeffs):
 #         Query point in the complex plane.
 #     t : float
 #         Time parameter (tau = exp(t)).
-#     a_coeffs : ndarray
+#     coeffs : ndarray
 #         Coefficients defining P(zeta,y) in the monomial basis.
 #     w_init : complex
 #         Initial guess for w.
@@ -189,7 +189,7 @@ def eval_P_partials(z, m, a_coeffs):
 #     .. code-block:: python
 #
 #         w, ok = fd_solve_w(
-#             z=0.5 + 1e-6j, t=2.0, a_coeffs=a_coeffs, w_init=m1_fn(0.5 + 1e-6j),
+#             z=0.5 + 1e-6j, t=2.0, coeffs=coeffs, w_init=m1_fn(0.5 + 1e-6j),
 #             max_iter=50, tol=1e-12
 #         )
 #     """
@@ -213,7 +213,7 @@ def eval_P_partials(z, m, a_coeffs):
 #         zeta = z + alpha / w
 #         y = tau * w
 #
-#         F, Pz, Py = eval_P_partials(zeta, y, a_coeffs)
+#         F, Pz, Py = eval_P_partials(zeta, y, coeffs)
 #         F = complex(F)
 #         Pz = complex(Pz)
 #         Py = complex(Py)
@@ -243,7 +243,7 @@ def eval_P_partials(z, m, a_coeffs):
 #             zeta_new = z + alpha / w_new
 #             y_new = tau * w_new
 #
-#             F_new = eval_P_partials(zeta_new, y_new, a_coeffs)[0]
+#             F_new = eval_P_partials(zeta_new, y_new, coeffs)[0]
 #             F_new = complex(F_new)
 #
 #             if abs(F_new) <= (1.0 - armijo * lam) * F_abs:
@@ -256,10 +256,10 @@ def eval_P_partials(z, m, a_coeffs):
 #         if not ok:
 #             return w, False
 #
-#     F_end = eval_P_partials(z + alpha / w, tau * w, a_coeffs)[0]
+#     F_end = eval_P_partials(z + alpha / w, tau * w, coeffs)[0]
 #     return w, (abs(F_end) <= 10.0 * tol)
 
-def fd_solve_w(z, t, a_coeffs, w_init, max_iter=50, tol=1e-12,
+def fd_solve_w(z, t, coeffs, w_init, max_iter=50, tol=1e-12,
                armijo=1e-4, min_lam=1e-6, w_min=1e-14):
     """
     Solve for w = m(t,z) from the implicit FD equation using damped Newton.
@@ -280,7 +280,7 @@ def fd_solve_w(z, t, a_coeffs, w_init, max_iter=50, tol=1e-12,
         Query point in the complex plane.
     t : float
         Time parameter (tau = exp(t)).
-    a_coeffs : ndarray
+    coeffs : ndarray
         Coefficients defining P(zeta,y) in the monomial basis.
     w_init : complex
         Initial guess for w.
@@ -314,7 +314,7 @@ def fd_solve_w(z, t, a_coeffs, w_init, max_iter=50, tol=1e-12,
     .. code-block:: python
 
         w, ok = fd_solve_w(
-            z=0.5 + 1e-6j, t=2.0, a_coeffs=a_coeffs, w_init=m1_fn(0.5 + 1e-6j),
+            z=0.5 + 1e-6j, t=2.0, coeffs=coeffs, w_init=m1_fn(0.5 + 1e-6j),
             max_iter=50, tol=1e-12
         )
     """
@@ -341,7 +341,7 @@ def fd_solve_w(z, t, a_coeffs, w_init, max_iter=50, tol=1e-12,
         # zeta = z + alpha / w
         # y = tau * w
         #
-        # F, Pz, Py = eval_P_partials(zeta, y, a_coeffs)
+        # F, Pz, Py = eval_P_partials(zeta, y, coeffs)
         # F = complex(F)
         # Pz = complex(Pz)
         # Py = complex(Py)
@@ -371,7 +371,7 @@ def fd_solve_w(z, t, a_coeffs, w_init, max_iter=50, tol=1e-12,
         #     zeta_new = z + alpha / w_new
         #     y_new = tau * w_new
         #
-        #     F_new = eval_P_partials(zeta_new, y_new, a_coeffs)[0]
+        #     F_new = eval_P_partials(zeta_new, y_new, coeffs)[0]
         #     F_new = complex(F_new)
         #
         #     if abs(F_new) <= (1.0 - armijo * lam) * F_abs:
@@ -397,7 +397,7 @@ def fd_solve_w(z, t, a_coeffs, w_init, max_iter=50, tol=1e-12,
         #     P(z + beta/y, y) = 0,  beta = tau - 1.
         # Multiply by y^deg_z to clear denominators and get a polynomial in y.
 
-        a = numpy.asarray(a_coeffs, dtype=numpy.complex128)
+        a = numpy.asarray(coeffs, dtype=numpy.complex128)
         deg_z = a.shape[0] - 1
         deg_m = a.shape[1] - 1
 
@@ -460,13 +460,13 @@ def fd_solve_w(z, t, a_coeffs, w_init, max_iter=50, tol=1e-12,
         w = complex(best)
 
         # final residual check
-        F_end = eval_P_partials(z + alpha / w, tau * w, a_coeffs)[0]
+        F_end = eval_P_partials(z + alpha / w, tau * w, coeffs)[0]
         return w, (abs(F_end) <= 1e3 * tol)
 
     # -------------------
 
 
-    F_end = eval_P_partials(z + alpha / w, tau * w, a_coeffs)[0]
+    F_end = eval_P_partials(z + alpha / w, tau * w, coeffs)[0]
     return w, (abs(F_end) <= 10.0 * tol)
 
 
@@ -474,7 +474,7 @@ def fd_solve_w(z, t, a_coeffs, w_init, max_iter=50, tol=1e-12,
 # NEW FUNCTION
 # ============
 
-def fd_candidates_w(z, t, a_coeffs, w_min=1e-14):
+def fd_candidates_w(z, t, coeffs, w_min=1e-14):
     """
     Return candidate roots w solving P(z + alpha/w, tau*w)=0 with Im(w)>0 (if Im(z)>0).
     """
@@ -483,7 +483,7 @@ def fd_candidates_w(z, t, a_coeffs, w_min=1e-14):
     alpha = 1.0 - 1.0 / tau
     want_pos_imag = (z.imag > 0.0)
 
-    a = numpy.asarray(a_coeffs, dtype=numpy.complex128)
+    a = numpy.asarray(coeffs, dtype=numpy.complex128)
     deg_z = a.shape[0] - 1
     deg_m = a.shape[1] - 1
 
@@ -521,7 +521,7 @@ def fd_candidates_w(z, t, a_coeffs, w_min=1e-14):
         # residual filter (optional but helps)
         # -------------
         # TEST
-        # F = eval_P_partials(z + alpha / w, tau * w, a_coeffs)[0]
+        # F = eval_P_partials(z + alpha / w, tau * w, coeffs)[0]
         # if abs(F) < 1e-6:
         #     cands.append(complex(w))
         # ---------------
@@ -536,7 +536,7 @@ def fd_candidates_w(z, t, a_coeffs, w_min=1e-14):
 # decompress newton
 # =================
 
-def decompress_newton(z_list, t_grid, a_coeffs, w0_list=None,
+def decompress_newton(z_list, t_grid, coeffs, w0_list=None,
                       dt_max=0.1, sweep=True, time_rel_tol=5.0,
                       active_imag_eps=None, sweep_pad=20,
                       max_iter=50, tol=1e-12, armijo=1e-4,
@@ -556,7 +556,7 @@ def decompress_newton(z_list, t_grid, a_coeffs, w0_list=None,
         Query points z (typically x + 1j*eta with eta > 0), ordered along x.
     t_grid : array_like of float
         Strictly increasing time grid.
-    a_coeffs : ndarray
+    coeffs : ndarray
         Coefficients defining P(z,m) in the monomial basis.
     w0_list : array_like of complex
         Initial values w(t0,z) at t_grid[0].
@@ -616,7 +616,7 @@ def decompress_newton(z_list, t_grid, a_coeffs, w0_list=None,
     # -----------------
 
     def _candidates(iz, t):
-        cands = fd_candidates_w(z_list[iz], t, a_coeffs, w_min=w_min)
+        cands = fd_candidates_w(z_list[iz], t, coeffs, w_min=w_min)
         if len(cands) == 0:
             # fallback: carry previous value as a candidate
             return [complex(w_prev[iz])]
@@ -724,7 +724,7 @@ def decompress_newton(z_list, t_grid, a_coeffs, w0_list=None,
         if refine_newton:
             for iz in range(nz):
                 w_sol, success = fd_solve_w(
-                    z_list[iz], t, a_coeffs, w_row[iz],
+                    z_list[iz], t, coeffs, w_row[iz],
                     max_iter=max_iter, tol=tol, armijo=armijo,
                     min_lam=min_lam, w_min=w_min)
                 w_row[iz] = w_sol

freealg/_algebraic_form/_decompress5.py

@@ -6,7 +6,7 @@
 #
 # Public API (used by AlgebraicForm.decompress):
 #   build_time_grid(size, n0, min_n_times=0) -> (t_all, idx_req)
-#   decompress_newton(z_list, t_grid, a_coeffs, w0_list=None, **opts) -> (W, ok)
+#   decompress_newton(z_list, t_grid, coeffs, w0_list=None, **opts) -> (W, ok)
 #
 # Core equation (FD):
 #   tau = exp(t) - 1
@@ -102,13 +102,13 @@ def build_time_grid(size, n0, min_n_times=0):
 # Polynomial utilities
 # ===================
 
-def _poly_coef_in_w(z, a_coeffs):
+def _poly_coef_in_w(z, coeffs):
     """
     For fixed z, return coefficients c[j] so that P(z,w)=sum_j c[j] w^j.
-    a_coeffs[i,j] corresponds to z^i w^j.
+    coeffs[i,j] corresponds to z^i w^j.
     """
     z = complex(z)
-    a = np.asarray(a_coeffs, dtype=np.complex128)
+    a = np.asarray(coeffs, dtype=np.complex128)
     deg_z = int(a.shape[0] - 1)
     # Horner in z for each j
     zp = 1.0 + 0.0j
@@ -119,8 +119,8 @@ def _poly_coef_in_w(z, a_coeffs):
     return c  # shape (s+1,)
 
 
-def _eval_P(z, w, a_coeffs):
-    c = _poly_coef_in_w(z, a_coeffs)
+def _eval_P(z, w, coeffs):
+    c = _poly_coef_in_w(z, coeffs)
     # Horner in w
     ww = complex(w)
     out = 0.0 + 0.0j
@@ -129,11 +129,11 @@ def _eval_P(z, w, a_coeffs):
     return out
 
 
-def _eval_dP_dw(z, w, a_coeffs):
+def _eval_dP_dw(z, w, coeffs):
     """
     d/dw P(z,w)
     """
-    c = _poly_coef_in_w(z, a_coeffs)  # c[j] w^j
+    c = _poly_coef_in_w(z, coeffs)  # c[j] w^j
     ww = complex(w)
     # derivative coefficients: j*c[j]
     out = 0.0 + 0.0j
@@ -142,13 +142,13 @@ def _eval_dP_dw(z, w, a_coeffs):
     return out
 
 
-def _eval_dP_dz(z, w, a_coeffs):
+def _eval_dP_dz(z, w, coeffs):
     """
     d/dz P(z,w)
     """
     z = complex(z)
     w = complex(w)
-    a = np.asarray(a_coeffs, dtype=np.complex128)
+    a = np.asarray(coeffs, dtype=np.complex128)
     deg_z = int(a.shape[0] - 1)
     # compute b[j] = sum_{i>=1} i*a[i,j]*z^{i-1}
     if deg_z <= 0:
@@ -165,15 +165,15 @@ def _eval_dP_dz(z, w, a_coeffs):
     return out
 
 
-def _fd_F_and_dF(w, z, tau, a_coeffs):
+def _fd_F_and_dF(w, z, tau, coeffs):
     """
     F(w) = P(z - tau*w, w).
     dF/dw = dP/dz * (-tau) + dP/dw evaluated at (zeta, w).
     """
     zeta = z - tau * w
-    F = _eval_P(zeta, w, a_coeffs)
-    dPdw = _eval_dP_dw(zeta, w, a_coeffs)
-    dPdz = _eval_dP_dz(zeta, w, a_coeffs)
+    F = _eval_P(zeta, w, coeffs)
+    dPdw = _eval_dP_dw(zeta, w, coeffs)
+    dPdz = _eval_dP_dz(zeta, w, coeffs)
     dF = dPdw - tau * dPdz
     return F, dF
 
@@ -185,7 +185,7 @@ def _fd_F_and_dF(w, z, tau, a_coeffs):
 def _newton_fd_scalar(
     z,
     t,
-    a_coeffs,
+    coeffs,
     w_init,
     *,
     max_iter=60,
@@ -212,7 +212,7 @@ def _newton_fd_scalar(
         w = complex(w.real, w_min)
 
     # initial
-    F, dF = _fd_F_and_dF(w, z, tau, a_coeffs)
+    F, dF = _fd_F_and_dF(w, z, tau, coeffs)
     res0 = abs(F)
     if not np.isfinite(res0):
         return complex(np.nan, np.nan), False, 0, np.inf
@@ -239,7 +239,7 @@ def _newton_fd_scalar(
                 w_new = w + lam * step
                 if w_min > 0.0 and w_new.imag < w_min:
                     w_new = complex(w_new.real, w_min)
-                F_new, dF_new = _fd_F_and_dF(w_new, z, tau, a_coeffs)
+                F_new, dF_new = _fd_F_and_dF(w_new, z, tau, coeffs)
                 f1 = abs(F_new)
                 if np.isfinite(f1) and (f1 <= (1.0 - 1e-4 * lam) * f0):
                     w, F, dF = w_new, F_new, dF_new
@@ -252,10 +252,10 @@ def _newton_fd_scalar(
             w = w + step
             if w_min > 0.0 and w.imag < w_min:
                 w = complex(w.real, w_min)
-            F, dF = _fd_F_and_dF(w, z, tau, a_coeffs)
+            F, dF = _fd_F_and_dF(w, z, tau, coeffs)
 
     # final
-    F, _ = _fd_F_and_dF(w, z, tau, a_coeffs)
+    F, _ = _fd_F_and_dF(w, z, tau, coeffs)
     ok = np.isfinite(F.real) and np.isfinite(F.imag) and (abs(F) <= 1e3 * tol * (1.0 + res0))
     return w, bool(ok), max_iter, abs(F)
 
@@ -294,7 +294,7 @@ def _dedup_cands(cands, tol=1e-10):
 def _fd_candidates(
     z,
     t,
-    a_coeffs,
+    coeffs,
     seeds,
     *,
     max_iter=60,
@@ -313,7 +313,7 @@ def _fd_candidates(
     ress = []
     for s in seeds:
         w, ok, _, res = _newton_fd_scalar(
-            z, t, a_coeffs, s,
+            z, t, coeffs, s,
             max_iter=max_iter, tol=tol,
             armijo=armijo, min_lam=min_lam, w_min=w_min
         )
@@ -525,7 +525,7 @@ def _renormalize_density(z_list, w_path, target_mass=1.0):
 def decompress_newton(
     z_list: np.ndarray,
     t_grid: np.ndarray,
-    a_coeffs: np.ndarray,
+    coeffs: np.ndarray,
     w0_list: np.ndarray | None = None,
     *,
     dt_max: float = 0.05,
@@ -633,7 +633,7 @@ def decompress_newton(
                 seeds.append(complex(-1.0 / (z_list[iz] - tau * w_prev[iz] + 1e-30)))
 
                 cands, oks, ress = _fd_candidates(
-                    z_list[iz], float(t_sub), a_coeffs, seeds,
+                    z_list[iz], float(t_sub), coeffs, seeds,
                     max_iter=max_iter, tol=tol,
                     armijo=armijo, min_lam=min_lam, w_min=w_min,
                     keep_best=keep_best,

freealg/_algebraic_form/_decompress6.py

@@ -6,7 +6,7 @@ FD decompression with correct characteristic map + robust root selection.
 
 Keeps public API:
   - build_time_grid(size, n0, min_n_times=..., include_t0=True) -> (t_all, idx_req)
-  - decompress_newton(z_list, t_grid, a_coeffs, w0_list=None, **newton_opt) -> (W, ok)
+  - decompress_newton(z_list, t_grid, coeffs, w0_list=None, **newton_opt) -> (W, ok)
 
 IMPORTANT: This implements the characteristic transform consistent with:
   τ(t)=e^t,  α(t)=1-τ^{-1},
@@ -83,13 +83,13 @@ def build_time_grid(size, n0, min_n_times=0, include_t0=True):
 # Polynomial curve utilities
 # ===========================
 
-def _poly_w_coeffs(z: complex, t: float, a_coeffs: np.ndarray) -> np.ndarray:
+def _poly_w_coeffs(z: complex, t: float, coeffs: np.ndarray) -> np.ndarray:
     """
     Build Q(w) coeffs (descending) for:
       Q(w) = w^{deg_z} * P(z + α/w, τ w)
     where τ=e^t, α=1-1/τ.
     """
-    a = np.asarray(a_coeffs, dtype=np.complex128)
+    a = np.asarray(coeffs, dtype=np.complex128)
     deg_z = a.shape[0] - 1
     deg_m = a.shape[1] - 1
 
@@ -169,8 +169,8 @@ def _newton_poly_root(coeff_desc: np.ndarray, w0: complex, max_iter: int, tol: f
     return w, bool(np.isfinite(f) and abs(f) <= float(tol) * (1.0 + abs(w)))
 
 
-def _roots_of_Q(z: complex, t: float, a_coeffs: np.ndarray):
-    coeff_desc = _poly_w_coeffs(z, t, a_coeffs)
+def _roots_of_Q(z: complex, t: float, coeffs: np.ndarray):
+    coeff_desc = _poly_w_coeffs(z, t, coeffs)
     if coeff_desc.size <= 1:
         return coeff_desc, np.empty((0,), np.complex128)
     r = np.roots(coeff_desc)
@@ -178,7 +178,7 @@ def _roots_of_Q(z: complex, t: float, a_coeffs: np.ndarray):
     return coeff_desc, r.astype(np.complex128, copy=False)
 
 
-def _physical_anchor_for_x(x: float, t: float, a_coeffs: np.ndarray,
+def _physical_anchor_for_x(x: float, t: float, coeffs: np.ndarray,
                            eta_hi: float, eta_lo: float, n_eta: int,
                            herglotz_tol: float,
                            max_iter: int, tol: float,
@@ -186,7 +186,7 @@ def _physical_anchor_for_x(x: float, t: float, a_coeffs: np.ndarray,
     etas = np.linspace(float(eta_hi), float(eta_lo), int(n_eta))
     z0 = complex(x, etas[0])
 
-    coeff0, roots0 = _roots_of_Q(z0, t, a_coeffs)
+    coeff0, roots0 = _roots_of_Q(z0, t, coeffs)
     if roots0.size == 0:
         return -1.0 / z0, False
 
@@ -203,10 +203,10 @@ def _physical_anchor_for_x(x: float, t: float, a_coeffs: np.ndarray,
 
     for eta in etas[1:]:
         z = complex(x, eta)
-        coeff, _ = _roots_of_Q(z, t, a_coeffs)
+        coeff, _ = _roots_of_Q(z, t, coeffs)
         w, ok2 = _newton_poly_root(coeff, w, max_iter=max_iter, tol=tol, armijo=armijo, min_lam=min_lam)
         if not ok2:
-            _coeff, roots = _roots_of_Q(z, t, a_coeffs)
+            _coeff, roots = _roots_of_Q(z, t, coeffs)
             if roots.size == 0:
                 return w, False
             roots = np.asarray(roots, dtype=np.complex128)
@@ -328,7 +328,7 @@ def _viterbi_path(cand_list, z_list, w_prev,
 def decompress_newton(
     z_list,
     t_grid,
-    a_coeffs,
+    coeffs,
     w0_list=None,
     *,
     dt_max=0.05,
@@ -375,7 +375,7 @@ def decompress_newton(
             from ._edge import evolve_edges, merge_edges
             if edge_support is None:
                 raise ValueError("edge_support must be provided when edge_use=True")
-            complex_edges = evolve_edges(t_grid, a_coeffs, support=edge_support)
+            complex_edges = evolve_edges(t_grid, coeffs, support=edge_support)
             # merge_edges in your package expects edges array (nt, 2k) and returns (real_merged_edges, active_k)
             real_edges, _active_k = merge_edges(complex_edges, t_grid)
         except Exception:
@@ -414,7 +414,7 @@ def decompress_newton(
             anchor_ok = np.ones((nz,), dtype=bool)
             for iz in range(nz):
                 w_a, ok_a = _physical_anchor_for_x(
-                    float(x[iz]), float(t_sub), a_coeffs,
+                    float(x[iz]), float(t_sub), coeffs,
                     eta_hi=float(eta_hi), eta_lo=float(eta_lo),
                     n_eta=int(n_eta),
                     herglotz_tol=float(herglotz_tol),
@@ -427,7 +427,7 @@ def decompress_newton(
             cand_list = []
             for iz in range(nz):
                 z = z_list[iz]
-                coeff, roots = _roots_of_Q(z, float(t_sub), a_coeffs)
+                coeff, roots = _roots_of_Q(z, float(t_sub), coeffs)
 
                 anc = anchors[iz]
                 im_floor = None

freealg/_algebraic_form/_decompress7.py

@@ -32,21 +32,21 @@ __all__ = ['decompress_newton']
 # scalar poly evaluation
 # =====================
 
-def _eval_a_and_da(z: complex, a_coeffs: numpy.ndarray) -> tuple[numpy.ndarray, numpy.ndarray]:
+def _eval_a_and_da(z: complex, coeffs: numpy.ndarray) -> tuple[numpy.ndarray, numpy.ndarray]:
     """Evaluate a_j(z) and a'_j(z) for j=0..s where P(z,y)=sum_j a_j(z) y^j.
 
-    a_coeffs has shape (deg_z+1, s+1) storing coefficients in z ascending:
-        a_coeffs[i,j] = coeff of z^i in a_j(z).
+    coeffs has shape (deg_z+1, s+1) storing coefficients in z ascending:
+        coeffs[i,j] = coeff of z^i in a_j(z).
     """
-    deg_z = a_coeffs.shape[0] - 1
-    s = a_coeffs.shape[1] - 1
+    deg_z = coeffs.shape[0] - 1
+    s = coeffs.shape[1] - 1
 
     a = numpy.empty(s + 1, dtype=numpy.complex128)
     da = numpy.empty(s + 1, dtype=numpy.complex128)
 
     # Horner for each column j
     for j in range(s + 1):
-        col = a_coeffs[:, j]
+        col = coeffs[:, j]
         # a_j(z)
         v = complex(col[deg_z])
         for i in range(deg_z - 1, -1, -1):
@@ -65,10 +65,10 @@ def _eval_a_and_da(z: complex, a_coeffs: numpy.ndarray) -> tuple[numpy.ndarray,
     return a, da
 
 
-def _eval_P_Pz_Py(z: complex, y: complex, a_coeffs: numpy.ndarray) -> tuple[complex, complex, complex]:
+def _eval_P_Pz_Py(z: complex, y: complex, coeffs: numpy.ndarray) -> tuple[complex, complex, complex]:
     """Return P(z,y), Pz(z,y)=\partial_z P, Py(z,y)=\partial_y P (scalars)."""
-    a, da = _eval_a_and_da(z, a_coeffs)
-    s = a_coeffs.shape[1] - 1
+    a, da = _eval_a_and_da(z, coeffs)
+    s = coeffs.shape[1] - 1
 
     # Build powers of y incrementally (cheap; s is small)
     ypow = 1.0 + 0.0j
@@ -100,7 +100,7 @@ def _newton_2x2(
     tau: float,
     zeta0: complex,
     y0: complex,
-    a_coeffs: numpy.ndarray,
+    coeffs: numpy.ndarray,
     *,
     max_iter: int,
     tol: float,
@@ -120,7 +120,7 @@ def _newton_2x2(
         y = (w_min + 0.0j)
 
     for it in range(max_iter):
-        P, Pz, Py = _eval_P_Pz_Py(zeta, y, a_coeffs)
+        P, Pz, Py = _eval_P_Pz_Py(zeta, y, coeffs)
         F1 = P
         F2 = z - zeta + tau_m1 / y
 
@@ -198,7 +198,7 @@ def _newton_2x2(
 def decompress_newton(
     z_query,
     t_all,
-    a_coeffs,
+    coeffs,
     *,
     w0_list=None,
     max_iter: int = 40,
@@ -298,7 +298,7 @@ def decompress_newton(
                 zeta0 = zeta_seed[j]
 
             zeta, y, okj, nit = _newton_2x2(
-                z, tau, zeta0, y0, a_coeffs,
+                z, tau, zeta0, y0, coeffs,
                 max_iter=max_iter, tol=tol,
                 damping=damping, step_clip=step_clip,
                 w_min=w_min, require_imw_pos=require_imw_pos,
@@ -311,7 +311,7 @@ def decompress_newton(
                 for k in range(1, int(max_split) + 1):
                     tau_mid = tau_prev + (tau - tau_prev) * (k / float(max_split))
                     zeta_mid, y_mid, ok_mid, _ = _newton_2x2(
-                        z, tau_mid, zeta0, y0, a_coeffs,
+                        z, tau_mid, zeta0, y0, coeffs,
                         max_iter=max_iter, tol=tol,
                         damping=damping, step_clip=step_clip,
                         w_min=w_min, require_imw_pos=require_imw_pos,
@@ -322,7 +322,7 @@ def decompress_newton(
                         zeta0b = zeta_mid
                         y0b = y_mid
                         zeta, y, okj, nit = _newton_2x2(
-                            z, tau, zeta0b, y0b, a_coeffs,
+                            z, tau, zeta0b, y0b, coeffs,
                             max_iter=max_iter, tol=tol,
                             damping=damping, step_clip=step_clip,
                             w_min=w_min, require_imw_pos=require_imw_pos,