freealg 0.7.5__py3-none-any.whl → 0.7.6__py3-none-any.whl

freealg/__version__.py

@@ -1 +1 @@
-__version__ = "0.7.5"
+__version__ = "0.7.6"

freealg/_algebraic_form/_constraints.py

@@ -0,0 +1,98 @@
+
+# SPDX-FileCopyrightText: Copyright 2025, Siavash Ameli <sameli@berkeley.edu>
+# SPDX-License-Identifier: BSD-3-Clause
+# SPDX-FileType: SOURCE
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the license found in the LICENSE.txt file in the root directory
+# of this source tree.
+
+
+# =======
+# Imports
+# =======
+
+import numpy
+
+__all__ = ['build_moment_constraint_matrix']
+
+
+# ==========
+# series mul
+# ==========
+
+def _series_mul(a, b, q_max):
+
+    na = min(len(a), q_max + 1)
+    nb = min(len(b), q_max + 1)
+    out = numpy.zeros(q_max + 1, dtype=float)
+    for i in range(na):
+        if a[i] == 0.0:
+            continue
+        j_max = min(nb - 1, q_max - i)
+        if j_max >= 0:
+            out[i:i + j_max + 1] += a[i] * b[:j_max + 1]
+    return out
+
+
+# ==========
+# series pow
+# ==========
+
+def _series_pow(mser, j, q_max):
+    if j == 0:
+        out = numpy.zeros(q_max + 1, dtype=float)
+        out[0] = 1.0
+        return out
+    out = mser.copy()
+    for _ in range(1, j):
+        out = _series_mul(out, mser, q_max)
+    return out
+
+
+# ===============================
+# build moment constraints matrix
+# ===============================
+
+def build_moment_constraint_matrix(pairs, deg_z, s, mu):
+
+    mu = numpy.asarray(mu, dtype=float).ravel()
+    if mu.size == 0:
+        return numpy.zeros((0, len(pairs)), dtype=float)
+
+    # m(z) = -sum_{p>=0} mu_p / z^{p+1}; t = 1/z so m(t) = -sum mu_p t^{p+1}
+    r = mu.size - 1
+    q_max = r
+
+    mser = numpy.zeros(q_max + 1, dtype=float)
+    for p in range(mu.size):
+        q = p + 1
+        if q <= q_max:
+            mser[q] = -float(mu[p])
+
+    # Precompute (m(t))^j coefficients up to t^{q_max}
+    mpow = []
+    for j in range(s + 1):
+        mpow.append(_series_pow(mser, j, q_max))
+
+    # Constraints: coeff of t^q in Q(t) := t^{deg_z} P(1/t, m(t)) must be 0
+    # Q(t) = sum_{i,j} c_{i,j} * t^{deg_z - i} * (m(t))^j
+    n_coef = len(pairs)
+    B = numpy.zeros((q_max + 1, n_coef), dtype=float)
+
+    for k, (i, j) in enumerate(pairs):
+        shift = deg_z - i
+        if shift < 0:
+            continue
+        mj = mpow[j]
+        for q in range(q_max + 1):
+            qq = q - shift
+            if 0 <= qq <= q_max:
+                B[q, k] = mj[qq]
+
+    # Drop all-zero rows (can happen if index-set can't support higher moments)
+    row_norm = numpy.linalg.norm(B, axis=1)
+    keep = row_norm > 0.0
+    B = B[keep, :]
+
+    return B

freealg/_algebraic_form/_continuation_algebraic.py

@@ -13,6 +13,7 @@
 
 import numpy
 from .._geometric_form._continuation_genus0 import joukowski_z
+from ._constraints import build_moment_constraint_matrix
 
 __all__ = ['sample_z_joukowski', 'filter_z_away_from_cuts', 'powers',
            'fit_polynomial_relation', 'sanity_check_stieltjes_branch',
@@ -131,7 +132,11 @@ def powers(x, deg):
 # =======================
 
 def fit_polynomial_relation(z, m, s, deg_z, ridge_lambda=0.0, weights=None,
-                            triangular=None, normalize=False):
+                            triangular=None, normalize=False,
+                            mu=None, mu_reg=None):
+    """
+    Fits polynomial P(z, m) = 0 with samples from the physical branch.
+    """
 
     z = numpy.asarray(z, dtype=complex).ravel()
     m = numpy.asarray(m, dtype=complex).ravel()
@@ -198,13 +203,81 @@ def fit_polynomial_relation(z, m, s, deg_z, ridge_lambda=0.0, weights=None,
     s_col[s_col == 0.0] = 1.0
     As = Ar / s_col[None, :]
 
-    if ridge_lambda > 0.0:
-        L = numpy.sqrt(ridge_lambda) * numpy.eye(n_coef, dtype=float)
-        As = numpy.vstack([As, L])
+    # Optional moment constraints B c = 0 (hard via nullspace, soft via
+    # weighted rows)
+    if mu is not None:
+        B = build_moment_constraint_matrix(pairs, deg_z, s, mu)
+        if B.shape[0] > 0:
+            Bs = B / s_col[None, :]
+
+            if mu_reg is None:
+                # Hard constraints: solve in nullspace of Bs
+                uB, sB, vhB = numpy.linalg.svd(Bs, full_matrices=True)
+                tolB = 1e-12 * (sB[0] if sB.size else 1.0)
+                rankB = int(numpy.sum(sB > tolB))
+                if rankB >= n_coef:
+                    raise RuntimeError(
+                        'Moment constraints leave no feasible coefficients.')
+
+                N = vhB[rankB:, :].T  # (n_coef, n_free)
+                AN = As @ N
+
+                if ridge_lambda > 0.0:
+                    L = numpy.sqrt(ridge_lambda) * numpy.eye(N.shape[1],
+                                                             dtype=float)
+                    AN = numpy.vstack([AN, L])
+
+                _, _, vhN = numpy.linalg.svd(AN, full_matrices=False)
+                y = vhN[-1, :]
+                coef_scaled = N @ y
+
+                coef = coef_scaled / s_col
+
+            else:
+                mu_reg = float(mu_reg)
+                if mu_reg > 0.0:
+                    As_aug = As
+                    Bs_w = numpy.sqrt(mu_reg) * Bs
+                    As_aug = numpy.vstack([As_aug, Bs_w])
+
+                    if ridge_lambda > 0.0:
+                        L = numpy.sqrt(ridge_lambda) * numpy.eye(n_coef,
+                                                                 dtype=float)
+                        As_aug = numpy.vstack([As_aug, L])
+
+                    _, _, vh = numpy.linalg.svd(As_aug, full_matrices=False)
+                    coef_scaled = vh[-1, :]
+                    coef = coef_scaled / s_col
+                else:
+                    # mu_reg == 0 => ignore constraints
+                    if ridge_lambda > 0.0:
+                        L = numpy.sqrt(ridge_lambda) * numpy.eye(n_coef,
+                                                                 dtype=float)
+                        As = numpy.vstack([As, L])
+
+                    _, _, vh = numpy.linalg.svd(As, full_matrices=False)
+                    coef_scaled = vh[-1, :]
+                    coef = coef_scaled / s_col
 
-    _, _, vh = numpy.linalg.svd(As, full_matrices=False)
-    coef_scaled = vh[-1, :]
-    coef = coef_scaled / s_col
+        else:
+            # B has no effective rows -> proceed unconstrained
+            if ridge_lambda > 0.0:
+                L = numpy.sqrt(ridge_lambda) * numpy.eye(n_coef, dtype=float)
+                As = numpy.vstack([As, L])
+
+            _, _, vh = numpy.linalg.svd(As, full_matrices=False)
+            coef_scaled = vh[-1, :]
+            coef = coef_scaled / s_col
+
+    else:
+        # No moment constraints
+        if ridge_lambda > 0.0:
+            L = numpy.sqrt(ridge_lambda) * numpy.eye(n_coef, dtype=float)
+            As = numpy.vstack([As, L])
+
+        _, _, vh = numpy.linalg.svd(As, full_matrices=False)
+        coef_scaled = vh[-1, :]
+        coef = coef_scaled / s_col
 
     full = numpy.zeros((deg_z + 1, s + 1), dtype=complex)
     for k, (i, j) in enumerate(pairs):

freealg/_algebraic_form/algebraic_form.py

@@ -194,6 +194,7 @@ class AlgebraicForm(object):
 
         # Initialize
         self.a_coeffs = None               # Polynomial coefficients
+        self.status = None                 # Fitting status
         self.cache = {}                    # Cache inner-computations
 
     # ===
@@ -207,10 +208,38 @@ class AlgebraicForm(object):
             y_eps=2e-2,
             x_pad=0.0,
             triangular=None,
+            mu=None,
+            mu_reg=None,
             normalize=False,
             verbose=False):
         """
-        Fits polynomial.
+        Fit polynomial.
+
+        Parameters
+        ----------
+
+        deg_m : int
+            Degree :math:`\\deg_m(P)`
+
+        deg_z : int
+            Degree :math:`\\deg_z(P)`
+
+        mu : array_like, default=None
+            If an array :math:`[\\mu_0, \\mu_`, \\dots, \\mu_r]` is given,
+            it enforces the first :math:`r+1` moments. Note that :math:`\\mu_0`
+            should be :math:`1` to ensure unit mass. See also ``mu_reg`.
+
+        mu_reg: float, default=None
+            If `None`, the constraints ``mu`` are applied as hard constraint.
+            If a positive number, the constraints are applied as a soft
+            constraints with regularisation ``mu_reg``.
+
+        Notes
+        -----
+
+        When the input data are from an exact model, hard moment constraint is
+        preferred over soft constraint as the latter can hurt an already a good
+        fit.
         """
 
         # Very important: reset cache whenever this function is called. This
@@ -231,11 +260,13 @@ class AlgebraicForm(object):
         z_fit = filter_z_away_from_cuts(z_fit, self.support, y_eps=y_eps,
                                         x_pad=x_pad)
 
+        # Fitting (w_inf = None means adaptive weight selection)
         m1_fit = self.stieltjes(z_fit)
         a_coeffs = fit_polynomial_relation(z_fit, m1_fit, s=deg_m, deg_z=deg_z,
                                            ridge_lambda=reg,
                                            triangular=triangular,
-                                           normalize=normalize)
+                                           normalize=normalize, mu=mu,
+                                           mu_reg=mu_reg)
 
         self.a_coeffs = a_coeffs
 
@@ -251,8 +282,9 @@ class AlgebraicForm(object):
                                                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
+        status['res_max'] = float(res_max)
+        status['res_99_9'] = float(res_99_9)
+        self.status = status
 
         if verbose:
             print(f'fit residual max  : {res_max:>0.4e}')
@@ -657,11 +689,16 @@ class AlgebraicForm(object):
             z_query = x + 1j * self.delta
 
             # Initial condition at t=0 (physical branch)
-            w0_list = self.stieltjes(z_query)
+            # w0_list = self.stieltjes(z_query)
+            stieltjes = numpy.vectorize(m_fn)
+            w0_list = stieltjes(z_query)
 
             # Times
             t = numpy.log(alpha)
 
+            # Ensure it starts from t = 0
+            t = numpy.concatenate([numpy.zeros(1), t])
+
             # Evolve
             W, ok = decompress_newton(
                 z_query, t, self.a_coeffs,
@@ -669,6 +706,9 @@ class AlgebraicForm(object):
 
             rho = W.imag / numpy.pi
 
+            # Remove time zero
+            rho = rho[1:, :]
+
             if verbose:
                 print("success rate per t:", ok.mean(axis=1))
 

freealg/_util.py

@@ -14,7 +14,7 @@
 import numpy
 import scipy
 
-__all__ = ['resolve_complex_dtype', 'compute_eig']
+__all__ = ['resolve_complex_dtype', 'compute_eig', 'subsample_matrix']
 
 
 # =====================
@@ -70,3 +70,26 @@ def compute_eig(A, lower=False):
     eig = scipy.linalg.eigvalsh(A, lower=lower, driver='ev')
 
     return eig
+
+
+# ================
+# subsample matrix
+# ================
+
+def subsample_matrix(matrix, submatrix_size, seed=None):
+    """
+    Generate a random subsample of a larger matrix
+    """
+
+    if matrix.shape[0] != matrix.shape[1]:
+        raise ValueError("Matrix must be square")
+
+    n = matrix.shape[0]
+    if submatrix_size > n:
+        raise ValueError("Submatrix size cannot exceed matrix size")
+
+    rng = numpy.random.default_rng(seed)
+    idx = rng.choice(n, size=submatrix_size, replace=False)
+    idx = numpy.sort(idx)  # optional, preserves original ordering
+
+    return matrix[numpy.ix_(idx, idx)]

{freealg-0.7.5.dist-info → freealg-0.7.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.7.5
+Version: 0.7.6
 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.dist-info → freealg-0.7.6.dist-info}/RECORD

@@ -1,14 +1,15 @@
 freealg/__init__.py,sha256=SjcYb6HWmaclnnM-m1eC1honZRyfNBWYDYBx23kSdjo,833
-freealg/__version__.py,sha256=6qL_qyowXO9Pc6v11Zx2s-yd28_548ZZC-OsfzO_Pjc,22
-freealg/_util.py,sha256=E254DRTCeST7h1QHrfLeyg9jQntRaOyui1oXD7nMaWQ,1890
+freealg/__version__.py,sha256=wu65dmVM9fKR1rBHH263ls8Ca2FZzb0ejYcrP_Ld0iY,22
+freealg/_util.py,sha256=RzccUCORgzrI9NdNqwMVugiHU0uDKkJFcIyjFMUOnv8,2518
 freealg/_algebraic_form/__init__.py,sha256=MIB_jVgw2qI-JW_ypqaFSeNAB6c4GvpjNySnap_a6hg,398
-freealg/_algebraic_form/_continuation_algebraic.py,sha256=eQqc6f_fvW4-lVox8pFHcMu32ImYDESdQk9gOm1NElc,16147
+freealg/_algebraic_form/_constraints.py,sha256=37U7nvtCTocuS7l_nfUznkPi195PY7eXFzeiikrv3B0,2448
+freealg/_algebraic_form/_continuation_algebraic.py,sha256=SyuWjw0jABlIst9RjHS13gG2M94KZwwrTa3eeJNfmRI,19098
 freealg/_algebraic_form/_decompress.py,sha256=gGtixLOVxlMy5S-NsXgoA7lIrB7u7nUZImQk1mIDo3s,21101
 freealg/_algebraic_form/_decompress2.py,sha256=Ng9w9xmGe9M-DApp35IeNeQlvszfzT4NZx5BQn0lQ3I,2459
 freealg/_algebraic_form/_edge.py,sha256=7l9QyLJDxaEY4WB6MCUFtfEZSf04wyHwH7YPHFJXSbM,10690
 freealg/_algebraic_form/_homotopy.py,sha256=2oMcqJ2VJGzG7WKGM6FUS3923GT8Adtq_hLPEGgzqoU,3990
 freealg/_algebraic_form/_sheets_util.py,sha256=6OLzWQKu-gN8rxM2rbpbN8TjNZFmD8UJ-8t9kcZdkCo,4174
-freealg/_algebraic_form/algebraic_form.py,sha256=MrbZbu8IU_zgWSTvj4t57Npp7ToaJU1fH9bRx8_TEGs,31311
+freealg/_algebraic_form/algebraic_form.py,sha256=N-R8cv7580p-iPW7oPlDZ9py7BVjEmPcCjs25UVtNV4,32706
 freealg/_free_form/__init__.py,sha256=5cnSX7kHci3wKx6-BEFhmVY_NjjmQAq1JjWPTEqETTg,611
 freealg/_free_form/_chebyshev.py,sha256=zkyVA8NLf7uUKlJdLz4ijd_SurdsqUgkA5nHGWSybaE,6916
 freealg/_free_form/_damp.py,sha256=k2vtBtWOxQBf4qXaWu_En81lQBXbEO4QbxxWpvuVhdE,1802
@@ -41,9 +42,9 @@ freealg/distributions/_wigner.py,sha256=epgx6ne6R_7to5j6-QsWIAVFJQFquWMmYgnZYMN4
 freealg/visualization/__init__.py,sha256=NLq_zwueF7ytZ8sl8zLPqm-AODxxXNvfMozHGmmklcE,435
 freealg/visualization/_glue_util.py,sha256=2oKnEYjUOS4OZfivmciVLauVr53kyHMwi6c2zRKilTQ,693
 freealg/visualization/_rgb_hsv.py,sha256=rEskxXxSlKKxIrHRslVkgxHtD010L3ge9YtcVsOPl8E,3650
-freealg-0.7.5.dist-info/licenses/AUTHORS.txt,sha256=0b67Nz4_JgIzUupHJTAZxu5QdSUM_HRM_X_w4xCb17o,30
-freealg-0.7.5.dist-info/licenses/LICENSE.txt,sha256=J-EEYEtxb3VVf_Bn1TYfWnpY5lMFIM15iLDDcnaDTPA,1443
-freealg-0.7.5.dist-info/METADATA,sha256=s_6RoaIXAYy3JOmaDl-g-bTB81LH5vk3ptpfPQfXqd8,5516
-freealg-0.7.5.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-freealg-0.7.5.dist-info/top_level.txt,sha256=eR2wrgYwDdnnJ9Zf5PruPqe4kQav0GMvRsqct6y00Q8,8
-freealg-0.7.5.dist-info/RECORD,,
+freealg-0.7.6.dist-info/licenses/AUTHORS.txt,sha256=0b67Nz4_JgIzUupHJTAZxu5QdSUM_HRM_X_w4xCb17o,30
+freealg-0.7.6.dist-info/licenses/LICENSE.txt,sha256=J-EEYEtxb3VVf_Bn1TYfWnpY5lMFIM15iLDDcnaDTPA,1443
+freealg-0.7.6.dist-info/METADATA,sha256=cifScuAeI6gPbjzzCzBMMLqTYtxbqIIJhuICSIi-BkE,5516
+freealg-0.7.6.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+freealg-0.7.6.dist-info/top_level.txt,sha256=eR2wrgYwDdnnJ9Zf5PruPqe4kQav0GMvRsqct6y00Q8,8
+freealg-0.7.6.dist-info/RECORD,,