freealg 0.5.4__py3-none-any.whl → 0.6.1__py3-none-any.whl

freealg/freeform.py

@@ -12,10 +12,8 @@
 # =======
 
 import numpy
-from scipy.stats import gaussian_kde
-# from statsmodels.nonparametric.kde import KDEUnivariate
 from functools import partial
-from ._util import compute_eig, beta_kde, force_density
+from ._util import resolve_complex_dtype, compute_eig, kde, force_density
 from ._jacobi import jacobi_sample_proj, jacobi_kernel_proj, jacobi_density, \
     jacobi_stieltjes
 from ._chebyshev import chebyshev_sample_proj, chebyshev_kernel_proj, \
@@ -25,8 +23,8 @@ from ._damp import jackson_damping, lanczos_damping, fejer_damping, \
 from ._plot_util import plot_fit, plot_density, plot_hilbert, plot_stieltjes
 from ._pade import fit_pade, eval_pade
 from ._decompress import decompress
-from ._sample import qmc_sample
-from ._support import detect_support
+from ._sample import sample
+from ._support import supp
 
 # Fallback to previous numpy API
 if not hasattr(numpy, 'trapezoid'):
@@ -59,8 +57,21 @@ class FreeForm(object):
         Size of perturbations into the upper half plane for Plemelj's
         formula.
 
+    dtype : {``'complex128'``, ``'complex256'``}, default = ``'complex128'``
+        Data type for inner computations of complex variables:
+
+        * ``'complex128'``: 128-bit complex numbers, equivalent of two double
+          precision floating point.
+        * ``'complex256'``: 256-bit complex numbers, equivalent of two long
+          double precision floating point. This optino is only available on
+          Linux machines.
+
+        When using series acceleration methods (such as setting
+        ``continuation`` in :func:`fit` function to ``wynn-eps``), setting a
+        higher precision floating point arithmetics might improve conference.
+
     **kwargs : dict, optional
-        Parameters for the ``detect_support`` function can also be prescribed
+        Parameters for the :func:`supp` function can also be prescribed
         here when ``support=None``.
 
     Notes
@@ -135,7 +146,8 @@ class FreeForm(object):
     # init
     # ====
 
-    def __init__(self, A, support=None, delta=1e-6, **kwargs):
+    def __init__(self, A, support=None, delta=1e-6, dtype='complex128',
+                 **kwargs):
         """
         Initialization.
         """
@@ -144,6 +156,9 @@ class FreeForm(object):
         self.eig = None
         self.delta = delta    # Offset above real axis to apply Plemelj formula
 
+        # Data type for complex arrays
+        self.dtype = resolve_complex_dtype(dtype)
+
         # Eigenvalues
         if A.ndim == 1:
             # When A is a 1D array, it is assumed A is the eigenvalue array.
@@ -160,12 +175,16 @@ class FreeForm(object):
 
         # Support
         if support is None:
-            self.lam_m, self.lam_p = detect_support(self.eig, **kwargs)
+            # Detect support
+            self.lam_m, self.lam_p = supp(self.eig, **kwargs)
         else:
-            self.lam_m = support[0]
-            self.lam_p = support[1]
+            self.lam_m = float(support[0])
+            self.lam_p = float(support[1])
         self.support = (self.lam_m, self.lam_p)
 
+        # Number of quadrature points to evaluate Stieltjes using Gauss-Jacobi
+        self.n_quad = None
+
         # Initialize
         self.method = None                 # fitting rho: jacobi, chebyshev
         self.continuation = None           # analytic continuation: pade, wynn
@@ -173,15 +192,17 @@ class FreeForm(object):
         self.psi = None                    # coefficients of estimating rho
         self.alpha = None                  # Jacobi polynomials alpha parameter
         self.beta = None                   # Jacobi polynomials beta parameter
+        self.cache = {}                    # Cache inner-computations
 
     # ===
     # fit
     # ===
 
-    def fit(self, method='jacobi', K=10, alpha=0.0, beta=0.0, reg=0.0,
-            projection='gaussian', kernel_bw=0.001, damp=None, force=False,
-            continuation='pade', pade_p=0, pade_q=1, odd_side='left',
-            pade_reg=0.0, optimizer='ls', plot=False, latex=False, save=False):
+    def fit(self, method='jacobi', K=10, alpha=0.0, beta=0.0, n_quad=60,
+            reg=0.0, projection='gaussian', kernel_bw=0.001, damp=None,
+            force=False, continuation='pade', pade_p=0, pade_q=1,
+            odd_side='left', pade_reg=0.0, optimizer='ls', plot=False,
+            latex=False, save=False):
         """
         Fit model to eigenvalues.
 
@@ -205,6 +226,11 @@ class FreeForm(object):
             fitting model on the left side of interval. This should be greater
             then -1. This option is only applicable when ``method='jacobi'``.
 
+        n_quad : int, default=60
+            Number of quadrature points to evaluate Stieltjes transform later
+            on (when :func:`decompress` is called) using Gauss-Jacob
+            quadrature. This option is relevant only if ``method='jacobi'``.
+
         reg : float, default=0.0
             Tikhonov regularization coefficient.
 
@@ -234,7 +260,7 @@ class FreeForm(object):
             If `True`, it forces the density to have unit mass and to be
             strictly positive.
 
-        continuation : {``'pade'``, ``'wynn-eps'``, ``'wynn-rho'``,
+        continuation : {``'pade'``, ``'wynn-eps'``, ``'wynn-rho'``, \
             ``'levin'``, ``'weniger'``, ``'brezinski'``}, default= ``'pade'``
             Method of analytic continuation to construct the second branch of
             Steltjes transform in the lower-half complex plane:
@@ -242,10 +268,12 @@ class FreeForm(object):
             * ``'pade'``: using Riemann-Hilbert problem with Pade
               approximation.
             * ``'wynn-eps'``: Wynn's :math:`\\epsilon` algorithm.
-            * ``'wynn-rho'``: Wynn's :math:`\\rho` algorithm.
-            * ``'levin'``: Levin's :math:`u` transform.
-            * ``'weniger'``: Weniger's :math:`\\delta^2` algorithm.
-            * ``'brezinski'``: Brezinski's :math:`\\theta` algorithm.
+            * ``'wynn-rho'``: Wynn's :math:`\\rho` algorithm (`experimental`).
+            * ``'levin'``: Levin's :math:`u` transform (`experimental`).
+            * ``'weniger'``: Weniger's :math:`\\delta^2` algorithm
+              (`experimental`).
+            * ``'brezinski'``: Brezinski's :math:`\\theta` algorithm
+              (`experimental`).
 
         pade_p : int, default=0
             Degree of polynomial :math:`P(z)` is :math:`q+p` where :math:`p`
@@ -318,6 +346,10 @@ class FreeForm(object):
             >>> from freealg import FreeForm
         """
 
+        # Very important: reset cache whenever this function is called. This
+        # also empties all references holdign a cache copy.
+        self.cache.clear()
+
         if alpha <= -1:
             raise ValueError('"alpha" should be greater then "-1".')
 
@@ -333,56 +365,42 @@ class FreeForm(object):
         # Project eigenvalues to Jacobi polynomials basis
         if method == 'jacobi':
 
+            # Set number of Gauss-Jacobi quadratures. This is not used in this
+            # function (used later when decompress is called)
+            self.n_quad = n_quad
+
             if projection == 'sample':
                 psi = jacobi_sample_proj(self.eig, support=self.support, K=K,
                                          alpha=alpha, beta=beta, reg=reg)
-            else:
+            elif projection in ['gaussian', 'beta']:
                 # smooth KDE on a fixed grid
                 xs = numpy.linspace(self.lam_m, self.lam_p, 2000)
 
-                if projection == 'gaussian':
-                    pdf = gaussian_kde(self.eig, bw_method=kernel_bw)(xs)
-                else:
-                    pdf = beta_kde(self.eig, xs, self.lam_m, self.lam_p,
-                                   kernel_bw)
-
-                # Adaptive KDE
-                # k = KDEUnivariate(self.eig)
-                # k.fit(bw="silverman", fft=False, weights=None, gridsize=1024,
-                #       adaptive=True)
-                # pdf = k.evaluate(xs)
-
-                # import matplotlib.pyplot as plt
-                # plt.plot(xs, pdf)
-                # plt.grid(True)
-                # plt.show()
+                pdf = kde(self.eig, xs, self.lam_m, self.lam_p, kernel_bw,
+                          kernel=projection)
 
                 psi = jacobi_kernel_proj(xs, pdf, support=self.support, K=K,
                                          alpha=alpha, beta=beta, reg=reg)
+            else:
+                raise NotImplementedError('"projection" is invalid.')
 
         elif method == 'chebyshev':
 
             if projection == 'sample':
                 psi = chebyshev_sample_proj(self.eig, support=self.support,
                                             K=K, reg=reg)
-            else:
+            elif projection in ['gaussian', 'beta']:
                 # smooth KDE on a fixed grid
                 xs = numpy.linspace(self.lam_m, self.lam_p, 2000)
 
-                if projection == 'gaussian':
-                    pdf = gaussian_kde(self.eig, bw_method=kernel_bw)(xs)
-                else:
-                    pdf = beta_kde(self.eig, xs, self.lam_m, self.lam_p,
-                                   kernel_bw)
-
-                # Adaptive KDE
-                # k = KDEUnivariate(self.eig)
-                # k.fit(bw="silverman", fft=False, weights=None, gridsize=1024,
-                #       adaptive=True)
-                # pdf = k.evaluate(xs)
+                pdf = kde(self.eig, xs, self.lam_m, self.lam_p, kernel_bw,
+                          kernel=projection)
 
                 psi = chebyshev_kernel_proj(xs, pdf, support=self.support,
                                             K=K, reg=reg)
+            else:
+                raise NotImplementedError('"projection" is invalid.')
+
         else:
             raise NotImplementedError('"method" is invalid.')
 
@@ -639,8 +657,8 @@ class FreeForm(object):
         diff = x[:, None] - x_s[None, :]
         D = rho_s[None, :] / diff
 
-        # Principal‐value: wherever t == x_i, then diff == 0, zero that entry
-        # (numpy.isclose handles floating‐point exactly)
+        # Principal-value: wherever t == x_i, then diff == 0, zero that entry
+        # (numpy.isclose handles floating-point exactly)
         D[numpy.isclose(diff, 0.0)] = 0.0
 
         # Integrate each row over t using trapezoid rule on x_s
@@ -726,6 +744,7 @@ class FreeForm(object):
 
         See Also
         --------
+
         density
         hilbert
 
@@ -757,7 +776,7 @@ class FreeForm(object):
 
         # Create y if not given
         if (plot is False) and (y is None):
-            # Do no tuse a Cartesian grid. Create a 1D array z slightly above
+            # Do not use a Cartesian grid. Create a 1D array z slightly above
             # the real line.
             y = self.delta * 1j
             z = x.astype(complex) + y             # shape (Nx,)
@@ -809,29 +828,39 @@ class FreeForm(object):
         if self.psi is None:
             raise RuntimeError('"fit" the model first.')
 
-        # Allow for arbitrary input shapes
         z = numpy.asarray(z)
-        shape = z.shape
-        if len(shape) == 0:
-            shape = (1,)
-        z = z.reshape(-1, 1)
-
-        # # Set the number of bases as the number of x points insides support
-        # mask_sup = numpy.logical_and(z.real >= self.lam_m,
-        #                              z.real <= self.lam_p)
-        # n_base = 2 * numpy.sum(mask_sup)
 
         # Stieltjes function
         if self.method == 'jacobi':
-            stieltjes = partial(jacobi_stieltjes, psi=self.psi,
-                                support=self.support, alpha=self.alpha,
-                                beta=self.beta, continuation=self.continuation)
-            # n_base = n_base
+
+            # Number of quadrature points
+            if z.ndim == 2:
+                # set to twice num x points inside support. This oversampling
+                # avoids anti-aliasing when visualizing.
+                x = z[0, :].real
+                mask_sup = numpy.logical_and(x >= self.lam_m, x <= self.lam_p)
+                n_quad = 2 * numpy.sum(mask_sup)
+            else:
+                # If this is None, the calling function will handle it.
+                n_quad = self.n_quad
+
+            stieltjes = partial(jacobi_stieltjes, cache=self.cache,
+                                psi=self.psi, support=self.support,
+                                alpha=self.alpha, beta=self.beta,
+                                continuation=self.continuation,
+                                dtype=self.dtype, n_quad=n_quad)
 
         elif self.method == 'chebyshev':
             stieltjes = partial(chebyshev_stieltjes, psi=self.psi,
                                 support=self.support,
-                                continuation=self.continuation)
+                                continuation=self.continuation,
+                                dtype=self.dtype)
+
+        # Allow for arbitrary input shapes
+        shape = z.shape
+        if len(shape) == 0:
+            shape = (1,)
+        z = z.reshape(-1, 1)
 
         mask_p = z.imag >= 0.0
         mask_m = z.imag < 0.0
@@ -928,7 +957,7 @@ class FreeForm(object):
             Estimated spectral density at locations x. ``rho`` can be a 1D or
             2D array output:
 
-            * If ``size`` is a scalar, ``rho`` is a 1D array od the same size
+            * If ``size`` is a scalar, ``rho`` is a 1D array of the same size
               as ``x``.
             * If ``size`` is an array of size `n`, ``rho`` is a 2D array with
               `n` rows, where each row corresponds to decompression to a size.
@@ -1002,7 +1031,7 @@ class FreeForm(object):
             # Initial guess for roots (only for the first iteration)
             # if i == 0:
             #     roots = numpy.full(x.shape, numpy.mean(self.support) - 0.1j,
-            #                        dtype=numpy.complex128)
+            #                        dtype=self.dtype)
             roots = None
 
             rho[i, :], roots = decompress(
@@ -1081,7 +1110,7 @@ class FreeForm(object):
             size = self.n
 
         rho, x = self.decompress(size, **kwargs)
-        eigs = numpy.sort(qmc_sample(x, rho, size, seed=seed))
+        eigs = numpy.sort(sample(x, rho, size, method='qmc', seed=seed))
 
         return eigs
 

{freealg-0.5.4.dist-info → freealg-0.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.5.4
+Version: 0.6.1
 Summary: Free probability for large matrices
 Home-page: https://github.com/ameli/freealg
 Download-URL: https://github.com/ameli/freealg/archive/main.zip

freealg-0.6.1.dist-info/RECORD

@@ -0,0 +1,26 @@
+freealg/__init__.py,sha256=muuYCvlsXjuX1W67YGFca9nFxprFsALLyB3CrJpXFnY,728
+freealg/__version__.py,sha256=baAcEjLSYFIeNZF51tOMmA_zAMhN8HvKael-UU-Ruec,22
+freealg/_chebyshev.py,sha256=zkyVA8NLf7uUKlJdLz4ijd_SurdsqUgkA5nHGWSybaE,6916
+freealg/_damp.py,sha256=k2vtBtWOxQBf4qXaWu_En81lQBXbEO4QbxxWpvuVhdE,1802
+freealg/_decompress.py,sha256=bFhQx--uptWJ7OjVwEs_tWYT6mLijBKJ9EbrD24Sbl0,32199
+freealg/_jacobi.py,sha256=z0X6Ws_BEo_h8EQBzDNHGFhLF9F2PUmnGeBVs0bNL7w,10709
+freealg/_linalg.py,sha256=0BzJNTXiY1VH3OKrCFgbE0QHLgRoKyiILsBWtnygFGc,13141
+freealg/_pade.py,sha256=BthDHScn2lILTTU2hlGNP-8YqddU3Uyxe0n0FkprwDs,13645
+freealg/_plot_util.py,sha256=GKvmc1wjVGeqoomrULPbzBEt6P86FdoR2idBLYh5EDY,20068
+freealg/_sample.py,sha256=yLJSGlq27j8tA-kDntRwfHIUU8Oo2IOmOTxS8yTRGRU,3075
+freealg/_series.py,sha256=33LLCUe4svmV0eWyzhP_XClfDzccQHTW9WBJlYlLfHY,11475
+freealg/_support.py,sha256=nxDa2OFlWBgjD0_1qoSMWG7kub6-GIuxIA04n5bdaYw,6614
+freealg/_util.py,sha256=NaEhcOxbue44l_xAhefnNZYTy3pBBGBFyk9HdaRjQKo,6899
+freealg/freeform.py,sha256=FBC9ab-3JWaQibMAM4LlbYPYvELaUDReJWCwAG0Fwwg,43779
+freealg/distributions/__init__.py,sha256=t_yZyEkW_W_tSV9IvgYXtVASxD2BEdiNVXcV2ebMy8M,579
+freealg/distributions/_kesten_mckay.py,sha256=BM_U8cX3eRstbAA4IZRK4qA_6S9zcogaXeuHyKXen14,19897
+freealg/distributions/_marchenko_pastur.py,sha256=xwk40GwpLvEm9--FN7-T2NWtHTkfzcvOS4tFyrm71ww,16990
+freealg/distributions/_meixner.py,sha256=8zmDnoCp-GOMnd6T2rKLQaMfn6uFmSnd-i5PLlfGOUM,17526
+freealg/distributions/_wachter.py,sha256=d601xAaFSVGeK13SSDavjsJ5a-MJnI2mgzWiplX0Quk,16898
+freealg/distributions/_wigner.py,sha256=w8OlZL9pSfGnXVSSB6A4KBiImr0Zz4iH2PDLCHFfpaY,15877
+freealg-0.6.1.dist-info/licenses/AUTHORS.txt,sha256=0b67Nz4_JgIzUupHJTAZxu5QdSUM_HRM_X_w4xCb17o,30
+freealg-0.6.1.dist-info/licenses/LICENSE.txt,sha256=J-EEYEtxb3VVf_Bn1TYfWnpY5lMFIM15iLDDcnaDTPA,1443
+freealg-0.6.1.dist-info/METADATA,sha256=0iyTPrQe2ZBGlPQr9dAOsunwRx_KS6dRFSaz__Uq2oI,5530
+freealg-0.6.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+freealg-0.6.1.dist-info/top_level.txt,sha256=eR2wrgYwDdnnJ9Zf5PruPqe4kQav0GMvRsqct6y00Q8,8
+freealg-0.6.1.dist-info/RECORD,,

freealg-0.5.4.dist-info/RECORD

@@ -1,26 +0,0 @@
-freealg/__init__.py,sha256=KfzqG7qig6ZZCKqgHcC2ApTg4rTLkrbJsvVoJd8UFG8,625
-freealg/__version__.py,sha256=DITpct-LrdIsTgwx2NgH5Ghx5y8Xgz1YMimy1ZV5RTY,22
-freealg/_chebyshev.py,sha256=UHU9e9LyiTJcs_01h3oIbX8_QQ9wH0P8GRmA3phvWhU,6780
-freealg/_damp.py,sha256=k2vtBtWOxQBf4qXaWu_En81lQBXbEO4QbxxWpvuVhdE,1802
-freealg/_decompress.py,sha256=RKYnuLKMx1V6-XrFjYX1UkGMRbUD9Gmf9XTyS4ffPSc,31970
-freealg/_jacobi.py,sha256=k1zYZtvoA3_gcanqepIVSoA0RJrExtluQzDamkRz_Uk,7570
-freealg/_linalg.py,sha256=0BzJNTXiY1VH3OKrCFgbE0QHLgRoKyiILsBWtnygFGc,13141
-freealg/_pade.py,sha256=Ecm373RvBWznAaf8a5D9qtjcRA8O_8NQsePwto-dsP4,13656
-freealg/_plot_util.py,sha256=GKvmc1wjVGeqoomrULPbzBEt6P86FdoR2idBLYh5EDY,20068
-freealg/_sample.py,sha256=MUY9ZkJbdhbC5thoy5_JMRWOHz_OfqMfaH0g2VhKPhg,2550
-freealg/_series.py,sha256=MV8yDHentc06aqPuPlqrIQUNgG0-WiviD8ZWMmLWC0I,11490
-freealg/_support.py,sha256=ZfU0T7CCDaTXMdEHSbwOL-rMnCPvJWsRb6JtqUMsrzY,6441
-freealg/_util.py,sha256=xKhtPgbW4vHidNAG6F5c5aQhTaG4MmaUqCsxwjBznfU,3786
-freealg/freeform.py,sha256=i09DcRikLL6dlsu4JzoC1AQ7EHTyacx2fgyEz3hFakI,42432
-freealg/distributions/__init__.py,sha256=t_yZyEkW_W_tSV9IvgYXtVASxD2BEdiNVXcV2ebMy8M,579
-freealg/distributions/_kesten_mckay.py,sha256=4EvW0seBZUv-cZjuLzfVCredmrCiOJcQ_hJM0mJDl6g,19899
-freealg/distributions/_marchenko_pastur.py,sha256=r-jmz8Wq5vG0-x7rB0qvVemqvu0Oq6S-BN67pqH0uiw,16992
-freealg/distributions/_meixner.py,sha256=bZv-x4mwS4yjisKoYSZAffHXtvDEKEis-74BeAjK4_s,17530
-freealg/distributions/_wachter.py,sha256=rkAmrBLqD2zvpBh0F32aQBscjXv8earXDH9_BITgFF0,16900
-freealg/distributions/_wigner.py,sha256=w8OlZL9pSfGnXVSSB6A4KBiImr0Zz4iH2PDLCHFfpaY,15877
-freealg-0.5.4.dist-info/licenses/AUTHORS.txt,sha256=0b67Nz4_JgIzUupHJTAZxu5QdSUM_HRM_X_w4xCb17o,30
-freealg-0.5.4.dist-info/licenses/LICENSE.txt,sha256=J-EEYEtxb3VVf_Bn1TYfWnpY5lMFIM15iLDDcnaDTPA,1443
-freealg-0.5.4.dist-info/METADATA,sha256=JVYKHOmi-IQ1z0jMhAIBqzK1QbblWy9B2aEtGWvZdkQ,5530
-freealg-0.5.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-freealg-0.5.4.dist-info/top_level.txt,sha256=eR2wrgYwDdnnJ9Zf5PruPqe4kQav0GMvRsqct6y00Q8,8
-freealg-0.5.4.dist-info/RECORD,,