freealg 0.1.11__py3-none-any.whl → 0.7.12__py3-none-any.whl

freealg/{_pade.py → _free_form/_pade.py}

@@ -12,9 +12,7 @@
 # =======
 
 import numpy
-import numba
 from numpy.linalg import lstsq
-from itertools import product
 from scipy.optimize import least_squares, differential_evolution
 
 __all__ = ['fit_pade', 'eval_pade']
@@ -28,8 +26,8 @@ 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
+    * 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
@@ -74,13 +72,13 @@ def _default_poles(q, lam_m, lam_p, safety=1.0, odd_side='left'):
 
 def _encode_poles(a, lam_m, lam_p):
     """
-    Map real pole a_j → unconstrained s_j,
+    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
+    # 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
@@ -94,13 +92,13 @@ def _encode_poles(a, lam_m, lam_p):
 
 def _decode_poles(s, lam_m, lam_p):
     """
-    Inverse map s_j → real pole a_j outside the interval.
+    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_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)
     )
 
@@ -109,32 +107,35 @@ def _decode_poles(s, lam_m, lam_p):
 # inner ls
 # ========
 
-def _inner_ls(x, f, poles, p=1, pade_reg=0.0):
+def _inner_ls(x, f, poles, dpq=1, pade_reg=0.0):
     """
     This is the inner least square (blazing fast).
+
+    dqp is the difference between the order of P (numerator) and Q
+    (denominator).
     """
 
-    if poles.size == 0 and p == -1:
+    if poles.size == 0 and dpq == -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 = [numpy.ones_like(x)] if dpq >= 0 else []
+        if dpq == 1:
             cols.append(x)
         A = numpy.column_stack(cols)
         # ---
         theta, *_ = lstsq(A, f, rcond=None)
         # c, D = theta  # TEST
-        if p == -1:
+        if dpq == -1:
             c = 0.0
             D = 0.0
             resid = numpy.empty(0)
-        elif p == 0:
+        elif dpq == 0:
             c = theta[0]
             D = 0.0
             resid = numpy.empty(0)
-        else:  # p == 1
+        else:  # dpq == 1
             c, D = theta
             resid = numpy.empty(0)
     else:
@@ -143,28 +144,28 @@ def _inner_ls(x, f, poles, p=1, pade_reg=0.0):
         # # 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 = [numpy.ones_like(x)] if dpq >= 0 else []
+        # if dpq == 1:
         #     cols.append(x)
         #     cols.append(phi)
         #     A = numpy.column_stack(cols)
         #     theta, *_ = lstsq(A, f, rcond=None)
-        # if p == -1:
+        # if dpq == -1:
         #     c = 0.0
         #     D = 0.0
         #     resid = theta
-        # elif p == 0:
+        # elif dpq == 0:
         #     c = theta[0]
         #     D = 0.0
         #     resid = theta[1:]
-        # else:  # p == 1
+        # else:  # dpq == 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 = [numpy.ones_like(x)] if dpq >= 0 else []
+        if dpq == 1:
             cols.append(x)
         cols.append(phi)
 
@@ -180,14 +181,14 @@ def _inner_ls(x, f, poles, p=1, pade_reg=0.0):
             # theta = numpy.linalg.solve(ATA, ATf)
 
             # figure out how many elements to skip
-            if p == 1:
+            if dpq == 1:
                 skip = 2     # skip c and D
-            elif p == 0:
+            elif dpq == 0:
                 skip = 1     # skip c only
             else:
                 skip = 0     # all entries are residues
 
-            # add λ only for the residue positions
+            # add lambda only for the residue positions
             n = ATA.shape[0]
             for i in range(skip, n):
                 ATA[i, i] += pade_reg
@@ -199,11 +200,11 @@ def _inner_ls(x, f, poles, p=1, pade_reg=0.0):
         else:
             theta, *_ = lstsq(A, f, rcond=None)
 
-        if p == -1:
+        if dpq == -1:
             c, D, resid = 0.0, 0.0, theta
-        elif p == 0:
+        elif dpq == 0:
             c, D, resid = theta[0], 0.0, theta[1:]
-        else:  # p == 1
+        else:  # dpq == 1
             c, D, resid = theta[0], theta[1], theta[2:]
 
     return c, D, resid
@@ -236,61 +237,12 @@ def _eval_rational(z, c, D, poles, resid):
 
     return c + D * z + term
 
-# ========
-# Wynn epsilon algorithm for Pade
-# ========
-
-@numba.jit(nopython=True, parallel=True)
-def wynn_pade(coeffs, x):
-    """
-    Given the coefficients of a power series
-        f(x) = sum_{n=0}^∞ coeffs[n] * x^n,
-    returns a function handle that computes the Pade approximant at any x
-    using Wynn's epsilon algorithm.
-
-    Parameters:
-        coeffs (list or array): Coefficients [a0, a1, a2, ...] of the power series.
-
-    Returns:
-        function: A function approximant(x) that returns the approximated value f(x).
-    """
-    # Number of coefficients
-    xn = x.ravel()
-    d = len(xn)
-    N = len(coeffs)
-    
-    # Compute the partial sums s_n = sum_{i=0}^n a_i * x^i for n=0,...,N-1
-    eps = numpy.zeros((N+1, N, d), dtype=numpy.complex128)
-    for i in numba.prange(d):
-        partial_sum = 0.0
-        for n in range(N):
-            partial_sum += coeffs[n] * (xn[i] ** n)
-            eps[0,n,i] = partial_sum
-
-    for i in numba.prange(d):
-        for k in range(1, N+1):
-            for j in range(N - k):
-                delta = eps[k-1, j+1,i] - eps[k-1, j,i]
-                if delta == 0:
-                    rec_delta = numpy.inf
-                elif numpy.isinf(delta) or numpy.isnan(delta):
-                    rec_delta = 0.0
-                else:
-                    rec_delta = 1.0 / delta
-                eps[k,j,i] = rec_delta
-                if k > 1:
-                    eps[k,j,i] += eps[k-2,j+1,i]
-
-    if (N % 2) == 0:
-        N -= 1
-    
-    return eps[N-1, 0, :].reshape(x.shape)
 
 # ========
 # fit pade
 # ========
 
-def fit_pade(x, f, lam_m, lam_p, p=1, q=2, odd_side='left', pade_reg=0.0,
+def fit_pade(x, f, lam_m, lam_p, p=2, 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):
     """
@@ -301,16 +253,19 @@ def fit_pade(x, f, lam_m, lam_p, p=1, q=2, odd_side='left', pade_reg=0.0,
     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.')
+    # Difference between the degrees of numerator and denominator
+    dpq = p - q
+    if not (dpq in [-1, 0, 1]):
+        raise ValueError('"pade_p" and "pade_q" can only differ by "+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:
+    if q == 0 and dpq <= 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)
+        c, D, resid = _inner_ls(x, f, poles0, dpq, pade_reg=pade_reg)
         pade_sol = {
             'c': c, 'D': D, 'poles': poles0, 'resid': resid,
             'outer_iters': 0
@@ -324,10 +279,10 @@ def fit_pade(x, f, lam_m, lam_p, p=1, q=2, odd_side='left', pade_reg=0.0,
     # residual
     # --------
 
-    def residual(s, p=p):
+    def residual(s, dpq=dpq):
         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)
+        c, D, resid = _inner_ls(x, f, poles, dpq, pade_reg=pade_reg)
         return _eval_rational(x, c, D, poles, resid) - f
 
     # ----------------
@@ -374,7 +329,7 @@ def fit_pade(x, f, lam_m, lam_p, p=1, q=2, odd_side='left', pade_reg=0.0,
 
     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)
+    c, D, resid = _inner_ls(x, f, poles, dpq, pade_reg=pade_reg)
 
     pade_sol = {
         'c': c, 'D': D, 'poles': poles, 'resid': resid,
@@ -393,7 +348,7 @@ def eval_pade(z, pade_sol):
     """
 
     # z_arr = numpy.asanyarray(z)                   # shape=(M,N)
-    # flat = z_arr.ravel()                          # 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']
@@ -412,126 +367,5 @@ def eval_pade(z, pade_sol):
 
     out = c + D*z
     for bj, rj in zip(poles, resid):
-        out += rj/(z - bj)       # each is an (N,) op, no N×q temp
+        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 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
-      - 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/{_plot_util.py → _free_form/_plot_util.py}

@@ -20,7 +20,7 @@ import matplotlib.ticker as ticker
 import matplotlib.gridspec as gridspec
 
 __all__ = ['plot_fit', 'plot_density', 'plot_hilbert', 'plot_stieltjes',
-           'plot_stieltjes_on_disk']
+           'plot_stieltjes_on_disk', 'plot_samples']
 
 
 # ========
@@ -34,7 +34,17 @@ def plot_fit(psi, x_supp, g_supp, g_supp_approx, support, latex=False,
 
     with texplot.theme(use_latex=latex):
 
-        fig, ax = plt.subplots(figsize=(9, 3), ncols=2)
+        if g_supp is None:
+            figsize = (4.5, 3)
+            ncols = 1
+        else:
+            figsize = (9, 3)
+            ncols = 2
+
+        fig, ax = plt.subplots(figsize=figsize, ncols=ncols)
+
+        if g_supp is None:
+            ax = [ax]
 
         # Plot psi
         n = numpy.arange(1, 1+psi.size)
@@ -46,22 +56,24 @@ def plot_fit(psi, x_supp, g_supp, g_supp_approx, support, latex=False,
         ax[0].set_yscale('log')
 
         # Plot pade
-        lam_m, lam_p = support
-        g_supp_min = numpy.min(g_supp)
-        g_supp_max = numpy.max(g_supp)
-        g_supp_dif = g_supp_max - g_supp_min
-        g_min = g_supp_min - g_supp_dif * 1.1
-        g_max = g_supp_max + g_supp_dif * 1.1
-
-        ax[1].plot(x_supp, g_supp, color='firebrick',
-                   label=r'$2 \pi \times $ Hilbert Transform')
-        ax[1].plot(x_supp, g_supp_approx, color='black', label='Pade estimate')
-        ax[1].legend(fontsize='small')
-        ax[1].set_xlim([lam_m, lam_p])
-        ax[1].set_ylim([g_min, g_max])
-        ax[1].set_title('Approximation of Glue Function')
-        ax[1].set_xlabel(r'$x$')
-        ax[1].set_ylabel(r'$G(x)$')
+        if g_supp is not None:
+            lam_m, lam_p = support
+            g_supp_min = numpy.min(g_supp)
+            g_supp_max = numpy.max(g_supp)
+            g_supp_dif = g_supp_max - g_supp_min
+            g_min = g_supp_min - g_supp_dif * 1.1
+            g_max = g_supp_max + g_supp_dif * 1.1
+
+            ax[1].plot(x_supp, g_supp, color='firebrick',
+                       label=r'$2 \pi \times $ Hilbert Transform')
+            ax[1].plot(x_supp, g_supp_approx, color='black',
+                       label='Pade estimate')
+            ax[1].legend(fontsize='small')
+            ax[1].set_xlim([lam_m, lam_p])
+            ax[1].set_ylim([g_min, g_max])
+            ax[1].set_title('Approximation of Glue Function')
+            ax[1].set_xlabel(r'$x$')
+            ax[1].set_ylabel(r'$G(x)$')
 
         plt.tight_layout()
 
@@ -129,7 +141,7 @@ def _auto_bins(array, method='scott', factor=5):
         num_bins = int(numpy.ceil(numpy.log2(len(array)) + 1))
 
     else:
-        raise ValueError('"method" is invalid.')
+        raise NotImplementedError('"method" is invalid.')
 
     return num_bins * factor
 
@@ -139,7 +151,7 @@ def _auto_bins(array, method='scott', factor=5):
 # ============
 
 def plot_density(x, rho, eig=None, support=None, label='',
-                 title='Spectral density', latex=False, save=False):
+                 title='Spectral Density', latex=False, save=False):
     """
     """
 
@@ -147,8 +159,11 @@ def plot_density(x, rho, eig=None, support=None, label='',
 
         fig, ax = plt.subplots(figsize=(6, 2.7))
 
-        if (support is not None) and (eig is not None):
-            lam_m, lam_p = support
+        if eig is not None:
+            if support is not None:
+                lam_m, lam_p = support
+            else:
+                lam_m, lam_p = min(eig), max(eig)
             bins = numpy.linspace(lam_m, lam_p, _auto_bins(eig))
             _ = ax.hist(eig, bins, density=True, color='silver',
                         edgecolor='none', label='Histogram')

freealg/{_sample.py → _free_form/_sample.py}

@@ -15,7 +15,7 @@ from scipy.integrate import cumulative_trapezoid
 from scipy.interpolate import PchipInterpolator
 from scipy.stats import qmc
 
-__all__ = ['qmc_sample']
+__all__ = ['sample']
 
 
 # =============
@@ -27,68 +27,104 @@ def _quantile_func(x, rho, clamp=1e-4, eps=1e-8):
     Construct a quantile function from evaluations of an estimated density
     on a grid (x, rho(x)).
     """
+
     rho_clamp = rho.copy()
     rho_clamp[rho < clamp] = eps
     cdf = cumulative_trapezoid(rho_clamp, x, initial=0)
     cdf /= cdf[-1]
-    return PchipInterpolator(cdf, x, extrapolate=False)
+    cdf_inv = PchipInterpolator(cdf, x, extrapolate=False)
+
+    return cdf_inv
 
 
-# ==========
-# qmc sample
-# ==========
+# ======
+# sample
+# ======
 
-def qmc_sample(x, rho, num_pts, seed=None):
+def sample(x, rho, num_pts, method='qmc', seed=None):
     """
-    Low-discrepancy sampling from a univariate density estimate using
-    Quasi-Monte Carlo.
+    Low-discrepancy sampling from density estimate.
 
     Parameters
     ----------
-    x : numpy.array, shape (n,)
-        Sorted abscissae at which the density has been evaluated.
 
-    rho : numpy.array, shape (n,)
+    x : numpy.array
+        Sorted abscissae at which the density has been evaluated. Shape `(n,)`.
+
+    rho : numpy.array
         Density values corresponding to `x`. Must be non-negative and define
         a valid probability density (i.e., integrate to 1 over the support).
+        Shape `(n,)`.
 
     num_pts : int
         Number of sample points to generate from the density estimate.
 
+    method : {``'mc'``, ``'qmc'``}, default= ``'qmc'``
+        Method of drawing samples from uniform distribution:
+
+        * ``'mc'``: Monte Carlo
+        * ``'qmc'``: Quasi Monte Carlo
+
     seed : int, default=None
         Seed for random number generator
 
     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.
+
+    freealg.supp
+    freealg.kde
+
+    Notes
+    -----
+
+    The underlying Quasi-Monte Carlo engine uses ``scipy.stats.qmc.Halton``
+    function for generating low-discrepancy points.
 
     Examples
     --------
+
     .. code-block:: python
+        :emphasize-lines: 8
 
         >>> import numpy
-        >>> from your_module import qmc_sample
+        >>> from freealg import sample
+
+        >>> # density of Beta(3,1) on [0,1]
         >>> 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)
+        >>> rho = 3 * x**2
+
+        >>> samples = sample(x, rho, num_pts=1000, method='qmc')
         >>> assert samples.shape == (1000,)
+
         >>> # Empirical mean should be close to 3/4
         >>> numpy.allclose(samples.mean(), 0.75, atol=0.02)
     """
 
-    if seed is not None:
-        numpy.random.rand(seed)
-
+    rng = numpy.random.default_rng(seed)
     quantile = _quantile_func(x, rho)
-    engine = qmc.Halton(d=1)
-    u = engine.random(num_pts)
+
+    # Draw from uniform distribution
+    if method == 'mc':
+        u = rng.random(num_pts)
+
+    elif method == 'qmc':
+        try:
+            engine = qmc.Halton(d=1, scramble=True, rng=rng)
+        except TypeError:
+            engine = qmc.Halton(d=1, scramble=True, seed=rng)
+        u = engine.random(num_pts).ravel()
+
+    else:
+        raise NotImplementedError('"method" is invalid.')
+
+    # Draw from distribution by mapping from inverse CDF
     samples = quantile(u)
+
     return samples.ravel()