freealg 0.7.3__tar.gz → 0.7.4__tar.gz

{freealg-0.7.3 → freealg-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.7.3
+Version: 0.7.4
 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.4/freealg/__version__.py

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

{freealg-0.7.3 → freealg-0.7.4}/freealg/_algebraic_form/_continuation_algebraic.py

@@ -23,12 +23,14 @@ __all__ = ['sample_z_joukowski', 'filter_z_away_from_cuts', 'powers',
 # normalize coefficients
 # ======================
 
-def _normalize_coefficients(a):
+def _normalize_coefficients(arr):
     """
     Trim rows and columns on the sides (equivalent to factorizing or reducing
     degree) and normalize so that the sum of the first column is one.
     """
 
+    a = numpy.asarray(arr).copy()
+
     if a.size == 0:
         return a
 
@@ -51,7 +53,7 @@ def _normalize_coefficients(a):
     a = a[:, first_col:last_col]
 
     # --- Normalize so first column sums to 1 ---
-    col_sum = numpy.sum(a[:, 0])
+    col_sum = numpy.sum(numpy.abs(a[:, 0]))
     if col_sum != 0:
         a = a / col_sum
 

freealg-0.7.4/freealg/_algebraic_form/_decompress2.py

@@ -0,0 +1,86 @@
+# =======
+# Imports
+# =======
+
+import numpy
+from scipy.special import comb
+from ._continuation_algebraic import _normalize_coefficients
+
+__all__ = ['decompress_coeffs']
+
+
+# =================
+# decompress_coeffs
+# =================
+
+def decompress_coeffs(a, t, normalize=True):
+    """
+    Compute the decompressed coefficients A[r, s](t) induced by
+    the transform Q_t(z, m) = m^L P(z + (1 - e^{-t}) / m, e^t m).
+
+    Parameters
+    ----------
+    a : array_like of float, shape (L+1, K+1)
+        Coefficients defining P(z, m) in the monomial basis:
+            P(z, m) = sum_{j=0..L} sum_{k=0..K} a[j, k] z^j m^k.
+    t : float
+        Time parameter.
+
+    Returns
+    -------
+    A : ndarray, shape (L+1, L+K+1)
+        Coefficients A[r, s](t) such that
+            sum_{r=0..L} sum_{s=0..L+K} A[r, s](t) z^r m^s = 0,
+        normalized by normalize_coefficients.
+    """
+    a = numpy.asarray(a)
+    if a.ndim != 2:
+        raise ValueError("a must be a 2D array-like of shape (L+1, K+1).")
+
+    l_degree = a.shape[0] - 1
+    k_degree = a.shape[1] - 1
+
+    c = 1.0 - numpy.exp(-t)
+
+    # Scale columns of a by e^{t k}: scaled[j, k] = a[j, k] e^{t k}.
+    exp_factors = numpy.exp(numpy.arange(k_degree + 1) * t)
+    scaled = a * exp_factors
+
+    # Output coefficients.
+    out_dtype = numpy.result_type(a, float)
+    a_out = numpy.zeros((l_degree + 1, l_degree + k_degree + 1),
+                        dtype=out_dtype)
+
+    # Precompute binomial(j, r) * c^{j-r} for all j, r (lower-triangular).
+    j_inds = numpy.arange(l_degree + 1)[:, None]
+    r_inds = numpy.arange(l_degree + 1)[None, :]
+    mask = r_inds <= j_inds
+
+    binom_weights = numpy.zeros((l_degree + 1, l_degree + 1), dtype=float)
+    binom_weights[mask] = comb(j_inds, r_inds, exact=False)[mask]
+    binom_weights[mask] *= (c ** (j_inds - r_inds))[mask]
+
+    # Main accumulation:
+    # For fixed j and r, add:
+    #   A[r, (L - j + r) + k] += binom_weights[j, r] * scaled[j, k],
+    # for k = 0..K.
+    for j in range(l_degree + 1):
+        row_scaled = scaled[j]
+        if numpy.all(row_scaled == 0):
+            continue
+
+        base0 = l_degree - j
+        row_b = binom_weights[j]
+
+        for r in range(j + 1):
+            coeff = row_b[r]
+            if coeff == 0:
+                continue
+
+            start = base0 + r
+            a_out[r, start:start + (k_degree + 1)] += coeff * row_scaled
+
+    if normalize:
+        return _normalize_coefficients(a_out)
+
+    return a_out

freealg-0.7.4/freealg/_algebraic_form/_homotopy.py

@@ -0,0 +1,138 @@
+# =======
+# Imports
+# =======
+
+import numpy
+
+__all__ = ['stieltjes_poly']
+
+
+# =====================
+# stieltjes select root
+# =====================
+
+def stieltjes_select_root(roots, z, w_prev=None):
+    """
+    Select the Stieltjes-branch root among candidates at a given z.
+
+    Parameters
+    ----------
+    roots : array_like of complex
+        Candidate roots for m at the given z.
+    z : complex
+        Evaluation point. The Stieltjes/Herglotz branch satisfies
+        sign(Im(m)) = sign(Im(z)) away from the real axis.
+    w_prev : complex or None, optional
+        Previous continuation value used to enforce continuity. If None,
+        the asymptotic target -1/z is used.
+
+    Returns
+    -------
+    w : complex
+        Selected root corresponding to the Stieltjes branch.
+    """
+
+    z = complex(z)
+    roots = numpy.asarray(roots, dtype=numpy.complex128).ravel()
+
+    if roots.size == 0:
+        raise ValueError("roots must contain at least one candidate root.")
+
+    desired_sign = numpy.sign(z.imag)
+
+    if w_prev is None:
+        target = -1.0 / z
+    else:
+        target = complex(w_prev)
+
+    # Apply a soft Herglotz sign filter: prefer roots with Im(w) having the
+    # same sign as Im(z), allowing tiny numerical violations near the axis.
+    imag_roots = numpy.imag(roots)
+
+    good = roots[numpy.sign(imag_roots) == desired_sign]
+    if good.size == 0:
+        good = roots[(imag_roots * desired_sign) > -1e-12]
+
+    candidates = good if good.size > 0 else roots
+    idx = int(numpy.argmin(numpy.abs(candidates - target)))
+    return candidates[idx]
+
+
+# ==============
+# stieltjes poly
+# ==============
+
+def stieltjes_poly(z, a, eps=None, height=1e4, steps=100):
+    """
+    Evaluate the Stieltjes-branch solution m(z) of an algebraic equation.
+
+    The coefficients `a` define a polynomial relation
+        P(z, m) = 0,
+    where P is a polynomial in z and m with monomial-basis coefficients
+    arranged so that for fixed z, the coefficients of the polynomial in m
+    can be assembled from powers of z.
+
+    Parameters
+    ----------
+    z : complex
+        Evaluation point. Must be a single value.
+    a : ndarray, shape (L, K)
+        Coefficient matrix defining P(z, m) in the monomial basis.
+    eps : float or None, optional
+        If Im(z) == 0, use z + i*eps as the boundary evaluation point.
+        If None and Im(z) == 0, eps is set to 1e-8 * max(1, |z|).
+    height : float, optional
+        Imaginary height used for the starting point z0 in the same
+        half-plane as the evaluation point.
+    steps : int, optional
+        Number of continuation steps along the homotopy path.
+
+    Returns
+    -------
+    w : complex
+        Value of the Stieltjes-branch solution m(z) (or m(z+i*eps) if z is
+        real).
+    """
+
+    z = complex(z)
+    a = numpy.asarray(a)
+
+    if a.ndim != 2:
+        raise ValueError('a must be a 2D array.')
+
+    if steps < 1:
+        raise ValueError("steps must be a positive integer.")
+
+    a_l, _ = a.shape
+
+    def poly_coeffs_m(z_val):
+        z_powers = z_val ** numpy.arange(a_l)
+        return (z_powers @ a)[::-1]
+
+    def poly_roots(z_val):
+        coeffs = numpy.asarray(poly_coeffs_m(z_val), dtype=numpy.complex128)
+        return numpy.roots(coeffs)
+
+    # If user asked for a real-axis value, interpret as boundary value from C+.
+    if z.imag == 0.0:
+        if eps is None:
+            eps = 1e-8 * max(1.0, abs(z))
+        z_eval = z + 1j * float(eps)
+    else:
+        z_eval = z
+
+    half_sign = numpy.sign(z_eval.imag)
+    if half_sign == 0.0:
+        half_sign = 1.0
+
+    z0 = 1j * float(half_sign) * float(height)
+
+    # Initialize at z0 via asymptotic / Im-sign selection.
+    w_prev = stieltjes_select_root(poly_roots(z0), z0, w_prev=None)
+
+    # Straight-line homotopy from z0 to z_eval.
+    for tau in numpy.linspace(0.0, 1.0, int(steps) + 1)[1:]:
+        z_tau = z0 + tau * (z_eval - z0)
+        w_prev = stieltjes_select_root(poly_roots(z_tau), z_tau, w_prev=w_prev)
+
+    return w_prev

{freealg-0.7.3 → freealg-0.7.4}/freealg/_algebraic_form/algebraic_form.py

@@ -11,13 +11,18 @@
 # Imports
 # =======
 
+import inspect
 import numpy
-from .._util import resolve_complex_dtype
+from .._util import resolve_complex_dtype, compute_eig
 # from .._util import compute_eig
 from ._continuation_algebraic import sample_z_joukowski, \
         filter_z_away_from_cuts, fit_polynomial_relation, eval_P
 from ._edge import evolve_edges, merge_edges
 from ._decompress import decompress_newton
+from ._decompress2 import decompress_coeffs
+from ._homotopy import stieltjes_poly
+from .._free_form._support import supp
+from .._free_form._plot_util import plot_density
 
 # Fallback to previous numpy API
 if not hasattr(numpy, 'trapezoid'):
@@ -129,46 +134,66 @@ class AlgebraicForm(object):
     # def __init__(self, A, support=None, delta=1e-6, dtype='complex128',
     #              **kwargs):
 
-    def __init__(self, stieltjes, support=None, delta=1e-5, dtype='complex128',
+    def __init__(self, A, support=None, delta=1e-5, dtype='complex128',
                  **kwargs):
         """
         Initialization.
         """
 
-        # self.A = None
-        # self.eig = None
-        self.stieltjes = stieltjes
+        self.A = None
+        self.eig = None
+        self.stieltjes = None
         self.support = support
         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.
-        #     self.eig = A
-        #     self.n = len(A)
-        # elif A.ndim == 2:
-        #     # When A is a 2D array, it is assumed A is the actual array,
-        #     # and its eigenvalues will be computed.
-        #     self.A = A
-        #     self.n = A.shape[0]
-        #     assert A.shape[0] == A.shape[1], \
-        #         'Only square matrices are permitted.'
-        #     self.eig = compute_eig(A)
+        if inspect.isclass(A) and hasattr(A, "stieltjes") and \
+                callable(getattr(A, "stieltjes", None)):
+            # This is one of the distribution objects, like MarchenkoPastur
+            self.stieltjes = A.stieltjes
+            self.n = 1
+
+        elif callable(A):
+            # This is a custom function
+            self.stieltjes = A
+            self.n = 1
+
+        else:
+            # Eigenvalues
+            if A.ndim == 1:
+                # If A is a 1D array, it is assumed A is the eigenvalues array.
+                self.eig = A
+                self.n = len(A)
+            elif A.ndim == 2:
+                # When A is a 2D array, it is assumed A is the actual array,
+                # and its eigenvalues will be computed.
+                self.A = A
+                self.n = A.shape[0]
+                assert A.shape[0] == A.shape[1], \
+                    'Only square matrices are permitted.'
+                self.eig = compute_eig(A)
+
+            # Use empirical Stieltjes function
+            self.stieltjes = lambda z: \
+                numpy.mean(1.0/(self.eig-z[:, numpy.newaxis]), axis=-1)
 
         # Support
-        # if support is None:
-        #     # Detect support
-        #     self.lam_m, self.lam_p = supp(self.eig, **kwargs)
-        # else:
-        #     self.lam_m = float(support[0])
-        #     self.lam_p = float(support[1])
-        # self.support = (self.lam_m, self.lam_p)
+        if support is None:
+            if self.eig is None:
+                raise RuntimeError("Support must be provided without data")
+            # Detect support
+            self.lam_m, self.lam_p = supp(self.eig, **kwargs)
+            self.support = [(self.lam_m, self.lam_p)]
+            self.broad_support = self.support[0]
+        else:
+            self.support = support
+            self.lam_m = min([s[0] for s in self.support])
+            self.lam_p = max([s[1] for s in self.support])
+            self.broad_support = (self.lam_m, self.lam_p)
 
         # Initialize
-        # self.method = None                 # fitting rho: jacobi, chebyshev
         self.a_coeffs = None               # Polynomial coefficients
         self.cache = {}                    # Cache inner-computations
 
@@ -193,8 +218,6 @@ class AlgebraicForm(object):
         # also empties all references holdign a cache copy.
         # self.cache.clear()
 
-        # return self.a_coeffs
-
         z_fits = []
         for sup in self.support:
             a, b = sup
@@ -205,12 +228,10 @@ class AlgebraicForm(object):
 
         z_fit = numpy.concatenate(z_fits)
 
-        # Remove points too close to ANY cut
+        # Remove points too close to any cut
         z_fit = filter_z_away_from_cuts(z_fit, self.support, y_eps=y_eps,
                                         x_pad=x_pad)
 
-        # ---------
-
         m1_fit = self.stieltjes(z_fit)
         a_coeffs = fit_polynomial_relation(z_fit, m1_fit, s=deg_m, deg_z=deg_z,
                                            ridge_lambda=reg,
@@ -225,7 +246,7 @@ class AlgebraicForm(object):
             print("fit residual 99.9%:",
                   numpy.quantile(P_res[numpy.isfinite(P_res)], 0.999))
 
-            print('\nCoefficinets')
+            print('\nCoefficients')
             with numpy.printoptions(precision=4, suppress=True):
                 for i in range(a_coeffs.shape[0]):
                     for j in range(a_coeffs.shape[1]):
@@ -233,7 +254,7 @@ class AlgebraicForm(object):
                         print(f"{v.real:>+0.4f}{v.imag:>+0.4f}j", end=" ")
                     print('')
 
-            print('\nCoefficients mangitudes')
+            print('\nCoefficient Magnitudes')
             with numpy.printoptions(precision=6, suppress=True):
                 print(numpy.abs(a_coeffs))
 
@@ -243,22 +264,22 @@ class AlgebraicForm(object):
     # generate grid
     # =============
 
-    # def _generate_grid(self, scale, extend=1.0, N=500):
-    #     """
-    #     Generate a grid of points to evaluate density / Hilbert / Stieltjes
-    #     transforms.
-    #     """
-    #
-    #     radius = 0.5 * (self.lam_p - self.lam_m)
-    #     center = 0.5 * (self.lam_p + self.lam_m)
-    #
-    #     x_min = numpy.floor(extend * (center - extend * radius * scale))
-    #     x_max = numpy.ceil(extend * (center + extend * radius * scale))
-    #
-    #     x_min /= extend
-    #     x_max /= extend
-    #
-    #     return numpy.linspace(x_min, x_max, N)
+    def _generate_grid(self, scale, extend=1.0, N=500):
+        """
+        Generate a grid of points to evaluate density / Hilbert / Stieltjes
+        transforms.
+        """
+
+        radius = 0.5 * (self.lam_p - self.lam_m)
+        center = 0.5 * (self.lam_p + self.lam_m)
+
+        x_min = numpy.floor(extend * (center - extend * radius * scale))
+        x_max = numpy.ceil(extend * (center + extend * radius * scale))
+
+        x_min /= extend
+        x_max /= extend
+
+        return numpy.linspace(x_min, x_max, N)
 
     # =======
     # density
@@ -312,16 +333,19 @@ class AlgebraicForm(object):
             raise RuntimeError('The model needs to be fit using the .fit() ' +
                                'function.')
 
-        # # Create x if not given
-        # if x is None:
-        #     x = self._generate_grid(1.25)
-        #
-        # # Preallocate density to zero
-        # rho = numpy.zeros_like(x)
-        #
-        # # Compute density only inside support
-        # mask = numpy.logical_and(x >= self.lam_m, x <= self.lam_p)
-        #
+        # Create x if not given
+        if x is None:
+            x = self._generate_grid(1.25)
+
+        # Preallocate density to zero
+        rho = numpy.zeros_like(x)
+
+        for idx, x_i in enumerate(x):
+            m_i = stieltjes_poly(x_i, self.a_coeffs)
+            rho[idx] = m_i.imag
+
+        rho = rho / numpy.pi
+
         # if self.method == 'jacobi':
         #     rho[mask] = jacobi_density(x[mask], self.psi, self.support,
         #                                self.alpha, self.beta)
@@ -341,12 +365,12 @@ class AlgebraicForm(object):
         # if min_rho < 0.0 - 1e-3:
         #     print(f'"rho" is not positive. min_rho: {min_rho:>0.3f}. Set ' +
         #           r'"force=True".')
-        #
-        # if plot:
-        #     plot_density(x, rho, eig=self.eig, support=self.support,
-        #                  label='Estimate', latex=latex, save=save)
-        #
-        # return rho
+
+        if plot:
+            plot_density(x, rho, eig=self.eig, support=self.broad_support,
+                         label='Estimate', latex=latex, save=save)
+
+        return rho
 
     # =======
     # hilbert
@@ -568,68 +592,99 @@ class AlgebraicForm(object):
     # decompress
     # ==========
 
-    def decompress(self, x, t,
-                   max_iter=50,
-                   tol=1e-12,
-                   armijo=1e-4,
-                   min_lam=1e-6,
-                   w_min=1e-14,
-                   sweep=True,
-                   verbose=False):
+    def decompress(self, size, x=None, method='one', plot=False, latex=False,
+                   save=False, verbose=False, newton_opt={
+                       'max_iter': 50, 'tol': 1e-12, 'armijo': 1e-4,
+                       'min_lam': 1e-6, 'w_min': 1e-14, 'sweep': True}):
         """
         Free decompression of spectral density.
         """
 
         # Check size argument
-        # if numpy.isscalar(size):
-        #     size = int(size)
-        # else:
-        #     # Check monotonic increment (either all increasing or decreasing)
-        #     diff = numpy.diff(size)
-        #     if not (numpy.all(diff >= 0) or numpy.all(diff <= 0)):
-        #         raise ValueError('"size" increment should be monotonic.')
+        if numpy.isscalar(size):
+            size = int(size)
+        else:
+            # Check monotonic increment (either all increasing or decreasing)
+            diff = numpy.diff(size)
+            if not (numpy.all(diff >= 0) or numpy.all(diff <= 0)):
+                raise ValueError('"size" increment should be monotonic.')
 
         # Decompression ratio equal to e^{t}.
-        # alpha = numpy.atleast_1d(size) / self.n
+        alpha = numpy.atleast_1d(size) / self.n
 
-        # # If the input size was only a scalar, return a 1D rho, otherwise 2D.
-        # if numpy.isscalar(size):
-        #     rho = numpy.squeeze(rho)
-        #
-        # # Plot only the last size
-        # if plot:
-        #     if numpy.isscalar(size):
-        #         rho_last = rho
-        #     else:
-        #         rho_last = rho[-1, :]
-        #     plot_density(x, rho_last, support=(lb, ub),
-        #                  label='Decompression', latex=latex, save=save)
-        #
-        # return rho, x
+        def m_fn(z):
+            return stieltjes_poly(z, self.a_coeffs)
 
-        # Query grid on the real axis + a small imaginary buffer
-        z_query = x + 1j * self.delta
+        # Lower and upper bound on new support
+        hilb_lb = (1.0 / m_fn(self.lam_m + self.delta * 1j).item()).real
+        hilb_ub = (1.0 / m_fn(self.lam_p + self.delta * 1j).item()).real
+        lb = self.lam_m - (numpy.max(alpha) - 1) * hilb_lb
+        ub = self.lam_p - (numpy.max(alpha) - 1) * hilb_ub
 
-        # Initial condition at t=0 (physical branch)
-        w0_list = self.stieltjes(z_query)
+        # Create x if not given
+        if x is None:
+            radius = 0.5 * (ub - lb)
+            center = 0.5 * (ub + lb)
+            scale = 1.25
+            x_min = numpy.floor(center - radius * scale)
+            x_max = numpy.ceil(center + radius * scale)
+            x = numpy.linspace(x_min, x_max, 200)
+        else:
+            x = numpy.asarray(x)
 
-        # Evolve
-        W, ok = decompress_newton(
-            z_query, t, self.a_coeffs,
-            w0_list=w0_list,
-            max_iter=max_iter,
-            tol=tol,
-            armijo=armijo,
-            min_lam=min_lam,
-            w_min=w_min,
-            sweep=sweep)
+        if method == 'one':
 
-        rho = W.imag / numpy.pi
+            # Query grid on the real axis + a small imaginary buffer
+            z_query = x + 1j * self.delta
 
-        if verbose:
-            print("success rate per t:", ok.mean(axis=1))
+            # Initial condition at t=0 (physical branch)
+            w0_list = self.stieltjes(z_query)
 
-        return rho
+            # Times
+            t = numpy.log(alpha)
+
+            # Evolve
+            W, ok = decompress_newton(
+                z_query, t, self.a_coeffs,
+                w0_list=w0_list, **newton_opt)
+
+            rho = W.imag / numpy.pi
+
+            if verbose:
+                print("success rate per t:", ok.mean(axis=1))
+
+        elif method == 'two':
+
+            # Preallocate density to zero
+            rho = numpy.zeros((alpha.size, x.size), dtype=float)
+
+            # Decompress to each alpha
+            for i in range(alpha.size):
+                coeffs_i = decompress_coeffs(self.a_coeffs,
+                                             numpy.log(alpha[i]))
+                for j, x_j in enumerate(x):
+                    m_j = stieltjes_poly(x_j, coeffs_i)
+                    rho[i, j] = m_j.imag
+
+            rho = rho / numpy.pi
+
+        else:
+            raise ValueError('"method" is invalid.')
+
+        # If the input size was only a scalar, return a 1D rho, otherwise 2D.
+        if numpy.isscalar(size):
+            rho = numpy.squeeze(rho)
+
+        # Plot only the last size
+        if plot:
+            if numpy.isscalar(size):
+                rho_last = rho
+            else:
+                rho_last = rho[-1, :]
+            plot_density(x, rho_last, support=(lb, ub),
+                         label='Decompression', latex=latex, save=save)
+
+        return rho, x
 
     # ====
     # edge

{freealg-0.7.3 → freealg-0.7.4}/freealg/distributions/_deformed_wigner.py

@@ -290,26 +290,14 @@ class DeformedWigner(object):
         A : numpy.ndarray
             A matrix of the size :math:`n \\times n`.
 
-        Parameters
-        ----------
-        size : int
-            Size n of the matrix.
-
-        seed : int, default=None
-            Seed for random number generator.
-
-        Returns
-        -------
-        A : numpy.ndarray
-            Symmetric matrix of shape (n, n).
-
         Notes
         -----
 
-        Generate an :math:`n x n` matrix :math:`\\mathbf{A} = \\mathbf{T} +
-        \\sigma \\mathbf{W}` whose ESD converges to
-        :math:`H \\boxplus SC_{\\sigma^2}`, where
-        :math:`H = w_1 \\delta_{t_1} + (1-w_1) \\delta_{t_2}`.
+        Generate an :math:`n \\times n` matrix
+        :math:`\\mathbf{A} = \\mathbf{T} + \\sigma \\mathbf{W}`
+        whose ESD converges to
+        :math:`H \\boxplus \\mathrm{SC}_{\\sigma^2}`, where
+        :math:`H = w_1 \\delta_{t_1} + (1 - w_1) \\delta_{t_2}`.
 
         Examples
         --------
@@ -317,8 +305,8 @@ class DeformedWigner(object):
         .. code-block::python
 
             >>> from freealg.distributions import DeformedWigner
-            >>> mp = DeformedWigner(1/50)
-            >>> A = mp.matrix(2000)
+            >>> dwg = DeformedWigner(1/50)
+            >>> A = dwg.matrix(2000)
         """
 
         n = int(size)

{freealg-0.7.3 → freealg-0.7.4}/freealg.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.7.3
+Version: 0.7.4
 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.3 → freealg-0.7.4}/freealg.egg-info/SOURCES.txt

@@ -19,7 +19,9 @@ freealg.egg-info/top_level.txt
 freealg/_algebraic_form/__init__.py
 freealg/_algebraic_form/_continuation_algebraic.py
 freealg/_algebraic_form/_decompress.py
+freealg/_algebraic_form/_decompress2.py
 freealg/_algebraic_form/_edge.py
+freealg/_algebraic_form/_homotopy.py
 freealg/_algebraic_form/_sheets_util.py
 freealg/_algebraic_form/algebraic_form.py
 freealg/_free_form/__init__.py

freealg-0.7.3/freealg/__version__.py

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