freealg 0.7.11__py3-none-any.whl → 0.7.14__py3-none-any.whl

freealg/distributions/__init__.py

@@ -14,6 +14,8 @@ from ._meixner import Meixner
 from ._chiral_block import ChiralBlock
 from ._deformed_wigner import DeformedWigner
 from ._deformed_marchenko_pastur import DeformedMarchenkoPastur
+from ._compound_poisson import CompoundPoisson
 
 __all__ = ['MarchenkoPastur', 'Wigner', 'KestenMcKay', 'Wachter', 'Meixner',
-           'ChiralBlock', 'DeformedWigner', 'DeformedMarchenkoPastur']
+           'ChiralBlock', 'DeformedWigner', 'DeformedMarchenkoPastur',
+           'CompoundPoisson']

freealg/distributions/_compound_poisson.py

@@ -0,0 +1,464 @@
+# 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-e^{-\\lambda}, 0)`.
+
+    This model is the additive free compound Poisson law whose R-transform is
+
+    .. math::
+
+        R(w) = \\lambda \\left(
+            w_1 \\frac{a_1}{1-a_1 w} + (1-w_1) \\frac{a_2}{1-a_2 w}
+        \\right),
+
+    where :math:`\\lambda>0` is the total rate (intensity),
+    :math:`a_1,a_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::
+
+        z = 1/m(z) + R(m(z)).
+
+    For two atoms, clearing denominators yields a cubic polynomial in
+    :math:`m`:
+
+    .. math::
+
+        a_3(z)m^3 + a_2(z)m^2 + a_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, a1, a2, w1, lam):
+        """
+        Parameters
+        ----------
+        a1, a2 : float
+            Jump sizes (must be > 0). For PSD-like support, keep them > 0.
+
+        w1 : float
+            Mixture weight in (0, 1) for a1. Second weight is 1-w1.
+
+        lam : float
+            Total rate (intensity), must be > 0.
+        """
+
+        a1 = float(a1)
+        a2 = float(a2)
+        w1 = float(w1)
+        lam = float(lam)
+
+        if a1 <= 0.0 or a2 <= 0.0:
+            raise ValueError("a1 and a2 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.a1 = a1
+        self.a2 = a2
+        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.
+        """
+
+        a1 = float(self.a1)
+        a2 = float(self.a2)
+        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 + a2(z)m^2 + a1(z)m + a0(z) = 0
+        c3 = z * a1 * a2
+        c2 = (-z * (a1 + a2)) - (a1 * a2) * (1.0 - (lam1 + lam2))
+        c1 = z + (a1 + a2) - (lam1 * a1 + lam2 * a2)
+        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 z = 1/m + R(m) for scalar z using Newton iterations.
+        """
+
+        a1 = float(self.a1)
+        a2 = float(self.a2)
+        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 - a1 * m
+            d2 = 1.0 - a2 * m
+
+            # f(m) = 1/m + R(m) - z
+            f = (1.0 / m) + (lam1 * a1 / d1) + (lam2 * a2 / d2) - z
+
+            # f'(m) = -1/m^2 + sum lam_i a_i^2/(1-a_i m)^2
+            fp = (-1.0 / (m * m)) + (
+                lam1 * (a1 * a1) / (d1 * d1) +
+                lam2 * (a2 * a2) / (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
+        a1 = float(self.a1)
+        a2 = float(self.a2)
+        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 - a1 * ma
+            d2 = 1.0 - a2 * ma
+
+            f = (1.0 / ma) + (lam1 * a1 / d1) + (lam2 * a2 / d2) - za
+
+            fp = (-1.0 / (ma * ma)) + (
+                lam1 * (a1 * a1) / (d1 * d1) +
+                lam2 * (a2 * a2) / (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):
+        """
+        Density rho(x) from Im m(x + i eta) / pi.
+        """
+
+        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
+        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
+
+        a1 = float(self.a1)
+        a2 = float(self.a2)
+        lam = float(self.lam)
+
+        if x_max is None:
+            # Heuristic: scale grows ~ O(lam * max(a))
+            x_max = (1.0 + lam) * max(a1, a2) * 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)
+
+        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 PSD 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 PSD matrix (n x n).
+        """
+
+        n = int(size)
+        if n <= 0:
+            raise ValueError("size must be a positive integer.")
+
+        a1 = float(self.a1)
+        a2 = float(self.a2)
+        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 = a1 * 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 = a2 * 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.
+        """
+
+        a1 = float(self.a1)
+        a2 = float(self.a2)
+        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 * a1 * a2
+        a[0, 3] = 0.0
+        a[1, 3] = a1 * a2
+
+        # c2 = -z (a1+a2) - a1 a2 (1 - (lam1+lam2))
+        a[0, 2] = -(a1 * a2) * (1.0 - (lam1 + lam2))
+        a[1, 2] = -(a1 + a2)
+
+        # c1 = z + (a1+a2) - (lam1 a1 + lam2 a2)
+        a[0, 1] = (a1 + a2) - (lam1 * a1 + lam2 * a2)
+        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

@@ -673,3 +673,54 @@ class DeformedMarchenkoPastur(object):
         S = X @ X.T
 
         return S
+
+    # ====
+    # poly
+    # ====
+
+    def poly(self):
+        """
+        Return a_coeffs for the exact cubic P(z,m)=0 of the two-atom deformed
+        MP model.
+
+        This is the eliminated polynomial in m (not underline{m}).
+        a_coeffs[i, j] is the coefficient of z^i m^j.
+        Shape is (3, 4).
+        """
+
+        t1 = float(self.t1)
+        t2 = float(self.t2)
+        w1 = float(self.w1)
+        w2 = 1.0 - w1
+        c = float(self.c)
+
+        # mu1 = w1 * t1 + w2 * t2
+
+        a = numpy.zeros((3, 4), dtype=numpy.complex128)
+
+        # NOTE: This polynomial is defined up to a global nonzero factor.
+        # The scaling below is chosen so that the m^3 term is (-c^3 t1 t2) z^2.
+
+        # ---- m^3:  (-c^3 t1 t2) z^2
+        a[2, 3] = -(c**3) * t1 * t2
+
+        # ---- m^2:  -( 2 c^3 t1 t2 z - 2 c^2 t1 t2 z + c^2 (t1+t2) z^2 )
+        a[0, 2] = 0.0
+        a[1, 2] = -(2.0 * (c**3) * t1 * t2 - 2.0 * (c**2) * t1 * t2)
+        a[2, 2] = -(c**2) * (t1 + t2)
+
+        # ---- m^1:
+        #   -c * [ c^2 t1 t2 - 2 c t1 t2 + t1 t2
+        #          + z^2
+        #          + z*( -c*w1*t1 + 2c*t1 + c*w1*t2 + c*t2 - t1 - t2 ) ]
+        a[0, 1] = -c * ((c**2) * t1 * t2 - 2.0 * c * t1 * t2 + t1 * t2)
+        a[1, 1] = -c * ((-c * w1 * t1) + (2.0 * c * t1) + (c * w1 * t2) +
+                        (c * t2) - t1 - t2)
+        a[2, 1] = -c * (1.0)
+
+        # ---- m^0:  -c z + c(1-c) (w2 t1 + w1 t2)
+        a[0, 0] = c * (1.0 - c) * (w2 * t1 + w1 * t2)
+        a[1, 0] = -c
+        a[2, 0] = 0.0
+
+        return a

freealg/distributions/_deformed_wigner.py

@@ -340,3 +340,47 @@ class DeformedWigner(object):
         A = T + sigma * W
 
         return A
+
+    # ====
+    # poly
+    # ====
+
+    def poly(self):
+        """
+        Return a_coeffs for the exact cubic P(z,m)=0 of the two-atom deformed
+        Wigner model.
+
+        a_coeffs[i, j] is the coefficient of z^i m^j.
+        Shape is (deg_z+1, deg_m+1) = (3, 4).
+        """
+
+        t1 = float(self.t1)
+        t2 = float(self.t2)
+        w1 = float(self.w1)
+        w2 = 1.0 - w1
+        sigma = float(self.sigma)
+        s2 = sigma * sigma
+
+        a = numpy.zeros((3, 4), dtype=numpy.complex128)
+
+        # m^0 column (a0(z) = z - (w1 t2 + w2 t1))
+        a[0, 0] = -(w1 * t2 + w2 * t1)
+        a[1, 0] = 1.0
+        a[2, 0] = 0.0
+
+        # m^1 column (a1(z) = z^2 - (t1+t2)z + t1 t2 + s2)
+        a[0, 1] = t1 * t2 + s2
+        a[1, 1] = -(t1 + t2)
+        a[2, 1] = 1.0
+
+        # m^2 column (a2(z) = s2 z - s2 (t1+t2))
+        a[0, 2] = -s2 * (t1 + t2)
+        a[1, 2] = 2.0 * s2
+        a[2, 2] = 0.0
+
+        # m^3 column (a3(z) = s2^2)
+        a[0, 3] = s2 * s2
+        a[1, 3] = 0.0
+        a[2, 3] = 0.0
+
+        return a

{freealg-0.7.11.dist-info → freealg-0.7.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.7.11
+Version: 0.7.14
 Summary: Free probability for large matrices
 Home-page: https://github.com/ameli/freealg
 Download-URL: https://github.com/ameli/freealg/archive/main.zip
@@ -37,6 +37,7 @@ Requires-Dist: matplotlib
 Requires-Dist: colorcet
 Requires-Dist: statsmodels
 Requires-Dist: numba
+Requires-Dist: tqdm
 Provides-Extra: test
 Provides-Extra: docs
 Dynamic: classifier

{freealg-0.7.11.dist-info → freealg-0.7.14.dist-info}/RECORD

@@ -1,18 +1,33 @@
-freealg/__init__.py,sha256=SjcYb6HWmaclnnM-m1eC1honZRyfNBWYDYBx23kSdjo,833
-freealg/__version__.py,sha256=wcKNUm4uZK839U_xaeQFOEaUVqbjHp-EU_6MMaml4qk,23
+freealg/__init__.py,sha256=is4de7kygj1be0S3EAcAlW_vGriWjdjHCR-J9NN6wyk,873
+freealg/__version__.py,sha256=7BOggTpADa3sz2Lo7K_EuX10-Jk_mW3PS3k2rLh8AF8,23
 freealg/_util.py,sha256=RzccUCORgzrI9NdNqwMVugiHU0uDKkJFcIyjFMUOnv8,2518
-freealg/_algebraic_form/__init__.py,sha256=MIB_jVgw2qI-JW_ypqaFSeNAB6c4GvpjNySnap_a6hg,398
+freealg/_algebraic_form/__init__.py,sha256=etgaRiuipcmxtwHzMVxZwO_qbX8R7m9j39mKvgRyTZg,463
 freealg/_algebraic_form/_branch_points.py,sha256=jzvHszw7xFe9B15a5RZV3pGfCGtndvrKJ4GIX6F3qhc,7814
-freealg/_algebraic_form/_constraints.py,sha256=37U7nvtCTocuS7l_nfUznkPi195PY7eXFzeiikrv3B0,2448
+freealg/_algebraic_form/_constraints.py,sha256=xBpsKAL0-Czxf9ZF9tspLpTaFJ1m2DDyqc2KH9bl5Xg,3601
 freealg/_algebraic_form/_continuation_algebraic.py,sha256=vVHFlMJYeXm97pgwEceJB2rGJeGOVhk_Ywg6mjoIA-g,19390
-freealg/_algebraic_form/_decompress.py,sha256=uKiq5jlwmOvGriptIDz97fQiKs_F10uH6eMX1Ix43PQ,22538
-freealg/_algebraic_form/_decompress2.py,sha256=Ng9w9xmGe9M-DApp35IeNeQlvszfzT4NZx5BQn0lQ3I,2459
-freealg/_algebraic_form/_edge.py,sha256=7l9QyLJDxaEY4WB6MCUFtfEZSf04wyHwH7YPHFJXSbM,10690
-freealg/_algebraic_form/_homotopy.py,sha256=q5z8YmrT_8m7L3qw_4FD1Sd5eELIvAiAHr2ucOLW258,9508
-freealg/_algebraic_form/_moments.py,sha256=u55RpvQhIMJFGsq8LZ3IlnTKxNgQPhwnPuYUS34YEyw,12400
+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=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/_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=L5qJFYOX5Qm8LlrBv6YwyuTxROUdn6cCjfXoDklmrlQ,32962
+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
@@ -33,10 +48,11 @@ freealg/_geometric_form/_elliptic_functions.py,sha256=Rr_pb1A_FjrJlraYQj2G5shdO6
 freealg/_geometric_form/_sphere_maps.py,sha256=NlhTgWXKWXKdyR2dQxMmePsIwHp7IWyYh6uoxgW5Osc,1465
 freealg/_geometric_form/_torus_maps.py,sha256=7m5QsbmnXTWHJE5rWjKG3_TnErHEEQ41vW-3hsOc3lo,3338
 freealg/_geometric_form/geometric_form.py,sha256=whHKYQdakqShtR-jCEugevnje72JEr9M0HSvZ2BYoKs,33379
-freealg/distributions/__init__.py,sha256=POoSAPVazz83y79pfdKeevPtKqpSATNb8S3ocYMdEzI,798
+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=ov7mIqEj5I5i9euzTSBSng8BrryxVDUhi3hYNah53bI,19394
-freealg/distributions/_deformed_wigner.py,sha256=9rekAGCKSTEWvMP0l25Lor60p4Gq2oxJuxHXmcJJ1AE,8046
+freealg/distributions/_compound_poisson.py,sha256=weckLA0ix0gHLnacPPOxs0WhqAtlvVVxcUuRZQUWuJM,11810
+freealg/distributions/_deformed_marchenko_pastur.py,sha256=iZixcZiXUKpe9Vi4I1_x_p_lIVqJeo7Tlb8ENqbZa94,20929
+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
 freealg/distributions/_meixner.py,sha256=GbcWeHrXMxK3Hdj4pCTESlMts9dEPQE1DhClxYprWfg,17590
@@ -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.11.dist-info/licenses/AUTHORS.txt,sha256=0b67Nz4_JgIzUupHJTAZxu5QdSUM_HRM_X_w4xCb17o,30
-freealg-0.7.11.dist-info/licenses/LICENSE.txt,sha256=J-EEYEtxb3VVf_Bn1TYfWnpY5lMFIM15iLDDcnaDTPA,1443
-freealg-0.7.11.dist-info/METADATA,sha256=Cinwx4ei_4R4aY743wVBq_DreuX8KPlwARHCWT--AWo,5517
-freealg-0.7.11.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-freealg-0.7.11.dist-info/top_level.txt,sha256=eR2wrgYwDdnnJ9Zf5PruPqe4kQav0GMvRsqct6y00Q8,8
-freealg-0.7.11.dist-info/RECORD,,
+freealg-0.7.14.dist-info/licenses/AUTHORS.txt,sha256=0b67Nz4_JgIzUupHJTAZxu5QdSUM_HRM_X_w4xCb17o,30
+freealg-0.7.14.dist-info/licenses/LICENSE.txt,sha256=J-EEYEtxb3VVf_Bn1TYfWnpY5lMFIM15iLDDcnaDTPA,1443
+freealg-0.7.14.dist-info/METADATA,sha256=9QtOauh9E-xiAUPG5Dg9-H7f9ldRLg6buhnkBapCoik,5537
+freealg-0.7.14.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+freealg-0.7.14.dist-info/top_level.txt,sha256=eR2wrgYwDdnnJ9Zf5PruPqe4kQav0GMvRsqct6y00Q8,8
+freealg-0.7.14.dist-info/RECORD,,

{freealg-0.7.11.dist-info → freealg-0.7.14.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any