freealg 0.0.3__tar.gz → 0.1.0__tar.gz

{freealg-0.0.3/freealg.egg-info → freealg-0.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.0.3
+Version: 0.1.0
 Summary: Free probability for large matrices
 Keywords: leaderboard bot chat
 Platform: Linux
@@ -29,6 +29,7 @@ Requires-Dist: scipy
 Requires-Dist: texplot
 Requires-Dist: matplotlib
 Requires-Dist: colorcet
+Requires-Dist: networkx
 Provides-Extra: test
 Requires-Dist: tox; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"

freealg-0.1.0/freealg/__version__.py

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

freealg-0.1.0/freealg/_pade.py

@@ -0,0 +1,463 @@
+# 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
+from numpy.linalg import lstsq
+from itertools import product
+from scipy.optimize import least_squares, differential_evolution
+
+__all__ = ['fit_pade', 'eval_pade']
+
+
+# =============
+# default poles
+# =============
+
+def _default_poles(q, lam_m, lam_p, safety=1.0, odd_side='left'):
+    """
+    Generate q real poles outside [lam_m, lam_p].
+
+    • even q  : q/2 on each side (Chebyshev-like layout)
+    • odd  q  : (q+1)/2 on the *left*,  (q–1)/2 on the right
+                so q=1 => single pole on whichever side `odd_side` says.
+
+    safety >= 1: 1, then poles start half an interval away; >1 pushes them
+    farther.
+    """
+
+    if q == 0:
+        return numpy.empty(0)
+
+    Delta = 0.5 * (lam_p - lam_m)
+
+    # Decide how many poles on each side. m_L and m_R determine how many poles
+    # to be on the left and right of the support interval.
+    if q % 2 == 0:
+        m_L = m_R = q // 2
+    else:
+        if odd_side == 'left':
+            m_L = (q + 1) // 2
+            m_R = q // 2
+        else:
+            m_L = q // 2
+            m_R = (q + 1) // 2
+
+    # Chebyshev-extrema offsets  (all positive)
+    kL = numpy.arange(m_L)
+    tL = (2 * kL + 1) * numpy.pi / (2 * m_L)
+    offsL = safety * Delta * (1 + numpy.cos(tL))
+
+    kR = numpy.arange(m_R)
+    tR = (2 * kR + 1) * numpy.pi / (2 * m_R + (m_R == 0))
+    offsR = safety * Delta * (1 + numpy.cos(tR))
+
+    left = lam_m - offsL
+    right = lam_p + offsR
+
+    return numpy.sort(numpy.concatenate([left, right]))
+
+
+# ============
+# encode poles
+# ============
+
+def _encode_poles(a, lam_m, lam_p):
+    """
+    Map real pole a_j → unconstrained s_j,
+    so that the default left-of-interval pole stays left.
+    """
+
+    # half-width of the interval
+    d = 0.5 * (lam_p - lam_m)
+    # if a < lam_m, we want s ≥ 0; if a > lam_p, s < 0
+    return numpy.where(
+        a < lam_m,
+        numpy.log((lam_m - a) / d),   # zero at a = lam_m - d
+        -numpy.log((a - lam_p) / d)   # zero at a = lam_p + d
+    )
+
+
+# ============
+# decode poles
+# ============
+
+def _decode_poles(s, lam_m, lam_p):
+    """
+    Inverse map s_j → real pole a_j outside the interval.
+    """
+
+    d = 0.5 * (lam_p - lam_m)
+    return numpy.where(
+        s >= 0,
+        lam_m - d * numpy.exp(s),     # maps s=0 to a=lam_m−d (left)
+        lam_p + d * numpy.exp(-s)     # maps s=0 to a=lam_p+d (right)
+    )
+
+
+# ========
+# inner ls
+# ========
+
+# def _inner_ls(x, f, poles):  # TEST
+def _inner_ls(x, f, poles, p=1):
+    """
+    This is the inner least square (blazing fast).
+    """
+
+    if poles.size == 0 and p == -1:
+        return 0.0, 0.0, numpy.empty(0)
+
+    if poles.size == 0:                      # q = 0
+        # A = numpy.column_stack((numpy.ones_like(x), x))
+        cols = [numpy.ones_like(x)] if p >= 0 else []
+        if p == 1:
+            cols.append(x)
+        A = numpy.column_stack(cols)
+        # ---
+        theta, *_ = lstsq(A, f, rcond=None)
+        # c, D = theta  # TEST
+        if p == -1:
+            c = 0.0
+            D = 0.0
+            resid = numpy.empty(0)
+        elif p == 0:
+            c = theta[0]
+            D = 0.0
+            resid = numpy.empty(0)
+        else:  # p == 1
+            c, D = theta
+            resid = numpy.empty(0)
+    else:
+        # phi = 1.0 / (x[:, None] - poles[None, :])
+        # # A = numpy.column_stack((numpy.ones_like(x), x, phi))  # TEST
+        # # theta, *_ = lstsq(A, f, rcond=None)
+        # # c, D, resid = theta[0], theta[1], theta[2:]
+        # phi = 1.0 / (x[:, None] - poles[None, :])
+        # cols = [numpy.ones_like(x)] if p >= 0 else []
+        # if p == 1:
+        #     cols.append(x)
+        #     cols.append(phi)
+        #     A = numpy.column_stack(cols)
+        #     theta, *_ = lstsq(A, f, rcond=None)
+        # if p == -1:
+        #     c = 0.0
+        #     D = 0.0
+        #     resid = theta
+        # elif p == 0:
+        #     c = theta[0]
+        #     D = 0.0
+        #     resid = theta[1:]
+        # else:  # p == 1
+        #     c = theta[0]
+        #     D = theta[1]
+        #     resid = theta[2:]
+
+        phi = 1.0 / (x[:, None] - poles[None, :])
+        cols = [numpy.ones_like(x)] if p >= 0 else []
+        if p == 1:
+            cols.append(x)
+        cols.append(phi)
+
+        A = numpy.column_stack(cols)
+        theta, *_ = lstsq(A, f, rcond=None)
+
+        if p == -1:
+            c, D, resid = 0.0, 0.0, theta
+        elif p == 0:
+            c, D, resid = theta[0], 0.0, theta[1:]
+        else:  # p == 1
+            c, D, resid = theta[0], theta[1], theta[2:]
+
+    return c, D, resid
+
+
+# =============
+# eval rational
+# =============
+
+def _eval_rational(z, c, D, poles, resid):
+    """
+    """
+
+    # z = z[:, None]
+    # if poles.size == 0:
+    #     term = 0.0
+    # else:
+    #     term = numpy.sum(resid / (z - poles), axis=1)
+    #
+    # return c + D * z.ravel() + term
+
+    # ensure z is a 1-D array
+    z = numpy.asarray(z)
+    z_col = z[:, None]
+
+    if poles.size == 0:
+        term = 0.0
+    else:
+        term = numpy.sum(resid / (z_col - poles[None, :]), axis=1)
+
+    return c + D * z + term
+
+
+# ========
+# fit pade
+# ========
+
+def fit_pade(x, f, lam_m, lam_p, p=1, q=2, odd_side='left', safety=1.0,
+             max_outer=40, xtol=1e-12, ftol=1e-12, optimizer='ls', verbose=0):
+    """
+    This is the outer optimiser.
+
+    Fits  G(x) = (p>=1 ? c : 0) + (p==1 ? D x : 0) + sum r_j/(x - a_j) # TEST
+    """
+
+    # Checks
+    if not (odd_side in ['left', 'right']):
+        raise ValueError('"odd_side" can only be "left" or "right".')
+
+    if not (p in [-1, 0, 1]):
+        raise ValueError('"pade_p" can only be -1, 0, or 1.')
+
+    x = numpy.asarray(x, float)
+    f = numpy.asarray(f, float)
+
+    poles0 = _default_poles(q, lam_m, lam_p, safety=safety, odd_side=odd_side)
+    # if q == 0:                               # nothing to optimise
+    if q == 0 and p <= 0:
+        # c, D, resid = _inner_ls(x, f, poles0)  # TEST
+        c, D, resid = _inner_ls(x, f, poles0, p)
+        pade_sol = {
+            'c': c, 'D': D, 'poles': poles0, 'resid': resid,
+            'outer_iters': 0
+        }
+
+        return pade_sol
+
+    s0 = _encode_poles(poles0, lam_m, lam_p)
+
+    # --------
+    # residual
+    # --------
+
+    # def residual(s): # TEST
+    def residual(s, p=p):
+        poles = _decode_poles(s, lam_m, lam_p)
+        # c, D, resid = _inner_ls(x, f, poles) # TEST
+        c, D, resid = _inner_ls(x, f, poles, p)
+        return _eval_rational(x, c, D, poles, resid) - f
+
+    # ----------------
+
+    # Optimizer
+    if optimizer == 'ls':
+        # scale = numpy.maximum(1.0, numpy.abs(s0))
+        res = least_squares(residual, s0,
+                            method='trf',
+                            # method='lm',
+                            # x_scale=scale,
+                            max_nfev=max_outer, xtol=xtol, ftol=ftol,
+                            verbose=verbose)
+
+    elif optimizer == 'de':
+
+        # Bounds
+        # span = lam_p - lam_m
+        # B = 3.0  # multiples of span
+        # L = numpy.log(B * span)
+        # bounds = [(-L, L)] * len(s0)
+
+        d = 0.5*(lam_p - lam_m)
+        # the minimum factor so that lam_m - d*exp(s)=0 is exp(s)=lam_m/d
+        min_factor = lam_m/d
+        B = max(10.0, min_factor*10.0)
+        L = numpy.log(B)
+        bounds = [(-L, L)] * len(s0)
+
+        # Global stage
+        glob = differential_evolution(lambda s: numpy.sum(residual(s)**2),
+                                      bounds, maxiter=50, popsize=10,
+                                      polish=False)
+
+        # local polish
+        res = least_squares(
+                residual, glob.x,
+                method='lm',
+                max_nfev=max_outer, xtol=xtol, ftol=ftol,
+                verbose=verbose)
+
+    else:
+        raise RuntimeError('"optimizer" is invalid.')
+
+    poles = _decode_poles(res.x, lam_m, lam_p)
+    # c, D, resid = _inner_ls(x, f, poles) # TEST
+    c, D, resid = _inner_ls(x, f, poles, p)
+
+    pade_sol = {
+        'c': c, 'D': D, 'poles': poles, 'resid': resid,
+        'outer_iters': res.nfev
+    }
+
+    return pade_sol
+
+
+# =========
+# eval pade
+# =========
+
+def eval_pade(z, pade_sol):
+    """
+    """
+
+    # z_arr = numpy.asanyarray(z)                   # shape=(M,N)
+    # flat = z_arr.ravel()                          # shape=(M·N,)
+    # c, D = pade_sol['c'], pade_sol['D']
+    # poles = pade_sol['poles']
+    # resid = pade_sol['resid']
+    #
+    # # _eval_rational takes a 1-D array of z's and returns 1-D outputs
+    # flat_out = _eval_rational(flat, c, D, poles, resid)
+    #
+    # # restore the original shape
+    # out = flat_out.reshape(z_arr.shape)         # shape=(M,N)
+    #
+    # return out
+
+    z = numpy.asanyarray(z)      # complex or real, any shape
+    c, D = pade_sol['c'], pade_sol['D']
+    poles, resid = pade_sol['poles'], pade_sol['resid']
+
+    out = c + D*z
+    for bj, rj in zip(poles, resid):
+        out += rj/(z - bj)       # each is an (N,) op, no N×q temp
+    return out
+
+
+# ============
+# fit pade old
+# ============
+
+def fit_pade_old(x, f, lam_m, lam_p, p, q, delta=1e-8, B=numpy.inf,
+                 S=numpy.inf, B_default=10.0, S_factor=2.0, maxiter_de=200):
+    """
+    Fit a [p/q] rational P/Q of the form:
+      P(x) = s * prod_{i=0..p-1}(x - a_i)
+      Q(x) = prod_{j=0..q-1}(x - b_j)
+
+    Constraints:
+      a_i ∈ [lam_m, lam_p]
+      b_j ∈ (-infty, lam_m - delta] cup [lam_p + delta, infty)
+
+    Approach:
+      - Brute‐force all 2^q left/right assignments for denominator roots
+      - Global search with differential_evolution, fallback to zeros if needed
+      - Local refinement with least_squares
+
+    Returns a dict with keys:
+      's'     : optimal scale factor
+      'a'     : array of p numerator roots (in [lam_m, lam_p])
+      'b'     : array of q denominator roots (outside the interval)
+      'resid' : final residual norm
+      'signs' : tuple indicating left/right pattern for each b_j
+    """
+
+    # Determine finite bounds for DE
+    if not numpy.isfinite(B):
+        B_eff = B_default
+    else:
+        B_eff = B
+    if not numpy.isfinite(S):
+        # scale bound: S_factor * max|f| * interval width + safety
+        S_eff = S_factor * numpy.max(numpy.abs(f)) * (lam_p - lam_m) + 1.0
+        if S_eff <= 0:
+            S_eff = 1.0
+    else:
+        S_eff = S
+
+    def map_roots(signs, b):
+        """Map unconstrained b_j -> real root outside the interval."""
+        out = numpy.empty_like(b)
+        for j, (s_val, bj) in enumerate(zip(signs, b)):
+            if s_val > 0:
+                out[j] = lam_p + delta + numpy.exp(bj)
+            else:
+                out[j] = lam_m - delta - numpy.exp(bj)
+        return out
+
+    best = {'resid': numpy.inf}
+
+    # Enumerate all left/right sign patterns
+    for signs in product([-1, 1], repeat=q):
+        # Residual vector for current pattern
+        def resid_vec(z):
+            s_val = z[0]
+            a = z[1:1+p]
+            b = z[1+p:]
+            P = s_val * numpy.prod(x[:, None] - a[None, :], axis=1)
+            roots_Q = map_roots(signs, b)
+            Q = numpy.prod(x[:, None] - roots_Q[None, :], axis=1)
+            return P - f * Q
+
+        def obj(z):
+            r = resid_vec(z)
+            return r.dot(r)
+
+        # Build bounds for DE
+        bounds = []
+        bounds.append((-S_eff, S_eff))      # s
+        bounds += [(lam_m, lam_p)] * p      # a_i
+        bounds += [(-B_eff, B_eff)] * q     # b_j
+
+        # 1) Global search
+        try:
+            de = differential_evolution(obj, bounds,
+                                        maxiter=maxiter_de,
+                                        polish=False)
+            z0 = de.x
+        except ValueError:
+            # fallback: start at zeros
+            z0 = numpy.zeros(1 + p + q)
+
+        # 2) Local refinement
+        ls = least_squares(resid_vec, z0, xtol=1e-12, ftol=1e-12)
+
+        rnorm = numpy.linalg.norm(resid_vec(ls.x))
+        if rnorm < best['resid']:
+            best.update(resid=rnorm, signs=signs, x=ls.x.copy())
+
+    # Unpack best solution
+    z_best = best['x']
+    s_opt = z_best[0]
+    a_opt = z_best[1:1+p]
+    b_opt = map_roots(best['signs'], z_best[1+p:])
+
+    return {
+        's':     s_opt,
+        'a':     a_opt,
+        'b':     b_opt,
+        'resid': best['resid'],
+        'signs': best['signs'],
+    }
+
+
+# =============
+# eval pade old
+# =============
+
+def eval_pade_old(z, s, a, b):
+    """
+    """
+
+    Pz = s * numpy.prod([z - aj for aj in a], axis=0)
+    Qz = numpy.prod([z - bj for bj in b], axis=0)
+
+    return Pz / Qz

{freealg-0.0.3 → freealg-0.1.0}/freealg/_plot_util.py

@@ -23,34 +23,6 @@ __all__ = ['plot_fit', 'plot_density', 'plot_hilbert', 'plot_stieltjes',
            'plot_stieltjes_on_disk']
 
 
-# ==============
-# plot coeff fit
-# ==============
-
-def plot_coeff_fit(psi, latex=False, save=False):
-    """
-    """
-
-    with texplot.theme(use_latex=latex):
-
-        fig, ax = plt.subplots(figsize=(6, 2.7))
-
-        # Save
-        if save is False:
-            save_status = False
-            save_filename = ''
-        else:
-            save_status = True
-            if isinstance(save, str):
-                save_filename = save
-            else:
-                save_filename = 'energy.pdf'
-
-        texplot.show_or_save_plot(plt, default_filename=save_filename,
-                                  transparent_background=True, dpi=400,
-                                  show_and_save=save_status, verbose=True)
-
-
 # ========
 # plot fit
 # ========
@@ -400,6 +372,12 @@ def plot_stieltjes_on_disk(r, t, m1_D, m2_D, support, latex=False, save=False):
     lam_m_z = (lam_m - 1j) / (lam_m + 1j)
     theta_p = numpy.angle(lam_p_z)
     theta_n = numpy.angle(lam_m_z)
+
+    if theta_n < 0:
+        theta_n += 2.0 * numpy.pi
+    if theta_p < 0:
+        theta_p += 2.0 * numpy.pi
+
     theta_branch = numpy.linspace(theta_n, theta_p, 100)
     theta_alt_branch = numpy.linspace(theta_p, theta_n + 2*numpy.pi, 100)
     r_branch = numpy.ones_like(theta_branch)

freealg-0.1.0/freealg/_sample.py

@@ -0,0 +1,85 @@
+# 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
+# =======
+
+from scipy.integrate import cumulative_trapezoid
+from scipy.interpolate import interp1d
+from scipy.stats import qmc
+
+__all__ = ['qmc_sample']
+
+
+# =============
+# quantile func
+# =============
+
+def _quantile_func(x, rho):
+    """
+    Construct a quantile function from evaluations of an estimated density
+    on a grid (x, rho(x)).
+    """
+    cdf = cumulative_trapezoid(rho, x, initial=0)
+    cdf /= cdf[-1]
+    return interp1d(cdf, x, bounds_error=False, assume_sorted=True)
+
+
+# ==========
+# qmc sample
+# ==========
+
+def qmc_sample(x, rho, num_pts):
+    """
+    Low-discrepancy sampling from a univariate density estimate using
+    Quasi-Monte Carlo.
+
+    Parameters
+    ----------
+    x : numpy.array, shape (n,)
+        Sorted abscissae at which the density has been evaluated.
+
+    rho : numpy.array, shape (n,)
+        Density values corresponding to `x`. Must be non-negative and define
+        a valid probability density (i.e., integrate to 1 over the support).
+
+    num_pts : int
+        Number of sample points to generate from the density estimate.
+
+    Returns
+    -------
+    samples : numpy.array, shape (num_pts,)
+        Samples drawn from the estimated density using a one-dimensional Halton
+        sequence mapped through the estimated quantile function.
+
+    See Also
+    --------
+    scipy.stats.qmc.Halton
+        Underlying Quasi-Monte Carlo engine used for generating low-discrepancy
+        points.
+
+    Examples
+    --------
+    .. code-block:: python
+
+        >>> import numpy
+        >>> from your_module import qmc_sample
+        >>> x = numpy.linspace(0, 1, 200)
+        >>> rho = 3 * x**2                    # density of Beta(3,1) on [0,1]
+        >>> samples = qmc_sample(x, rho, num_pts=1000)
+        >>> assert samples.shape == (1000,)
+        >>> # Empirical mean should be close to 3/4
+        >>> numpy.allclose(samples.mean(), 0.75, atol=0.02)
+    """
+
+    quantile = _quantile_func(x, rho)
+    engine = qmc.Halton(d=1)
+    u = engine.random(num_pts)
+    samples = quantile(u)
+    return samples.ravel()

{freealg-0.0.3 → freealg-0.1.0}/freealg/distributions/__init__.py

@@ -7,10 +7,10 @@
 # directory of this source tree.
 
 from .marchenko_pastur import MarchenkoPastur
-# from .wigner import Wigner
-# from .kesten_mckay import KestenMcKay
-# from .wachter import Wachter
+from .wigner import Wigner
+from .kesten_mckay import KestenMcKay
+from .wachter import Wachter
 # from .meixner import meixner
 
 # __all__ = ['MarchenkoPastur', 'Wigner', 'KestenMcKay', 'Wachter', 'Meixner']
-__all__ = ['MarchenkoPastur']
+__all__ = ['MarchenkoPastur', 'Wigner', 'KestenMcKay', 'Wachter']