freealg 0.6.1__tar.gz → 0.6.2__tar.gz

{freealg-0.6.1 → freealg-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.6.1
+Version: 0.6.2
 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.6.2/freealg/__version__.py

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

{freealg-0.6.1 → freealg-0.6.2}/freealg/_pade.py

@@ -108,32 +108,35 @@ def _decode_poles(s, lam_m, lam_p):
 # inner ls
 # ========
 
-def _inner_ls(x, f, poles, p=1, pade_reg=0.0):
+def _inner_ls(x, f, poles, dpq=1, pade_reg=0.0):
     """
     This is the inner least square (blazing fast).
+
+    dqp is the difference between the order of P (numerator) and Q
+    (denominator).
     """
 
-    if poles.size == 0 and p == -1:
+    if poles.size == 0 and dpq == -1:
         return 0.0, 0.0, numpy.empty(0)
 
     if poles.size == 0:                      # q = 0
         # A = numpy.column_stack((numpy.ones_like(x), x))
-        cols = [numpy.ones_like(x)] if p >= 0 else []
-        if p == 1:
+        cols = [numpy.ones_like(x)] if dpq >= 0 else []
+        if dpq == 1:
             cols.append(x)
         A = numpy.column_stack(cols)
         # ---
         theta, *_ = lstsq(A, f, rcond=None)
         # c, D = theta  # TEST
-        if p == -1:
+        if dpq == -1:
             c = 0.0
             D = 0.0
             resid = numpy.empty(0)
-        elif p == 0:
+        elif dpq == 0:
             c = theta[0]
             D = 0.0
             resid = numpy.empty(0)
-        else:  # p == 1
+        else:  # dpq == 1
             c, D = theta
             resid = numpy.empty(0)
     else:
@@ -142,28 +145,28 @@ def _inner_ls(x, f, poles, p=1, pade_reg=0.0):
         # # theta, *_ = lstsq(A, f, rcond=None)
         # # c, D, resid = theta[0], theta[1], theta[2:]
         # phi = 1.0 / (x[:, None] - poles[None, :])
-        # cols = [numpy.ones_like(x)] if p >= 0 else []
-        # if p == 1:
+        # cols = [numpy.ones_like(x)] if dpq >= 0 else []
+        # if dpq == 1:
         #     cols.append(x)
         #     cols.append(phi)
         #     A = numpy.column_stack(cols)
         #     theta, *_ = lstsq(A, f, rcond=None)
-        # if p == -1:
+        # if dpq == -1:
         #     c = 0.0
         #     D = 0.0
         #     resid = theta
-        # elif p == 0:
+        # elif dpq == 0:
         #     c = theta[0]
         #     D = 0.0
         #     resid = theta[1:]
-        # else:  # p == 1
+        # else:  # dpq == 1
         #     c = theta[0]
         #     D = theta[1]
         #     resid = theta[2:]
 
         phi = 1.0 / (x[:, None] - poles[None, :])
-        cols = [numpy.ones_like(x)] if p >= 0 else []
-        if p == 1:
+        cols = [numpy.ones_like(x)] if dpq >= 0 else []
+        if dpq == 1:
             cols.append(x)
         cols.append(phi)
 
@@ -179,9 +182,9 @@ def _inner_ls(x, f, poles, p=1, pade_reg=0.0):
             # theta = numpy.linalg.solve(ATA, ATf)
 
             # figure out how many elements to skip
-            if p == 1:
+            if dpq == 1:
                 skip = 2     # skip c and D
-            elif p == 0:
+            elif dpq == 0:
                 skip = 1     # skip c only
             else:
                 skip = 0     # all entries are residues
@@ -198,11 +201,11 @@ def _inner_ls(x, f, poles, p=1, pade_reg=0.0):
         else:
             theta, *_ = lstsq(A, f, rcond=None)
 
-        if p == -1:
+        if dpq == -1:
             c, D, resid = 0.0, 0.0, theta
-        elif p == 0:
+        elif dpq == 0:
             c, D, resid = theta[0], 0.0, theta[1:]
-        else:  # p == 1
+        else:  # dpq == 1
             c, D, resid = theta[0], theta[1], theta[2:]
 
     return c, D, resid
@@ -240,7 +243,7 @@ def _eval_rational(z, c, D, poles, resid):
 # fit pade
 # ========
 
-def fit_pade(x, f, lam_m, lam_p, p=1, q=2, odd_side='left', pade_reg=0.0,
+def fit_pade(x, f, lam_m, lam_p, p=2, q=2, odd_side='left', pade_reg=0.0,
              safety=1.0, max_outer=40, xtol=1e-12, ftol=1e-12, optimizer='ls',
              verbose=0):
     """
@@ -251,16 +254,19 @@ def fit_pade(x, f, lam_m, lam_p, p=1, q=2, odd_side='left', pade_reg=0.0,
     if not (odd_side in ['left', 'right']):
         raise ValueError('"odd_side" can only be "left" or "right".')
 
-    if not (p in [-1, 0, 1]):
-        raise ValueError('"pade_p" can only be -1, 0, or 1.')
+    # Difference between the degrees of numerator and denominator
+    dpq = p - q
+    if not (dpq in [-1, 0, 1]):
+        raise ValueError('"pade_p" and "pade_q" can only differ by "+1", ' +
+                         '"0", or "-1".')
 
     x = numpy.asarray(x, float)
     f = numpy.asarray(f, float)
 
     poles0 = _default_poles(q, lam_m, lam_p, safety=safety, odd_side=odd_side)
-    if q == 0 and p <= 0:
+    if q == 0 and dpq <= 0:
         # c, D, resid = _inner_ls(x, f, poles0, pade_reg=pade_reg)  # TEST
-        c, D, resid = _inner_ls(x, f, poles0, p, pade_reg=pade_reg)
+        c, D, resid = _inner_ls(x, f, poles0, dpq, pade_reg=pade_reg)
         pade_sol = {
             'c': c, 'D': D, 'poles': poles0, 'resid': resid,
             'outer_iters': 0
@@ -274,10 +280,10 @@ def fit_pade(x, f, lam_m, lam_p, p=1, q=2, odd_side='left', pade_reg=0.0,
     # residual
     # --------
 
-    def residual(s, p=p):
+    def residual(s, dpq=dpq):
         poles = _decode_poles(s, lam_m, lam_p)
         # c, D, resid = _inner_ls(x, f, poles, pade_reg=pade_reg) # TEST
-        c, D, resid = _inner_ls(x, f, poles, p, pade_reg=pade_reg)
+        c, D, resid = _inner_ls(x, f, poles, dpq, pade_reg=pade_reg)
         return _eval_rational(x, c, D, poles, resid) - f
 
     # ----------------
@@ -324,7 +330,7 @@ def fit_pade(x, f, lam_m, lam_p, p=1, q=2, odd_side='left', pade_reg=0.0,
 
     poles = _decode_poles(res.x, lam_m, lam_p)
     # c, D, resid = _inner_ls(x, f, poles, pade_reg=pade_reg) # TEST
-    c, D, resid = _inner_ls(x, f, poles, p, pade_reg=pade_reg)
+    c, D, resid = _inner_ls(x, f, poles, dpq, pade_reg=pade_reg)
 
     pade_sol = {
         'c': c, 'D': D, 'poles': poles, 'resid': resid,
@@ -364,127 +370,3 @@ def eval_pade(z, pade_sol):
     for bj, rj in zip(poles, resid):
         out += rj/(z - bj)       # each is an (N,) op, no N*q temp
     return out
-
-
-# ============
-# fit pade old
-# ============
-
-def fit_pade_old(x, f, lam_m, lam_p, p, q, delta=1e-8, B=numpy.inf,
-                 S=numpy.inf, B_default=10.0, S_factor=2.0, maxiter_de=200):
-    """
-    Deprecated.
-
-    Fit a [p/q] rational P/Q of the form:
-      P(x) = s * prod_{i=0..p-1}(x - a_i)
-      Q(x) = prod_{j=0..q-1}(x - b_j)
-
-    Constraints:
-      a_i in [lam_m, lam_p]
-      b_j in (-infty, lam_m - delta] cup [lam_p + delta, infty)
-
-    Approach:
-      - Brute-force all 2^q left/right assignments for denominator roots
-      - Global search with differential_evolution, fallback to zeros if needed
-      - Local refinement with least_squares
-
-    Returns a dict with keys:
-      's'     : optimal scale factor
-      'a'     : array of p numerator roots (in [lam_m, lam_p])
-      'b'     : array of q denominator roots (outside the interval)
-      'resid' : final residual norm
-      'signs' : tuple indicating left/right pattern for each b_j
-    """
-
-    # Determine finite bounds for DE
-    if not numpy.isfinite(B):
-        B_eff = B_default
-    else:
-        B_eff = B
-    if not numpy.isfinite(S):
-        # scale bound: S_factor * max|f| * interval width + safety
-        S_eff = S_factor * numpy.max(numpy.abs(f)) * (lam_p - lam_m) + 1.0
-        if S_eff <= 0:
-            S_eff = 1.0
-    else:
-        S_eff = S
-
-    def map_roots(signs, b):
-        """Map unconstrained b_j -> real root outside the interval."""
-        out = numpy.empty_like(b)
-        for j, (s_val, bj) in enumerate(zip(signs, b)):
-            if s_val > 0:
-                out[j] = lam_p + delta + numpy.exp(bj)
-            else:
-                out[j] = lam_m - delta - numpy.exp(bj)
-        return out
-
-    best = {'resid': numpy.inf}
-
-    # Enumerate all left/right sign patterns
-    for signs in product([-1, 1], repeat=q):
-        # Residual vector for current pattern
-        def resid_vec(z):
-            s_val = z[0]
-            a = z[1:1+p]
-            b = z[1+p:]
-            P = s_val * numpy.prod(x[:, None] - a[None, :], axis=1)
-            roots_Q = map_roots(signs, b)
-            Q = numpy.prod(x[:, None] - roots_Q[None, :], axis=1)
-            return P - f * Q
-
-        def obj(z):
-            r = resid_vec(z)
-            return r.dot(r)
-
-        # Build bounds for DE
-        bounds = []
-        bounds.append((-S_eff, S_eff))      # s
-        bounds += [(lam_m, lam_p)] * p      # a_i
-        bounds += [(-B_eff, B_eff)] * q     # b_j
-
-        # 1) Global search
-        try:
-            de = differential_evolution(obj, bounds,
-                                        maxiter=maxiter_de,
-                                        polish=False)
-            z0 = de.x
-        except ValueError:
-            # fallback: start at zeros
-            z0 = numpy.zeros(1 + p + q)
-
-        # 2) Local refinement
-        ls = least_squares(resid_vec, z0, xtol=1e-12, ftol=1e-12)
-
-        rnorm = numpy.linalg.norm(resid_vec(ls.x))
-        if rnorm < best['resid']:
-            best.update(resid=rnorm, signs=signs, x=ls.x.copy())
-
-    # Unpack best solution
-    z_best = best['x']
-    s_opt = z_best[0]
-    a_opt = z_best[1:1+p]
-    b_opt = map_roots(best['signs'], z_best[1+p:])
-
-    return {
-        's':     s_opt,
-        'a':     a_opt,
-        'b':     b_opt,
-        'resid': best['resid'],
-        'signs': best['signs'],
-    }
-
-
-# =============
-# eval pade old
-# =============
-
-def eval_pade_old(z, s, a, b):
-    """
-    Deprecated.
-    """
-
-    Pz = s * numpy.prod([z - aj for aj in a], axis=0)
-    Qz = numpy.prod([z - bj for bj in b], axis=0)
-
-    return Pz / Qz

{freealg-0.6.1 → freealg-0.6.2}/freealg/_sample.py

@@ -113,9 +113,14 @@ def sample(x, rho, num_pts, method='qmc', seed=None):
     # Draw from uniform distribution
     if method == 'mc':
         u = rng.random(num_pts)
+
     elif method == 'qmc':
-        engine = qmc.Halton(d=1, rng=rng)
-        u = engine.random(num_pts)
+        try:
+            engine = qmc.Halton(d=1, scramble=True, rng=rng)
+        except TypeError:
+            engine = qmc.Halton(d=1, scramble=True, seed=rng)
+        u = engine.random(num_pts).ravel()
+
     else:
         raise NotImplementedError('"method" is invalid.')
 

{freealg-0.6.1 → freealg-0.6.2}/freealg/_util.py

@@ -126,6 +126,27 @@ def kde(eig, xs, lam_m, lam_p, h, kernel='beta', plot=False):
 
     freealg.supp
     freealg.sample
+
+    Notes
+    -----
+
+    In Beta kernel density estimation, the shape parameters "a" and "b" of the
+    Beta(a, b)) distribution are computed for each data point "u" as:
+
+        a = (u / h) + 1.0
+        b = ((1.0 - u) / h) + 1.0
+
+    This is a standard way of using Beta kernel (see R-package documentation:
+    https://search.r-project.org/CRAN/refmans/DELTD/html/Beta.html
+
+    These equations are derived from "moment matching" method, where
+
+        Mean(Beta(a,b)) = u
+        Var(Beta(a,b)) = (1-u) u h
+
+    Solving these two equations for "a" and "b" yields the relations above.
+    See paper (page 134)
+    https://www.songxichen.com/Uploads/Files/Publication/Chen-CSD-99.pdf
     """
 
     if kernel == 'gaussian':
@@ -141,28 +162,39 @@ def kde(eig, xs, lam_m, lam_p, h, kernel='beta', plot=False):
 
         span = lam_p - lam_m
         if span <= 0:
-            raise ValueError("lam_p must be larger than lam_m")
+            raise ValueError('"lam_p" must be larger than "lam_m".')
 
         # map samples and grid to [0, 1]
         u = (eig - lam_m) / span
         t = (xs - lam_m) / span
 
-        if u.min() < 0 or u.max() > 1:
-            mask = (u > 0) & (u < 1)
-            u = u[mask]
+        # keep only samples strictly inside (0,1)
+        if (u.min() < 0) or (u.max() > 1):
+            u = u[(u > 0) & (u < 1)]
+
+        n = u.size
+        if n == 0:
+            return numpy.zeros_like(xs, dtype=float)
 
-        pdf = numpy.zeros_like(xs, dtype=float)
-        n = len(u)
+        # Shape parameters "a" and "b" or the kernel Beta(a, b), which is
+        # computed for each data point "u" (see notes above). These are
+        # vectorized.
+        a = (u / h) + 1.0
+        b = ((1.0 - u) / h) + 1.0
 
-        # tiny positive number to keep shape parameters > 0
+        # # tiny positive number to keep shape parameters > 0
         eps = 1e-6
-        for ui in u:
-            a = max(ui / h + 1.0, eps)
-            b = max((1.0 - ui) / h + 1.0, eps)
-            pdf += beta.pdf(t, a, b)
+        a = numpy.clip(a, eps, None)
+        b = numpy.clip(b, eps, None)
+
+        # Beta kernel
+        pdf_matrix = beta.pdf(t[None, :], a[:, None], b[:, None])
+
+        # Average and re-normalize back to x variable
+        pdf = pdf_matrix.sum(axis=0) / (n * span)
 
-        pdf /= n * span                        # renormalise
-        pdf[(t < 0) | (t > 1)] = 0.0           # exact zeros outside
+        # Exact zeros outside [lam_m, lam_p]
+        pdf[(t < 0) | (t > 1)] = 0.0
 
     else:
         raise NotImplementedError('"kernel" is invalid.')

{freealg-0.6.1 → freealg-0.6.2}/freealg/distributions/_kesten_mckay.py

@@ -526,9 +526,15 @@ class KestenMcKay(object):
         # Draw from uniform distribution
         if method == 'mc':
             u = rng.random(size)
+
         elif method == 'qmc':
-            engine = qmc.Halton(d=1, rng=rng)
-            u = engine.random(size)
+            try:
+                engine = qmc.Halton(d=1, scramble=True, rng=rng)
+            except TypeError:
+                # Older scipy versions
+                engine = qmc.Halton(d=1, scramble=True, seed=rng)
+            u = engine.random(size).ravel()
+
         else:
             raise NotImplementedError('"method" is invalid.')
 

{freealg-0.6.1 → freealg-0.6.2}/freealg/distributions/_marchenko_pastur.py

@@ -533,9 +533,15 @@ class MarchenkoPastur(object):
         # Draw from uniform distribution
         if method == 'mc':
             u = rng.random(size)
+
         elif method == 'qmc':
-            engine = qmc.Halton(d=1, rng=rng)
-            u = engine.random(size)
+            try:
+                engine = qmc.Halton(d=1, scramble=True, rng=rng)
+            except TypeError:
+                # Older scipy versions
+                engine = qmc.Halton(d=1, scramble=True, seed=rng)
+            u = engine.random(size).ravel()
+
         else:
             raise NotImplementedError('"method" is invalid.')
 

{freealg-0.6.1 → freealg-0.6.2}/freealg/distributions/_meixner.py

@@ -177,18 +177,12 @@ class Meixner(object):
         rho = numpy.zeros_like(x)
         mask = numpy.logical_and(x > self.lam_m, x < self.lam_p)
 
-        # rho[mask] = \
-        #     numpy.sqrt(4.0 * (1.0 + self.b) - (x[mask] - self.a)**2) / \
-        #     (2.0 * numpy.pi * (self.b * x[mask]**2 + self.a * x[mask] + 1))
-
         numer = numpy.zeros_like(x)
         denom = numpy.ones_like(x)
         numer[mask] = self.c * numpy.sqrt(4.0 * self.b - (x[mask] - self.a)**2)
-        denom[mask] = (1 - self.c)*(x[mask] - self.a)**2
-        denom[mask] += self.a * (2 - self.c)*(x[mask] - self.a)
-        denom[mask] += self.a**2 + self.b * self.c**2
-        denom[mask] *= 2 * numpy.pi
-
+        denom[mask] = 2.0 * numpy.pi * (
+            (1.0 - self.c) * x[mask]**2 + self.a * self.c * x[mask] +
+            self.b * self.c**2)
         rho[mask] = numer[mask] / denom[mask]
 
         if plot:
@@ -260,14 +254,14 @@ class Meixner(object):
         def _P(x):
             # denom = 1.0 + self.b
             # return ((1.0 + 2.0 * self.b) * x + self.a) / denom
-            P = ((self.c - 2.0) * x - self.a * self.c) / 2.0
+            P = (self.c - 2.0) * x - self.a * self.c
             return P
 
         def _Q(x):
             # denom = 1.0 + self.b
             # return (self.b * x**2 + self.a * x + 1.0) / denom
-            Q = ((1.0 - self.c) * x**2 + self.a * self.c * x +
-                 self.b * self.c**2) / 4.0
+            Q = (1.0 - self.c) * x**2 + self.a * self.c * x + \
+                 self.b * self.c**2
             return Q
 
         P = _P(x)
@@ -277,9 +271,6 @@ class Meixner(object):
         sign = numpy.sign(P)
         hilb = (P - sign * Delta) / (2.0 * Q)
 
-        # using negative sign convention
-        hilb = -hilb
-
         if plot:
             plot_hilbert(x, hilb, support=self.support, latex=latex, save=save)
 
@@ -299,21 +290,26 @@ class Meixner(object):
         # denom = 1.0 + self.b
         # A = (self.b * z**2 + self.a * z + 1.0) / denom
         # B = ((1.0 + 2.0 * self.b) * z + self.a) / denom
-        A = ((1.0 - self.c) * z**2 + self.a * self.c * z +
-             self.b * self.c**2) / 4.0
-        B = ((self.c - 2.0) * z - self.a * self.c) / 2.0
+        # A = ((1.0 - self.c) * z**2 + self.a * self.c * z +
+        #      self.b * self.c**2) / 4.0
+        # B = ((self.c - 2.0) * z - self.a * self.c) / 2.0
+
+        Q = (1.0 - self.c) * z**2 + self.a * self.c * z + \
+            self.b * self.c**2
+        P = (self.c - 2.0) * z - self.a * self.c
 
         # D = B**2 - 4 * A
         # sqrtD = numpy.sqrt(D)
 
         # Avoid numpy picking the wrong branch
-        d = 2 * numpy.sqrt(1.0 + self.b)
-        r_min = self.a - d
-        r_max = self.a + d
-        sqrtD = numpy.sqrt(z - r_min) * numpy.sqrt(z - r_max)
+        # d = 2 * numpy.sqrt(1.0 + self.b)
+        # r_min = self.a - d
+        # r_max = self.a + d
+        # sqrtD = numpy.sqrt(z - r_min) * numpy.sqrt(z - r_max)
+        sqrtD = numpy.sqrt(P**2 - 4.0 * Q)
 
-        m1 = (-B + sqrtD) / (2 * A)
-        m2 = (-B - sqrtD) / (2 * A)
+        m1 = (P + sqrtD) / (2 * Q)
+        m2 = (P - sqrtD) / (2 * Q)
 
         # pick correct branch only for non-masked entries
         upper = z.imag >= 0
@@ -558,9 +554,15 @@ class Meixner(object):
         # Draw from uniform distribution
         if method == 'mc':
             u = rng.random(size)
+
         elif method == 'qmc':
-            engine = qmc.Halton(d=1, rng=rng)
-            u = engine.random(size)
+            try:
+                engine = qmc.Halton(d=1, scramble=True, rng=rng)
+            except TypeError:
+                # Older scipy versions
+                engine = qmc.Halton(d=1, scramble=True, seed=rng)
+            u = engine.random(size).ravel()
+
         else:
             raise NotImplementedError('"method" is invalid.')
 

{freealg-0.6.1 → freealg-0.6.2}/freealg/distributions/_wachter.py

@@ -533,9 +533,15 @@ class Wachter(object):
         # Draw from uniform distribution
         if method == 'mc':
             u = rng.random(size)
+
         elif method == 'qmc':
-            engine = qmc.Halton(d=1, rng=rng)
-            u = engine.random(size)
+            try:
+                engine = qmc.Halton(d=1, scramble=True, rng=rng)
+            except TypeError:
+                # Older scipy versions
+                engine = qmc.Halton(d=1, scramble=True, seed=rng)
+            u = engine.random(size).ravel()
+
         else:
             raise NotImplementedError('"method" is invalid.')
 

{freealg-0.6.1 → freealg-0.6.2}/freealg/distributions/_wigner.py

@@ -510,9 +510,15 @@ class Wigner(object):
         # Draw from uniform distribution
         if method == 'mc':
             u = rng.random(size)
+
         elif method == 'qmc':
-            engine = qmc.Halton(d=1, rng=rng)
-            u = engine.random(size)
+            try:
+                engine = qmc.Halton(d=1, scramble=True, rng=rng)
+            except TypeError:
+                # Older scipy versions
+                engine = qmc.Halton(d=1, scramble=True, seed=rng)
+            u = engine.random(size).ravel()
+
         else:
             raise NotImplementedError('"method" is invalid.')
 

{freealg-0.6.1 → freealg-0.6.2}/freealg/freeform.py

@@ -200,7 +200,7 @@ class FreeForm(object):
 
     def fit(self, method='jacobi', K=10, alpha=0.0, beta=0.0, n_quad=60,
             reg=0.0, projection='gaussian', kernel_bw=0.001, damp=None,
-            force=False, continuation='pade', pade_p=0, pade_q=1,
+            force=False, continuation='pade', pade_p=1, pade_q=1,
             odd_side='left', pade_reg=0.0, optimizer='ls', plot=False,
             latex=False, save=False):
         """
@@ -275,14 +275,15 @@ class FreeForm(object):
             * ``'brezinski'``: Brezinski's :math:`\\theta` algorithm
               (`experimental`).
 
-        pade_p : int, default=0
-            Degree of polynomial :math:`P(z)` is :math:`q+p` where :math:`p`
-            can only be ``-1``, ``0``, or ``1``. See notes below. This option
+        pade_p : int, default=1
+            Degree of polynomial :math:`P(z)` is :math:`p` where :math:`p` can
+            only be ``q-1``, ``q``, or ``q+1``. See notes below. This option
             is applicable if ``continuation='pade'``.
 
         pade_q : int, default=1
-            Degree of polynomial :math:`Q(z)` is :math:`q`. See notes below.
-            This option is applicable if ``continuation='pade'``.
+            Degree of polynomial :math:`Q(z)` is :math:`q` where :math:`q` can
+            only be ``p-1``, ``p``, or ``p+1``. See notes below. This option
+            is applicable if ``continuation='pade'``.
 
         odd_side : {``'left'``, ``'right'``}, default= ``'left'``
             In case of odd number of poles (when :math:`q` is odd), the extra

{freealg-0.6.1 → freealg-0.6.2}/freealg.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.6.1
+Version: 0.6.2
 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.6.1/freealg/__version__.py

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