freealg 0.1.12__py3-none-any.whl → 0.1.13__py3-none-any.whl

freealg/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.12"
+__version__ = "0.1.13"

freealg/_decompress.py

@@ -15,13 +15,133 @@ import numpy
 
 __all__ = ['decompress', 'reverse_characteristics']
 
+def secant_complex(f, z0, z1, a=0+0j, tol=1e-12, max_iter=100,
+    alpha=0.5, max_bt=12, eps=1e-30, verbose=False):
+    """
+    Solves :math:``f(z) = a`` for many starting points simultaneously
+    using the secant method in the complex plane.
+
+    Parameters
+    ----------
+    f : callable
+        Function that accepts and returns complex `ndarray`s.
+
+    z0, z1 : array_like
+        Two initial guesses. ``z1`` may be broadcast to ``z0``.
+
+    a : complex or array_like, optional
+        Right‑hand‑side targets (broadcasted to ``z0``). Defaults to ``0+0j``.
+
+    tol : float, optional
+        Convergence criterion on ``|f(z) - a|``. Defaults to ``1e-12``.
+
+    max_iter : int, optional
+        Maximum number of secant iterations. Defaults to ``100``.
+
+    alpha : float, optional
+        Back‑tracking shrink factor (``0 < alpha < 1``). Defaults to ``0.5``.
+
+    max_bt : int, optional
+        Maximum back‑tracking trials per iteration. Defaults to ``12``.
+
+    eps : float, optional
+        Safeguard added to tiny denominators. Defaults to ``1e-30``.
+
+    verbose : bool, optional
+        If *True*, prints progress every 10 iterations.
+
+    Returns
+    -------
+    roots : ndarray
+        Estimated roots, shaped like the broadcast inputs.
+    residuals : ndarray
+        Final residuals ``|f(root) - a|``.
+    iterations : ndarray
+        Iteration count for each point.
+    """
+
+    # Broadcast inputs
+    z0, z1, a = numpy.broadcast_arrays(
+        numpy.asarray(z0, numpy.complex128),
+        numpy.asarray(z1, numpy.complex128),
+        numpy.asarray(a,  numpy.complex128),
+    )
+    orig_shape = z0.shape
+    z0, z1, a = (x.ravel() for x in (z0, z1, a))
+
+    n_points   = z0.size
+    roots      = z1.copy()
+    iterations = numpy.zeros(n_points, dtype=int)
+
+    f0 = f(z0) - a
+    f1 = f(z1) - a
+    residuals = numpy.abs(f1)
+    converged = residuals < tol
+
+    # Entering main loop
+    for k in range(max_iter):
+        active = ~converged
+        if not active.any():
+            break
+
+        # Secant step
+        denom = f1 - f0
+        denom = numpy.where(numpy.abs(denom) < eps, denom + eps, denom)
+        dz    = (z1 - z0) * f1 / denom
+        z2    = z1 - dz
+        f2    = f(z2) - a
+
+        # Line search by backtracking
+        worse = (numpy.abs(f2) >= numpy.abs(f1)) & active
+        if worse.any():
+            shrink = numpy.ones_like(dz)
+            for _ in range(max_bt):
+                shrink[worse] *= alpha
+                z_try = z1[worse] - shrink[worse] * dz[worse]
+                f_try = f(z_try) - a[worse]
+
+                improved = numpy.abs(f_try) < numpy.abs(f1[worse])
+                if not improved.any():
+                    continue
+
+                idx = numpy.flatnonzero(worse)[improved]
+                z2[idx], f2[idx] = z_try[improved], f_try[improved]
+                worse[idx] = False
+                if not worse.any():
+                    break
+
+        # Book‑keeping
+        newly_conv = (numpy.abs(f2) < tol) & active
+        converged[newly_conv] = True
+        iterations[newly_conv] = k + 1
+        roots[newly_conv] = z2[newly_conv]
+        residuals[newly_conv] = numpy.abs(f2[newly_conv])
+
+        still = active & ~newly_conv
+        z0[still], z1[still] = z1[still], z2[still]
+        f0[still], f1[still] = f1[still], f2[still]
+
+        if verbose and k % 10 == 0:
+            print(f"Iter {k}: {converged.sum()} / {n_points} converged")
+
+    # Non‑converged points
+    remaining = ~converged
+    roots[remaining] = z1[remaining]
+    residuals[remaining] = numpy.abs(f1[remaining])
+    iterations[remaining] = max_iter
+
+    return (
+        roots.reshape(orig_shape),
+        residuals.reshape(orig_shape),
+        iterations.reshape(orig_shape),
+    )
 
 # ==========
 # decompress
 # ==========
 
-def decompress(freeform, size, x=None, delta=1e-6, iterations=500,
-               step_size=0.1, tolerance=1e-9):
+def decompress(freeform, size, x=None, delta=1e-6, max_iter=500,
+               tolerance=1e-12):
     """
     Free decompression of spectral density.
 
@@ -42,15 +162,11 @@ def decompress(freeform, size, x=None, delta=1e-6, iterations=500,
         Size of the perturbation into the upper half plane for Plemelj's
         formula.
 
-    iterations: int, default=500
-        Maximum number of Newton iterations.
+    max_iter: int, default=500
+        Maximum number of secant method iterations.
 
-    step_size: float, default=0.1
-        Step size for Newton iterations.
-
-    tolerance: float, default=1e-4
-        Tolerance for the solution obtained by the Newton solver. Also
-        used for the finite difference approximation to the derivative.
+    tolerance: float, default=1e-12
+        Tolerance for the solution obtained by the secant method solver.
 
     Returns
     -------
@@ -99,42 +215,34 @@ def decompress(freeform, size, x=None, delta=1e-6, iterations=500,
         x_max = numpy.ceil(center + radius * scale)
         x = numpy.linspace(x_min, x_max, 500)
 
-    def _char_z(z):
-        return z + (1 / m(z)[1]) * (1 - alpha)
-
     # Ensure that input is an array
     x = numpy.asarray(x)
-
     target = x + delta * 1j
+    if numpy.isclose(alpha, 1.0):
+        return freeform.density(x), x, freeform.support
 
-    z = numpy.full(target.shape, numpy.mean(freeform.support) - .1j,
-                   dtype=numpy.complex128)
-
-    # Broken Newton steps can produce a lot of warnings. Removing them
-    # for now.
-    with numpy.errstate(all='ignore'):
-        for _ in range(iterations):
-            objective = _char_z(z) - target
-            mask = numpy.abs(objective) >= tolerance
-            if not numpy.any(mask):
-                break
-            z_m = z[mask]
-
-            # Perform finite difference approximation
-            dfdz = _char_z(z_m+tolerance) - _char_z(z_m-tolerance)
-            dfdz /= 2*tolerance
-            dfdz[dfdz == 0] = 1.0
+    # Characteristic curve map
+    def _char_z(z):
+        return z + (1 / m(z)[1]) * (1 - alpha)
 
-            # Perform Newton step
-            z[mask] = z_m - step_size * objective[mask] / dfdz
+    z0 = numpy.full(target.shape, numpy.mean(freeform.support) + delta*1j,
+                    dtype=numpy.complex128)
+    z1 = z0 - numpy.log(alpha) * 1j
+    
+    roots, _, _ = secant_complex(
+        _char_z, z0, z1,
+        a=target,
+        tol=tolerance,
+        max_iter=max_iter
+    )
 
     # Plemelj's formula
+    z = roots
     char_s = m(z)[1] / alpha
     rho = numpy.maximum(0, char_s.imag / numpy.pi)
     rho[numpy.isnan(rho) | numpy.isinf(rho)] = 0
-    rho = rho.reshape(*x.shape)
 
-    return rho, x, (lb, ub)
+    return rho.reshape(*x.shape), x, (lb, ub)
 
 
 # =======================

freealg/freeform.py

@@ -783,7 +783,7 @@ class FreeForm(object):
     # decompress
     # ==========
 
-    def decompress(self, size, x=None, iterations=500, eigvals=True,
+    def decompress(self, size, x=None, max_iter=500, eigvals=True,
                    step_size=0.1, tolerance=1e-9, seed=None, plot=False,
                    latex=False, save=False):
         """
@@ -799,8 +799,8 @@ class FreeForm(object):
             Positions where density to be evaluated at. If `None`, an interval
             slightly larger than the support interval will be used.
 
-        iterations: int, default=500
-            Maximum number of Newton iterations.
+        max_iter: int, default=500
+            Maximum number of secant method iterations.
 
         eigvals: bool, default=True
             Return estimated (sampled) eigenvalues as well as the density.
@@ -867,8 +867,7 @@ class FreeForm(object):
         size = int(size)
 
         rho, x, (lb, ub) = decompress(self, size, x=x, delta=self.delta,
-                                      iterations=iterations,
-                                      step_size=step_size, tolerance=tolerance)
+                                      max_iter=max_iter, tolerance=tolerance)
         x, rho = x.ravel(), rho.ravel()
 
         if plot:

{freealg-0.1.12.dist-info → freealg-0.1.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.1.12
+Version: 0.1.13
 Summary: Free probability for large matrices
 Keywords: leaderboard bot chat
 Platform: Linux

{freealg-0.1.12.dist-info → freealg-0.1.13.dist-info}/RECORD

@@ -1,24 +1,24 @@
 freealg/__init__.py,sha256=YqewBd3fq4nm-L3oGcExhEDR2wtVcrtggkSGzfpDqr4,528
-freealg/__version__.py,sha256=LcIlFjHZFfiF9Rd4UHoakmombOFkxIYk00I181frGBM,23
+freealg/__version__.py,sha256=khDKUuWafURKVs5EAZkpOMiUHI2-V7axlqrWLPUpuZo,23
 freealg/_chebyshev.py,sha256=oDJtRCwKEHazitzVBDbfdQz1jkyfsJOJfcAfo-PNkNo,5745
 freealg/_damp.py,sha256=k2vtBtWOxQBf4qXaWu_En81lQBXbEO4QbxxWpvuVhdE,1802
-freealg/_decompress.py,sha256=WdKXkZ9cbrzIHEACEZyVmLNR9kMK7OQLaBFsZKUjIKQ,4723
+freealg/_decompress.py,sha256=vTnxV_7XPYUVVnWCnALCrZkQT77IAPm_CzrWMgiTiqg,7986
 freealg/_jacobi.py,sha256=AT4ONSHGGDxVKE3MGMLyMR8uDFiO-e9u3x5udYfdJJk,5635
 freealg/_pade.py,sha256=yREJYSmnWaVUNRBNxjuQUqeLe_XSaGa9_VzV6HG5RkA,15164
 freealg/_plot_util.py,sha256=BOYre8FPhrxmW1VRj3I40dCjWTFqUBTInmXc3wFunKQ,19648
 freealg/_sample.py,sha256=ckC75eqv-mRP1F5BnhvsjfLTaoAzHK8bebl9bCRZYDo,2561
 freealg/_support.py,sha256=A8hUjfKnSkHm09KLcEkeEXeTieKjhH-sVPd7I3_p4VE,3100
 freealg/_util.py,sha256=PWLXcsTb0-FinGWvNiY12D-f4CHQB5bP_W3ThqfY4FY,3681
-freealg/freeform.py,sha256=OtFiLeaViEUUzxI4Ivp5twf6Pkr7hpqERFppa6C6kCA,30435
+freealg/freeform.py,sha256=_HDgchJaeryUTgywobSM4Yr8SjXi6pRVG8kQkTKDdMM,30375
 freealg/distributions/__init__.py,sha256=t_yZyEkW_W_tSV9IvgYXtVASxD2BEdiNVXcV2ebMy8M,579
 freealg/distributions/_kesten_mckay.py,sha256=HDMjbM1AcNxlwrpYeGmRqcbP10QsLI5RCeKvjVK3tOk,19566
 freealg/distributions/_marchenko_pastur.py,sha256=th921hlEEtTbnHnRyBgT54a_e-9ZzAl9rB78O9FjorY,16688
 freealg/distributions/_meixner.py,sha256=ItE0zYG2vhyUkObxbx4bDZaJ0BHVQWPzAJGLdMz10l4,17206
 freealg/distributions/_wachter.py,sha256=lw70PT3TZlCf7mHU8IqoygXFUWB4IL57obkng0_ZGeI,16591
 freealg/distributions/_wigner.py,sha256=2ZSPjgmDr9q9qiz6jO6yhXFo4ALHfxK1f0EzolzhRNE,15565
-freealg-0.1.12.dist-info/licenses/AUTHORS.txt,sha256=0b67Nz4_JgIzUupHJTAZxu5QdSUM_HRM_X_w4xCb17o,30
-freealg-0.1.12.dist-info/licenses/LICENSE.txt,sha256=J-EEYEtxb3VVf_Bn1TYfWnpY5lMFIM15iLDDcnaDTPA,1443
-freealg-0.1.12.dist-info/METADATA,sha256=Xwep_keCRRaY_GBIsLUnZ8Opx5-I20dhXJ8us53_wAI,4029
-freealg-0.1.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-freealg-0.1.12.dist-info/top_level.txt,sha256=eR2wrgYwDdnnJ9Zf5PruPqe4kQav0GMvRsqct6y00Q8,8
-freealg-0.1.12.dist-info/RECORD,,
+freealg-0.1.13.dist-info/licenses/AUTHORS.txt,sha256=0b67Nz4_JgIzUupHJTAZxu5QdSUM_HRM_X_w4xCb17o,30
+freealg-0.1.13.dist-info/licenses/LICENSE.txt,sha256=J-EEYEtxb3VVf_Bn1TYfWnpY5lMFIM15iLDDcnaDTPA,1443
+freealg-0.1.13.dist-info/METADATA,sha256=83nEmVJt6xwHPu6o0qlYN0JQ_zYuqgIPgQBvHsAdvkE,4029
+freealg-0.1.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+freealg-0.1.13.dist-info/top_level.txt,sha256=eR2wrgYwDdnnJ9Zf5PruPqe4kQav0GMvRsqct6y00Q8,8
+freealg-0.1.13.dist-info/RECORD,,