freealg 0.7.16__tar.gz → 0.7.17__tar.gz

{freealg-0.7.16 → freealg-0.7.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.7.16
+Version: 0.7.17
 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.17/freealg/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.7.17"

{freealg-0.7.16 → freealg-0.7.17}/freealg/distributions/_compound_poisson.py

@@ -372,23 +372,6 @@ class CompoundPoisson(object):
         """
         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
@@ -401,6 +384,33 @@ class CompoundPoisson(object):
         -------
         A : numpy.ndarray
             Symmetric matrix (n x n).
+
+        Notes
+        -----
+
+        Use a sum of two independent (rotationally invariant) Wishart terms,
+        which are asymptotically free:
+
+        .. math::
+
+            A = s_1 \\frac{1}{m_1} \\mathbf{Z}_1 \\mathbf{Z}_1^{\\intercal} +
+            s_2 * \\frac{1}{m_2} \\mathbf{Z}_2 \\mathbf{Z}_2^{\\intefcal},
+
+        where :math:`\\mathbf{Z}_i` are :math:`n \\times m_`i` i.i.d.
+        :math:`N(0,1)`. Choose aspect ratios :math:`c_i = n/m_i` and
+        scales :math:`s_i` so each term has R-transform
+
+        .. math::
+
+            R_i(w) = \\lambda_i \\frac{a_i}{(1 - a_i w},
+
+        with :math:`\\lambda_1 = \\lambda w1`,
+        :math:`\\lambda_2 = \\lambda (1-w_1)`. This is achieved by setting
+
+        .. math::
+
+            c_i = 1 / \\lambda_i,
+            s_i = a_i * \\lambda_i.
         """
 
         n = int(size)

{freealg-0.7.16 → freealg-0.7.17}/freealg/distributions/_deformed_marchenko_pastur.py

@@ -246,91 +246,35 @@ class DeformedMarchenkoPastur(object):
     # density
     # =======
 
-    def density(self, x, eta=1e-3):
+    def density(self, x, eta=1e-3, ac_only=True):
         """
         Density via Stieltjes inversion with robust x-continuation.
 
-        Notes:
+        Notes
+        -----
+
           - Do not warm-start across x<0 (MP-type support is >=0).
           - Reset warm-start when previous u is (nearly) real.
           - If Newton lands on a non-Herglotz root, fall back to cubic roots +
             pick.
-        """
 
-        # Unpack parameters
-        t1 = self.t1
-        t2 = self.t2
-        w1 = self.w1
-        c = self.c
+        If ac_only is True and c < 1, subtract the smeared atom at zero of mass
+        (1-c) for visualization.
+        """
 
         x = numpy.asarray(x, dtype=numpy.float64)
-        rho = numpy.zeros_like(x, dtype=numpy.float64)
-
-        c = float(c)
-        if c < 0.0:
-            raise ValueError("c must be >= 0.")
-        if c == 0.0:
-            # Degenerate: μ = H when c=0, so m(z)=E[1/(t-z)] and rho from Im m.
-            z = x + 1j * float(eta)
-            w2 = 1.0 - w1
-            m = (w1 / (t1 - z)) + (w2 / (t2 - z))
-            rho = numpy.maximum(numpy.imag(m) / numpy.pi, 0.0)
-            return rho
-
-        # MP-type spectra live on x>=0; probing code includes x<0 (x_min<0),
-        # so we keep rho(x<0)=0 and DO NOT carry warm-start across 0.
-        mask = (x >= 0.0)
-        if not numpy.any(mask):
-            return rho
-
-        xp = x[mask]
-
-        # Preserve original order (support probing uses increasing xp).
-        order = numpy.argsort(xp)
-        inv = numpy.empty_like(order)
-        inv[order] = numpy.arange(order.size)
-
-        xp_sorted = xp[order]
-        z = xp_sorted + 1j * float(eta)
-        zf = z.ravel()
-
-        u = numpy.empty_like(zf, dtype=numpy.complex128)
-        u_prev = None
-
-        # thresholds
-        imag_eps = 1e-14
-
-        w2 = 1.0 - w1
-
-        for i in range(zf.size):
-            zi = zf[i]
-
-            # Warm start only if previous iterate had meaningful imaginary part
-            # (otherwise we risk sticking to a real branch across the bulk).
-            if (u_prev is None) or (abs(u_prev.imag) <= imag_eps):
-                ui0 = -1.0 / zi
-            else:
-                ui0 = complex(u_prev)
-
-            ui, _ = self._solve_u_newton(zi, u0=ui0, max_iter=120, tol=1e-13)
-
-            # Enforce Herglotz: sign(Im z) == sign(Im u) (eta>0 => Im u must be
-            # >0)
-            if (not numpy.isfinite(ui)) or (ui.imag <= 0.0):
-                u_roots = self._roots_cubic_u_scalar(zi)
-                ui = _pick_physical_root_scalar(zi, u_roots)
-
-            u[i] = ui
-            u_prev = ui
+        z = x + 1j * float(eta)
 
-        m = (u + (1.0 - c) / zf) / c
-        rh = numpy.maximum(numpy.imag(m) / numpy.pi, 0.0)
+        m = self.stieltjes(z)
+        rho = numpy.imag(m) / numpy.pi
 
-        # Unsort back
-        rh = rh.reshape(xp_sorted.shape)
-        rho[mask] = rh[inv]
+        # Optional: remove the atom at zero (only for visualization of AC part)
+        if ac_only and (self.c > 1.0):
+            w0 = 1.0 - 1.0 / self.c
+            rho = rho - w0 * (float(eta) / numpy.pi) / \
+                (x * x + float(eta) * float(eta))
 
-        return rho
+        return numpy.maximum(rho, 0.0)
 
     # =====
     # roots

{freealg-0.7.16 → freealg-0.7.17}/freealg/distributions/_deformed_wigner.py

@@ -139,50 +139,13 @@ class DeformedWigner(object):
         """
         """
 
-        # Unpack parameters
-        t1 = self.t1
-        t2 = self.t2
-        w1 = self.w1
-        sigma = self.sigma
-
         x = numpy.asarray(x, dtype=numpy.float64)
         z = x + 1j * float(eta)
 
-        zf = z.ravel()
-        m = numpy.empty_like(zf, dtype=numpy.complex128)
-
-        m_prev = None
-        for i in range(zf.size):
-            zi = zf[i]
-            if m_prev is None:
-                mi = -1.0 / zi
-            else:
-                mi = complex(m_prev)
-
-            for _ in range(80):
-                d1 = (t1 - zi - (sigma * sigma) * mi)
-                d2 = (t2 - zi - (sigma * sigma) * mi)
-
-                f = mi - (w1 / d1 + (1.0 - w1) / d2)
-                fp = 1.0 - (
-                    w1 * (sigma * sigma) / (d1 * d1) +
-                    (1.0 - w1) * (sigma * sigma) / (d2 * d2)
-                )
-
-                step = f / fp
-                mi2 = mi - step
-                if abs(step) < 1e-12 * (1.0 + abs(mi2)):
-                    mi = mi2
-                    break
-                mi = mi2
-
-            m[i] = mi
-            m_prev = mi
-
-        m = m.reshape(z.shape)
+        m = self.stieltjes(z)
         rho = numpy.imag(m) / numpy.pi
-        rho = numpy.maximum(rho, 0.0)
-        return rho
+
+        return numpy.maximum(rho, 0.0)
 
     # =====
     # roots

{freealg-0.7.16 → freealg-0.7.17}/freealg.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.7.16
+Version: 0.7.17
 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.16/freealg/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.7.16"