freealg 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

freealg/_linalg.py

@@ -21,19 +21,20 @@ __all__ = ['eigvalsh', 'cond', 'norm', 'trace', 'slogdet']
 # subsample apply
 # ===============
 
-def _subsample_apply(f, A, output_array=False):
+def _subsample_apply(f, A, output_array=False, seed=None):
     """
     Compute f(A_n) over subsamples A_n of A. If the output of
     f is an array (e.g. eigvals), specify output_array to be True.
     """
 
-    if A.ndim != 2 or A.shape[0] != A.shape[1]:
+    if (A.ndim != 2) or (A.shape[0] != A.shape[1]):
         raise RuntimeError("Only square matrices are permitted.")
 
     n = A.shape[0]
 
     # Size of sample matrix
-    n_s = int(80*(1 + numpy.log(n)))
+    n_s = int(80.0 * (1.0 + numpy.log(n)))
+
     # If matrix is not large enough, return eigenvalues
     if n < n_s:
         return f(A), n, n
@@ -43,14 +44,15 @@ def _subsample_apply(f, A, output_array=False):
 
     # Collect eigenvalue samples
     samples = []
+    rng = numpy.random.default_rng(seed=seed)
     for _ in range(num_samples):
-        indices = numpy.random.choice(n, n_s, replace=False)
+        indices = rng.choice(n, n_s, replace=False)
         samples.append(f(A[numpy.ix_(indices, indices)]))
 
     if output_array:
-        return numpy.concatenate(samples).ravel(), n, n_s
-
-    return numpy.array(samples), n, n_s
+        return numpy.concatenate(samples), n, n_s
+    else:
+        return numpy.array(samples), n, n_s
 
 
 # ========
@@ -83,7 +85,8 @@ def eigvalsh(A, size=None, psd=None, seed=None, plot=False, **kwargs):
         if all sampled eigenvalues are positive.
 
     seed : int, default=None
-        The seed for the Quasi-Monte Carlo sampler.
+        The seed for sampling rows/columns of matirx as well as the Quasi-Monte
+        Carlo sampler for eigenvalues from density.
 
     plot : bool, default=False
         Print out all relevant plots for diagnosing eigenvalue accuracy.
@@ -130,7 +133,8 @@ def eigvalsh(A, size=None, psd=None, seed=None, plot=False, **kwargs):
         >>> eigs = eigvalsh(A)
     """
 
-    samples, n, n_s = _subsample_apply(compute_eig, A, output_array=True)
+    samples, n, n_s = _subsample_apply(compute_eig, A, output_array=True,
+                                       seed=seed)
 
     if size is None:
         size = n
@@ -140,18 +144,28 @@ def eigvalsh(A, size=None, psd=None, seed=None, plot=False, **kwargs):
         psd = samples.min() > 0
 
     ff = FreeForm(samples)
+
     # Since we are resampling, we need to provide the correct matrix size
     ff.n = n_s
 
     # Perform fit and estimate eigenvalues
     order = 1 + int(len(samples)**0.2)
     ff.fit(method='chebyshev', K=order, projection='sample',
-           force=True, plot=False, latex=False, save=False)
+           continuation='wynn', force=True, plot=False, latex=False,
+           save=False)
 
     if plot:
         ff.density(plot=True)
         ff.stieltjes(plot=True)
 
+    # Sampling method using Pade seems to need a lower tolerance to properly
+    # work. Here we set defaults unless user provides otherwise. Note that the
+    # default of tolerance in ff._decompress is much larger (1e-4) for other
+    # methods (Newton, and non-sampling projections such as Gaussian and beta)
+    # to work properly.
+    kwargs.setdefault('tolerance', 1e-9)
+    kwargs.setdefault('method', 'secant')
+
     eigs = ff.eigvalsh(size, seed=seed, plot=plot, **kwargs)
 
     if psd:

freealg/_pade.py

@@ -12,7 +12,6 @@
 # =======
 
 import numpy
-import numba
 from numpy.linalg import lstsq
 from itertools import product
 from scipy.optimize import least_squares, differential_evolution
@@ -237,64 +236,6 @@ def _eval_rational(z, c, D, poles, resid):
     return c + D * z + term
 
 
-# =========
-# Wynn 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
 # ========
@@ -432,6 +373,8 @@ def eval_pade(z, pade_sol):
 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):
     """
+    Deprecated.
+
     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)
@@ -538,6 +481,7 @@ def fit_pade_old(x, f, lam_m, lam_p, p, q, delta=1e-8, B=numpy.inf,
 
 def eval_pade_old(z, s, a, b):
     """
+    Deprecated.
     """
 
     Pz = s * numpy.prod([z - aj for aj in a], axis=0)

freealg/_plot_util.py

@@ -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
 

freealg/_sample.py

@@ -27,10 +27,12 @@ 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)
 
 
@@ -45,6 +47,7 @@ def qmc_sample(x, rho, num_pts, seed=None):
 
     Parameters
     ----------
+
     x : numpy.array, shape (n,)
         Sorted abscissae at which the density has been evaluated.
 
@@ -72,23 +75,27 @@ def qmc_sample(x, rho, num_pts, seed=None):
 
     Examples
     --------
+
     .. code-block:: python
 
         >>> import numpy
-        >>> from your_module import qmc_sample
+        >>> from freealg import qmc_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]
+        >>> rho = 3 * x**2
+
         >>> 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)
     """
 
-    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)
+    engine = qmc.Halton(d=1, rng=rng)
     u = engine.random(num_pts)
     samples = quantile(u)
+
     return samples.ravel()

freealg/_series.py

@@ -0,0 +1,123 @@
+# 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__ = ['partial_sum', 'wynn_epsilon']
+
+
+# ===========
+# partial sum
+# ===========
+
+def partial_sum(coeffs, x):
+    """
+    Compute partial sum:
+
+    .. math::
+
+        S_n(x) = \\sum_{n=0}^{N} coeffs[n] * x^n.
+
+    Parameters
+    ----------
+
+    coeffs : array_like
+        Coefficients [a0, a1, a2, ...] of the power series of the size N.
+
+    x : numpy.array
+        A flattened array of the size d.
+
+    Returns
+    -------
+
+    Sn : numpy.ndarray
+        Partial sums of the size (N, d), where the n-th row is the n-th
+        partial sum.
+    """
+
+    xn = x.ravel()
+    N = len(coeffs)
+    d = xn.size
+
+    # Forming partial sum via Horner method
+    Sn = numpy.zeros((N, d), dtype=x.dtype)
+    sum_ = numpy.zeros((d,), dtype=x.dtype)
+    pow_x = numpy.ones((d,), dtype=x.dtype)
+
+    for n in range(N):
+        sum_ += coeffs[n] * pow_x
+        Sn[n, :] = sum_
+
+        if n < N-1:
+            pow_x *= xn
+
+    return Sn
+
+
+# ============
+# wynn epsilon
+# ============
+
+def wynn_epsilon(Sn):
+    """
+    Accelerate conversion of a series using Wynn's epsilon algorithm.
+
+    Parameters
+    ----------
+
+    Sn : numpy.ndarray
+        A 2D array of the size (N, d), where N is the number of partial sums
+        and d is the vector size.
+
+    Returns
+    -------
+
+    S : numpy.array
+        A 1D array of the size (d,) which is the accelerated value of the
+        series at each vector element.
+    """
+
+    # N: number of partial sums, d: vector size
+    N, d = Sn.shape
+
+    eps = numpy.zeros((N+1, N, d), dtype=Sn.dtype)
+    eps[0, :, :] = Sn
+
+    tol = numpy.finfo(float).eps
+
+    # Wynn's epsilon algorithm
+    for k in range(1, N+1):
+        Nk = N - k
+
+        delta = eps[k-1, 1:N-k+1, :] - eps[k-1, :Nk, :]
+
+        # Reciprocal of delta
+        rec_delta = numpy.empty_like(delta)
+
+        # Avoid division by zero error
+        mask_inf = numpy.abs(delta) < tol
+        rec_delta[mask_inf] = numpy.inf
+        rec_delta[~mask_inf] = 1.0 / delta[~mask_inf]
+
+        mask_zero = numpy.logical_or(numpy.isinf(delta),
+                                     numpy.isnan(delta))
+        rec_delta[mask_zero] = 0.0
+
+        eps[k, :Nk, :] = rec_delta
+
+        if k > 1:
+            eps[k, :Nk, :] += eps[k-2, 1:Nk+1, :]
+
+    k_even = 2 * (N // 2)
+    series = eps[k_even, 0, :]
+
+    return series

freealg/_support.py

@@ -109,6 +109,7 @@ def detect_support(eigs, method='asymp', k=None, p=0.001, **kwargs):
 
     Parameters
     ----------
+
     method : {``'range'``, ``'asymp'``, ``'jackknife'``, ``'regression'``,
                 ``'interior'``, ``'interior_smooth'``}, \
             default= ``'asymp'``
@@ -146,6 +147,7 @@ def detect_support(eigs, method='asymp', k=None, p=0.001, **kwargs):
            time-series. In Mathematical Proceedings of the Cambridge
            Philosophical Society (Vol. 45, No. 3, pp. 483-484). Cambridge
            University Press.
+
     .. [2] Cuevas, A., & Fraiman, R. (1997). A plug-in approach to support
            estimation. The Annals of Statistics, 2300-2312.
     """

freealg/_util.py

@@ -61,7 +61,7 @@ def beta_kde(eig, xs, lam_m, lam_p, h):
     if span <= 0:
         raise ValueError("lam_p must be larger than lam_m")
 
-    # map samples and grid to [0,1]
+    # map samples and grid to [0, 1]
     u = (eig - lam_m) / span
     t = (xs - lam_m) / span
 

freealg/distributions/_kesten_mckay.py

@@ -502,9 +502,6 @@ class KestenMcKay(object):
             :class: custom-dark
         """
 
-        if seed is not None:
-            numpy.random.seed(seed)
-
         if x_min is None:
             x_min = self.lam_m
 
@@ -523,14 +520,17 @@ class KestenMcKay(object):
         inv_cdf = interp1d(cdf, xs, bounds_error=False,
                            fill_value=(x_min, x_max))
 
+        # Random generator
+        rng = numpy.random.default_rng(seed)
+
         # Draw from uniform distribution
         if method == 'mc':
-            u = numpy.random.rand(size)
+            u = rng.random(size)
         elif method == 'qmc':
-            engine = qmc.Halton(d=1)
+            engine = qmc.Halton(d=1, rng=rng)
             u = engine.random(size)
         else:
-            raise ValueError('"method" is invalid.')
+            raise NotImplementedError('"method" is invalid.')
 
         # Draw from distribution by mapping from inverse CDF
         samples = inv_cdf(u).ravel()

freealg/distributions/_marchenko_pastur.py

@@ -268,7 +268,7 @@ class MarchenkoPastur(object):
     def _m_mp_numeric_vectorized(self, z, alt_branch=False, tol=1e-8):
         """
         Stieltjes transform (principal or secondary branch)
-        for Marchenko–Pastur distribution on upper half-plane.
+        for Marchenko-Pastur distribution on upper half-plane.
         """
 
         sigma = 1.0
@@ -509,9 +509,6 @@ class MarchenkoPastur(object):
             :class: custom-dark
         """
 
-        if seed is not None:
-            numpy.random.seed(seed)
-
         if x_min is None:
             x_min = self.lam_m
 
@@ -530,14 +527,17 @@ class MarchenkoPastur(object):
         inv_cdf = interp1d(cdf, xs, bounds_error=False,
                            fill_value=(x_min, x_max))
 
+        # Random generator
+        rng = numpy.random.default_rng(seed)
+
         # Draw from uniform distribution
         if method == 'mc':
-            u = numpy.random.rand(size)
+            u = rng.random(size)
         elif method == 'qmc':
-            engine = qmc.Halton(d=1)
+            engine = qmc.Halton(d=1, rng=rng)
             u = engine.random(size)
         else:
-            raise ValueError('"method" is invalid.')
+            raise NotImplementedError('"method" is invalid.')
 
         # Draw from distribution by mapping from inverse CDF
         samples = inv_cdf(u).ravel()
@@ -587,14 +587,12 @@ class MarchenkoPastur(object):
             >>> A = mp.matrix(2000)
         """
 
-        if seed is not None:
-            numpy.random.seed(seed)
-
         # Parameters
         m = int(size / self.lam)
 
         # Generate random matrix X (n x m) with i.i.d. standard normal entries.
-        X = numpy.random.randn(size, m)
+        rng = numpy.random.default_rng(seed)
+        X = rng.standard_normal((size, m))
 
         # Form the sample covariance matrix A = (1/m)*XX^T.
         A = X @ X.T / m

freealg/distributions/_meixner.py

@@ -534,9 +534,6 @@ class Meixner(object):
             :class: custom-dark
         """
 
-        if seed is not None:
-            numpy.random.seed(seed)
-
         if x_min is None:
             x_min = self.lam_m
 
@@ -555,14 +552,17 @@ class Meixner(object):
         inv_cdf = interp1d(cdf, xs, bounds_error=False,
                            fill_value=(x_min, x_max))
 
+        # Random generator
+        rng = numpy.random.default_rng(seed)
+
         # Draw from uniform distribution
         if method == 'mc':
-            u = numpy.random.rand(size)
+            u = rng.random(size)
         elif method == 'qmc':
-            engine = qmc.Halton(d=1)
+            engine = qmc.Halton(d=1, rng=rng)
             u = engine.random(size)
         else:
-            raise ValueError('"method" is invalid.')
+            raise NotImplementedError('"method" is invalid.')
 
         # Draw from distribution by mapping from inverse CDF
         samples = inv_cdf(u).ravel()

freealg/distributions/_wachter.py

@@ -509,9 +509,6 @@ class Wachter(object):
             :class: custom-dark
         """
 
-        if seed is not None:
-            numpy.random.seed(seed)
-
         if x_min is None:
             x_min = self.lam_m
 
@@ -530,14 +527,17 @@ class Wachter(object):
         inv_cdf = interp1d(cdf, xs, bounds_error=False,
                            fill_value=(x_min, x_max))
 
+        # Random generator
+        rng = numpy.random.default_rng(seed)
+
         # Draw from uniform distribution
         if method == 'mc':
-            u = numpy.random.rand(size)
+            u = rng.random(size)
         elif method == 'qmc':
-            engine = qmc.Halton(d=1)
+            engine = qmc.Halton(d=1, rng=rng)
             u = engine.random(size)
         else:
-            raise ValueError('"method" is invalid.')
+            raise NotImplementedError('"method" is invalid.')
 
         # Draw from distribution by mapping from inverse CDF
         samples = inv_cdf(u).ravel()
@@ -590,15 +590,13 @@ class Wachter(object):
             >>> A = wa.matrix(2000)
         """
 
-        if seed is not None:
-            numpy.random.seed(seed)
-
         n = size
         m1 = int(self.a * n)
         m2 = int(self.b * n)
 
-        X = numpy.random.randn(n, m1)
-        Y = numpy.random.randn(n, m2)
+        rng = numpy.random.default_rng(seed)
+        X = rng.standard_normal((n, m1))
+        Y = rng.standard_normal((n, m2))
 
         Sx = X @ X.T
         Sy = Y @ Y.T

freealg/distributions/_wigner.py

@@ -486,9 +486,6 @@ class Wigner(object):
             :class: custom-dark
         """
 
-        if seed is not None:
-            numpy.random.seed(seed)
-
         if x_min is None:
             x_min = self.lam_m
 
@@ -507,14 +504,17 @@ class Wigner(object):
         inv_cdf = interp1d(cdf, xs, bounds_error=False,
                            fill_value=(x_min, x_max))
 
+        # Random generator
+        rng = numpy.random.default_rng(seed)
+
         # Draw from uniform distribution
         if method == 'mc':
-            u = numpy.random.rand(size)
+            u = rng.random(size)
         elif method == 'qmc':
-            engine = qmc.Halton(d=1)
+            engine = qmc.Halton(d=1, rng=rng)
             u = engine.random(size)
         else:
-            raise ValueError('"method" is invalid.')
+            raise NotImplementedError('"method" is invalid.')
 
         # Draw from distribution by mapping from inverse CDF
         samples = inv_cdf(u).ravel()
@@ -564,12 +564,11 @@ class Wigner(object):
             >>> A = wg.matrix(2000)
         """
 
-        if seed is not None:
-            numpy.random.seed(seed)
+        rng = numpy.random.default_rng(seed)
 
         # Parameters
         n = size
-        X = numpy.random.randn(n, n)
+        X = rng.standard_normal(size=(n, n))
         X = (numpy.triu(X, 0) + numpy.triu(X, 1).T)
 
         return X * (self.r / (2.0 * numpy.sqrt(n)))