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

freealg/__version__.py

@@ -1 +1 @@
-__version__ = "0.6.0"
+__version__ = "0.6.1"

freealg/_chebyshev.py

@@ -203,7 +203,7 @@ def chebyshev_stieltjes(z, psi, support, continuation='pade',
         Methof of analytiv continuation.
 
     dtype : numpy.type, default=numpy.complex128
-        Data type for compelx arrays. This might enhance series acceleration.
+        Data type for complex arrays. This might enhance series acceleration.
 
     Returns
     -------
@@ -218,7 +218,7 @@ def chebyshev_stieltjes(z, psi, support, continuation='pade',
     span = lam_p - lam_m
     center = 0.5 * (lam_m + lam_p)
 
-    # Map z -> u in the standard [-1,1] domain
+    # Map z to u in the standard [-1,1] domain
     u = (2.0 * (z - center)) / span
 
     # Inverse-Joukowski: pick branch sqrt with +Im
@@ -232,15 +232,15 @@ def chebyshev_stieltjes(z, psi, support, continuation='pade',
 
     # This depends on the method of analytic continuation
     if continuation == 'pade':
-        # Build powers J^(k+1) for k = 0, ..., K
+        # Horner summation for S0(J) = sum_{k=0}^K psi_k * J**k
         K = len(psi) - 1
-        Jpow = J[..., None] ** numpy.arange(1, K+2)  # shape: (..., K+1)
-
-        # Summing psi_k * J^(k+1)
-        S = numpy.sum(psi * Jpow, axis=-1)
+        S0 = numpy.zeros_like(J)
+        for k in range(K, -1, -1):
+            S0 = psi[k] + J * S0
+        S = J * S0
 
     else:
-        # Flatten J before passing to Wynn method.
+        # Flatten J before passing to any of the acceleration methods.
         psi_zero = numpy.concatenate([[0.0], psi])
         Sn = partial_sum(psi_zero, J.ravel(), p=0)
 

freealg/_jacobi.py

@@ -97,7 +97,7 @@ def jacobi_kernel_proj(xs, pdf, support, K=10, alpha=0.0, beta=0.0, reg=0.0):
         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
+        # \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:
@@ -168,36 +168,41 @@ def jacobi_density(x, psi, support, alpha=0.0, beta=0.0):
 # jacobi stieltjes
 # ================
 
-def jacobi_stieltjes(z, psi, support, alpha=0.0, beta=0.0, n_base=40,
+def jacobi_stieltjes(z, cache, psi, support, alpha=0.0, beta=0.0, n_quad=None,
                      continuation='pade', dtype=numpy.complex128):
     """
     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
+    .. math::
+
+        m_k(z) = \\int \\frac{w^{(alpha, beta)}(t) P_k^{(alpha, beta)}(t)}{
+        (u(z)-t)} \\mathrm{d} t
 
     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.
+    for that k. This follows the user's request: 1 quadrature rule per P_k.
 
     Parameters
     ----------
 
     z : complex or ndarray
 
+    cache : dict
+        Pass a dict to enable cross-call caching.
+
     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).
+    n_quad : int, default=None
+        Number of Gauss-Jacobi quadrature points.
 
     continuation : str, default= ``'pade'``
-        Methof of analytiv continuation.
+        Method of analytic continuation.
 
     dtype : numpy.type, default=numpy.complex128
-        Data type for compelx arrays. This might enhance series acceleration.
+        Data type for complex arrays. This might enhance series acceleration.
 
     Returns
     -------
@@ -209,67 +214,132 @@ def jacobi_stieltjes(z, psi, support, alpha=0.0, beta=0.0, n_base=40,
         Same shape as z
     """
 
+    if not isinstance(cache, dict):
+        raise TypeError('"cache" must be a dict; pass a persistent dict '
+                        '(e.g., self.cache).')
+
+    # Number of quadratures
+    if 'n_quad' not in cache:
+        if n_quad is None:
+            # Set number of quadratures based on Bernstein ellipse. Here using
+            # an evaluation point a with distance delta from support, to
+            # achieve the quadrature error below tol.
+            tol = 1e-16
+            delta = 1e-2
+            n_quad = int(-numpy.log(tol) / (2.0 * numpy.sqrt(delta)))
+        n_quad = max(n_quad, psi.size)
+        cache['n_quad'] = n_quad
+    else:
+        n_quad = cache['n_quad']
+
+    # Quadrature nodes and weights
+    if ('t_nodes' not in cache) or ('w_nodes' not in cache):
+        t_nodes, w_nodes = roots_jacobi(n_quad, alpha, beta)   # (n_quad,)
+        cache['t_nodes'] = t_nodes
+        cache['w_nodes'] = w_nodes
+    else:
+        t_nodes = cache['t_nodes']
+        w_nodes = cache['w_nodes']
+
     z = numpy.asarray(z, dtype=dtype)
     lam_minus, lam_plus = support
     span = lam_plus - lam_minus
     centre = 0.5 * (lam_plus + lam_minus)
 
-    # Map z -> u in the standard [-1,1] domain
+    # Map z to u in the standard [-1,1] domain
     u = (2.0 / span) * (z - centre)
 
-    m_total = numpy.zeros_like(z, dtype=dtype)
+    # Cauchy Kernel (flattened for all z)
+    u_flat = u.ravel()
+    ker = (1.0 / (t_nodes[:, None] - u_flat[None, :])).astype(
+        dtype, copy=False)  # (n_quad, Ny*Nx)
+
+    if continuation == 'pade':
+
+        if 'integrand_nodes' not in cache:
+
+            # Compute sum_k psi_k P_k (call it s_node)
+            s_nodes = numpy.zeros_like(t_nodes, dtype=dtype)
+            for k, psi_k in enumerate(psi):
+
+                # Evaluate P_k at the quadrature nodes
+                P_k_nodes = eval_jacobi(k, alpha, beta, t_nodes)   # (n_quad,)
+                s_nodes += psi_k * P_k_nodes
+
+            integrand_nodes = (2.0 / span) * (w_nodes * s_nodes).astype(dtype)
+            cache['integrand_nodes'] = integrand_nodes
 
-    if continuation != 'pade':
-        # Stores  m with the ravel size of z.
-        m_partial = numpy.zeros((psi.size, z.size), dtype=dtype)
+        else:
+            integrand_nodes = cache['integrand_nodes']
+
+        Q_flat = (integrand_nodes[:, None] * ker).sum(axis=0)
+        m_total = Q_flat.reshape(z.shape)
+
+        return m_total
+
+    else:
 
-    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,)
+        # Continuation is not Pade. This is one of Wynn, Levin, etc. These
+        # methods need the series for m for 1, ..., k.
 
-        # Evaluate P_k at the quadrature nodes
-        P_k_nodes = eval_jacobi(k, alpha, beta, t_nodes)     # (n_quad,)
+        if 'B' not in cache:
+            # All P_k at quadrature nodes (real), row-scale by weights
+            P_nodes = numpy.empty((psi.size, n_quad), dtype=w_nodes.dtype)
+            for k in range(psi.size):
+                P_nodes[k, :] = eval_jacobi(k, alpha, beta, t_nodes)
 
-        # Integrand values at nodes: w_nodes already include the weight
-        integrand = w_nodes * P_k_nodes                      # (n_quad,)
+            # All P_k * w shape (K+1, n_quad)
+            B = (2.0 / span) * (P_nodes * w_nodes[None, :]).astype(
+                dtype, copy=False)
+            cache['B'] = B
 
-        # Evaluate jacobi polynomals of the second kind, Q_k using quadrature
-        diff = t_nodes[:, None, None] - u[None, ...]         # (n_quad, Ny, Nx)
-        Q_k = (integrand[:, None, None] / diff).sum(axis=0).astype(dtype)
+        else:
+            B = cache['B']
+
+        # Principal branch. 2D matrix for all k
+        m_k_all = B @ ker
 
-        # Principal branch
-        m_k = (2.0 / span) * Q_k
+        # Compute m on secondary branch from the principal branch, which is
+        # m_k = m_k + 2 \pi i rho_k(z), and rho(z) is the analytic extension of
+        # rho_k(x) using the k-th basis. Basically, rho_k(z) is w * P_k(z).
 
-        # Compute secondary branch from the principal branch
-        if continuation != 'pade':
+        # Lower-half-plane jump for ALL k at once (vectorized)
+        mask_m = (z.imag <= 0)
+        if numpy.any(mask_m):
+            idx = numpy.flatnonzero(mask_m.ravel())
+            u_m = u_flat[idx].astype(dtype, copy=False)  # complex
 
-            # Compute analytic extension of rho(z) to lower-half plane for
-            # when rho is just the k-th Jacobi basis: w(z) P_k(z). FOr this,
-            # we create a psi array (called unit_psi_j), with all zeros, except
-            # its k-th element is one. Ten we call jacobi_density.
-            unit_psi_k = numpy.zeros_like(psi)
-            unit_psi_k[k] = 1.0
+            # Scipy's eval_jacobi tops out at complex128 type. If u_m is
+            # complex256, downcast to complex128.
+            if u_m.dtype.itemsize > numpy.dtype(numpy.complex128).itemsize:
+                u_m_eval = u_m.astype(numpy.complex128, copy=False)
+                down_cast = True
+            else:
+                u_m_eval = u_m
+                down_cast = False
 
-            # Only lower-half plane
-            mask_m = z.imag <= 0
-            z_m = z[mask_m]
+            # P_k at complex u_m (all means for all k = 1,...,K)
+            P_all_m = numpy.empty((psi.size, u_m.size), dtype=dtype)
+            for k in range(psi.size):
+                P_all_m[k, :] = eval_jacobi(k, alpha, beta, u_m_eval)
 
-            # Dnesity here is rho = w(z) P_k
-            rho_k = jacobi_density(z_m.ravel(), unit_psi_k, support,
-                                   alpha=alpha, beta=beta).reshape(z_m.shape)
+            # Jacobi weight. Must match jacobi_density's branch
+            w_m = numpy.power(1.0 - u_m, alpha) * numpy.power(1.0 + u_m, beta)
 
-            # Secondary branch is principal branch + 2 \pi i rho, using Plemelj
-            # (in fact, Riemann-Hirbert jump).
-            m_k[mask_m] = m_k[mask_m] + 2.0 * numpy.pi * 1j * rho_k
+            # rho_k(z) in x-units is (2/span) * w(u) * P_k(u)
+            rho_all = ((2.0 / span) * w_m[None, :] * P_all_m).astype(
+                dtype, copy=False)
 
-        # Accumulate with factor 2/span
-        m_total += psi_k * m_k
+            if down_cast:
+                rho_all = rho_all.astype(dtype)
 
-        if continuation != 'pade':
-            m_partial[k, :] = m_total.ravel()
+            # compute analytic extension of rho(z) to lower-half plane for when
+            # rho is just the k-th Jacobi basis: w(z) P_k(z). For this, we
+            m_k_all[:, idx] = m_k_all[:, idx] + (2.0 * numpy.pi * 1j) * rho_all
 
-    if continuation != 'pade':
+        # Partial sums S_k = sum_{j<=k} psi_j * m_j
+        WQ = (psi[:, None].astype(dtype, copy=False) * m_k_all)
+        m_partial = numpy.cumsum(WQ, axis=0)
 
         if continuation == 'wynn-eps':
             S = wynn_epsilon(m_partial)
@@ -281,7 +351,9 @@ def jacobi_stieltjes(z, psi, support, alpha=0.0, beta=0.0, n_base=40,
             S = weniger_delta(m_partial)
         elif continuation == 'brezinski':
             S = brezinski_theta(m_partial)
+        else:
+            # No acceleration (likely diverges in the lower-half plane)
+            S = m_partial[-1, :]
 
         m_total = S.reshape(z.shape)
-
-    return m_total
+        return m_total

freealg/freeform.py

@@ -178,10 +178,13 @@ class FreeForm(object):
             # 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
@@ -189,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.
 
@@ -221,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.
 
@@ -336,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".')
 
@@ -351,6 +365,10 @@ 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)
@@ -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,25 +828,27 @@ 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,
-                                dtype=self.dtype)
-            # 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,
@@ -835,6 +856,12 @@ class FreeForm(object):
                                 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
 
@@ -930,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.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.6.0
+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.0.dist-info → freealg-0.6.1.dist-info}/RECORD

@@ -1,9 +1,9 @@
 freealg/__init__.py,sha256=muuYCvlsXjuX1W67YGFca9nFxprFsALLyB3CrJpXFnY,728
-freealg/__version__.py,sha256=cID1jLnC_vj48GgMN6Yb1FA3JsQ95zNmCHmRYE8TFhY,22
-freealg/_chebyshev.py,sha256=1RqSKHgm6WPWbflBk4O0xaQbgven5MiucUnjuAMyUcs,6912
+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=6oFY6aZpuosozP2PNEWd3zcWJIGHfeEF5ElFgtxT6z0,8064
+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
@@ -11,16 +11,16 @@ 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=Grp1sdEy2QPagtkZunBixxykY8nTMdbV68t3B8WU-bQ,42679
+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.0.dist-info/licenses/AUTHORS.txt,sha256=0b67Nz4_JgIzUupHJTAZxu5QdSUM_HRM_X_w4xCb17o,30
-freealg-0.6.0.dist-info/licenses/LICENSE.txt,sha256=J-EEYEtxb3VVf_Bn1TYfWnpY5lMFIM15iLDDcnaDTPA,1443
-freealg-0.6.0.dist-info/METADATA,sha256=5iMEjHYzw0gEmpxLhLRBZMXW39OSIS-bwVK46ZtcmqY,5530
-freealg-0.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-freealg-0.6.0.dist-info/top_level.txt,sha256=eR2wrgYwDdnnJ9Zf5PruPqe4kQav0GMvRsqct6y00Q8,8
-freealg-0.6.0.dist-info/RECORD,,
+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,,