freealg 0.7.1__tar.gz → 0.7.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.7.1
+Version: 0.7.4
 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.1 → freealg-0.7.4}/freealg/__init__.py

@@ -6,7 +6,7 @@
 # under the terms of the license found in the LICENSE.txt file in the root
 # directory of this source tree.
 
-from ._freeform import FreeForm, eigvalsh, cond, norm, trace, slogdet, supp, \
+from ._free_form import FreeForm, eigvalsh, cond, norm, trace, slogdet, supp, \
     sample, kde
 from ._algebraic_form import AlgebraicForm
 from ._geometric_form import GeometricForm

freealg-0.7.4/freealg/__version__.py

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

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

@@ -14,10 +14,50 @@
 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']
+__all__ = ['sample_z_joukowski', 'filter_z_away_from_cuts', 'powers',
+           'fit_polynomial_relation', 'eval_P', 'eval_roots',
+           'build_sheets_from_roots']
+
+
+# ======================
+# normalize coefficients
+# ======================
+
+def _normalize_coefficients(arr):
+    """
+    Trim rows and columns on the sides (equivalent to factorizing or reducing
+    degree) and normalize so that the sum of the first column is one.
+    """
+
+    a = numpy.asarray(arr).copy()
+
+    if a.size == 0:
+        return a
+
+    # --- Trim zero rows (top and bottom) ---
+    non_zero_rows = numpy.any(a != 0, axis=1)
+    if not numpy.any(non_zero_rows):
+        return a[:0, :0]
+
+    first_row = numpy.argmax(non_zero_rows)
+    last_row = len(non_zero_rows) - numpy.argmax(non_zero_rows[::-1])
+    a = a[first_row:last_row, :]
+
+    # --- Trim zero columns (left and right) ---
+    non_zero_cols = numpy.any(a != 0, axis=0)
+    if not numpy.any(non_zero_cols):
+        return a[:, :0]
+
+    first_col = numpy.argmax(non_zero_cols)
+    last_col = len(non_zero_cols) - numpy.argmax(non_zero_cols[::-1])
+    a = a[:, first_col:last_col]
+
+    # --- Normalize so first column sums to 1 ---
+    col_sum = numpy.sum(numpy.abs(a[:, 0]))
+    if col_sum != 0:
+        a = a / col_sum
+
+    return a
 
 
 # ==================
@@ -91,7 +131,7 @@ def powers(x, deg):
 # =======================
 
 def fit_polynomial_relation(z, m, s, deg_z, ridge_lambda=0.0, weights=None,
-                            triangular=None):
+                            triangular=None, normalize=False):
 
     z = numpy.asarray(z, dtype=complex).ravel()
     m = numpy.asarray(m, dtype=complex).ravel()
@@ -167,6 +207,9 @@ def fit_polynomial_relation(z, m, s, deg_z, ridge_lambda=0.0, weights=None,
     for k, (i, j) in enumerate(pairs):
         full[i, j] = coef[k]
 
+    if normalize:
+        full = _normalize_coefficients(full)
+
     return full
 
 

freealg-0.7.4/freealg/_algebraic_form/_decompress2.py

@@ -0,0 +1,86 @@
+# =======
+# Imports
+# =======
+
+import numpy
+from scipy.special import comb
+from ._continuation_algebraic import _normalize_coefficients
+
+__all__ = ['decompress_coeffs']
+
+
+# =================
+# decompress_coeffs
+# =================
+
+def decompress_coeffs(a, t, normalize=True):
+    """
+    Compute the decompressed coefficients A[r, s](t) induced by
+    the transform Q_t(z, m) = m^L P(z + (1 - e^{-t}) / m, e^t m).
+
+    Parameters
+    ----------
+    a : array_like of float, shape (L+1, K+1)
+        Coefficients defining P(z, m) in the monomial basis:
+            P(z, m) = sum_{j=0..L} sum_{k=0..K} a[j, k] z^j m^k.
+    t : float
+        Time parameter.
+
+    Returns
+    -------
+    A : ndarray, shape (L+1, L+K+1)
+        Coefficients A[r, s](t) such that
+            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)
+    if a.ndim != 2:
+        raise ValueError("a must be a 2D array-like of shape (L+1, K+1).")
+
+    l_degree = a.shape[0] - 1
+    k_degree = a.shape[1] - 1
+
+    c = 1.0 - numpy.exp(-t)
+
+    # Scale columns of a by e^{t k}: scaled[j, k] = a[j, k] e^{t k}.
+    exp_factors = numpy.exp(numpy.arange(k_degree + 1) * t)
+    scaled = a * exp_factors
+
+    # Output coefficients.
+    out_dtype = numpy.result_type(a, float)
+    a_out = numpy.zeros((l_degree + 1, l_degree + k_degree + 1),
+                        dtype=out_dtype)
+
+    # Precompute binomial(j, r) * c^{j-r} for all j, r (lower-triangular).
+    j_inds = numpy.arange(l_degree + 1)[:, None]
+    r_inds = numpy.arange(l_degree + 1)[None, :]
+    mask = r_inds <= j_inds
+
+    binom_weights = numpy.zeros((l_degree + 1, l_degree + 1), dtype=float)
+    binom_weights[mask] = comb(j_inds, r_inds, exact=False)[mask]
+    binom_weights[mask] *= (c ** (j_inds - r_inds))[mask]
+
+    # Main accumulation:
+    # For fixed j and r, add:
+    #   A[r, (L - j + r) + k] += binom_weights[j, r] * scaled[j, k],
+    # for k = 0..K.
+    for j in range(l_degree + 1):
+        row_scaled = scaled[j]
+        if numpy.all(row_scaled == 0):
+            continue
+
+        base0 = l_degree - j
+        row_b = binom_weights[j]
+
+        for r in range(j + 1):
+            coeff = row_b[r]
+            if coeff == 0:
+                continue
+
+            start = base0 + r
+            a_out[r, start:start + (k_degree + 1)] += coeff * row_scaled
+
+    if normalize:
+        return _normalize_coefficients(a_out)
+
+    return a_out

freealg-0.7.4/freealg/_algebraic_form/_homotopy.py

@@ -0,0 +1,138 @@
+# =======
+# Imports
+# =======
+
+import numpy
+
+__all__ = ['stieltjes_poly']
+
+
+# =====================
+# stieltjes select root
+# =====================
+
+def stieltjes_select_root(roots, z, w_prev=None):
+    """
+    Select the Stieltjes-branch root among candidates at a given z.
+
+    Parameters
+    ----------
+    roots : array_like of complex
+        Candidate roots for m at the given z.
+    z : complex
+        Evaluation point. The Stieltjes/Herglotz branch satisfies
+        sign(Im(m)) = sign(Im(z)) away from the real axis.
+    w_prev : complex or None, optional
+        Previous continuation value used to enforce continuity. If None,
+        the asymptotic target -1/z is used.
+
+    Returns
+    -------
+    w : complex
+        Selected root corresponding to the Stieltjes branch.
+    """
+
+    z = complex(z)
+    roots = numpy.asarray(roots, dtype=numpy.complex128).ravel()
+
+    if roots.size == 0:
+        raise ValueError("roots must contain at least one candidate root.")
+
+    desired_sign = numpy.sign(z.imag)
+
+    if w_prev is None:
+        target = -1.0 / z
+    else:
+        target = complex(w_prev)
+
+    # Apply a soft Herglotz sign filter: prefer roots with Im(w) having the
+    # same sign as Im(z), allowing tiny numerical violations near the axis.
+    imag_roots = numpy.imag(roots)
+
+    good = roots[numpy.sign(imag_roots) == desired_sign]
+    if good.size == 0:
+        good = roots[(imag_roots * desired_sign) > -1e-12]
+
+    candidates = good if good.size > 0 else roots
+    idx = int(numpy.argmin(numpy.abs(candidates - target)))
+    return candidates[idx]
+
+
+# ==============
+# stieltjes poly
+# ==============
+
+def stieltjes_poly(z, a, eps=None, height=1e4, steps=100):
+    """
+    Evaluate the Stieltjes-branch solution m(z) of an algebraic equation.
+
+    The coefficients `a` define a polynomial relation
+        P(z, m) = 0,
+    where P is a polynomial in z and m with monomial-basis coefficients
+    arranged so that for fixed z, the coefficients of the polynomial in m
+    can be assembled from powers of z.
+
+    Parameters
+    ----------
+    z : complex
+        Evaluation point. Must be a single value.
+    a : ndarray, shape (L, K)
+        Coefficient matrix defining P(z, m) in the monomial basis.
+    eps : float or None, optional
+        If Im(z) == 0, use z + i*eps as the boundary evaluation point.
+        If None and Im(z) == 0, eps is set to 1e-8 * max(1, |z|).
+    height : float, optional
+        Imaginary height used for the starting point z0 in the same
+        half-plane as the evaluation point.
+    steps : int, optional
+        Number of continuation steps along the homotopy path.
+
+    Returns
+    -------
+    w : complex
+        Value of the Stieltjes-branch solution m(z) (or m(z+i*eps) if z is
+        real).
+    """
+
+    z = complex(z)
+    a = numpy.asarray(a)
+
+    if a.ndim != 2:
+        raise ValueError('a must be a 2D array.')
+
+    if steps < 1:
+        raise ValueError("steps must be a positive integer.")
+
+    a_l, _ = a.shape
+
+    def poly_coeffs_m(z_val):
+        z_powers = z_val ** numpy.arange(a_l)
+        return (z_powers @ a)[::-1]
+
+    def poly_roots(z_val):
+        coeffs = numpy.asarray(poly_coeffs_m(z_val), dtype=numpy.complex128)
+        return numpy.roots(coeffs)
+
+    # If user asked for a real-axis value, interpret as boundary value from C+.
+    if z.imag == 0.0:
+        if eps is None:
+            eps = 1e-8 * max(1.0, abs(z))
+        z_eval = z + 1j * float(eps)
+    else:
+        z_eval = z
+
+    half_sign = numpy.sign(z_eval.imag)
+    if half_sign == 0.0:
+        half_sign = 1.0
+
+    z0 = 1j * float(half_sign) * float(height)
+
+    # Initialize at z0 via asymptotic / Im-sign selection.
+    w_prev = stieltjes_select_root(poly_roots(z0), z0, w_prev=None)
+
+    # Straight-line homotopy from z0 to z_eval.
+    for tau in numpy.linspace(0.0, 1.0, int(steps) + 1)[1:]:
+        z_tau = z0 + tau * (z_eval - z0)
+        w_prev = stieltjes_select_root(poly_roots(z_tau), z_tau, w_prev=w_prev)
+
+    return w_prev