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

freealg/_decompress.py

@@ -1,180 +0,0 @@
-# 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 scipy.integrate import solve_ivp
-
-__all__ = ['decompress', 'reverse_characteristics']
-
-
-# ==========
-# decompress
-# ==========
-
-def decompress(freeform, size, x=None, delta=1e-4, iterations=500,
-               step_size=0.1, tolerance=1e-4):
-    """
-    Free decompression of spectral density.
-
-    Parameters
-    ----------
-
-    freeform : FreeForm
-        The initial freeform object of 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 / freeform.n
-    m = freeform._eval_stieltjes
-    # Lower and upper bound on new support
-    hilb_lb = (1 / m(freeform.lam_m + delta * 1j)[1]).real
-    hilb_ub = (1 / m(freeform.lam_p + delta * 1j)[1]).real
-    lb = freeform.lam_m - (alpha - 1) * hilb_lb
-    ub = freeform.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(freeform.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)
-
-
-# =======================
-# reverse characteristics
-# =======================
-
-def reverse_characteristics(freeform, z_inits, T, iterations=500,
-                            step_size=0.1, tolerance=1e-8):
-    """
-    """
-
-    t_span = (0, T)
-    t_eval = numpy.linspace(t_span[0], t_span[1], 50)
-
-    m = freeform._eval_stieltjes
-
-    def _char_z(z, t):
-        return z + (1 / m(z)[1]) * (1 - numpy.exp(t))
-
-    target_z, target_t = numpy.meshgrid(z_inits, t_eval)
-
-    z = numpy.full(target_z.shape, numpy.mean(freeform.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_t) - target_z
-            mask = numpy.abs(objective) >= tolerance
-            if not numpy.any(mask):
-                break
-            z_m = z[mask]
-            t_m = target_t[mask]
-
-            # Perform finite difference approximation
-            dfdz = _char_z(z_m+tolerance, t_m) - _char_z(z_m-tolerance, t_m)
-            dfdz /= 2*tolerance
-            dfdz[dfdz == 0] = 1.0
-
-            # Perform Newton step
-            z[mask] = z_m - step_size * objective[mask] / dfdz
-
-    return z

freealg/_jacobi.py

@@ -1,218 +0,0 @@
-# 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 scipy.special import eval_jacobi, roots_jacobi
-from scipy.special import gammaln, beta as Beta
-
-__all__ = ['jacobi_sample_proj', 'jacobi_kernel_proj', 'jacobi_approx',
-           'jacobi_stieltjes']
-
-
-# ==============
-# jacobi sq norm
-# ==============
-
-def jacobi_sq_norm(k, alpha, beta):
-    """
-    Norm of P_k
-    Special-case k = 0 to avoid gamma(0) issues when alpha + beta + 1 = 0.
-    """
-
-    if k == 0:
-        return 2.0**(alpha + beta + 1) * Beta(alpha + 1, beta + 1)
-
-    # Use logs instead to avoid overflow in gamma function.
-    lg_num = (alpha + beta + 1) * numpy.log(2.0) \
-        + gammaln(k + alpha + 1) \
-        + gammaln(k + beta + 1)
-
-    lg_den = numpy.log(2*k + alpha + beta + 1) \
-        + gammaln(k + 1) \
-        + gammaln(k + alpha + beta + 1)
-
-    return numpy.exp(lg_num - lg_den)
-
-
-# ==================
-# jacobi sample proj
-# ==================
-
-def jacobi_sample_proj(eig, support, K=10, alpha=0.0, beta=0.0, reg=0.0):
-    """
-    """
-
-    lam_m, lam_p = support
-
-    # Convert to [-1, 1] interval
-    x = (2.0 * eig - (lam_p + lam_m)) / (lam_p - lam_m)
-
-    psi = numpy.empty(K + 1)
-
-    # Empirical moments and coefficients
-    for k in range(K + 1):
-        moment = numpy.mean(eval_jacobi(k, alpha, beta, x))
-        N_k = jacobi_sq_norm(k, alpha, beta)  # normalization
-
-        if k == 0:
-            # Do not penalize at k=0, as this  keeps unit mass.
-            # k=0 has unit mass, while k>0 has zero mass by orthogonality.
-            penalty = 0
-        else:
-            penalty = reg * (k / (K + 1))**2
-
-        # Add regularization on the diagonal
-        psi[k] = moment / (N_k + penalty)
-
-    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
-# =============
-
-def jacobi_approx(x, psi, support, alpha=0.0, beta=0.0):
-    """
-    Reconstruct Jacobi approximation.
-
-    Parameters
-    ----------
-
-    psi : array_like, shape (K+1, )
-        Jacobi expansion coefficients.
-
-    x : array_like
-        Points (in original eigenvalue scale) to evaluate at.
-
-    support : tuple (lam_m, lam_p)
-
-    alpha : float
-        Jacobi parameter.
-
-    beta : float
-        Jacobi parameter.
-
-    Returns
-    -------
-
-    rho : ndarray
-    """
-
-    lam_m, lam_p = support
-    t = (2 * x - (lam_p + lam_m)) / (lam_p - lam_m)
-    w = (1 - t)**alpha * (1 + t)**beta
-    P = numpy.vstack([eval_jacobi(k, alpha, beta, t) for k in range(len(psi))])
-
-    rho_t = w * (psi @ P)                            # density in t–variable
-    rho_x = rho_t * (2.0 / (lam_p - lam_m))          # back to x–variable
-
-    return rho_x
-
-
-# ================
-# jacobi stieltjes
-# ================
-
-def jacobi_stieltjes(z, psi, support, alpha=0.0, beta=0.0, n_base=40):
-    """
-    Compute m(z) = sum_k psi_k * m_k(z) where
-
-    m_k(z) = \\int w^{(alpha, beta)}(t) P_k^{(alpha, beta)}(t) / (u(z)-t) dt
-
-    Each m_k is evaluated *separately* with a Gauss–Jacobi rule sized
-    for that k.  This follows the user's request: 1 quadrature rule per P_k.
-
-    Parameters
-    ----------
-
-    z : complex or ndarray
-
-    psi : (K+1,) array_like
-
-    support : (lambda_minus, lambda_plus)
-
-    alpha, beta : float
-
-    n_base : int
-        Minimum quadrature size.  For degree-k polynomial we use
-        n_quad = max(n_base, k+1).
-
-    Returns
-    -------
-
-    m1 : ndarray  (same shape as z)
-
-    m12 : ndarray  (same shape as z)
-    """
-
-    z = numpy.asarray(z, dtype=numpy.complex128)
-    lam_minus, lam_plus = support
-    span = lam_plus - lam_minus
-    centre = 0.5 * (lam_plus + lam_minus)
-    u_z = (2.0 / span) * (z - centre)          # map z -> u
-
-    m_total = numpy.zeros_like(z, dtype=numpy.complex128)
-
-    for k, psi_k in enumerate(psi):
-        # Select quadrature size tailored to this P_k
-        n_quad = max(n_base, k + 1)
-        t_nodes, w_nodes = roots_jacobi(n_quad, alpha, beta)  # (n_quad,)
-
-        # Evaluate P_k at the quadrature nodes
-        P_k_nodes = eval_jacobi(k, alpha, beta, t_nodes)     # (n_quad,)
-
-        # Integrand values at nodes: w_nodes already include the weight
-        integrand = w_nodes * P_k_nodes                      # (n_quad,)
-
-        # Broadcast over z: shape (n_quad, ...) / ...
-        diff = u_z[None, ...] - t_nodes[:, None, None]       # (n_quad, Ny, Nx)
-        m_k = (integrand[:, None, None] / diff).sum(axis=0)
-
-        # Accumulate with factor 2/span
-        m_total += psi_k * (2.0 / span) * m_k
-
-    # We use a negative sign convention
-    m_total = -m_total
-
-    return m_total

freealg/_support.py

@@ -1,85 +0,0 @@
-import numpy
-from scipy.stats import gaussian_kde
-
-def detect_support(eigs, method='interior_smooth', k = None, p = 0.001, **kwargs):
-    """
-    Estimates the support of the eigenvalue density.
-
-    Parameters
-    ----------
-    method : {``'range'``, ``'jackknife'``, ``'regression'``, ``'interior'``, 
-                ``'interior_smooth'``}, \
-            default= ``'jackknife'``
-        The method of support estimation:
-
-        * ``'range'``: no estimation; the support is the range of the eigenvalues
-        * ``'jackknife'``: estimates the support using Quenouille's [1]
-            jackknife estimator. Fast and simple, more accurate than the range.
-        * ``'regression'``: estimates the support by performing a regression under
-            the assumption that the edge behavior is of square-root type. Often
-            most accurate.
-        * ``'interior'``: estimates a support assuming the range overestimates;
-            uses quantiles (p, 1-p).
-        * ``'interior_smooth'``: same as ``'interior'`` but using kernel density
-            estimation.
-
-    k : int, default = None
-        Number of extreme order statistics to use for ``method='regression'``. 
-    
-    p : float, default=0.001
-        The edges of the support of the distribution is detected by the
-        :math:`p`-quantile on the left and :math:`(1-p)`-quantile on the right
-        where ``method='interior'`` or ``method='interior_smooth'``.
-        This value should be between 0 and 1, ideally a small number close to
-        zero.
-
-    References
-    ----------
-
-    .. [1] Quenouille, M. H. (1949, July). Approximate tests of correlation in time-series. 
-        In Mathematical Proceedings of the Cambridge Philosophical Society (Vol. 45, No. 3, 
-        pp. 483-484). Cambridge University Press.
-    """
-
-    if method=='range':
-        lam_m = eigs.min()
-        lam_p = eigs.max()
-
-    elif method=='jackknife':
-        x, n = numpy.sort(eigs), len(eigs)
-        lam_m = x[0]  - (n - 1)/n * (x[1]  - x[0])
-        lam_p = x[-1] + (n - 1)/n * (x[-1] - x[-2])
-
-    elif method=='regression':
-        x, n = numpy.sort(eigs), len(eigs)
-        if k is None:
-            k = int(round(n ** (2/3)))
-            k = max(5, min(k, n // 2))
-
-        # The theoretical cdf near the edge behaves like const*(x - a)^{3/2},
-        # so (i/n) ≈ (x - a)^{3/2}  ⇒  x ≈ a + const*(i/n)^{2/3}.
-        y = ((numpy.arange(1, k + 1) - 0.5) / n) ** (2 / 3)
-
-        # Left edge: regress x_{(i)} on y
-        _, lam_m = numpy.polyfit(y, x[:k], 1)
-
-        # Right edge: regress x_{(n-i+1)} on y
-        _, lam_p = numpy.polyfit(y, x[-k:][::-1], 1)
-
-    elif method=='interior':
-        lam_m, lam_p = numpy.quantile(eigs, [p, 1-p])
-    
-    elif method=='interior_smooth':
-        kde = gaussian_kde(eigs)
-        xs = numpy.linspace(eigs.min(), eigs.max(), 1000)
-        fs = kde(xs)
-
-        cdf = numpy.cumsum(fs)
-        cdf /= cdf[-1]
-
-        lam_m = numpy.interp(p, cdf, xs)
-        lam_p = numpy.interp(1-p, cdf, xs)
-    else:
-        raise NotImplementedError("Unknown method")
-
-    return lam_m, lam_p