freealg 0.0.2__py3-none-any.whl → 0.1.0__py3-none-any.whl

freealg/__version__.py

@@ -1 +1 @@
-__version__ = "0.0.2"
+__version__ = "0.1.0"

freealg/_decompress.py

@@ -0,0 +1,136 @@
+# 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__ = ['decompress']
+
+
+# ==========
+# decompress
+# ==========
+
+def decompress(matrix, size, x=None, delta=1e-4, iterations=500, step_size=0.1,
+               tolerance=1e-4):
+    """
+    Free decompression of spectral density.
+
+    Parameters
+    ----------
+
+    matrix : FreeForm
+        The initial matrix to be decompressed
+
+    size : int
+        Size of the decompressed matrix.
+
+    x : numpy.array, default=None
+        Positions where density to be evaluated at. If `None`, an interval
+        slightly larger than the support interval will be used.
+
+    delta: float, default=1e-4
+        Size of the perturbation into the upper half plane for Plemelj's
+        formula.
+
+    iterations: int, default=500
+        Maximum number of Newton iterations.
+
+    step_size: float, default=0.1
+        Step size for Newton iterations.
+
+    tolerance: float, default=1e-4
+        Tolerance for the solution obtained by the Newton solver. Also
+        used for the finite difference approximation to the derivative.
+
+    Returns
+    -------
+
+    rho : numpy.array
+        Spectral density
+
+    See Also
+    --------
+
+    density
+    stieltjes
+
+    Notes
+    -----
+
+    Work in progress.
+
+    References
+    ----------
+
+    .. [1] tbd
+
+    Examples
+    --------
+
+    .. code-block:: python
+
+        >>> from freealg import FreeForm
+    """
+
+    alpha = size / matrix.n
+    m = matrix._eval_stieltjes
+    # Lower and upper bound on new support
+    hilb_lb = (1 / m(matrix.lam_m + delta * 1j)[1]).real
+    hilb_ub = (1 / m(matrix.lam_p + delta * 1j)[1]).real
+    lb = matrix.lam_m - (alpha - 1) * hilb_lb
+    ub = matrix.lam_p - (alpha - 1) * hilb_ub
+
+    # Create x if not given
+    if x is None:
+        radius = 0.5 * (ub - lb)
+        center = 0.5 * (ub + lb)
+        scale = 1.25
+        x_min = numpy.floor(center - radius * scale)
+        x_max = numpy.ceil(center + radius * scale)
+        x = numpy.linspace(x_min, x_max, 500)
+
+    def _char_z(z):
+        return z + (1 / m(z)[1]) * (1 - alpha)
+
+    # Ensure that input is an array
+    x = numpy.asarray(x)
+
+    target = x + delta * 1j
+
+    z = numpy.full(target.shape, numpy.mean(matrix.support) - .1j,
+                   dtype=numpy.complex128)
+
+    # Broken Newton steps can produce a lot of warnings. Removing them
+    # for now.
+    with numpy.errstate(all='ignore'):
+        for _ in range(iterations):
+            objective = _char_z(z) - target
+            mask = numpy.abs(objective) >= tolerance
+            if not numpy.any(mask):
+                break
+            z_m = z[mask]
+
+            # Perform finite difference approximation
+            dfdz = _char_z(z_m+tolerance) - _char_z(z_m-tolerance)
+            dfdz /= 2*tolerance
+            dfdz[dfdz == 0] = 1.0
+
+            # Perform Newton step
+            z[mask] = z_m - step_size * objective[mask] / dfdz
+
+    # Plemelj's formula
+    char_s = m(z)[1] / alpha
+    rho = numpy.maximum(0, char_s.imag / numpy.pi)
+    rho[numpy.isnan(rho) | numpy.isinf(rho)] = 0
+    rho = rho.reshape(*x.shape)
+
+    return rho, x, (lb, ub)

freealg/_jacobi.py

@@ -174,9 +174,7 @@ def jacobi_stieltjes(z, psi, support, alpha=0.0, beta=0.0, n_base=40):
         integrand = w_nodes * P_k_nodes                      # (n_quad,)
 
         # Broadcast over z: shape (n_quad, ...) / ...
-        # diff = u_z[None, ...] - t_nodes[:, None]           # (n_quad, ...)
         diff = u_z[None, ...] - t_nodes[:, None, None]       # (n_quad, Ny, Nx)
-        # m_k  = (integrand[:, None] / diff).sum(axis=0)     # shape like z
         m_k = (integrand[:, None, None] / diff).sum(axis=0)
 
         # Accumulate with factor 2/span

freealg/_pade.py

@@ -12,18 +12,342 @@
 # =======
 
 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, 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', 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)
@@ -125,11 +449,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

@@ -19,28 +19,51 @@ import colorsys
 import matplotlib.ticker as ticker
 import matplotlib.gridspec as gridspec
 
-__all__ = ['plot_coeff', 'plot_density', 'plot_hilbert', 'plot_stieltjes',
-           'plot_stieltjes_on_disk', 'plot_glue_fit']
+__all__ = ['plot_fit', 'plot_density', 'plot_hilbert', 'plot_stieltjes',
+           'plot_stieltjes_on_disk']
 
 
-# ==========
-# plot coeff
-# ==========
+# ========
+# plot fit
+# ========
 
-def plot_coeff(psi, latex=False, save=False):
+def plot_fit(psi, x_supp, g_supp, g_supp_approx, support, latex=False,
+             save=False):
     """
     """
 
     with texplot.theme(use_latex=latex):
 
-        fig, ax = plt.subplots(figsize=(6, 2.7))
+        fig, ax = plt.subplots(figsize=(9, 3), ncols=2)
+
+        # Plot psi
         n = numpy.arange(1, 1+psi.size)
-        ax.plot(n, psi**2, '-o', markersize=3, color='black')
-        ax.set_xlim([n[0]-1e-3, n[-1]+1e-3])
-        ax.set_xlabel(r'$k$')
-        ax.set_ylabel(r'$\vert \psi_k \vert^2$')
-        ax.set_title('Spectral Energy per Mode')
-        ax.set_yscale('log')
+        ax[0].plot(n, psi**2, '-o', markersize=3, color='black')
+        ax[0].set_xlim([n[0]-1e-3, n[-1]+1e-3])
+        ax[0].set_xlabel(r'$k$')
+        ax[0].set_ylabel(r'$\vert \psi_k \vert^2$')
+        ax[0].set_title('Spectral Energy per Mode')
+        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)$')
+
+        plt.tight_layout()
 
         # Save
         if save is False:
@@ -51,7 +74,7 @@ def plot_coeff(psi, latex=False, save=False):
             if isinstance(save, str):
                 save_filename = save
             else:
-                save_filename = 'energy.pdf'
+                save_filename = 'fit.pdf'
 
         texplot.show_or_save_plot(plt, default_filename=save_filename,
                                   transparent_background=True, dpi=400,
@@ -349,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)
@@ -462,45 +491,6 @@ def plot_stieltjes_on_disk(r, t, m1_D, m2_D, support, latex=False, save=False):
                                   show_and_save=save_status, verbose=True)
 
 
-# =============
-# plot glue fit
-# =============
-
-def plot_glue_fit(x_supp, g_supp, g_supp_approx, support, latex=False,
-                  save=False):
-    """
-    """
-
-    with texplot.theme(use_latex=latex):
-
-        fig, ax = plt.subplots(figsize=(6, 3))
-
-        lam_m, lam_p = support
-        ax.plot(x_supp, g_supp, color='black', label='Glue target')
-        ax.plot(x_supp, g_supp_approx, color='firebrick',
-                label='Glue estimate')
-        ax.legend(fontsize='small')
-        ax.set_xlim([lam_m, lam_p])
-        ax.set_title('Approximation of Glue function on real axis')
-        ax.set_xlabel(r'$x$')
-        ax.set_ylabel(r'$G(x)$')
-
-        # Save
-        if save is False:
-            save_status = False
-            save_filename = ''
-        else:
-            save_status = True
-            if isinstance(save, str):
-                save_filename = save
-            else:
-                save_filename = 'glue_fit.pdf'
-
-        texplot.show_or_save_plot(plt, default_filename=save_filename,
-                                  transparent_background=True, dpi=400,
-                                  show_and_save=save_status, verbose=True)
-
-
 # ============
 # plot samples
 # ============