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

freealg/distributions/_compound_poisson.py

@@ -0,0 +1,481 @@
+# SPDX-FileCopyrightText: Copyright 2026, 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 .._algebraic_form._sheets_util import _pick_physical_root_scalar
+
+__all__ = ['CompoundPoisson']
+
+
+# ================
+# Compound Poisson
+# ================
+
+class CompoundPoisson(object):
+    """
+    Two-atom free compound Poisson model (MP-like, FD-closed).
+
+    Notes
+    -----
+
+    This model has atom at zero with mass :math:`\\max(1-\\lambda, 0)`.
+
+    This model is the additive free compound Poisson law whose R-transform is
+
+    .. math::
+
+        R(w) = \\lambda \\left(
+            w_1 \\frac{t_1}{1-t_1 w} + (1-w_1) \\frac{t_2}{1-t_2 w}
+        \\right),
+
+    where :math:`\\lambda>0` is the total rate (intensity),
+    :math:`t_1,t_2>0` are jump sizes, and :math:`w_1 \\in (0,1)` is the mixture
+    weight for the first jump.
+
+    The Stieltjes transform :math:`m(z)` satisfies
+
+    .. math::
+
+        R(-m(z)) = z + 1/m(z).
+
+    For two atoms, clearing denominators yields a cubic polynomial in
+    :math:`m`:
+
+    .. math::
+
+        a_3(z)m^3 + t_2(z)m^2 + t_1(z)m + a_0(z) = 0.
+
+    FD-closure (free decompression):
+        Under the FD rule that scales the argument of R, this family stays
+        closed by scaling the jump sizes: :math:`a_i(t) = e^{-t} a_i`
+        (keeping :math:`\\lambda,w_1` fixed). If your convention uses
+        :math:`R_t(w)=R_0(e^{+t}w)`, then use :math:`a_i(t)=e^{+t}a_i` instead.
+    """
+
+    # ====
+    # init
+    # ====
+
+    def __init__(self, t1, t2, w1, lam):
+        """
+        Parameters
+        ----------
+        t1, t2 : float
+            Jump sizes (must be > 0). For PSD-like support, keep them > 0.
+
+        w1 : float
+            Mixture weight in (0, 1) for t1. Second weight is 1-w1.
+
+        lam : float
+            Total rate (intensity), must be > 0.
+        """
+
+        t1 = float(t1)
+        t2 = float(t2)
+        w1 = float(w1)
+        lam = float(lam)
+
+        if t1 <= 0.0 or t2 <= 0.0:
+            raise ValueError("t1 and t2 must be > 0.")
+
+        if not (0.0 < w1 < 1.0):
+            raise ValueError("w1 must be in (0, 1).")
+
+        if lam <= 0.0:
+            raise ValueError("lam must be > 0.")
+
+        self.t1 = t1
+        self.t2 = t2
+        self.w1 = w1
+        self.lam = lam
+
+    # ====================
+    # roots cubic m scalar
+    # ====================
+
+    def _roots_cubic_m_scalar(self, z):
+        """
+        Return the three roots of the cubic equation in m at scalar z.
+        """
+
+        t1 = float(self.t1)
+        t2 = float(self.t2)
+        w1 = float(self.w1)
+        lam = float(self.lam)
+        w2 = 1.0 - w1
+
+        lam1 = lam * w1
+        lam2 = lam * w2
+
+        z = complex(z)
+
+        # Coefficients for:
+        #   a3(z)m^3 + t2(z)m^2 + t1(z)m + a0(z) = 0
+        c3 = z * t1 * t2
+        c2 = (z * (t1 + t2)) + (t1 * t2) * (1.0 - (lam1 + lam2))
+        c1 = z + (t1 + t2) - (lam1 * t1 + lam2 * t2)
+        c0 = 1.0
+
+        coeffs = numpy.array([c3, c2, c1, c0], dtype=numpy.complex128)
+        roots = numpy.roots(coeffs)
+        return roots
+
+    # =====================
+    # solve m newton scalar
+    # =====================
+
+    def _solve_m_newton(self, z, m0=None, max_iter=100, tol=1e-12):
+        """
+        Solve R(-m) = z + 1/m for scalar z using Newton iterations.
+        """
+
+        t1 = float(self.t1)
+        t2 = float(self.t2)
+        w1 = float(self.w1)
+        lam = float(self.lam)
+        w2 = 1.0 - w1
+
+        lam1 = lam * w1
+        lam2 = lam * w2
+
+        z = complex(z)
+        if m0 is None:
+            m = -1.0 / z
+        else:
+            m = complex(m0)
+
+        for _ in range(int(max_iter)):
+            d1 = 1.0 + t1 * m
+            d2 = 1.0 + t2 * m
+
+            # f(m) = -1/m + R(-m) - z
+            f = (-1.0 / m) + (lam1 * t1 / d1) + (lam2 * t2 / d2) - z
+
+            # f'(m) = 1/m^2 - sum lam_i a_i^2/(1+a_i m)^2
+            fp = (1.0 / (m * m)) - (
+                lam1 * (t1 * t1) / (d1 * d1) +
+                lam2 * (t2 * t2) / (d2 * d2)
+            )
+
+            step = f / fp
+            m2 = m - step
+
+            if abs(step) < tol * (1.0 + abs(m2)):
+                return m2, True
+
+            m = m2
+
+        return m, False
+
+    # =========
+    # stieltjes
+    # =========
+
+    def stieltjes(self, z, max_iter=100, tol=1e-12):
+        """
+        Physical/Herglotz branch of m(z) for the two-atom compound Poisson law.
+        Fast masked Newton in m, keeping z's original shape.
+        """
+
+        # Unpack parameters
+        t1 = float(self.t1)
+        t2 = float(self.t2)
+        w1 = float(self.w1)
+        lam = float(self.lam)
+        w2 = 1.0 - w1
+
+        lam1 = lam * w1
+        lam2 = lam * w2
+
+        z = numpy.asarray(z, dtype=numpy.complex128)
+        scalar = (z.ndim == 0)
+        if scalar:
+            z = z.reshape((1,))
+
+        # m initial guess
+        m = -1.0 / z
+        active = numpy.isfinite(m)
+
+        for _ in range(int(max_iter)):
+            if not numpy.any(active):
+                break
+
+            idx = numpy.flatnonzero(active)
+            ma = m.ravel()[idx]
+            za = z.ravel()[idx]
+
+            d1 = 1.0 + t1 * ma
+            d2 = 1.0 + t2 * ma
+
+            f = (-1.0 / ma) + (lam1 * t1 / d1) + (lam2 * t2 / d2) - za
+
+            fp = (1.0 / (ma * ma)) - (
+                lam1 * (t1 * t1) / (d1 * d1) +
+                lam2 * (t2 * t2) / (d2 * d2))
+
+            step = f / fp
+            mn = ma - step
+
+            # write back m
+            m_flat = m.ravel()
+            m_flat[idx] = mn
+
+            converged = numpy.abs(step) < tol * (1.0 + numpy.abs(mn))
+            still = (~converged) & numpy.isfinite(mn)
+
+            a_flat = active.ravel()
+            a_flat[idx] = still
+
+        # Herglotz sanity: sign(Im z) == sign(Im m)
+        sign = numpy.where(numpy.imag(z) >= 0.0, 1.0, -1.0)
+        bad = (~numpy.isfinite(m)) | (sign * numpy.imag(m) <= 0.0)
+
+        if numpy.any(bad):
+            zb = z.ravel()
+            mb = m.ravel()
+            bad_idx = numpy.flatnonzero(bad)
+            for i in bad_idx:
+                zi = zb[i]
+                m_roots = self._roots_cubic_m_scalar(zi)
+                mb[i] = _pick_physical_root_scalar(zi, m_roots)
+            m = mb.reshape(z.shape)
+
+        if scalar:
+            return m.reshape(())
+        return m
+
+    # =======
+    # density
+    # =======
+
+    def density(self, x, eta=2e-4, max_iter=100, tol=1e-12, ac_only=True):
+        """
+        Density rho(x) from Im m(x + i eta) / pi.
+
+        ac_only: bool, default=True
+            If `True`, computes the absolutely-continuous (AC) part. This
+            matters when for :math:`\\lambda < 1`, the distribution has an
+            atom at zero of mass :math:`1 - \\lambda`, and for plotting, this
+            often shows as a spike. Setting this option to true prevents this
+            issue in plotting. Also, to compute support, this option allows
+            proper detection of the support intervals.
+        """
+
+        z = numpy.asarray(x, dtype=numpy.float64) + 1j * float(eta)
+        m = self.stieltjes(z, max_iter=max_iter, tol=tol)
+        rho = numpy.imag(m) / numpy.pi
+
+        # If it has an atom, subtract from density to get the absolutely
+        # continuous part before processing the support
+        if (ac_only is True) and (self.lam < 1.0):
+            zr = z.real
+            atom = (1.0 - self.lam) * \
+                (float(eta) / (numpy.pi * (zr*zr + float(eta)**2)))
+            rho = rho - atom
+            rho = numpy.maximum(rho, 0.0)
+
+        return rho
+
+    # =====
+    # roots
+    # =====
+
+    def roots(self, z):
+        """
+        Return all algebraic branches (roots of the cubic) at scalar z.
+        """
+
+        z = numpy.asarray(z, dtype=numpy.complex128)
+        if z.ndim != 0:
+            raise ValueError("roots(z) expects scalar z.")
+        return self._roots_cubic_m_scalar(z.reshape(()))
+
+    # =======
+    # support
+    # =======
+
+    def support(self, eta=2e-4, n_probe=4000, thr=5e-4, x_max=None,
+                x_pad=0.05, method='probe'):
+        """
+        Estimate support intervals by probing rho(x) on a grid.
+
+        Parameters
+        ----------
+        method : {'probe'}
+            Only probing is implemented here.
+        """
+
+        _ = method  # keep signature compatible
+
+        t1 = float(self.t1)
+        t2 = float(self.t2)
+        lam = float(self.lam)
+
+        if x_max is None:
+            # Heuristic: scale grows ~ O(lam * max(a))
+            x_max = (1.0 + lam) * max(t1, t2) * 6.0
+        x_max = float(x_max)
+        if x_max <= 0.0:
+            raise ValueError("x_max must be > 0.")
+
+        x = numpy.linspace(0.0, x_max, int(n_probe))
+        rho = self.density(x, eta=eta, ac_only=True)
+
+        mask = rho > float(thr)
+        if not numpy.any(mask):
+            return []
+
+        idx = numpy.flatnonzero(mask)
+        # split contiguous indices into intervals
+        splits = numpy.where(numpy.diff(idx) > 1)[0]
+        starts = numpy.r_[idx[0], idx[splits + 1]]
+        ends = numpy.r_[idx[splits], idx[-1]]
+
+        intervals = []
+        for s, e in zip(starts, ends):
+            xa = x[int(s)]
+            xb = x[int(e)]
+            pad = float(x_pad) * (xb - xa)
+            intervals.append((float(max(0.0, xa - pad)), float(xb + pad)))
+
+        return intervals
+
+    # ==========
+    # rho scalar
+    # ==========
+
+    def rho_scalar(self, x, eta=2e-4, max_iter=100, tol=1e-12):
+        """
+        Scalar density helper (returns float).
+        """
+
+        x = float(x)
+        z = x + 1j * float(eta)
+        m = self.stieltjes(z, max_iter=max_iter, tol=tol)
+        return float(numpy.imag(m) / numpy.pi)
+
+    # ======
+    # matrix
+    # ======
+
+    def matrix(self, size, seed=None):
+        """
+        Generate a symmetric random matrix whose ESD approximates this law.
+
+        Construction
+        ------------
+        Use a sum of two independent (rotationally invariant) Wishart terms,
+        which are asymptotically free:
+
+            A = s1 * (1/m1) Z1 Z1^T + s2 * (1/m2) Z2 Z2^T,
+
+        where Zi are n x mi i.i.d. N(0,1). Choose aspect ratios ci = n/mi and
+        scales si so each term has R-transform
+
+            Ri(w) = lam_i * a_i / (1 - a_i w),
+
+        with lam_1 = lam*w1, lam_2 = lam*(1-w1). This is achieved by setting
+
+            c_i = 1/lam_i,
+            s_i = a_i * lam_i.
+
+        Parameters
+        ----------
+        size : int
+            Matrix size n.
+
+        seed : int, default=None
+            RNG seed.
+
+        Returns
+        -------
+        A : numpy.ndarray
+            Symmetric matrix (n x n).
+        """
+
+        n = int(size)
+        if n <= 0:
+            raise ValueError("size must be a positive integer.")
+
+        t1 = float(self.t1)
+        t2 = float(self.t2)
+        w1 = float(self.w1)
+        lam = float(self.lam)
+        w2 = 1.0 - w1
+
+        lam1 = lam * w1
+        lam2 = lam * w2
+
+        rng = numpy.random.default_rng(seed)
+
+        A = numpy.zeros((n, n), dtype=numpy.float64)
+
+        # term 1
+        c1 = 1.0 / lam1
+        m1 = max(1, int(round(n / c1)))
+        s1 = t1 * lam1
+        Z1 = rng.standard_normal((n, m1))
+        A += s1 * (Z1 @ Z1.T) / float(m1)
+
+        # term 2
+        c2 = 1.0 / lam2
+        m2 = max(1, int(round(n / c2)))
+        s2 = t2 * lam2
+        Z2 = rng.standard_normal((n, m2))
+        A += s2 * (Z2 @ Z2.T) / float(m2)
+
+        return A
+
+    # ====
+    # poly
+    # ====
+
+    def poly(self):
+        """
+        Return a_coeffs for the exact cubic P(z,m)=0 of the two-atom free
+        compound Poisson model.
+
+        a_coeffs[i, j] is the coefficient of z^i m^j.
+        Shape is (2, 4) since deg_z=1 and deg_m=3.
+
+        Coefficients match _roots_cubic_m_scalar.
+        """
+
+        t1 = float(self.t1)
+        t2 = float(self.t2)
+        w1 = float(self.w1)
+        w2 = 1.0 - w1
+        lam = float(self.lam)
+
+        lam1 = lam * w1
+        lam2 = lam * w2
+
+        a = numpy.zeros((2, 4), dtype=numpy.complex128)
+
+        # c3 = z * t1 * t2
+        a[0, 3] = 0.0
+        a[1, 3] = t1 * t2
+
+        # c2 = z (t1+t2) + t1 t2 (1 - (lam1+lam2))
+        a[0, 2] = (t1 * t2) * (1.0 - (lam1 + lam2))
+        a[1, 2] = (t1 + t2)
+
+        # c1 = z + (t1+t2) - (lam1 t1 + lam2 t2)
+        a[0, 1] = (t1 + t2) - (lam1 * t1 + lam2 * t2)
+        a[1, 1] = 1.0
+
+        # c0 = 1
+        a[0, 0] = 1.0
+        a[1, 0] = 0.0
+
+        return a

freealg/distributions/_deformed_marchenko_pastur.py

@@ -90,9 +90,9 @@ class DeformedMarchenkoPastur(object):
 
     def _roots_cubic_u_scalar(self, z):
         """
-        Solve the cubic for u = \\underline{m}(z) for H = w1
-        \\delta_{t1} + (1-w1)
-        \\delta_{t2}.
+        Solve the cubic for u = \\underline{m}(z) for H = w_1
+        \\delta_{t_1} + (1-w_1)
+        \\delta_{t_2}.
         """
 
         # Unpack parameters
@@ -159,8 +159,8 @@ class DeformedMarchenkoPastur(object):
 
     def stieltjes(self, z, max_iter=100, tol=1e-12):
         """
-        Physical/Herglotz branch of m(z) for μ = H \\boxtimes MP_c with
-        H = w1 \\delta_{t1} + (1-w1) \\delta_{t2}.
+        Physical/Herglotz branch of m(z) for \\mu = H \\boxtimes MP_c with
+        H = w_1 \\delta_{t_1} + (1-w_1) \\delta_{t_2}.
         Fast masked Newton in u (companion Stieltjes), keeping z's original
         shape.
         """
@@ -206,8 +206,7 @@ class DeformedMarchenkoPastur(object):
             f = (-1.0 / ua) + c * (w1 * t1 / d1 + w2 * t2 / d2) - za
             fp = (1.0 / (ua * ua)) - c * (
                 w1 * (t1 * t1) / (d1 * d1) +
-                w2 * (t2 * t2) / (d2 * d2)
-            )
+                w2 * (t2 * t2) / (d2 * d2))
 
             step = f / fp
             un = ua - step

{freealg-0.7.12.dist-info → freealg-0.7.15.dist-info}/METADATA

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

@@ -1,18 +1,33 @@
 freealg/__init__.py,sha256=is4de7kygj1be0S3EAcAlW_vGriWjdjHCR-J9NN6wyk,873
-freealg/__version__.py,sha256=PjQNisQKLFjBRbjgoDmIiFnMrUFWFPsbOBfj_imtP4Q,23
+freealg/__version__.py,sha256=7TV8ktpkocjy2CbaPP0e82unkG7763a7BOPYX37gato,23
 freealg/_util.py,sha256=RzccUCORgzrI9NdNqwMVugiHU0uDKkJFcIyjFMUOnv8,2518
 freealg/_algebraic_form/__init__.py,sha256=etgaRiuipcmxtwHzMVxZwO_qbX8R7m9j39mKvgRyTZg,463
 freealg/_algebraic_form/_branch_points.py,sha256=jzvHszw7xFe9B15a5RZV3pGfCGtndvrKJ4GIX6F3qhc,7814
 freealg/_algebraic_form/_constraints.py,sha256=xBpsKAL0-Czxf9ZF9tspLpTaFJ1m2DDyqc2KH9bl5Xg,3601
 freealg/_algebraic_form/_continuation_algebraic.py,sha256=vVHFlMJYeXm97pgwEceJB2rGJeGOVhk_Ywg6mjoIA-g,19390
+freealg/_algebraic_form/_cusp.py,sha256=Vbk3V7pT9iyQSIGOoTMSzN7r7nfyoyXUMCIPXuHFVI4,10581
+freealg/_algebraic_form/_cusp_wrap.py,sha256=HkpJj6HEE_Qi2eVBPJYcpKUfDOAGqpbHfF7ccC0sEKE,8309
 freealg/_algebraic_form/_decompress.py,sha256=yCGTT3F-0NtGi3oENIS11Zcc7SVaMv_hxvzWuho5huw,22274
-freealg/_algebraic_form/_decompress2.py,sha256=tTAxJMLQM4WJJ32UxYgv3rhTlBnn3GfFSCbse4W4S8A,6583
+freealg/_algebraic_form/_decompress2.py,sha256=2eSoIOj8R1ZuxIuDTXaKgMXY5OXfsNmaTIbE0IiUukk,6585
+freealg/_algebraic_form/_decompress4.py,sha256=kq0KJIf_il8ed_wy66hOiwD91ixr77ru3Ovdpz-aetY,21586
+freealg/_algebraic_form/_decompress5.py,sha256=I2y2Qvc09LjsSlW8Q1cdIdAFRTJm0cQDDBMBZ6XmuME,22618
+freealg/_algebraic_form/_decompress6.py,sha256=Kn2TqWOjH8ifZEnfJ2UlLJZTgYZR1pWQ6nEZwNsadcQ,16774
+freealg/_algebraic_form/_decompress7.py,sha256=hRstLXa2hD0QvDhdhsycHujjqFWWn0Z7PbKsFBH1COs,10128
+freealg/_algebraic_form/_decompress8.py,sha256=IH05swHhA4vieOUa-4Kbapk5Q4XRggGC2c30W1QpMsY,11717
+freealg/_algebraic_form/_decompress9.py,sha256=PR5uSo6BUZZWDyx19MA8KSQVrIxG0sUVn178lo75dq8,11445
+freealg/_algebraic_form/_decompress_new.py,sha256=fOHtc1iTvpep3ccQPQFUTWaluv_GS1ahrGE11fJhtAw,12162
+freealg/_algebraic_form/_decompress_new_2.py,sha256=kzjYSa4roWm8-ntCjSSG88y_82ZjSHY7jQOPSBgUrUg,54182
+freealg/_algebraic_form/_decompress_util.py,sha256=TIaqr3tdMhsKvFskmb5-RNxKWUR-hKkHuCWqq8eWo8o,4836
 freealg/_algebraic_form/_edge.py,sha256=X91GeX8nZZ_Lf7C3l7u-JpESDmwRqACYA_G2l1KVs2Y,9604
 freealg/_algebraic_form/_homotopy.py,sha256=FdKQhUTjdk6Rmdd5zb8IzDJN0pteHUcgJL3eG_ySUzM,10912
-freealg/_algebraic_form/_moments.py,sha256=v_ahJIDDMgiiZEOiJ1yMYOVRIa-zQG4Gzmzp4QSHfE4,12432
+freealg/_algebraic_form/_homotopy2.py,sha256=gvfm0cabEw57zLuOMgGNJGFVqJ8ScF4Zs2FoCQSWbYs,8868
+freealg/_algebraic_form/_homotopy3.py,sha256=OfvvX6uc_fpcPuMa53zM8o7XHrCeWeRVjDoSjUlFySE,6345
+freealg/_algebraic_form/_homotopy4.py,sha256=dxHisWPIPdzyw1NsW1qS0EbLWtM_uyIcTrHQV3jYGis,10013
+freealg/_algebraic_form/_homotopy5.py,sha256=lHWA5tknnZBMymcWt_KQXcI0qLrd_ftUGgd_Qp-o3fs,6306
+freealg/_algebraic_form/_moments.py,sha256=R1-EepGsni4he-kNfiP3E3tFqR2Z27fz-ixtSVU2fSE,12427
 freealg/_algebraic_form/_sheets_util.py,sha256=6OLzWQKu-gN8rxM2rbpbN8TjNZFmD8UJ-8t9kcZdkCo,4174
-freealg/_algebraic_form/_support.py,sha256=9go_3NjmesSW1e08CiDu8oflpGmAbsh9iZRidMvlARI,7951
-freealg/_algebraic_form/algebraic_form.py,sha256=rKxuPizOMsfJZlq0YRwud439tsNCt08uNPiUOLDnNKM,37223
+freealg/_algebraic_form/_support.py,sha256=Gjp4nVQJb_Syou3M_uroSl52bPTafqKk6IUSJgglKu4,6791
+freealg/_algebraic_form/algebraic_form.py,sha256=14bKYTLdYb4F1vgIdEeFHi-PI_-AZGoAaEfzf5HAaJk,37762
 freealg/_free_form/__init__.py,sha256=5cnSX7kHci3wKx6-BEFhmVY_NjjmQAq1JjWPTEqETTg,611
 freealg/_free_form/_chebyshev.py,sha256=zkyVA8NLf7uUKlJdLz4ijd_SurdsqUgkA5nHGWSybaE,6916
 freealg/_free_form/_damp.py,sha256=k2vtBtWOxQBf4qXaWu_En81lQBXbEO4QbxxWpvuVhdE,1802
@@ -35,7 +50,8 @@ freealg/_geometric_form/_torus_maps.py,sha256=7m5QsbmnXTWHJE5rWjKG3_TnErHEEQ41vW
 freealg/_geometric_form/geometric_form.py,sha256=whHKYQdakqShtR-jCEugevnje72JEr9M0HSvZ2BYoKs,33379
 freealg/distributions/__init__.py,sha256=sCx2NVcRTaHwvxXpFRU_9unN98ZED6B-xFoFZ2eU9-E,875
 freealg/distributions/_chiral_block.py,sha256=YSC_Sk1u1UKlWVE1GGJEjX6VrWqpEEYNxBZ2j8Csc3A,13897
-freealg/distributions/_deformed_marchenko_pastur.py,sha256=iZixcZiXUKpe9Vi4I1_x_p_lIVqJeo7Tlb8ENqbZa94,20929
+freealg/distributions/_compound_poisson.py,sha256=TjeyfJod5ghPHtr-tbD8e4cbo-JhkSRvJUOFyfn8m2g,12676
+freealg/distributions/_deformed_marchenko_pastur.py,sha256=hrA2U_LBw7eB0QBqAwZtLuAU6Tq1nQsJgX2Y1_Y3ae8,20926
 freealg/distributions/_deformed_wigner.py,sha256=0933XQAplP3mifJKdSU7qXgrndqUs1MUpYMJHR-NId8,9086
 freealg/distributions/_kesten_mckay.py,sha256=Uv3QuUYsfXbPMovXSO_pN3wdkc1fTKGVX7iuHDgBRqk,20089
 freealg/distributions/_marchenko_pastur.py,sha256=eemaxDosKpV37TAn9uSiYpljIkVNoTWDJ9ZfYb8tAeY,20646
@@ -45,9 +61,9 @@ freealg/distributions/_wigner.py,sha256=epgx6ne6R_7to5j6-QsWIAVFJQFquWMmYgnZYMN4
 freealg/visualization/__init__.py,sha256=NLq_zwueF7ytZ8sl8zLPqm-AODxxXNvfMozHGmmklcE,435
 freealg/visualization/_glue_util.py,sha256=2oKnEYjUOS4OZfivmciVLauVr53kyHMwi6c2zRKilTQ,693
 freealg/visualization/_rgb_hsv.py,sha256=rEskxXxSlKKxIrHRslVkgxHtD010L3ge9YtcVsOPl8E,3650
-freealg-0.7.12.dist-info/licenses/AUTHORS.txt,sha256=0b67Nz4_JgIzUupHJTAZxu5QdSUM_HRM_X_w4xCb17o,30
-freealg-0.7.12.dist-info/licenses/LICENSE.txt,sha256=J-EEYEtxb3VVf_Bn1TYfWnpY5lMFIM15iLDDcnaDTPA,1443
-freealg-0.7.12.dist-info/METADATA,sha256=vzphSfQr5LulLS_XcKV38zmgb0PFfRPhMhqO0XCrmQg,5537
-freealg-0.7.12.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-freealg-0.7.12.dist-info/top_level.txt,sha256=eR2wrgYwDdnnJ9Zf5PruPqe4kQav0GMvRsqct6y00Q8,8
-freealg-0.7.12.dist-info/RECORD,,
+freealg-0.7.15.dist-info/licenses/AUTHORS.txt,sha256=0b67Nz4_JgIzUupHJTAZxu5QdSUM_HRM_X_w4xCb17o,30
+freealg-0.7.15.dist-info/licenses/LICENSE.txt,sha256=J-EEYEtxb3VVf_Bn1TYfWnpY5lMFIM15iLDDcnaDTPA,1443
+freealg-0.7.15.dist-info/METADATA,sha256=NRK-E0Ni96OuonpfAX_PAGCZIbHZ_A_kVRzQ4TmfTRQ,5537
+freealg-0.7.15.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+freealg-0.7.15.dist-info/top_level.txt,sha256=eR2wrgYwDdnnJ9Zf5PruPqe4kQav0GMvRsqct6y00Q8,8
+freealg-0.7.15.dist-info/RECORD,,