freealg 0.0.3__py3-none-any.whl → 0.1.1__py3-none-any.whl

freealg/__version__.py

@@ -1 +1 @@
-__version__ = "0.0.3"
+__version__ = "0.1.1"

freealg/_chebyshev.py

@@ -14,14 +14,15 @@
 import numpy
 from scipy.special import eval_chebyu
 
-__all__ = ['chebyshev_proj', 'chebyshev_approx', 'chebyshev_stieltjes']
+__all__ = ['chebyshev_sample_proj', 'chebyshev_kernel_proj',
+           'chebyshev_approx', 'chebyshev_stieltjes']
 
 
-# ==============
-# chebyshev proj
-# ==============
+# =====================
+# chebyshev sample proj
+# =====================
 
-def chebyshev_proj(eig, support, K=10, reg=0.0):
+def chebyshev_sample_proj(eig, support, K=10, reg=0.0):
     """
     Estimate the coefficients \\psi_k in
 
@@ -81,6 +82,39 @@ def chebyshev_proj(eig, support, K=10, reg=0.0):
     return psi
 
 
+# =====================
+# chebyshev kernel proj
+# =====================
+
+def chebyshev_kernel_proj(xs, pdf, support, K=10, reg=0.0):
+    """
+    Projection of a *continuous* density given on a grid (xs, pdf)
+    onto the Chebyshev-II basis.
+
+    xs  : 1-D numpy array (original x–axis, not the t-variable)
+    pdf : same shape as xs, integrates to 1 on xs
+    """
+
+    lam_m, lam_p = support
+    t = (2.0 * xs - (lam_m + lam_p)) / (lam_p - lam_m)   # map to [−1,1]
+
+    norm = numpy.pi / 2.0
+    psi = numpy.empty(K + 1)
+
+    for k in range(K + 1):
+        Pk = eval_chebyu(k, t)                       # U_k(t) on the grid
+        moment = numpy.trapz(Pk * pdf, xs)           # \int U_k(t) \rho(x) dx
+
+        if k == 0:
+            penalty = 0
+        else:
+            penalty = reg * (k / (K + 1))**2
+
+        psi[k] = moment / (norm + penalty)
+
+    return psi
+
+
 # ================
 # chebyshev approx
 # ================

freealg/_jacobi.py

@@ -15,7 +15,8 @@ import numpy
 from scipy.special import eval_jacobi, roots_jacobi
 from scipy.special import gammaln, beta as Beta
 
-__all__ = ['jacobi_proj', 'jacobi_approx', 'jacobi_stieltjes']
+__all__ = ['jacobi_sample_proj', 'jacobi_kernel_proj', 'jacobi_approx',
+           'jacobi_stieltjes']
 
 
 # ==============
@@ -43,11 +44,11 @@ def jacobi_sq_norm(k, alpha, beta):
     return numpy.exp(lg_num - lg_den)
 
 
-# ===========
-# jacobi pro
-# ===========
+# ==================
+# jacobi sample proj
+# ==================
 
-def jacobi_proj(eig, support, K=10, alpha=0.0, beta=0.0, reg=0.0):
+def jacobi_sample_proj(eig, support, K=10, alpha=0.0, beta=0.0, reg=0.0):
     """
     """
 
@@ -76,6 +77,37 @@ def jacobi_proj(eig, support, K=10, alpha=0.0, beta=0.0, reg=0.0):
     return psi
 
 
+# ==================
+# jacobi kernel proj
+# ==================
+
+def jacobi_kernel_proj(xs, pdf, support, K=10, alpha=0.0, beta=0.0, reg=0.0):
+    """
+    Same moments as `jacobi_proj`, but the target is a *continuous* density
+    given on a grid (xs, pdf).
+    """
+
+    lam_m, lam_p = support
+    t = (2.0 * xs - (lam_p + lam_m)) / (lam_p - lam_m)      # map to [-1,1]
+    psi = numpy.empty(K + 1)
+
+    for k in range(K + 1):
+        Pk = eval_jacobi(k, alpha, beta, t)
+        N_k = jacobi_sq_norm(k, alpha, beta)
+
+        #  \int P_k(t) w(t) \rho(t) dt. w(t) cancels with pdf already being rho
+        moment = numpy.trapz(Pk * pdf, xs)
+
+        if k == 0:
+            penalty = 0
+        else:
+            penalty = reg * (k / (K + 1))**2
+
+        psi[k] = moment / (N_k + penalty)
+
+    return psi
+
+
 # =============
 # jacobi approx
 # =============

freealg/_pade.py

@@ -12,26 +12,374 @@
 # =======
 
 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, p=1, pade_reg=0.0):
+    """
+    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) # TEST
+        if pade_reg > 0:
+            ATA = A.T.dot(A)
+
+            # # add pade_reg * I
+            # ATA.flat[:: ATA.shape[1]+1] += pade_reg
+            # ATf = A.T.dot(f)
+            # theta = numpy.linalg.solve(ATA, ATf)
+
+            # figure out how many elements to skip
+            if p == 1:
+                skip = 2     # skip c and D
+            elif p == 0:
+                skip = 1     # skip c only
+            else:
+                skip = 0     # all entries are residues
+
+            # add λ only for the residue positions
+            n = ATA.shape[0]
+            for i in range(skip, n):
+                ATA[i, i] += pade_reg
+
+            # then solve
+            ATf = A.T.dot(f)
+            theta = numpy.linalg.solve(ATA, ATf)
+
+        else:
+            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, q, delta=1e-8, B=numpy.inf, S=numpy.inf,
-             B_default=10.0, S_factor=2.0, maxiter_de=200):
+def fit_pade(x, f, lam_m, lam_p, p=1, q=2, odd_side='left', pade_reg=0.0,
+             safety=1.0, max_outer=40, xtol=1e-12, ftol=1e-12, optimizer='ls',
+             verbose=0):
+    """
+    This is the outer optimiser.
+    """
+
+    # 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 and p <= 0:
+        # c, D, resid = _inner_ls(x, f, poles0, pade_reg=pade_reg)  # TEST
+        c, D, resid = _inner_ls(x, f, poles0, p, pade_reg=pade_reg)
+        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, p=p):
+        poles = _decode_poles(s, lam_m, lam_p)
+        # c, D, resid = _inner_ls(x, f, poles, pade_reg=pade_reg) # TEST
+        c, D, resid = _inner_ls(x, f, poles, p, pade_reg=pade_reg)
+        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, pade_reg=pade_reg) # TEST
+    c, D, resid = _inner_ls(x, f, poles, p, pade_reg=pade_reg)
+
+    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)
+      a_i in [lam_m, lam_p]
+      b_j in (-infty, lam_m - delta] cup [lam_p + delta, infty)
 
     Approach:
       - Brute‐force all 2^q left/right assignments for denominator roots
@@ -125,11 +473,11 @@ def fit_pade(x, f, lam_m, lam_p, p, q, delta=1e-8, B=numpy.inf, S=numpy.inf,
     }
 
 
-# =========
-# eval pade
-# =========
+# =============
+# eval pade old
+# =============
 
-def eval_pade(z, s, a, b):
+def eval_pade_old(z, s, a, b):
     """
     """
 

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/_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/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']