freealg 0.6.1__py3-none-any.whl → 0.6.3__py3-none-any.whl

freealg/__version__.py

@@ -1 +1 @@
-__version__ = "0.6.1"
+__version__ = "0.6.3"

freealg/_decompress.py

@@ -855,16 +855,6 @@ def decompress(freeform, alpha, x, roots_init=None, method='newton',
     density
     stieltjes
 
-    Notes
-    -----
-
-    Work in progress.
-
-    References
-    ----------
-
-    .. [1] tbd
-
     Examples
     --------
 

freealg/_pade.py

@@ -13,7 +13,6 @@
 
 import numpy
 from numpy.linalg import lstsq
-from itertools import product
 from scipy.optimize import least_squares, differential_evolution
 
 __all__ = ['fit_pade', 'eval_pade']
@@ -108,32 +107,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 +144,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 +181,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 +200,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 +242,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 +253,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 +279,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 +329,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 +369,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/_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/_util.py

@@ -126,6 +126,38 @@ def kde(eig, xs, lam_m, lam_p, h, kernel='beta', plot=False):
 
     freealg.supp
     freealg.sample
+
+    References
+    ----------
+
+    .. [1] `R-package documentation for Beta kernel
+           <https://search.r-project.org/CRAN/refmans/DELTD/html/Beta.html>`__
+
+    .. [2] Chen, S. X. (1999). Beta Kernel estimators for density functions.
+           *Computational Statistics and Data Analysis* 31 p. 131--145.
+
+    Notes
+    -----
+
+    In Beta kernel density estimation, the shape parameters :math:`a` and
+    :math:`b` of the :math:`\\mathrm{Beta}(a, b)` distribution are computed
+    for each data point :math:`u` as:
+
+    .. math::
+
+        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
+    [1]_). These equations are derived from *moment matching* method, where
+
+    .. math::
+
+        \\mathrm{Mean}(\\mathrm{Beta}(a,b)) = u
+        \\mathrm{Var}(\\mathrm{Beta}(a,b)) = (1-u) u h
+
+    Solving these two equations for :math:`a` and :math:`b` yields the
+    relations above. See [2]_ (page 134).
     """
 
     if kernel == 'gaussian':
@@ -141,28 +173,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)]
 
-        pdf = numpy.zeros_like(xs, dtype=float)
-        n = len(u)
+        n = u.size
+        if n == 0:
+            return numpy.zeros_like(xs, dtype=float)
 
-        # tiny positive number to keep shape parameters > 0
+        # 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
         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/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/distributions/_marchenko_pastur.py

@@ -283,8 +283,8 @@ class MarchenkoPastur(object):
         if numpy.any(not_mask):
 
             sign = -1 if alt_branch else 1
-            A = self.lam * sigma**2 * z
-            B = z - sigma**2 * (1 - self.lam)
+            A = self.lam * sigma**2 * z[not_mask]
+            B = z[not_mask] - sigma**2 * (1 - self.lam)
             D = B**2 - 4 * A
             sqrtD = numpy.sqrt(D)
             m1 = (-B + sqrtD) / (2 * A)
@@ -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/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/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/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/freeform.py

@@ -74,16 +74,6 @@ class FreeForm(object):
         Parameters for the :func:`supp` function can also be prescribed
         here when ``support=None``.
 
-    Notes
-    -----
-
-    TBD
-
-    References
-    ----------
-
-    .. [1] Reference.
-
     Attributes
     ----------
 
@@ -200,7 +190,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 +265,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
@@ -748,16 +739,6 @@ class FreeForm(object):
         density
         hilbert
 
-        Notes
-        -----
-
-        Notes.
-
-        References
-        ----------
-
-        .. [1] tbd
-
         Examples
         --------
 
@@ -972,16 +953,6 @@ class FreeForm(object):
         density
         stieltjes
 
-        Notes
-        -----
-
-        Work in progress.
-
-        References
-        ----------
-
-        .. [1] tbd
-
         Examples
         --------
 

{freealg-0.6.1.dist-info → freealg-0.6.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.6.1
+Version: 0.6.3
 Summary: Free probability for large matrices
 Home-page: https://github.com/ameli/freealg
 Download-URL: https://github.com/ameli/freealg/archive/main.zip
@@ -142,19 +142,17 @@ code, we also welcome feature requests and bug reports.
 How to Cite
 ===========
 
-If you use this work, please cite our `arXiv paper <https://arxiv.org/abs/2506.11994>`__.
+If you use this work, please cite our `paper <https://openreview.net/pdf?id=2CeGVUpOd7>`__.
 
   .. code::
 
-      @article{spectral2025,
-          title={Spectral Estimation with Free Decompression},
-          author={Siavash Ameli and Chris van der Heide and Liam Hodgkinson and Michael W. Mahoney},
-          year={2025},
-          eprint={2506.11994},
-          archivePrefix={arXiv},
-          primaryClass={stat.ML},
-          url={https://arxiv.org/abs/2506.11994},
-          journal={arXiv preprint arXiv:2506.11994},
+      @inproceedings{
+            AMELI-2025,
+            title={Spectral Estimation with Free Decompression},
+            author={Siavash Ameli and Chris van der Heide and Liam Hodgkinson and Michael W. Mahoney},
+            booktitle={The Thirty-ninth Annual Conference on Neural Information Processing Systems},
+            year={2025},
+            url={https://openreview.net/forum?id=2CeGVUpOd7}
       }
 
 

freealg-0.6.3.dist-info/RECORD

@@ -0,0 +1,26 @@
+freealg/__init__.py,sha256=muuYCvlsXjuX1W67YGFca9nFxprFsALLyB3CrJpXFnY,728
+freealg/__version__.py,sha256=zYiFHqR7JwbvdK9dvKrh-RTNfUqjHUwC4CTcFAPVYLc,22
+freealg/_chebyshev.py,sha256=zkyVA8NLf7uUKlJdLz4ijd_SurdsqUgkA5nHGWSybaE,6916
+freealg/_damp.py,sha256=k2vtBtWOxQBf4qXaWu_En81lQBXbEO4QbxxWpvuVhdE,1802
+freealg/_decompress.py,sha256=_i37IToZ6oN9DdLXOM8r4y92EbazzcylhcnWwUOpaj0,32108
+freealg/_jacobi.py,sha256=z0X6Ws_BEo_h8EQBzDNHGFhLF9F2PUmnGeBVs0bNL7w,10709
+freealg/_linalg.py,sha256=0BzJNTXiY1VH3OKrCFgbE0QHLgRoKyiILsBWtnygFGc,13141
+freealg/_pade.py,sha256=_y89r7rVc2E5lgiN_ZjnxzW2IaVevWwpq5ISor2NVOo,10310
+freealg/_plot_util.py,sha256=GKvmc1wjVGeqoomrULPbzBEt6P86FdoR2idBLYh5EDY,20068
+freealg/_sample.py,sha256=rhfd_83TCTvvJh8cG8TzEYO4OR8VbtND2YCNtWEhMa8,3205
+freealg/_series.py,sha256=33LLCUe4svmV0eWyzhP_XClfDzccQHTW9WBJlYlLfHY,11475
+freealg/_support.py,sha256=nxDa2OFlWBgjD0_1qoSMWG7kub6-GIuxIA04n5bdaYw,6614
+freealg/_util.py,sha256=fcs18RuWsmWvpSiwvSLFBYNiTLvYkD6LwjeuIGnyV7E,8251
+freealg/freeform.py,sha256=GMlgCqrM-3tb_QZrZszVxC4pGUvQbYtOnbJBkc2PHQg,43544
+freealg/distributions/__init__.py,sha256=t_yZyEkW_W_tSV9IvgYXtVASxD2BEdiNVXcV2ebMy8M,579
+freealg/distributions/_kesten_mckay.py,sha256=FB7UtMxkn3Olg6XmjUKrh5njhdttMo6HwW78fDBTDJk,20078
+freealg/distributions/_marchenko_pastur.py,sha256=PtmOV9npUcbI1HgjeH8mjGlbYYCdrlNtLuQegO2r4NE,17191
+freealg/distributions/_meixner.py,sha256=-gDYBShAXxtfe3vY4-2bSvp7QM8uU9eeDC9v_YVNxrk,17579
+freealg/distributions/_wachter.py,sha256=Kv1qQF1MOFCli5-IDT5lZYRhqRXh4xCugEq7KSYbE4g,17079
+freealg/distributions/_wigner.py,sha256=FBGhSijbex5oFztnV6laEGAiSWGdn1z9g9lSfhgQ_sQ,16058
+freealg-0.6.3.dist-info/licenses/AUTHORS.txt,sha256=0b67Nz4_JgIzUupHJTAZxu5QdSUM_HRM_X_w4xCb17o,30
+freealg-0.6.3.dist-info/licenses/LICENSE.txt,sha256=J-EEYEtxb3VVf_Bn1TYfWnpY5lMFIM15iLDDcnaDTPA,1443
+freealg-0.6.3.dist-info/METADATA,sha256=FhjParK9WyqcDNCu2OBGe_uVssCT-HZhuM5zm0Yzhyw,5516
+freealg-0.6.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+freealg-0.6.3.dist-info/top_level.txt,sha256=eR2wrgYwDdnnJ9Zf5PruPqe4kQav0GMvRsqct6y00Q8,8
+freealg-0.6.3.dist-info/RECORD,,

freealg-0.6.1.dist-info/RECORD

@@ -1,26 +0,0 @@
-freealg/__init__.py,sha256=muuYCvlsXjuX1W67YGFca9nFxprFsALLyB3CrJpXFnY,728
-freealg/__version__.py,sha256=baAcEjLSYFIeNZF51tOMmA_zAMhN8HvKael-UU-Ruec,22
-freealg/_chebyshev.py,sha256=zkyVA8NLf7uUKlJdLz4ijd_SurdsqUgkA5nHGWSybaE,6916
-freealg/_damp.py,sha256=k2vtBtWOxQBf4qXaWu_En81lQBXbEO4QbxxWpvuVhdE,1802
-freealg/_decompress.py,sha256=bFhQx--uptWJ7OjVwEs_tWYT6mLijBKJ9EbrD24Sbl0,32199
-freealg/_jacobi.py,sha256=z0X6Ws_BEo_h8EQBzDNHGFhLF9F2PUmnGeBVs0bNL7w,10709
-freealg/_linalg.py,sha256=0BzJNTXiY1VH3OKrCFgbE0QHLgRoKyiILsBWtnygFGc,13141
-freealg/_pade.py,sha256=BthDHScn2lILTTU2hlGNP-8YqddU3Uyxe0n0FkprwDs,13645
-freealg/_plot_util.py,sha256=GKvmc1wjVGeqoomrULPbzBEt6P86FdoR2idBLYh5EDY,20068
-freealg/_sample.py,sha256=yLJSGlq27j8tA-kDntRwfHIUU8Oo2IOmOTxS8yTRGRU,3075
-freealg/_series.py,sha256=33LLCUe4svmV0eWyzhP_XClfDzccQHTW9WBJlYlLfHY,11475
-freealg/_support.py,sha256=nxDa2OFlWBgjD0_1qoSMWG7kub6-GIuxIA04n5bdaYw,6614
-freealg/_util.py,sha256=NaEhcOxbue44l_xAhefnNZYTy3pBBGBFyk9HdaRjQKo,6899
-freealg/freeform.py,sha256=FBC9ab-3JWaQibMAM4LlbYPYvELaUDReJWCwAG0Fwwg,43779
-freealg/distributions/__init__.py,sha256=t_yZyEkW_W_tSV9IvgYXtVASxD2BEdiNVXcV2ebMy8M,579
-freealg/distributions/_kesten_mckay.py,sha256=BM_U8cX3eRstbAA4IZRK4qA_6S9zcogaXeuHyKXen14,19897
-freealg/distributions/_marchenko_pastur.py,sha256=xwk40GwpLvEm9--FN7-T2NWtHTkfzcvOS4tFyrm71ww,16990
-freealg/distributions/_meixner.py,sha256=8zmDnoCp-GOMnd6T2rKLQaMfn6uFmSnd-i5PLlfGOUM,17526
-freealg/distributions/_wachter.py,sha256=d601xAaFSVGeK13SSDavjsJ5a-MJnI2mgzWiplX0Quk,16898
-freealg/distributions/_wigner.py,sha256=w8OlZL9pSfGnXVSSB6A4KBiImr0Zz4iH2PDLCHFfpaY,15877
-freealg-0.6.1.dist-info/licenses/AUTHORS.txt,sha256=0b67Nz4_JgIzUupHJTAZxu5QdSUM_HRM_X_w4xCb17o,30
-freealg-0.6.1.dist-info/licenses/LICENSE.txt,sha256=J-EEYEtxb3VVf_Bn1TYfWnpY5lMFIM15iLDDcnaDTPA,1443
-freealg-0.6.1.dist-info/METADATA,sha256=0iyTPrQe2ZBGlPQr9dAOsunwRx_KS6dRFSaz__Uq2oI,5530
-freealg-0.6.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-freealg-0.6.1.dist-info/top_level.txt,sha256=eR2wrgYwDdnnJ9Zf5PruPqe4kQav0GMvRsqct6y00Q8,8
-freealg-0.6.1.dist-info/RECORD,,