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

freealg/_algebraic_form/_decompress8.py

@@ -42,30 +42,30 @@ def _powers(x, deg):
     return xp
 
 
-def _poly_coef_in_y(zeta, a_coeffs):
+def _poly_coef_in_y(zeta, coeffs):
     """
     For each zeta, compute coefficients a_j(zeta) so that
         P(zeta, y) = sum_{j=0}^s a_j(zeta) y^j
     """
     zeta = numpy.asarray(zeta, dtype=numpy.complex128).ravel()
-    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)
 
     zp = _powers(zeta, deg_z)
     a = numpy.empty((zeta.size, s + 1), dtype=numpy.complex128)
     for j in range(s + 1):
-        a[:, j] = zp @ a_coeffs[:, j]
+        a[:, j] = zp @ coeffs[:, j]
     return a
 
 
-def _poly_coef_in_y_dzeta(zeta, a_coeffs):
+def _poly_coef_in_y_dzeta(zeta, coeffs):
     """
     For each zeta, compute coefficients da_j/dzeta(zeta) so that
         d/dzeta P(zeta, y) = sum_{j=0}^s (da_j/dzeta)(zeta) y^j
     """
     zeta = numpy.asarray(zeta, dtype=numpy.complex128).ravel()
-    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 deg_z <= 0:
         return numpy.zeros((zeta.size, s + 1), dtype=numpy.complex128)
@@ -74,7 +74,7 @@ def _poly_coef_in_y_dzeta(zeta, a_coeffs):
     zp = _powers(zeta, deg_z - 1)  # up to zeta^(deg_z-1)
     da = numpy.empty((zeta.size, s + 1), dtype=numpy.complex128)
     for j in range(s + 1):
-        col = a_coeffs[:, j]
+        col = coeffs[:, j]
         # sum_{i=1..deg_z} i*c_{i,j} zeta^(i-1)
         # build weighted coefficients for zp @ ...
         w = numpy.arange(deg_z + 1, dtype=numpy.complex128) * col
@@ -82,7 +82,7 @@ def _poly_coef_in_y_dzeta(zeta, a_coeffs):
     return da
 
 
-def _eval_P_and_partials(zeta, y, a_coeffs):
+def _eval_P_and_partials(zeta, y, coeffs):
     """
     Evaluate P(zeta,y), P_zeta(zeta,y), P_y(zeta,y).
 
@@ -92,8 +92,8 @@ def _eval_P_and_partials(zeta, y, a_coeffs):
     zeta = numpy.asarray(zeta, dtype=numpy.complex128).ravel()
     y = numpy.asarray(y, dtype=numpy.complex128).ravel()
 
-    a = _poly_coef_in_y(zeta, a_coeffs)          # (n, s+1)
-    da = _poly_coef_in_y_dzeta(zeta, a_coeffs)   # (n, s+1)
+    a = _poly_coef_in_y(zeta, coeffs)          # (n, s+1)
+    da = _poly_coef_in_y_dzeta(zeta, coeffs)   # (n, s+1)
 
     s = int(a.shape[1] - 1)
     # powers of y up to s
@@ -120,7 +120,7 @@ def _eval_P_and_partials(zeta, y, a_coeffs):
 # 2x2 complex Newton step
 # =======================
 
-def _newton_2x2(z, tau, zeta0, y0, a_coeffs, max_iter, tol,
+def _newton_2x2(z, tau, zeta0, y0, coeffs, max_iter, tol,
                 armijo, min_lam, w_min, enforce_imag=True):
     """
     Solve for (zeta,y) at given (z,tau) using damped Newton on the 2x2 complex
@@ -136,7 +136,7 @@ def _newton_2x2(z, tau, zeta0, y0, a_coeffs, max_iter, tol,
     def F(zeta_, y_):
         P, Pz, Py = _eval_P_and_partials(numpy.array([zeta_]),
                                          numpy.array([y_]),
-                                         a_coeffs)
+                                         coeffs)
         P = P[0]
         Pz = Pz[0]
         Py = Py[0]
@@ -211,7 +211,7 @@ def _newton_2x2(z, tau, zeta0, y0, a_coeffs, max_iter, tol,
 # Public entrypoint
 # =================
 
-def decompress_newton(z_query, t_all, a_coeffs, w0_list=None,
+def decompress_newton(z_query, t_all, coeffs, w0_list=None,
                      max_iter=50, tol=1e-12,
                      armijo=1e-4, min_lam=1e-6, w_min=1e-14,
                      sweep=True, verbose=False, **kwargs):
@@ -224,7 +224,7 @@ def decompress_newton(z_query, t_all, a_coeffs, w0_list=None,
     t_all : array_like (float)
         Time grid including t=0, increasing.
 
-    a_coeffs : ndarray
+    coeffs : ndarray
         Coefficient matrix for P(z,m) in monomial basis (deg_z+1, s+1)
 
     w0_list : array_like (complex), optional
@@ -331,7 +331,7 @@ def decompress_newton(z_query, t_all, a_coeffs, w0_list=None,
 
             # Solve
             zeta, y, okj, _ = _newton_2x2(
-                z, tau, zeta0, y0, a_coeffs,
+                z, tau, zeta0, y0, coeffs,
                 max_iter=max_iter, tol=tol,
                 armijo=armijo, min_lam=min_lam, w_min=w_min,
                 enforce_imag=True
@@ -345,7 +345,7 @@ def decompress_newton(z_query, t_all, a_coeffs, w0_list=None,
                 zeta0b = z + (tau - 1.0) / y_safe0b
 
                 zeta, y, okj, _ = _newton_2x2(
-                    z, tau, zeta0b, y0b, a_coeffs,
+                    z, tau, zeta0b, y0b, coeffs,
                     max_iter=max_iter, tol=tol,
                     armijo=armijo, min_lam=min_lam, w_min=w_min,
                     enforce_imag=True

freealg/_algebraic_form/_decompress9.py

@@ -28,34 +28,34 @@ def _poly_powers(z, deg):
     return zp
 
 
-def _eval_P_dP(z, m, a_coeffs):
+def _eval_P_dP(z, m, coeffs):
     """
-    Evaluate P(z,m), dP/dz, dP/dm for polynomial coefficients a_coeffs.
+    Evaluate P(z,m), dP/dz, dP/dm for polynomial coefficients coeffs.
 
-    a_coeffs has shape (deg_z+1, s+1), where
+    coeffs has shape (deg_z+1, s+1), where
         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
     """
     z = numpy.asarray(z, dtype=complex).ravel()
     m = numpy.asarray(m, dtype=complex).ravel()
 
-    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)
 
     zp = _poly_powers(z, deg_z)                 # (n, deg_z+1)
     # a_j(z) for all j
-    a = zp @ a_coeffs                            # (n, s+1)
+    a = zp @ coeffs                            # (n, s+1)
 
     # derivative a_j'(z)
     if deg_z >= 1:
         # coeffs multiplied by power index
         idx = numpy.arange(deg_z + 1, dtype=float)
-        a_coeffs_dz = a_coeffs * idx[:, None]
+        coeffs_dz = coeffs * idx[:, None]
         # powers z^{i-1}: shift zp right
         zp_m1 = numpy.zeros_like(zp)
         zp_m1[:, 0] = 0.0
         zp_m1[:, 1:] = zp[:, :-1]
-        a_dz = zp_m1 @ a_coeffs_dz              # (n, s+1)
+        a_dz = zp_m1 @ coeffs_dz              # (n, s+1)
     else:
         a_dz = numpy.zeros_like(a)
 
@@ -87,7 +87,7 @@ def _eval_P_dP(z, m, a_coeffs):
 # 2x2 complex Newton (correct)
 # ===========================
 
-def _newton_corrector(z_fixed, tau, a_coeffs, zeta0, y0,
+def _newton_corrector(z_fixed, tau, coeffs, zeta0, y0,
                       max_iter=50, tol=1e-12,
                       armijo=1e-4, min_lam=1e-6):
     """
@@ -103,7 +103,7 @@ def _newton_corrector(z_fixed, tau, a_coeffs, zeta0, y0,
     eps_y = 0.0
 
     for it in range(int(max_iter)):
-        P, Pz, Py = _eval_P_dP(numpy.array([zeta]), numpy.array([y]), a_coeffs)
+        P, Pz, Py = _eval_P_dP(numpy.array([zeta]), numpy.array([y]), coeffs)
         F1 = P[0]
         F2 = zeta - (tau - 1.0) / (y + eps_y) - z_fixed
 
@@ -139,7 +139,7 @@ def _newton_corrector(z_fixed, tau, a_coeffs, zeta0, y0,
             zeta_try = zeta + lam * dzeta
             y_try = y + lam * dy
 
-            P_try, _, _ = _eval_P_dP(numpy.array([zeta_try]), numpy.array([y_try]), a_coeffs)
+            P_try, _, _ = _eval_P_dP(numpy.array([zeta_try]), numpy.array([y_try]), coeffs)
             F1_try = P_try[0]
             F2_try = zeta_try - (tau - 1.0) / (y_try + eps_y) - z_fixed
             norm_try = max(abs(F1_try), abs(F2_try))
@@ -163,7 +163,7 @@ def _newton_corrector(z_fixed, tau, a_coeffs, zeta0, y0,
 # predictor step (tangent ODE)
 # ===========================
 
-def _predictor_step(z_fixed, tau0, tau1, a_coeffs, zeta0, y0):
+def _predictor_step(z_fixed, tau0, tau1, coeffs, zeta0, y0):
     """
     One explicit Euler predictor from tau0 to tau1 along the sheet.
 
@@ -175,7 +175,7 @@ def _predictor_step(z_fixed, tau0, tau1, a_coeffs, zeta0, y0):
     if dtau == 0.0:
         return zeta0, y0
 
-    P, Pz, Py = _eval_P_dP(numpy.array([zeta0]), numpy.array([y0]), a_coeffs)
+    P, Pz, Py = _eval_P_dP(numpy.array([zeta0]), numpy.array([y0]), coeffs)
     Pz = Pz[0]
     Py = Py[0]
 
@@ -202,7 +202,7 @@ def _predictor_step(z_fixed, tau0, tau1, a_coeffs, zeta0, y0):
 # decompress newton
 # =================
 
-def decompress_newton(z_query, t, a_coeffs, w0_list=None,
+def decompress_newton(z_query, t, coeffs, w0_list=None,
                      max_iter=50, tol=1e-12,
                      armijo=1e-4, min_lam=1e-6,
                      w_min=1e-14,
@@ -219,7 +219,7 @@ def decompress_newton(z_query, t, a_coeffs, w0_list=None,
         Query points z = x + i*delta (typically slightly above real axis).
     t : array_like (n_t,)
         Time grid (must be sorted increasing; should include 0).
-    a_coeffs : ndarray
+    coeffs : ndarray
         Polynomial coefficients of P(z,m)=0 as in AlgebraicForm.fit.
     w0_list : array_like (n_z,)
         Initial condition m(t=0, z_query) on the physical branch.
@@ -312,7 +312,7 @@ def decompress_newton(z_query, t, a_coeffs, w0_list=None,
 
                 # Predictor from a_tau to b_tau
                 zeta_pred, y_pred = _predictor_step(
-                    z_query[j], a_tau, b_tau, a_coeffs, a_zeta, a_y
+                    z_query[j], a_tau, b_tau, coeffs, a_zeta, a_y
                 )
 
                 # Guard tiny y_pred
@@ -321,7 +321,7 @@ def decompress_newton(z_query, t, a_coeffs, w0_list=None,
 
                 # Corrector at b_tau
                 zeta_corr, y_corr, ok1, _ = _newton_corrector(
-                    z_fixed=z_query[j], tau=b_tau, a_coeffs=a_coeffs,
+                    z_fixed=z_query[j], tau=b_tau, coeffs=coeffs,
                     zeta0=zeta_pred, y0=y_pred,
                     max_iter=max_iter, tol=tol, armijo=armijo, min_lam=min_lam
                 )

freealg/_algebraic_form/_decompress_new.py

@@ -54,19 +54,19 @@ def build_time_grid(sizes, n0, min_n_times=0):
 # eval P partials
 # ===============
 
-def eval_P_partials(z, m, a_coeffs):
+def eval_P_partials(z, m, coeffs):
     """
     Evaluate P(z,m) and partials dP/dz, dP/dm.
 
-    P is represented by a_coeffs in the monomial basis:
+    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
     """
     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)
 
     # Scalar fast path
     if (z.ndim == 0) and (m.ndim == 0):
@@ -77,7 +77,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):
@@ -119,10 +119,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:
@@ -135,7 +135,7 @@ def eval_P_partials(z, m, a_coeffs):
 # Newton for one (z,t) pair
 # =========================
 
-def _newton_one(z, t, a_coeffs, w0, max_iter=50, tol=1e-12,
+def _newton_one(z, t, coeffs, w0, max_iter=50, tol=1e-12,
                 armijo=1e-4, min_lam=1e-6, w_min=1e-14):
     """
     Solve F_t(z,w)=0 at a single (t,z) by damped Newton.
@@ -155,7 +155,7 @@ def _newton_one(z, t, a_coeffs, w0, max_iter=50, tol=1e-12,
             return numpy.nan + 1j * numpy.nan, numpy.nan + 1j * numpy.nan
         zeta = z + beta / w_val
         y = tau * w_val
-        P, Pz, Py = eval_P_partials(zeta, y, a_coeffs)
+        P, Pz, Py = eval_P_partials(zeta, y, coeffs)
         dF = (-beta / (w_val * w_val)) * Pz + tau * Py
         return P, dF
 
@@ -240,7 +240,7 @@ def _newton_one(z, t, a_coeffs, w0, max_iter=50, tol=1e-12,
 def decompress_newton(
     z_query,
     t_all,
-    a_coeffs,
+    coeffs,
     w0_list=None,
     max_iter=50,
     tol=1e-12,
@@ -310,7 +310,7 @@ def decompress_newton(
 
         # Initial anchor solve at first time
         w_anchor_prev, ok_anchor_prev = _newton_one(
-            z_anchor, float(t_all[0]), a_coeffs, -1.0 / z_anchor,
+            z_anchor, float(t_all[0]), coeffs, -1.0 / z_anchor,
             max_iter=max_iter, tol=homotopy_tol,
             armijo=armijo, min_lam=min_lam, w_min=w_min)
         if not ok_anchor_prev:
@@ -338,7 +338,7 @@ def decompress_newton(
                 z_next = z_anchor + (z_target - z_anchor) * s_next
 
                 w_next, ok_next = _newton_one(
-                    z_next, t, a_coeffs, w_curr,
+                    z_next, t, coeffs, w_curr,
                     max_iter=max_iter, tol=homotopy_tol,
                     armijo=armijo, min_lam=min_lam, w_min=w_min)
 
@@ -369,7 +369,7 @@ def decompress_newton(
         if use_homotopy:
             # Continue anchor in time
             w_anchor, ok_anchor = _newton_one(
-                z_anchor, t, a_coeffs, w_anchor_prev,
+                z_anchor, t, coeffs, w_anchor_prev,
                 max_iter=max_iter, tol=homotopy_tol,
                 armijo=armijo, min_lam=min_lam, w_min=w_min)
             if ok_anchor:
@@ -387,7 +387,7 @@ def decompress_newton(
 
                 # Fallback: direct Newton from previous time
                 w_d, ok_d = _newton_one(
-                    zq[j], t, a_coeffs, w_prev_time[j],
+                    zq[j], t, coeffs, w_prev_time[j],
                     max_iter=max_iter, tol=tol,
                     armijo=armijo, min_lam=min_lam, w_min=w_min)
                 if ok_d:
@@ -404,7 +404,7 @@ def decompress_newton(
                 else:
                     w0 = Wk[j - 1] if okk[j - 1] else w_prev_time[j]
                 w_sol, ok_sol = _newton_one(
-                    zq[j], t, a_coeffs, w0,
+                    zq[j], t, coeffs, w0,
                     max_iter=max_iter, tol=tol,
                     armijo=armijo, min_lam=min_lam, w_min=w_min)
                 Wk[j] = w_sol
@@ -413,7 +413,7 @@ def decompress_newton(
         else:
             for j in range(n_z):
                 w_sol, ok_sol = _newton_one(
-                    zq[j], t, a_coeffs, w_prev_time[j],
+                    zq[j], t, coeffs, w_prev_time[j],
                     max_iter=max_iter, tol=tol,
                     armijo=armijo, min_lam=min_lam, w_min=w_min)
                 Wk[j] = w_sol