freealg 0.7.4__tar.gz → 0.7.5__tar.gz

{freealg-0.7.4 → freealg-0.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.7.4
+Version: 0.7.5
 Summary: Free probability for large matrices
 Home-page: https://github.com/ameli/freealg
 Download-URL: https://github.com/ameli/freealg/archive/main.zip

freealg-0.7.5/freealg/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.7.5"

{freealg-0.7.4 → freealg-0.7.5}/freealg/_algebraic_form/_continuation_algebraic.py

@@ -15,8 +15,8 @@ import numpy
 from .._geometric_form._continuation_genus0 import joukowski_z
 
 __all__ = ['sample_z_joukowski', 'filter_z_away_from_cuts', 'powers',
-           'fit_polynomial_relation', 'eval_P', 'eval_roots',
-           'build_sheets_from_roots']
+           'fit_polynomial_relation', 'sanity_check_stieltjes_branch',
+           'eval_P', 'eval_roots', 'build_sheets_from_roots']
 
 
 # ======================
@@ -191,12 +191,15 @@ def fit_polynomial_relation(z, m, s, deg_z, ridge_lambda=0.0, weights=None,
     if w is not None:
         A = A * w[:, None]
 
-    s_col = numpy.max(numpy.abs(A), axis=0)
+    # Enforce real coefficients by solving: Re(A) c = 0 and Im(A) c = 0
+    Ar = numpy.vstack([A.real, A.imag])
+
+    s_col = numpy.max(numpy.abs(Ar), axis=0)
     s_col[s_col == 0.0] = 1.0
-    As = A / s_col[None, :]
+    As = Ar / s_col[None, :]
 
     if ridge_lambda > 0.0:
-        L = numpy.sqrt(ridge_lambda) * numpy.eye(n_coef, dtype=complex)
+        L = numpy.sqrt(ridge_lambda) * numpy.eye(n_coef, dtype=float)
         As = numpy.vstack([As, L])
 
     _, _, vh = numpy.linalg.svd(As, full_matrices=False)
@@ -213,6 +216,77 @@ def fit_polynomial_relation(z, m, s, deg_z, ridge_lambda=0.0, weights=None,
     return full
 
 
+# =============================
+# sanity check stieltjes branch
+# =============================
+
+def sanity_check_stieltjes_branch(a_coeffs, x_min, x_max, eta=0.1,
+                                  n_x=64, y0=None, max_bad_frac=0.05):
+    """
+    Quick sanity check: does P(z,m)=0 admit a continuously trackable root with
+    Im(m)>0 along z=x+i*eta.
+    """
+
+    x_min = float(x_min)
+    x_max = float(x_max)
+    eta = float(eta)
+    n_x = int(n_x)
+    if n_x < 4:
+        n_x = 4
+
+    if y0 is None:
+        y0 = 10.0 * max(1.0, abs(x_min), abs(x_max))
+    y0 = float(y0)
+
+    z0 = 1j * y0
+    m0_target = -1.0 / z0
+
+    c0 = _poly_coef_in_m(numpy.array([z0]), a_coeffs)[0]
+    r0 = numpy.roots(c0[::-1])
+    if r0.size == 0:
+        return {'ok': False, 'frac_bad': 1.0, 'n_test': 0, 'n_bad': 0}
+
+    k0 = int(numpy.argmin(numpy.abs(r0 - m0_target)))
+    m_prev = r0[k0]
+
+    xs = numpy.linspace(x_min, x_max, n_x)
+    zs = xs + 1j * eta
+
+    n_bad = 0
+    n_ok = 0
+
+    for z in zs:
+        c = _poly_coef_in_m(numpy.array([z]), a_coeffs)[0]
+        r = numpy.roots(c[::-1])
+        if r.size == 0 or not numpy.all(numpy.isfinite(r)):
+            n_bad += 1
+            continue
+
+        k = int(numpy.argmin(numpy.abs(r - m_prev)))
+        m_sel = r[k]
+        m_prev = m_sel
+        n_ok += 1
+
+        if not numpy.isfinite(m_sel) or (m_sel.imag <= 0.0):
+            n_bad += 1
+
+    n_test = n_ok + (n_bad - (n_x - n_ok))
+    if n_test <= 0:
+        n_test = n_x
+
+    frac_bad = float(n_bad) / float(n_x)
+    ok = frac_bad <= float(max_bad_frac)
+
+    status = {
+        'ok': ok,
+        'frac_bad': frac_bad,
+        'n_test': n_x,
+        'n_bad': n_bad
+    }
+
+    return status
+
+
 # ======
 # eval P
 # ======
@@ -361,6 +435,10 @@ def eval_roots(z, a_coeffs):
 # =======================
 
 def track_one_sheet_on_grid(z, roots, sheet_seed, cuts=None, i0=None, j0=None):
+    """
+    This is mostly used for visualization of the sheets.
+    """
+
     z = numpy.asarray(z)
     n_y, n_x = z.shape
     s = roots.shape[1]
@@ -467,6 +545,7 @@ def track_one_sheet_on_grid(z, roots, sheet_seed, cuts=None, i0=None, j0=None):
 # =======================
 
 def build_sheets_from_roots(z, roots, m1, cuts=None, i0=None, j0=None):
+
     z = numpy.asarray(z)
     m1 = numpy.asarray(m1)
 

{freealg-0.7.4 → freealg-0.7.5}/freealg/_algebraic_form/_homotopy.py

@@ -62,7 +62,7 @@ def stieltjes_select_root(roots, z, w_prev=None):
 # stieltjes poly
 # ==============
 
-def stieltjes_poly(z, a, eps=None, height=1e4, steps=100):
+def stieltjes_poly(z, a, eps=None, height=1e+4, steps=100):
     """
     Evaluate the Stieltjes-branch solution m(z) of an algebraic equation.
 

{freealg-0.7.4 → freealg-0.7.5}/freealg/_algebraic_form/algebraic_form.py

@@ -11,12 +11,12 @@
 # Imports
 # =======
 
-import inspect
 import numpy
 from .._util import resolve_complex_dtype, compute_eig
 # from .._util import compute_eig
 from ._continuation_algebraic import sample_z_joukowski, \
-        filter_z_away_from_cuts, fit_polynomial_relation, eval_P
+        filter_z_away_from_cuts, fit_polynomial_relation, \
+        sanity_check_stieltjes_branch, eval_P
 from ._edge import evolve_edges, merge_edges
 from ._decompress import decompress_newton
 from ._decompress2 import decompress_coeffs
@@ -149,8 +149,7 @@ class AlgebraicForm(object):
         # Data type for complex arrays
         self.dtype = resolve_complex_dtype(dtype)
 
-        if inspect.isclass(A) and hasattr(A, "stieltjes") and \
-                callable(getattr(A, "stieltjes", None)):
+        if hasattr(A, 'stieltjes') and callable(getattr(A, 'stieltjes', None)):
             # This is one of the distribution objects, like MarchenkoPastur
             self.stieltjes = A.stieltjes
             self.n = 1
@@ -215,7 +214,7 @@ class AlgebraicForm(object):
         """
 
         # Very important: reset cache whenever this function is called. This
-        # also empties all references holdign a cache copy.
+        # also empties all references holding a cache copy.
         # self.cache.clear()
 
         z_fits = []
@@ -240,25 +239,45 @@ class AlgebraicForm(object):
 
         self.a_coeffs = a_coeffs
 
+        # Reporting error
+        P_res = numpy.abs(eval_P(z_fit, m1_fit, a_coeffs))
+        res_max = numpy.max(P_res[numpy.isfinite(P_res)])
+        res_99_9 = numpy.quantile(P_res[numpy.isfinite(P_res)], 0.999)
+
+        # Check polynomial has Stieltjes root
+        x_min = self.lam_m - 1.0
+        x_max = self.lam_p + 1.0
+        status = sanity_check_stieltjes_branch(a_coeffs, x_min, x_max,
+                                               eta=max(y_eps, 1e-2), n_x=128,
+                                               max_bad_frac=0.05)
+
+        status['res_max'] = res_max
+        status['res_99_9'] = res_99_9
+
         if verbose:
-            P_res = numpy.abs(eval_P(z_fit, m1_fit, a_coeffs))
-            print("fit residual max:", numpy.max(P_res[numpy.isfinite(P_res)]))
-            print("fit residual 99.9%:",
-                  numpy.quantile(P_res[numpy.isfinite(P_res)], 0.999))
+            print(f'fit residual max  : {res_max:>0.4e}')
+            print(f'fit residual 99.9%: {res_99_9:>0.4e}')
 
-            print('\nCoefficients')
-            with numpy.printoptions(precision=4, suppress=True):
+            print('\nCoefficients (real)')
+            with numpy.printoptions(precision=8, suppress=True):
                 for i in range(a_coeffs.shape[0]):
                     for j in range(a_coeffs.shape[1]):
                         v = a_coeffs[i, j]
-                        print(f"{v.real:>+0.4f}{v.imag:>+0.4f}j", end=" ")
+                        print(f'{v.real:>+0.8f}', end=' ')
                     print('')
 
-            print('\nCoefficient Magnitudes')
-            with numpy.printoptions(precision=6, suppress=True):
-                print(numpy.abs(a_coeffs))
+            a_coeffs_img_norm = numpy.linalg.norm(a_coeffs.imag, ord='fro')
+            print(f'\nCoefficients (imag) norm: {a_coeffs_img_norm:>0.4e}')
+
+            if not status['ok']:
+                print("\nWARNING: sanity check failed:\n" +
+                      f"\tfrac_bad: {status['frac_bad']:>0.3f}\n" +
+                      f"\tn_bad   : {status['n_bad']}\n" +
+                      f"\tn_test  : {status['n_test']}")
+            else:
+                print('\nStieltjes sanity check: OK')
 
-        return a_coeffs
+        return a_coeffs, status
 
     # =============
     # generate grid

{freealg-0.7.4 → freealg-0.7.5}/freealg.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.7.4
+Version: 0.7.5
 Summary: Free probability for large matrices
 Home-page: https://github.com/ameli/freealg
 Download-URL: https://github.com/ameli/freealg/archive/main.zip

freealg-0.7.4/freealg/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.7.4"