freealg 0.7.1__py3-none-any.whl → 0.7.4__py3-none-any.whl

freealg/__init__.py

@@ -6,7 +6,7 @@
 # under the terms of the license found in the LICENSE.txt file in the root
 # directory of this source tree.
 
-from ._freeform import FreeForm, eigvalsh, cond, norm, trace, slogdet, supp, \
+from ._free_form import FreeForm, eigvalsh, cond, norm, trace, slogdet, supp, \
     sample, kde
 from ._algebraic_form import AlgebraicForm
 from ._geometric_form import GeometricForm

freealg/__version__.py

@@ -1 +1 @@
-__version__ = "0.7.1"
+__version__ = "0.7.4"

freealg/_algebraic_form/_continuation_algebraic.py

@@ -14,10 +14,50 @@
 import numpy
 from .._geometric_form._continuation_genus0 import joukowski_z
 
-__all__ = [
-    'sample_z_joukowski', 'filter_z_away_from_cuts', 'powers',
-    'fit_polynomial_relation', 'eval_P', 'eval_roots',
-    'build_sheets_from_roots']
+__all__ = ['sample_z_joukowski', 'filter_z_away_from_cuts', 'powers',
+           'fit_polynomial_relation', 'eval_P', 'eval_roots',
+           'build_sheets_from_roots']
+
+
+# ======================
+# normalize coefficients
+# ======================
+
+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
+
+    # --- Trim zero rows (top and bottom) ---
+    non_zero_rows = numpy.any(a != 0, axis=1)
+    if not numpy.any(non_zero_rows):
+        return a[:0, :0]
+
+    first_row = numpy.argmax(non_zero_rows)
+    last_row = len(non_zero_rows) - numpy.argmax(non_zero_rows[::-1])
+    a = a[first_row:last_row, :]
+
+    # --- Trim zero columns (left and right) ---
+    non_zero_cols = numpy.any(a != 0, axis=0)
+    if not numpy.any(non_zero_cols):
+        return a[:, :0]
+
+    first_col = numpy.argmax(non_zero_cols)
+    last_col = len(non_zero_cols) - numpy.argmax(non_zero_cols[::-1])
+    a = a[:, first_col:last_col]
+
+    # --- Normalize so first column sums to 1 ---
+    col_sum = numpy.sum(numpy.abs(a[:, 0]))
+    if col_sum != 0:
+        a = a / col_sum
+
+    return a
 
 
 # ==================
@@ -91,7 +131,7 @@ def powers(x, deg):
 # =======================
 
 def fit_polynomial_relation(z, m, s, deg_z, ridge_lambda=0.0, weights=None,
-                            triangular=None):
+                            triangular=None, normalize=False):
 
     z = numpy.asarray(z, dtype=complex).ravel()
     m = numpy.asarray(m, dtype=complex).ravel()
@@ -167,6 +207,9 @@ def fit_polynomial_relation(z, m, s, deg_z, ridge_lambda=0.0, weights=None,
     for k, (i, j) in enumerate(pairs):
         full[i, j] = coef[k]
 
+    if normalize:
+        full = _normalize_coefficients(full)
+
     return full
 
 

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/_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/_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
 
@@ -183,6 +208,7 @@ class AlgebraicForm(object):
             y_eps=2e-2,
             x_pad=0.0,
             triangular=None,
+            normalize=False,
             verbose=False):
         """
         Fits polynomial.
@@ -192,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
@@ -204,16 +228,15 @@ 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,
-                                           triangular=triangular)
+                                           triangular=triangular,
+                                           normalize=normalize)
 
         self.a_coeffs = a_coeffs
 
@@ -223,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]):
@@ -231,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))
 
@@ -241,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
@@ -310,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)
@@ -339,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
@@ -566,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/{_freeform → _free_form}/__init__.py

@@ -6,7 +6,7 @@
 # under the terms of the license found in the LICENSE.txt file in the root
 # directory of this source tree.
 
-from .freeform import FreeForm
+from .free_form import FreeForm
 from ._linalg import eigvalsh, cond, norm, trace, slogdet
 from ._support import supp
 from ._sample import sample

freealg/{_freeform → _free_form}/_linalg.py

@@ -12,7 +12,7 @@
 
 import numpy
 from .._util import compute_eig
-from .freeform import FreeForm
+from .free_form import FreeForm
 
 __all__ = ['eigvalsh', 'cond', 'norm', 'trace', 'slogdet']
 

freealg/{_freeform → _free_form}/_support.py

@@ -11,7 +11,7 @@
 # =======
 
 import numpy
-import numba
+# import numba
 from scipy.stats import gaussian_kde
 
 __all__ = ['support_from_density', 'supp']
@@ -21,10 +21,10 @@ __all__ = ['support_from_density', 'supp']
 # support from density
 # ====================
 
-@numba.njit(numba.types.UniTuple(numba.types.int64, 2)(
-    numba.types.float64,
-    numba.types.float64[::1]
-))
+# @numba.njit(numba.types.UniTuple(numba.types.int64, 2)(
+#     numba.types.float64,
+#     numba.types.float64[::1]
+# ))
 def support_from_density(dx, density):
     """
     Estimates the support from a collection of noisy observations of a

freealg/distributions/_chiral_block.py

@@ -404,7 +404,7 @@ class ChiralBlock(object):
         ----------
 
         size : int
-            Size :math:`n` of the matrix.
+            Total size :math:`N = n + m` of the returned matrix.
 
         seed : int, default=None
             Seed for random number generator.
@@ -413,7 +413,24 @@ class ChiralBlock(object):
         -------
 
         A : numpy.ndarray
-            A matrix of the size :math:`n \\times n`.
+            Symmetric matrix of shape :math:`N \\times N`.
+
+        Notes
+        -----
+
+        Generate a :math:`(n+m) x (n+m)` matrix
+
+        .. math::
+
+            H =
+            \\begin{bmatrix}
+                \\alpha \\mathbf{I}_n & (1/\\sqrt{m})) \\mathbf{X} \\
+                (1/\\sqrt{m})) \\mathbf{X}^{\\intercal} & \\beta \\mathbf{I}_m
+            \\end{bmatrix}
+
+
+        where :math:`\\mathbf{X}` has i.i.d. :math:`N(0,1)` entries and
+        :math:`n/m` approximates :math:`c`.
 
         Examples
         --------
@@ -425,16 +442,53 @@ class ChiralBlock(object):
             >>> A = mp.matrix(2000)
         """
 
-        # Parameters
-        # m = int(size / self.lam)
-        #
-        # # Generate random matrix X (n x m) with i.i.d.
-        # rng = numpy.random.default_rng(seed)
-        # X = rng.standard_normal((size, m))
-        #
-        # # Form the sample covariance matrix A = (1/m)*XX^T.
-        # A = X @ X.T / m
-        #
-        # return A
-
-        pass
+        N = int(size)
+        if N <= 1:
+            raise ValueError("size must be an integer >= 2.")
+
+        # Unpack parameters
+        alpha = float(self.alpha)
+        beta = float(self.beta)
+        c = float(self.c)
+
+        rng = numpy.random.default_rng(seed)
+
+        # Choose n,m so that n/m approx c and n+m = N.
+        # Solve n = c m and n + m = N -> m = N/(c+1), n = cN/(c+1).
+        m = int(round(N / (c + 1.0)))
+        m = max(1, min(N - 1, m))
+        n = N - m
+
+        # Optionally refine to get ratio closer to c (cheap local search).
+        # This keeps deterministic behavior.
+        best_n = n
+        best_m = m
+        best_err = abs((n / float(m)) - c)
+        for dm in (-2, -1, 0, 1, 2):
+            mm = m + dm
+            if mm <= 0 or mm >= N:
+                continue
+            nn = N - mm
+            err = abs((nn / float(mm)) - c)
+            if err < best_err:
+                best_err = err
+                best_n = nn
+                best_m = mm
+        n = best_n
+        m = best_m
+
+        # Draw X (n x m) with i.i.d. entries
+        X = rng.standard_normal((n, m))
+
+        # Assemble H
+        H = numpy.zeros((N, N), dtype=numpy.float64)
+
+        H[:n, :n] = alpha * numpy.eye(n, dtype=numpy.float64)
+        H[n:, n:] = beta * numpy.eye(m, dtype=numpy.float64)
+
+        s = 1.0 / numpy.sqrt(float(m))
+        B = s * X
+        H[:n, n:] = B
+        H[n:, :n] = B.T
+
+        return H

freealg/distributions/_deformed_marchenko_pastur.py

@@ -70,6 +70,15 @@ class DeformedMarchenkoPastur(object):
         Initialization.
         """
 
+        if not (0.0 <= w1 <= 1.0):
+            raise ValueError("w1 must be in [0, 1].")
+
+        if c < 0.0:
+            raise ValueError("c must be >= 0.")
+
+        if t1 < 0.0 or t2 < 0.0:
+            raise ValueError("t1 and t2 must be >= 0 for a covariance model.")
+
         self.t1 = t1
         self.t2 = t2
         self.w1 = w1
@@ -592,6 +601,24 @@ class DeformedMarchenkoPastur(object):
         A : numpy.ndarray
             A matrix of the size :math:`n \\times n`.
 
+        Notes
+        -----
+
+        Generate an :math:`n x n` sample covariance matrix :math:`\\mathbf{S}`
+        whose ESD converges to :math:`H \\boxtimes MP_c`, where
+        :math:`H = w_1 \\delta_{t_1} + (1-w_1) \\delta_{t_2}`.
+
+        Finite :math:`n` construction:
+
+        * :math:`m` is chosen so that :math:`n/m` approx :math:`c` (when
+          :math:`c>0`),
+        * :math:`Z` has i.i.d. :math:`N(0,1)`,
+        * :math:`\\boldsymbol{\\Sigma}` has eigenvalues :math:`t_1`,
+          :math:`t_2` with proportions
+          :math:`w_1`, and :math:`1-w_1`,
+        * :math:`\\mathbf{S} = (1/m) \\boldsymbol{\\Sigma}^{1/2} \\mathbf{Z}
+          \\mathbf{Z}^T \\boldsymbol{\\Sigma}^{1/2}`.
+
         Examples
         --------
 
@@ -602,16 +629,47 @@ class DeformedMarchenkoPastur(object):
             >>> A = mp.matrix(2000)
         """
 
-        # Parameters
-        # m = int(size / self.lam)
-        #
-        # # Generate random matrix X (n x m) with i.i.d.
-        # rng = numpy.random.default_rng(seed)
-        # X = rng.standard_normal((size, m))
-        #
-        # # Form the sample covariance matrix A = (1/m)*XX^T.
-        # A = X @ X.T / m
-        #
-        # return A
-
-        pass
+        n = int(size)
+        if n <= 0:
+            raise ValueError("size must be a positive integer.")
+
+        # Unpack parameters
+        t1 = float(self.t1)
+        t2 = float(self.t2)
+        w1 = float(self.w1)
+        c = float(self.c)
+
+        rng = numpy.random.default_rng(seed)
+
+        # Choose m so that n/m approx c (for c>0). For c=0, return population
+        # Sigma.
+        if c == 0.0:
+            n1 = int(round(w1 * n))
+            n1 = max(0, min(n, n1))
+            d = numpy.empty(n, dtype=numpy.float64)
+            d[:n1] = t1
+            d[n1:] = t2
+            rng.shuffle(d)
+            return numpy.diag(d)
+
+        # m must be positive integer
+        m = int(round(n / c)) if c > 0.0 else n
+        m = max(1, m)
+
+        # Build diagonal Sigma^{1/2} with two atoms
+        n1 = int(round(w1 * n))
+        n1 = max(0, min(n, n1))
+
+        s = numpy.empty(n, dtype=numpy.float64)
+        s[:n1] = numpy.sqrt(t1)
+        s[n1:] = numpy.sqrt(t2)
+        rng.shuffle(s)
+
+        # Draw Z and form X = Sigma^{1/2} Z / sqrt(m)
+        Z = rng.standard_normal((n, m))
+        X = (s[:, None] * Z) / numpy.sqrt(m)
+
+        # Sample covariance
+        S = X @ X.T
+
+        return S

freealg/distributions/_deformed_wigner.py

@@ -35,6 +35,9 @@ class DeformedWigner(object):
         Initialization.
         """
 
+        if not (0.0 <= w1 <= 1.0):
+            raise ValueError("w1 must be in [0, 1].")
+
         self.t1 = t1
         self.t2 = t2
         self.w1 = w1
@@ -287,26 +290,53 @@ class DeformedWigner(object):
         A : numpy.ndarray
             A matrix of the size :math:`n \\times n`.
 
+        Notes
+        -----
+
+        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
         --------
 
         .. code-block::python
 
-            >>> from freealg.distributions import MarchenkoPastur
-            >>> mp = MarchenkoPastur(1/50)
-            >>> A = mp.matrix(2000)
+            >>> from freealg.distributions import DeformedWigner
+            >>> dwg = DeformedWigner(1/50)
+            >>> A = dwg.matrix(2000)
         """
 
-        # Parameters
-        # m = int(size / self.lam)
-        #
-        # # Generate random matrix X (n x m) with i.i.d.
-        # rng = numpy.random.default_rng(seed)
-        # X = rng.standard_normal((size, m))
-        #
-        # # Form the sample covariance matrix A = (1/m)*XX^T.
-        # A = X @ X.T / m
-        #
-        # return A
-
-        pass
+        n = int(size)
+        if n <= 0:
+            raise ValueError("size must be a positive integer.")
+
+        # Unpack parameters
+        t1 = float(self.t1)
+        t2 = float(self.t2)
+        w1 = float(self.w1)
+        sigma = float(self.sigma)
+
+        # RNG
+        rng = numpy.random.default_rng(seed)
+
+        # T part
+        n1 = int(round(w1 * n))
+        n1 = max(0, min(n, n1))
+
+        d = numpy.empty(n, dtype=numpy.float64)
+        d[:n1] = t1
+        d[n1:] = t2
+        rng.shuffle(d)  # randomize positions
+        T = numpy.diag(d)
+
+        # W part: Symmetric Wigner with variance 1/n (up to symmetry)
+        G = rng.standard_normal((n, n))
+        W = (G + G.T) * (0.5 / numpy.sqrt(n))
+
+        # Compose
+        A = T + sigma * W
+
+        return A

freealg/distributions/_kesten_mckay.py

@@ -13,7 +13,7 @@
 
 import numpy
 from scipy.interpolate import interp1d
-from .._freeform._plot_util import plot_density, plot_hilbert, \
+from .._free_form._plot_util import plot_density, plot_hilbert, \
     plot_stieltjes, plot_stieltjes_on_disk, plot_samples
 
 try:

freealg/distributions/_marchenko_pastur.py

@@ -13,7 +13,7 @@
 
 import numpy
 from scipy.interpolate import interp1d
-from .._freeform._plot_util import plot_density, plot_hilbert, \
+from .._free_form._plot_util import plot_density, plot_hilbert, \
     plot_stieltjes, plot_stieltjes_on_disk, plot_samples
 from ..visualization import glue_branches
 

freealg/distributions/_meixner.py

@@ -13,7 +13,7 @@
 
 import numpy
 from scipy.interpolate import interp1d
-from .._freeform._plot_util import plot_density, plot_hilbert, \
+from .._free_form._plot_util import plot_density, plot_hilbert, \
     plot_stieltjes, plot_stieltjes_on_disk, plot_samples
 
 try:

freealg/distributions/_wachter.py

@@ -13,7 +13,7 @@
 
 import numpy
 from scipy.interpolate import interp1d
-from .._freeform._plot_util import plot_density, plot_hilbert, \
+from .._free_form._plot_util import plot_density, plot_hilbert, \
     plot_stieltjes, plot_stieltjes_on_disk, plot_samples
 
 try:

freealg/distributions/_wigner.py

@@ -13,7 +13,7 @@
 
 import numpy
 from scipy.interpolate import interp1d
-from .._freeform._plot_util import plot_density, plot_hilbert, \
+from .._free_form._plot_util import plot_density, plot_hilbert, \
     plot_stieltjes, plot_stieltjes_on_disk, plot_samples
 
 try:

{freealg-0.7.1.dist-info → freealg-0.7.4.dist-info}/METADATA

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

@@ -0,0 +1,49 @@
+freealg/__init__.py,sha256=SjcYb6HWmaclnnM-m1eC1honZRyfNBWYDYBx23kSdjo,833
+freealg/__version__.py,sha256=A6fZ_oURo3l_Fa_K29LgV21A4Onqu3NquwGYzL05E1Y,22
+freealg/_util.py,sha256=E254DRTCeST7h1QHrfLeyg9jQntRaOyui1oXD7nMaWQ,1890
+freealg/_algebraic_form/__init__.py,sha256=MIB_jVgw2qI-JW_ypqaFSeNAB6c4GvpjNySnap_a6hg,398
+freealg/_algebraic_form/_continuation_algebraic.py,sha256=q81HNWG6sLx05Gbbpqi1LBI7Y7cxT-1F7uLMyRapAfI,14237
+freealg/_algebraic_form/_decompress.py,sha256=gGtixLOVxlMy5S-NsXgoA7lIrB7u7nUZImQk1mIDo3s,21101
+freealg/_algebraic_form/_decompress2.py,sha256=Ng9w9xmGe9M-DApp35IeNeQlvszfzT4NZx5BQn0lQ3I,2459
+freealg/_algebraic_form/_edge.py,sha256=7l9QyLJDxaEY4WB6MCUFtfEZSf04wyHwH7YPHFJXSbM,10690
+freealg/_algebraic_form/_homotopy.py,sha256=VIAa3ijwm4coZBXBPA_Tp__yCRcvEyipai7tOmvcthU,3989
+freealg/_algebraic_form/_sheets_util.py,sha256=6OLzWQKu-gN8rxM2rbpbN8TjNZFmD8UJ-8t9kcZdkCo,4174
+freealg/_algebraic_form/algebraic_form.py,sha256=mok3Jta_K0Vo1caAm0fI81LNgs0eB3CKM5RzZLEFPY4,30499
+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
+freealg/_free_form/_decompress.py,sha256=_i37IToZ6oN9DdLXOM8r4y92EbazzcylhcnWwUOpaj0,32108
+freealg/_free_form/_density_util.py,sha256=C_0lKA5QzKAdxPRLJvajNO9zaw2QliZ-n7SI8g2a53M,6745
+freealg/_free_form/_jacobi.py,sha256=z0X6Ws_BEo_h8EQBzDNHGFhLF9F2PUmnGeBVs0bNL7w,10709
+freealg/_free_form/_linalg.py,sha256=GNiQpT193VWxLOejVdAUPQdNJas4ms8US3YR8ZaYXGA,13143
+freealg/_free_form/_pade.py,sha256=_y89r7rVc2E5lgiN_ZjnxzW2IaVevWwpq5ISor2NVOo,10310
+freealg/_free_form/_plot_util.py,sha256=GKvmc1wjVGeqoomrULPbzBEt6P86FdoR2idBLYh5EDY,20068
+freealg/_free_form/_sample.py,sha256=rhfd_83TCTvvJh8cG8TzEYO4OR8VbtND2YCNtWEhMa8,3205
+freealg/_free_form/_series.py,sha256=33LLCUe4svmV0eWyzhP_XClfDzccQHTW9WBJlYlLfHY,11475
+freealg/_free_form/_support.py,sha256=B6oSqW7MGikpJlTGzNbnMF63LhI5al2ccToqcncTPYs,6624
+freealg/_free_form/free_form.py,sha256=UaRLYSvA0ib5wy1xnLy3_9ndCJ6gUdhNswSm0m9-7go,43571
+freealg/_geometric_form/__init__.py,sha256=mWsXP0nXs3pY8RfUDhPRTgIfhOigKqw_VmoWnJOw2a0,485
+freealg/_geometric_form/_continuation_genus0.py,sha256=4jiXfQaA6w3IhVkJgtKVVjqqtBmavq78FY_YTGUQyY0,4026
+freealg/_geometric_form/_continuation_genus1.py,sha256=X8NZ1_6PxhJJLXZk5ASeGwxej_KwH3-ftuXkBrOFmgU,6021
+freealg/_geometric_form/_elliptic_functions.py,sha256=Rr_pb1A_FjrJlraYQj2G5shdO6f77aVQN2eQzrvIygI,4109
+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/_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/_kesten_mckay.py,sha256=Uv3QuUYsfXbPMovXSO_pN3wdkc1fTKGVX7iuHDgBRqk,20089
+freealg/distributions/_marchenko_pastur.py,sha256=eemaxDosKpV37TAn9uSiYpljIkVNoTWDJ9ZfYb8tAeY,20646
+freealg/distributions/_meixner.py,sha256=GbcWeHrXMxK3Hdj4pCTESlMts9dEPQE1DhClxYprWfg,17590
+freealg/distributions/_wachter.py,sha256=5nP4iqxgxltEHhZdb1ytei1zy_bDEI1cvldZdxlIXRk,17090
+freealg/distributions/_wigner.py,sha256=epgx6ne6R_7to5j6-QsWIAVFJQFquWMmYgnZYMN4wUI,16069
+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.4.dist-info/licenses/AUTHORS.txt,sha256=0b67Nz4_JgIzUupHJTAZxu5QdSUM_HRM_X_w4xCb17o,30
+freealg-0.7.4.dist-info/licenses/LICENSE.txt,sha256=J-EEYEtxb3VVf_Bn1TYfWnpY5lMFIM15iLDDcnaDTPA,1443
+freealg-0.7.4.dist-info/METADATA,sha256=PbWMFiZoF0N2_Z5HONh85lI2oGnKzC5k57SklP4UZMc,5516
+freealg-0.7.4.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+freealg-0.7.4.dist-info/top_level.txt,sha256=eR2wrgYwDdnnJ9Zf5PruPqe4kQav0GMvRsqct6y00Q8,8
+freealg-0.7.4.dist-info/RECORD,,

{freealg-0.7.1.dist-info → freealg-0.7.4.dist-info}/WHEEL

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

freealg-0.7.1.dist-info/RECORD

@@ -1,47 +0,0 @@
-freealg/__init__.py,sha256=ApA8Dl6Sm29NN_hrT-YRmLFLhrXWEb5N1mc0e0_tDDE,832
-freealg/__version__.py,sha256=2KJZDSMOG7KS82AxYOrZ4ZihYxX0wjfUjDsIZh3L024,22
-freealg/_util.py,sha256=E254DRTCeST7h1QHrfLeyg9jQntRaOyui1oXD7nMaWQ,1890
-freealg/_algebraic_form/__init__.py,sha256=MIB_jVgw2qI-JW_ypqaFSeNAB6c4GvpjNySnap_a6hg,398
-freealg/_algebraic_form/_continuation_algebraic.py,sha256=y2ZKppTM41SBmhD3AsPN02c-MIuJWwrH1EqG385aOdY,13036
-freealg/_algebraic_form/_decompress.py,sha256=gGtixLOVxlMy5S-NsXgoA7lIrB7u7nUZImQk1mIDo3s,21101
-freealg/_algebraic_form/_edge.py,sha256=7l9QyLJDxaEY4WB6MCUFtfEZSf04wyHwH7YPHFJXSbM,10690
-freealg/_algebraic_form/_sheets_util.py,sha256=6OLzWQKu-gN8rxM2rbpbN8TjNZFmD8UJ-8t9kcZdkCo,4174
-freealg/_algebraic_form/algebraic_form.py,sha256=MFWS-zxacFprUWgFWDNdygIk4GFU6Bp-Ed_ns4wVBmk,28298
-freealg/_freeform/__init__.py,sha256=fxHAqlCBK0AqLrK9VhA3FMeid8nutCy5UwsUSgkIhrI,610
-freealg/_freeform/_chebyshev.py,sha256=zkyVA8NLf7uUKlJdLz4ijd_SurdsqUgkA5nHGWSybaE,6916
-freealg/_freeform/_damp.py,sha256=k2vtBtWOxQBf4qXaWu_En81lQBXbEO4QbxxWpvuVhdE,1802
-freealg/_freeform/_decompress.py,sha256=_i37IToZ6oN9DdLXOM8r4y92EbazzcylhcnWwUOpaj0,32108
-freealg/_freeform/_density_util.py,sha256=C_0lKA5QzKAdxPRLJvajNO9zaw2QliZ-n7SI8g2a53M,6745
-freealg/_freeform/_jacobi.py,sha256=z0X6Ws_BEo_h8EQBzDNHGFhLF9F2PUmnGeBVs0bNL7w,10709
-freealg/_freeform/_linalg.py,sha256=U7b_FJwfjU1itO4R4K831Zm2rnUB5eNOdOzvjPSeH98,13142
-freealg/_freeform/_pade.py,sha256=_y89r7rVc2E5lgiN_ZjnxzW2IaVevWwpq5ISor2NVOo,10310
-freealg/_freeform/_plot_util.py,sha256=GKvmc1wjVGeqoomrULPbzBEt6P86FdoR2idBLYh5EDY,20068
-freealg/_freeform/_sample.py,sha256=rhfd_83TCTvvJh8cG8TzEYO4OR8VbtND2YCNtWEhMa8,3205
-freealg/_freeform/_series.py,sha256=33LLCUe4svmV0eWyzhP_XClfDzccQHTW9WBJlYlLfHY,11475
-freealg/_freeform/_support.py,sha256=nxDa2OFlWBgjD0_1qoSMWG7kub6-GIuxIA04n5bdaYw,6614
-freealg/_freeform/freeform.py,sha256=UaRLYSvA0ib5wy1xnLy3_9ndCJ6gUdhNswSm0m9-7go,43571
-freealg/_geometric_form/__init__.py,sha256=mWsXP0nXs3pY8RfUDhPRTgIfhOigKqw_VmoWnJOw2a0,485
-freealg/_geometric_form/_continuation_genus0.py,sha256=4jiXfQaA6w3IhVkJgtKVVjqqtBmavq78FY_YTGUQyY0,4026
-freealg/_geometric_form/_continuation_genus1.py,sha256=X8NZ1_6PxhJJLXZk5ASeGwxej_KwH3-ftuXkBrOFmgU,6021
-freealg/_geometric_form/_elliptic_functions.py,sha256=Rr_pb1A_FjrJlraYQj2G5shdO6f77aVQN2eQzrvIygI,4109
-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/_chiral_block.py,sha256=NxwD-2qx7-ewg5TwMALnPoesUNIWPDktXhyH8RSKi2w,12350
-freealg/distributions/_deformed_marchenko_pastur.py,sha256=cZN3XnAxK4L2zkteE4XL5rlslRz34ArUlInc9TzQIZA,17568
-freealg/distributions/_deformed_wigner.py,sha256=ZC7dj-ViSxaYdHRs45Yx6vf9Yw0WaTm4qZ7FumE0EEo,7239
-freealg/distributions/_kesten_mckay.py,sha256=Abnpz7cRUPvReqbkfXvOh7onrjjvuLDdUUx3wFpu1yA,20088
-freealg/distributions/_marchenko_pastur.py,sha256=G8nzyeZ2kfNIHfv4D2p0uN_9_0Z98JqKvr9PvV9k4o8,20645
-freealg/distributions/_meixner.py,sha256=oxtXpFhEnehPuGHp8d0XEdGCGwmP_KoNJABZRV5GgcQ,17589
-freealg/distributions/_wachter.py,sha256=qn8-_vBoCcpOtsuxXZK6vGd8XABqAgT5wO5FmoSvrc8,17089
-freealg/distributions/_wigner.py,sha256=C8pTM0LMrU79TYIVRvcgPUACG9mwRzMRajS-98YNHPw,16068
-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.1.dist-info/licenses/AUTHORS.txt,sha256=0b67Nz4_JgIzUupHJTAZxu5QdSUM_HRM_X_w4xCb17o,30
-freealg-0.7.1.dist-info/licenses/LICENSE.txt,sha256=J-EEYEtxb3VVf_Bn1TYfWnpY5lMFIM15iLDDcnaDTPA,1443
-freealg-0.7.1.dist-info/METADATA,sha256=xd4C9NmSiyjjLBVQjxFqzMx8VVpQ2rCK-x4tD55afEs,5516
-freealg-0.7.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-freealg-0.7.1.dist-info/top_level.txt,sha256=eR2wrgYwDdnnJ9Zf5PruPqe4kQav0GMvRsqct6y00Q8,8
-freealg-0.7.1.dist-info/RECORD,,