freealg 0.6.0__tar.gz → 0.6.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freealg
-Version: 0.6.0
+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.0 → freealg-0.6.2}/freealg/_chebyshev.py

@@ -203,7 +203,7 @@ def chebyshev_stieltjes(z, psi, support, continuation='pade',
         Methof of analytiv continuation.
 
     dtype : numpy.type, default=numpy.complex128
-        Data type for compelx arrays. This might enhance series acceleration.
+        Data type for complex arrays. This might enhance series acceleration.
 
     Returns
     -------
@@ -218,7 +218,7 @@ def chebyshev_stieltjes(z, psi, support, continuation='pade',
     span = lam_p - lam_m
     center = 0.5 * (lam_m + lam_p)
 
-    # Map z -> u in the standard [-1,1] domain
+    # Map z to u in the standard [-1,1] domain
     u = (2.0 * (z - center)) / span
 
     # Inverse-Joukowski: pick branch sqrt with +Im
@@ -232,15 +232,15 @@ def chebyshev_stieltjes(z, psi, support, continuation='pade',
 
     # This depends on the method of analytic continuation
     if continuation == 'pade':
-        # Build powers J^(k+1) for k = 0, ..., K
+        # Horner summation for S0(J) = sum_{k=0}^K psi_k * J**k
         K = len(psi) - 1
-        Jpow = J[..., None] ** numpy.arange(1, K+2)  # shape: (..., K+1)
-
-        # Summing psi_k * J^(k+1)
-        S = numpy.sum(psi * Jpow, axis=-1)
+        S0 = numpy.zeros_like(J)
+        for k in range(K, -1, -1):
+            S0 = psi[k] + J * S0
+        S = J * S0
 
     else:
-        # Flatten J before passing to Wynn method.
+        # Flatten J before passing to any of the acceleration methods.
         psi_zero = numpy.concatenate([[0.0], psi])
         Sn = partial_sum(psi_zero, J.ravel(), p=0)
 

{freealg-0.6.0 → freealg-0.6.2}/freealg/_jacobi.py

@@ -97,7 +97,7 @@ def jacobi_kernel_proj(xs, pdf, support, K=10, alpha=0.0, beta=0.0, reg=0.0):
         Pk = eval_jacobi(k, alpha, beta, t)
         N_k = jacobi_sq_norm(k, alpha, beta)
 
-        #  \int P_k(t) w(t) \rho(t) dt. w(t) cancels with pdf already being rho
+        # \int P_k(t) w(t) \rho(t) dt. w(t) cancels with pdf already being rho
         moment = numpy.trapz(Pk * pdf, xs)
 
         if k == 0:
@@ -168,36 +168,41 @@ def jacobi_density(x, psi, support, alpha=0.0, beta=0.0):
 # jacobi stieltjes
 # ================
 
-def jacobi_stieltjes(z, psi, support, alpha=0.0, beta=0.0, n_base=40,
+def jacobi_stieltjes(z, cache, psi, support, alpha=0.0, beta=0.0, n_quad=None,
                      continuation='pade', dtype=numpy.complex128):
     """
     Compute m(z) = sum_k psi_k * m_k(z) where
 
-    m_k(z) = \\int w^{(alpha, beta)}(t) P_k^{(alpha, beta)}(t) / (u(z)-t) dt
+    .. math::
+
+        m_k(z) = \\int \\frac{w^{(alpha, beta)}(t) P_k^{(alpha, beta)}(t)}{
+        (u(z)-t)} \\mathrm{d} t
 
     Each m_k is evaluated *separately* with a Gauss-Jacobi rule sized
-    for that k.  This follows the user's request: 1 quadrature rule per P_k.
+    for that k. This follows the user's request: 1 quadrature rule per P_k.
 
     Parameters
     ----------
 
     z : complex or ndarray
 
+    cache : dict
+        Pass a dict to enable cross-call caching.
+
     psi : (K+1,) array_like
 
     support : (lambda_minus, lambda_plus)
 
     alpha, beta : float
 
-    n_base : int
-        Minimum quadrature size.  For degree-k polynomial we use
-        n_quad = max(n_base, k+1).
+    n_quad : int, default=None
+        Number of Gauss-Jacobi quadrature points.
 
     continuation : str, default= ``'pade'``
-        Methof of analytiv continuation.
+        Method of analytic continuation.
 
     dtype : numpy.type, default=numpy.complex128
-        Data type for compelx arrays. This might enhance series acceleration.
+        Data type for complex arrays. This might enhance series acceleration.
 
     Returns
     -------
@@ -209,67 +214,132 @@ def jacobi_stieltjes(z, psi, support, alpha=0.0, beta=0.0, n_base=40,
         Same shape as z
     """
 
+    if not isinstance(cache, dict):
+        raise TypeError('"cache" must be a dict; pass a persistent dict '
+                        '(e.g., self.cache).')
+
+    # Number of quadratures
+    if 'n_quad' not in cache:
+        if n_quad is None:
+            # Set number of quadratures based on Bernstein ellipse. Here using
+            # an evaluation point a with distance delta from support, to
+            # achieve the quadrature error below tol.
+            tol = 1e-16
+            delta = 1e-2
+            n_quad = int(-numpy.log(tol) / (2.0 * numpy.sqrt(delta)))
+        n_quad = max(n_quad, psi.size)
+        cache['n_quad'] = n_quad
+    else:
+        n_quad = cache['n_quad']
+
+    # Quadrature nodes and weights
+    if ('t_nodes' not in cache) or ('w_nodes' not in cache):
+        t_nodes, w_nodes = roots_jacobi(n_quad, alpha, beta)   # (n_quad,)
+        cache['t_nodes'] = t_nodes
+        cache['w_nodes'] = w_nodes
+    else:
+        t_nodes = cache['t_nodes']
+        w_nodes = cache['w_nodes']
+
     z = numpy.asarray(z, dtype=dtype)
     lam_minus, lam_plus = support
     span = lam_plus - lam_minus
     centre = 0.5 * (lam_plus + lam_minus)
 
-    # Map z -> u in the standard [-1,1] domain
+    # Map z to u in the standard [-1,1] domain
     u = (2.0 / span) * (z - centre)
 
-    m_total = numpy.zeros_like(z, dtype=dtype)
+    # Cauchy Kernel (flattened for all z)
+    u_flat = u.ravel()
+    ker = (1.0 / (t_nodes[:, None] - u_flat[None, :])).astype(
+        dtype, copy=False)  # (n_quad, Ny*Nx)
+
+    if continuation == 'pade':
+
+        if 'integrand_nodes' not in cache:
+
+            # Compute sum_k psi_k P_k (call it s_node)
+            s_nodes = numpy.zeros_like(t_nodes, dtype=dtype)
+            for k, psi_k in enumerate(psi):
+
+                # Evaluate P_k at the quadrature nodes
+                P_k_nodes = eval_jacobi(k, alpha, beta, t_nodes)   # (n_quad,)
+                s_nodes += psi_k * P_k_nodes
+
+            integrand_nodes = (2.0 / span) * (w_nodes * s_nodes).astype(dtype)
+            cache['integrand_nodes'] = integrand_nodes
 
-    if continuation != 'pade':
-        # Stores  m with the ravel size of z.
-        m_partial = numpy.zeros((psi.size, z.size), dtype=dtype)
+        else:
+            integrand_nodes = cache['integrand_nodes']
+
+        Q_flat = (integrand_nodes[:, None] * ker).sum(axis=0)
+        m_total = Q_flat.reshape(z.shape)
+
+        return m_total
+
+    else:
 
-    for k, psi_k in enumerate(psi):
-        # Select quadrature size tailored to this P_k
-        n_quad = max(n_base, k + 1)
-        t_nodes, w_nodes = roots_jacobi(n_quad, alpha, beta)  # (n_quad,)
+        # Continuation is not Pade. This is one of Wynn, Levin, etc. These
+        # methods need the series for m for 1, ..., k.
 
-        # Evaluate P_k at the quadrature nodes
-        P_k_nodes = eval_jacobi(k, alpha, beta, t_nodes)     # (n_quad,)
+        if 'B' not in cache:
+            # All P_k at quadrature nodes (real), row-scale by weights
+            P_nodes = numpy.empty((psi.size, n_quad), dtype=w_nodes.dtype)
+            for k in range(psi.size):
+                P_nodes[k, :] = eval_jacobi(k, alpha, beta, t_nodes)
 
-        # Integrand values at nodes: w_nodes already include the weight
-        integrand = w_nodes * P_k_nodes                      # (n_quad,)
+            # All P_k * w shape (K+1, n_quad)
+            B = (2.0 / span) * (P_nodes * w_nodes[None, :]).astype(
+                dtype, copy=False)
+            cache['B'] = B
 
-        # Evaluate jacobi polynomals of the second kind, Q_k using quadrature
-        diff = t_nodes[:, None, None] - u[None, ...]         # (n_quad, Ny, Nx)
-        Q_k = (integrand[:, None, None] / diff).sum(axis=0).astype(dtype)
+        else:
+            B = cache['B']
+
+        # Principal branch. 2D matrix for all k
+        m_k_all = B @ ker
 
-        # Principal branch
-        m_k = (2.0 / span) * Q_k
+        # Compute m on secondary branch from the principal branch, which is
+        # m_k = m_k + 2 \pi i rho_k(z), and rho(z) is the analytic extension of
+        # rho_k(x) using the k-th basis. Basically, rho_k(z) is w * P_k(z).
 
-        # Compute secondary branch from the principal branch
-        if continuation != 'pade':
+        # Lower-half-plane jump for ALL k at once (vectorized)
+        mask_m = (z.imag <= 0)
+        if numpy.any(mask_m):
+            idx = numpy.flatnonzero(mask_m.ravel())
+            u_m = u_flat[idx].astype(dtype, copy=False)  # complex
 
-            # Compute analytic extension of rho(z) to lower-half plane for
-            # when rho is just the k-th Jacobi basis: w(z) P_k(z). FOr this,
-            # we create a psi array (called unit_psi_j), with all zeros, except
-            # its k-th element is one. Ten we call jacobi_density.
-            unit_psi_k = numpy.zeros_like(psi)
-            unit_psi_k[k] = 1.0
+            # Scipy's eval_jacobi tops out at complex128 type. If u_m is
+            # complex256, downcast to complex128.
+            if u_m.dtype.itemsize > numpy.dtype(numpy.complex128).itemsize:
+                u_m_eval = u_m.astype(numpy.complex128, copy=False)
+                down_cast = True
+            else:
+                u_m_eval = u_m
+                down_cast = False
 
-            # Only lower-half plane
-            mask_m = z.imag <= 0
-            z_m = z[mask_m]
+            # P_k at complex u_m (all means for all k = 1,...,K)
+            P_all_m = numpy.empty((psi.size, u_m.size), dtype=dtype)
+            for k in range(psi.size):
+                P_all_m[k, :] = eval_jacobi(k, alpha, beta, u_m_eval)
 
-            # Dnesity here is rho = w(z) P_k
-            rho_k = jacobi_density(z_m.ravel(), unit_psi_k, support,
-                                   alpha=alpha, beta=beta).reshape(z_m.shape)
+            # Jacobi weight. Must match jacobi_density's branch
+            w_m = numpy.power(1.0 - u_m, alpha) * numpy.power(1.0 + u_m, beta)
 
-            # Secondary branch is principal branch + 2 \pi i rho, using Plemelj
-            # (in fact, Riemann-Hirbert jump).
-            m_k[mask_m] = m_k[mask_m] + 2.0 * numpy.pi * 1j * rho_k
+            # rho_k(z) in x-units is (2/span) * w(u) * P_k(u)
+            rho_all = ((2.0 / span) * w_m[None, :] * P_all_m).astype(
+                dtype, copy=False)
 
-        # Accumulate with factor 2/span
-        m_total += psi_k * m_k
+            if down_cast:
+                rho_all = rho_all.astype(dtype)
 
-        if continuation != 'pade':
-            m_partial[k, :] = m_total.ravel()
+            # compute analytic extension of rho(z) to lower-half plane for when
+            # rho is just the k-th Jacobi basis: w(z) P_k(z). For this, we
+            m_k_all[:, idx] = m_k_all[:, idx] + (2.0 * numpy.pi * 1j) * rho_all
 
-    if continuation != 'pade':
+        # Partial sums S_k = sum_{j<=k} psi_j * m_j
+        WQ = (psi[:, None].astype(dtype, copy=False) * m_k_all)
+        m_partial = numpy.cumsum(WQ, axis=0)
 
         if continuation == 'wynn-eps':
             S = wynn_epsilon(m_partial)
@@ -281,7 +351,9 @@ def jacobi_stieltjes(z, psi, support, alpha=0.0, beta=0.0, n_base=40,
             S = weniger_delta(m_partial)
         elif continuation == 'brezinski':
             S = brezinski_theta(m_partial)
+        else:
+            # No acceleration (likely diverges in the lower-half plane)
+            S = m_partial[-1, :]
 
         m_total = S.reshape(z.shape)
-
-    return m_total
+        return m_total

{freealg-0.6.0 → 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.0 → 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.0 → 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.0 → 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.0 → 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.0 → 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.0 → 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.0 → 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.0 → freealg-0.6.2}/freealg/freeform.py

@@ -178,10 +178,13 @@ class FreeForm(object):
             # Detect support
             self.lam_m, self.lam_p = supp(self.eig, **kwargs)
         else:
-            self.lam_m = support[0]
-            self.lam_p = support[1]
+            self.lam_m = float(support[0])
+            self.lam_p = float(support[1])
         self.support = (self.lam_m, self.lam_p)
 
+        # Number of quadrature points to evaluate Stieltjes using Gauss-Jacobi
+        self.n_quad = None
+
         # Initialize
         self.method = None                 # fitting rho: jacobi, chebyshev
         self.continuation = None           # analytic continuation: pade, wynn
@@ -189,15 +192,17 @@ class FreeForm(object):
         self.psi = None                    # coefficients of estimating rho
         self.alpha = None                  # Jacobi polynomials alpha parameter
         self.beta = None                   # Jacobi polynomials beta parameter
+        self.cache = {}                    # Cache inner-computations
 
     # ===
     # fit
     # ===
 
-    def fit(self, method='jacobi', K=10, alpha=0.0, beta=0.0, reg=0.0,
-            projection='gaussian', kernel_bw=0.001, damp=None, force=False,
-            continuation='pade', pade_p=0, pade_q=1, odd_side='left',
-            pade_reg=0.0, optimizer='ls', plot=False, latex=False, save=False):
+    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=1, pade_q=1,
+            odd_side='left', pade_reg=0.0, optimizer='ls', plot=False,
+            latex=False, save=False):
         """
         Fit model to eigenvalues.
 
@@ -221,6 +226,11 @@ class FreeForm(object):
             fitting model on the left side of interval. This should be greater
             then -1. This option is only applicable when ``method='jacobi'``.
 
+        n_quad : int, default=60
+            Number of quadrature points to evaluate Stieltjes transform later
+            on (when :func:`decompress` is called) using Gauss-Jacob
+            quadrature. This option is relevant only if ``method='jacobi'``.
+
         reg : float, default=0.0
             Tikhonov regularization coefficient.
 
@@ -265,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
@@ -336,6 +347,10 @@ class FreeForm(object):
             >>> from freealg import FreeForm
         """
 
+        # Very important: reset cache whenever this function is called. This
+        # also empties all references holdign a cache copy.
+        self.cache.clear()
+
         if alpha <= -1:
             raise ValueError('"alpha" should be greater then "-1".')
 
@@ -351,6 +366,10 @@ class FreeForm(object):
         # Project eigenvalues to Jacobi polynomials basis
         if method == 'jacobi':
 
+            # Set number of Gauss-Jacobi quadratures. This is not used in this
+            # function (used later when decompress is called)
+            self.n_quad = n_quad
+
             if projection == 'sample':
                 psi = jacobi_sample_proj(self.eig, support=self.support, K=K,
                                          alpha=alpha, beta=beta, reg=reg)
@@ -726,6 +745,7 @@ class FreeForm(object):
 
         See Also
         --------
+
         density
         hilbert
 
@@ -757,7 +777,7 @@ class FreeForm(object):
 
         # Create y if not given
         if (plot is False) and (y is None):
-            # Do no tuse a Cartesian grid. Create a 1D array z slightly above
+            # Do not use a Cartesian grid. Create a 1D array z slightly above
             # the real line.
             y = self.delta * 1j
             z = x.astype(complex) + y             # shape (Nx,)
@@ -809,25 +829,27 @@ class FreeForm(object):
         if self.psi is None:
             raise RuntimeError('"fit" the model first.')
 
-        # Allow for arbitrary input shapes
         z = numpy.asarray(z)
-        shape = z.shape
-        if len(shape) == 0:
-            shape = (1,)
-        z = z.reshape(-1, 1)
-
-        # # Set the number of bases as the number of x points insides support
-        # mask_sup = numpy.logical_and(z.real >= self.lam_m,
-        #                              z.real <= self.lam_p)
-        # n_base = 2 * numpy.sum(mask_sup)
 
         # Stieltjes function
         if self.method == 'jacobi':
-            stieltjes = partial(jacobi_stieltjes, psi=self.psi,
-                                support=self.support, alpha=self.alpha,
-                                beta=self.beta, continuation=self.continuation,
-                                dtype=self.dtype)
-            # n_base = n_base
+
+            # Number of quadrature points
+            if z.ndim == 2:
+                # set to twice num x points inside support. This oversampling
+                # avoids anti-aliasing when visualizing.
+                x = z[0, :].real
+                mask_sup = numpy.logical_and(x >= self.lam_m, x <= self.lam_p)
+                n_quad = 2 * numpy.sum(mask_sup)
+            else:
+                # If this is None, the calling function will handle it.
+                n_quad = self.n_quad
+
+            stieltjes = partial(jacobi_stieltjes, cache=self.cache,
+                                psi=self.psi, support=self.support,
+                                alpha=self.alpha, beta=self.beta,
+                                continuation=self.continuation,
+                                dtype=self.dtype, n_quad=n_quad)
 
         elif self.method == 'chebyshev':
             stieltjes = partial(chebyshev_stieltjes, psi=self.psi,
@@ -835,6 +857,12 @@ class FreeForm(object):
                                 continuation=self.continuation,
                                 dtype=self.dtype)
 
+        # Allow for arbitrary input shapes
+        shape = z.shape
+        if len(shape) == 0:
+            shape = (1,)
+        z = z.reshape(-1, 1)
+
         mask_p = z.imag >= 0.0
         mask_m = z.imag < 0.0
 
@@ -930,7 +958,7 @@ class FreeForm(object):
             Estimated spectral density at locations x. ``rho`` can be a 1D or
             2D array output:
 
-            * If ``size`` is a scalar, ``rho`` is a 1D array od the same size
+            * If ``size`` is a scalar, ``rho`` is a 1D array of the same size
               as ``x``.
             * If ``size`` is an array of size `n`, ``rho`` is a 2D array with
               `n` rows, where each row corresponds to decompression to a size.

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

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

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