freealg 0.1.12__py3-none-any.whl → 0.1.14__py3-none-any.whl

freealg/__init__.py

@@ -6,7 +6,8 @@
 # under the terms of the license found in the LICENSE.txt file in the root
 # directory of this source tree.
 
-from .freeform import FreeForm, eigfree
+from .freeform import FreeForm
+from .eigfree import eigfree
 from . import distributions
 
 __all__ = ['FreeForm', 'distributions', 'eigfree']

freealg/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.12"
+__version__ = "0.1.14"

freealg/_chebyshev.py

@@ -58,7 +58,6 @@ def chebyshev_sample_proj(eig, support, K=10, reg=0.0):
 
     # Map to [–1,1] interval
     t = (2 * eig - (lam_m + lam_p)) / (lam_p - lam_m)
-    N = eig.size
 
     # Inner‐product norm of each U_k under w(t) = sqrt{1–t^2} is \\pi/2
     norm = numpy.pi / 2
@@ -104,7 +103,7 @@ def chebyshev_kernel_proj(xs, pdf, support, K=10, reg=0.0):
 
     for k in range(K + 1):
         Pk = eval_chebyu(k, t)                       # U_k(t) on the grid
-        moment = numpy.trapezoid(Pk * pdf, xs)           # \int U_k(t) \rho(x) dx
+        moment = numpy.trapezoid(Pk * pdf, xs)       # \int U_k(t) \rho(x) dx
 
         if k == 0:
             penalty = 0
@@ -226,12 +225,12 @@ def chebyshev_stieltjes(z, psi, support):
     S = wynn_pade(psi_zero, J)
 
     # build powers J^(k+1) for k=0..K
-    #K = len(psi) - 1
+    # K = len(psi) - 1
     # shape: (..., K+1)
-    #Jpow = J[..., None] ** numpy.arange(1, K+2)
+    # Jpow = J[..., None] ** numpy.arange(1, K+2)
 
     # sum psi_k * J^(k+1)
-    #S = numpy.sum(psi * Jpow, axis=-1)
+    # S = numpy.sum(psi * Jpow, axis=-1)
 
     # assemble m(z)
     m_z = -2 / span * numpy.pi * S

freealg/_decompress.py

@@ -11,17 +11,198 @@
 # =======
 
 import numpy
-# from scipy.integrate import solve_ivp
 
 __all__ = ['decompress', 'reverse_characteristics']
 
 
+# =============
+# secant method
+# =============
+
+
+def secant_complex(f, z0, z1, a=0+0j, tol=1e-12, max_iter=100,
+                   alpha=0.5, max_bt=2, eps=1e-30, step_factor=5.0,
+                   post_smooth=True, jump_tol=10.0, verbose=False):
+    """
+    Solves :math:``f(z) = a`` for many starting points simultaneously
+    using the secant method in the complex plane.
+
+    Parameters
+    ----------
+    f : callable
+        Function that accepts and returns complex `ndarray`s.
+
+    z0, z1 : array_like
+        Two initial guesses. ``z1`` may be broadcast to ``z0``.
+
+    a : complex or array_like, optional
+        Right‑hand‑side targets (broadcasted to ``z0``). Defaults to ``0+0j``.
+
+    tol : float, optional
+        Convergence criterion on ``|f(z) - a|``. Defaults to ``1e-12``.
+
+    max_iter : int, optional
+        Maximum number of secant iterations. Defaults to ``100``.
+
+    alpha : float, optional
+        Back‑tracking shrink factor (``0 < alpha < 1``). Defaults to ``0.5``.
+
+    max_bt : int, optional
+        Maximum back‑tracking trials per iteration. Defaults to ``0``.
+
+    eps : float, optional
+        Safeguard added to tiny denominators. Defaults to ``1e-30``.
+
+    post_smooth : bool, optional
+        If True (default) run a single vectorised clean-up pass that
+        re-solves points whose final root differs from the *nearest*
+        neighbour by more than ``jump_tol`` times the local median jump.
+
+    jump_tol : float, optional
+        Sensitivity of the clean-up pass; larger tolerance implies fewer
+        re-solves.
+
+    verbose : bool, optional
+        If *True*, prints progress every 10 iterations.
+
+    Returns
+    -------
+    roots : ndarray
+        Estimated roots, shaped like the broadcast inputs.
+    residuals : ndarray
+        Final residuals ``|f(root) - a|``.
+    iterations : ndarray
+        Iteration count for each point.
+    """
+
+    # Broadcast inputs
+    z0, z1, a = numpy.broadcast_arrays(
+        numpy.asarray(z0, numpy.complex128),
+        numpy.asarray(z1, numpy.complex128),
+        numpy.asarray(a,  numpy.complex128),
+    )
+    orig_shape = z0.shape
+    z0, z1, a = (x.ravel() for x in (z0, z1, a))
+
+    n_points = z0.size
+    roots = z1.copy()
+    iterations = numpy.zeros(n_points, dtype=int)
+
+    f0 = f(z0) - a
+    f1 = f(z1) - a
+    residuals = numpy.abs(f1)
+    converged = residuals < tol
+
+    # Entering main loop
+    for k in range(max_iter):
+        active = ~converged
+        if not active.any():
+            break
+
+        # Secant step
+        denom = f1 - f0
+        denom = numpy.where(numpy.abs(denom) < eps, denom + eps, denom)
+        dz = (z1 - z0) * f1 / denom
+
+        # Step-size limiter
+        prev_step = numpy.maximum(numpy.abs(z1 - z0), eps)
+        max_step = step_factor * prev_step
+        big = numpy.abs(dz) > max_step
+        dz[big] *= max_step[big] / numpy.abs(dz[big])
+
+        z2 = z1 - dz
+        f2 = f(z2) - a
+
+        # Line search by backtracking
+        worse = (numpy.abs(f2) >= numpy.abs(f1)) & active
+        if worse.any():
+            shrink = numpy.ones_like(dz)
+            for _ in range(max_bt):
+                shrink[worse] *= alpha
+                z_try = z1[worse] - shrink[worse] * dz[worse]
+                f_try = f(z_try) - a[worse]
+
+                improved = numpy.abs(f_try) < numpy.abs(f1[worse])
+                if not improved.any():
+                    continue
+
+                idx = numpy.flatnonzero(worse)[improved]
+                z2[idx], f2[idx] = z_try[improved], f_try[improved]
+                worse[idx] = False
+                if not worse.any():
+                    break
+
+        # Book‑keeping
+        newly_conv = (numpy.abs(f2) < tol) & active
+        converged[newly_conv] = True
+        iterations[newly_conv] = k + 1
+        roots[newly_conv] = z2[newly_conv]
+        residuals[newly_conv] = numpy.abs(f2[newly_conv])
+
+        still = active & ~newly_conv
+        z0[still], z1[still] = z1[still], z2[still]
+        f0[still], f1[still] = f1[still], f2[still]
+
+        if verbose and k % 10 == 0:
+            print(f"Iter {k}: {converged.sum()} / {n_points} converged")
+
+    # Non‑converged points
+    remaining = ~converged
+    roots[remaining] = z1[remaining]
+    residuals[remaining] = numpy.abs(f1[remaining])
+    iterations[remaining] = max_iter
+
+    # Optional clean-up pass
+    if post_smooth and n_points > 2:
+        # absolute jump to *nearest* neighbour (left or right)
+        diff_left = numpy.empty_like(roots)
+        diff_right = numpy.empty_like(roots)
+        diff_left[1:] = numpy.abs(roots[1:] - roots[:-1])
+        diff_right[:-1] = numpy.abs(roots[:-1] - roots[1:])
+        jump = numpy.minimum(diff_left, diff_right)
+
+        # ignore unconverged points
+        median_jump = numpy.median(jump[~remaining])
+        bad = (jump > jump_tol * median_jump) & ~remaining
+
+        if bad.any():
+            z_first_all = numpy.where(bad & (diff_left <= diff_right),
+                                      roots - diff_left,
+                                      roots + diff_right)
+
+            # keep only the offending indices
+            z_first = z_first_all[bad]
+            z_second = z_first + (roots[bad] - z_first) * 1e-2
+
+            # re-solve just the outliers in one vector call
+            new_root, new_res, new_iter = secant_complex(
+                f, z_first, z_second, a[bad],
+                tol=tol, max_iter=max_iter,
+                alpha=alpha, max_bt=max_bt,
+                eps=eps, step_factor=step_factor,
+                post_smooth=False,      # avoid recursion
+            )
+            roots[bad] = new_root
+            residuals[bad] = new_res
+            iterations[bad] = iterations[bad] + new_iter
+
+            if verbose:
+                print(f"Clean-up: re-solved {bad.sum()} outliers")
+
+    return (
+        roots.reshape(orig_shape),
+        residuals.reshape(orig_shape),
+        iterations.reshape(orig_shape),
+    )
+
+
 # ==========
 # decompress
 # ==========
 
-def decompress(freeform, size, x=None, delta=1e-6, iterations=500,
-               step_size=0.1, tolerance=1e-9):
+
+def decompress(freeform, size, x=None, delta=1e-4, max_iter=500,
+               tolerance=1e-8):
     """
     Free decompression of spectral density.
 
@@ -42,15 +223,11 @@ def decompress(freeform, size, x=None, delta=1e-6, iterations=500,
         Size of the perturbation into the upper half plane for Plemelj's
         formula.
 
-    iterations: int, default=500
-        Maximum number of Newton iterations.
+    max_iter: int, default=500
+        Maximum number of secant method iterations.
 
-    step_size: float, default=0.1
-        Step size for Newton iterations.
-
-    tolerance: float, default=1e-4
-        Tolerance for the solution obtained by the Newton solver. Also
-        used for the finite difference approximation to the derivative.
+    tolerance: float, default=1e-12
+        Tolerance for the solution obtained by the secant method solver.
 
     Returns
     -------
@@ -85,56 +262,55 @@ def decompress(freeform, size, x=None, delta=1e-6, iterations=500,
     alpha = size / freeform.n
     m = freeform._eval_stieltjes
     # Lower and upper bound on new support
-    hilb_lb = (1 / m(freeform.lam_m + delta * 1j)[1]).real
-    hilb_ub = (1 / m(freeform.lam_p + delta * 1j)[1]).real
+    hilb_lb = (1 / m(freeform.lam_m + delta * 1j)).real
+    hilb_ub = (1 / m(freeform.lam_p + delta * 1j)).real
     lb = freeform.lam_m - (alpha - 1) * hilb_lb
     ub = freeform.lam_p - (alpha - 1) * hilb_ub
 
     # Create x if not given
-    if x is None:
+    on_grid = (x is None)
+    if on_grid:
         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, 500)
-
-    def _char_z(z):
-        return z + (1 / m(z)[1]) * (1 - alpha)
-
-    # Ensure that input is an array
-    x = numpy.asarray(x)
+    else:
+        x = numpy.asarray(x)
 
     target = x + delta * 1j
+    if numpy.isclose(alpha, 1.0):
+        return freeform.density(x), x, freeform.support
 
-    z = numpy.full(target.shape, numpy.mean(freeform.support) - .1j,
-                   dtype=numpy.complex128)
-
-    # Broken Newton steps can produce a lot of warnings. Removing them
-    # for now.
-    with numpy.errstate(all='ignore'):
-        for _ in range(iterations):
-            objective = _char_z(z) - target
-            mask = numpy.abs(objective) >= tolerance
-            if not numpy.any(mask):
-                break
-            z_m = z[mask]
+    # Characteristic curve map
+    def _char_z(z):
+        return z + (1 / m(z)) * (1 - alpha)
 
-            # Perform finite difference approximation
-            dfdz = _char_z(z_m+tolerance) - _char_z(z_m-tolerance)
-            dfdz /= 2*tolerance
-            dfdz[dfdz == 0] = 1.0
+    z0 = numpy.full(target.shape, numpy.mean(freeform.support) + .1j,
+                    dtype=numpy.complex128)
+    z1 = z0 - .2j
 
-            # Perform Newton step
-            z[mask] = z_m - step_size * objective[mask] / dfdz
+    roots, _, _ = secant_complex(
+        _char_z, z0, z1,
+        a=target,
+        tol=tolerance,
+        max_iter=max_iter
+    )
 
     # Plemelj's formula
-    char_s = m(z)[1] / alpha
+    z = roots
+    char_s = m(z) / alpha
     rho = numpy.maximum(0, char_s.imag / numpy.pi)
     rho[numpy.isnan(rho) | numpy.isinf(rho)] = 0
-    rho = rho.reshape(*x.shape)
+    if on_grid:
+        x, rho = x.ravel(), rho.ravel()
+        # dx = x[1] - x[0]
+        # left_idx, right_idx = support_from_density(dx, rho)
+        # x, rho = x[left_idx-1:right_idx+1], rho[left_idx-1:right_idx+1]
+        rho = rho / numpy.trapezoid(rho, x)
 
-    return rho, x, (lb, ub)
+    return rho.reshape(*x.shape), x, (lb, ub)
 
 
 # =======================
@@ -152,7 +328,7 @@ def reverse_characteristics(freeform, z_inits, T, iterations=500,
     m = freeform._eval_stieltjes
 
     def _char_z(z, t):
-        return z + (1 / m(z)[1]) * (1 - numpy.exp(t))
+        return z + (1 / m(z)) * (1 - numpy.exp(t))
 
     target_z, target_t = numpy.meshgrid(z_inits, t_eval)
 

freealg/_pade.py

@@ -236,9 +236,10 @@ def _eval_rational(z, c, D, poles, resid):
 
     return c + D * z + term
 
-# ========
-# Wynn epsilon algorithm for Pade
-# ========
+
+# =========
+# Wynn pade
+# =========
 
 @numba.jit(nopython=True, parallel=True)
 def wynn_pade(coeffs, x):
@@ -248,48 +249,57 @@ def wynn_pade(coeffs, x):
     returns a function handle that computes the Pade approximant at any x
     using Wynn's epsilon algorithm.
 
-    Parameters:
-        coeffs (list or array): Coefficients [a0, a1, a2, ...] of the power series.
+    Parameters
+    ----------
+
+    coeffs (list or array):
+        Coefficients [a0, a1, a2, ...] of the power series.
 
-    Returns:
-        function: A function approximant(x) that returns the approximated value f(x).
+    Returns
+    -------
+
+    function:
+        A function approximant(x) that returns the approximated value f(x).
     """
+
     # Number of coefficients
     xn = x.ravel()
     d = len(xn)
     N = len(coeffs)
-    
+
     # Compute the partial sums s_n = sum_{i=0}^n a_i * x^i for n=0,...,N-1
     eps = numpy.zeros((N+1, N, d), dtype=numpy.complex128)
     for i in numba.prange(d):
         partial_sum = 0.0
         for n in range(N):
             partial_sum += coeffs[n] * (xn[i] ** n)
-            eps[0,n,i] = partial_sum
+            eps[0, n, i] = partial_sum
 
     for i in numba.prange(d):
         for k in range(1, N+1):
             for j in range(N - k):
-                delta = eps[k-1, j+1,i] - eps[k-1, j,i]
+                delta = eps[k-1, j+1, i] - eps[k-1, j, i]
                 if delta == 0:
                     rec_delta = numpy.inf
                 elif numpy.isinf(delta) or numpy.isnan(delta):
                     rec_delta = 0.0
                 else:
                     rec_delta = 1.0 / delta
-                eps[k,j,i] = rec_delta
+                eps[k, j, i] = rec_delta
                 if k > 1:
-                    eps[k,j,i] += eps[k-2,j+1,i]
+                    eps[k, j, i] += eps[k-2, j+1, i]
 
     if (N % 2) == 0:
         N -= 1
-    
+
     return eps[N-1, 0, :].reshape(x.shape)
 
+
 # ========
 # fit pade
 # ========
 
+
 def fit_pade(x, f, lam_m, lam_p, p=1, 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):

freealg/_plot_util.py

@@ -139,7 +139,7 @@ def _auto_bins(array, method='scott', factor=5):
 # ============
 
 def plot_density(x, rho, eig=None, support=None, label='',
-                 title='Spectral density', latex=False, save=False):
+                 title='Spectral Density', latex=False, save=False):
     """
     """
 
@@ -147,8 +147,11 @@ def plot_density(x, rho, eig=None, support=None, label='',
 
         fig, ax = plt.subplots(figsize=(6, 2.7))
 
-        if (support is not None) and (eig is not None):
-            lam_m, lam_p = support
+        if eig is not None:
+            if support is not None:
+                lam_m, lam_p = support
+            else:
+                lam_m, lam_p = min(eig), max(eig)
             bins = numpy.linspace(lam_m, lam_p, _auto_bins(eig))
             _ = ax.hist(eig, bins, density=True, color='silver',
                         edgecolor='none', label='Histogram')

freealg/_support.py

@@ -1,31 +1,126 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# SPDX-FileType: SOURCE
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the license found in the LICENSE.txt file in the root directory
+# of this source tree.
+
+
+# =======
+# Imports
+# =======
+
 import numpy
+import numba
 from scipy.stats import gaussian_kde
 
-def detect_support(eigs, method='interior_smooth', k = None, p = 0.001, **kwargs):
+
+@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
+    density over a grid of x-values with mesh spacing dx.
+    """
+    n = density.shape[0]
+    target = 1.0 / dx
+
+    # 1) compute total_sum once
+    total_sum = 0.0
+    for t in range(n):
+        total_sum += density[t]
+
+    # 2) set up our “best‐so‐far” trackers
+    large = 1e300
+    best_nonneg_sum = large
+    best_nonneg_idx = -1
+    best_nonpos_sum = -large
+    best_nonpos_idx = -1
+
+    # 3) seed with first element (i.e. prefix_sum for k=1)
+    prefix_sum = density[0]
+    if prefix_sum >= 0.0:
+        best_nonneg_sum, best_nonneg_idx = prefix_sum, 1
+    else:
+        best_nonpos_sum, best_nonpos_idx = prefix_sum, 1
+
+    # 4) sweep j from 2...n–1, updating prefix_sum on the fly
+    optimal_i, optimal_j = 1, 2
+    minimal_cost = large
+
+    for j in range(2, n):
+        # extend prefix_sum to cover density[0]...density[j-1]
+        prefix_sum += density[j-1]
+
+        # cost for [0...i], [i...j]
+        diff_mid = prefix_sum - target
+        if diff_mid >= 0.0 and best_nonneg_sum <= diff_mid:
+            cost12 = diff_mid
+            i_cand = best_nonneg_idx
+        elif diff_mid < 0.0 and best_nonpos_sum >= diff_mid:
+            cost12 = -diff_mid
+            i_cand = best_nonpos_idx
+        else:
+            cost_using_nonpos = diff_mid - 2.0 * best_nonpos_sum
+            cost_using_nonneg = 2.0 * best_nonneg_sum - diff_mid
+            if cost_using_nonpos < cost_using_nonneg:
+                cost12, i_cand = cost_using_nonpos, best_nonpos_idx
+            else:
+                cost12, i_cand = cost_using_nonneg, best_nonneg_idx
+
+        # cost for [j...n]
+        cost3 = total_sum - prefix_sum
+        if cost3 < 0.0:
+            cost3 = -cost3
+
+        # total and maybe update best split
+        total_cost = cost12 + cost3
+        if total_cost < minimal_cost:
+            minimal_cost = total_cost
+            optimal_i, optimal_j = i_cand, j
+
+        # update our prefix‐sum trackers
+        if prefix_sum >= 0.0:
+            if prefix_sum < best_nonneg_sum:
+                best_nonneg_sum, best_nonneg_idx = prefix_sum, j
+        else:
+            if prefix_sum > best_nonpos_sum:
+                best_nonpos_sum, best_nonpos_idx = prefix_sum, j
+
+    return optimal_i, optimal_j
+
+
+def detect_support(eigs, method='asymp', k=None, p=0.001, **kwargs):
     """
     Estimates the support of the eigenvalue density.
 
     Parameters
     ----------
-    method : {``'range'``, ``'jackknife'``, ``'regression'``, ``'interior'``, 
-                ``'interior_smooth'``}, \
-            default= ``'jackknife'``
+    method : {``'range'``, ``'asymp'``, ``'jackknife'``, ``'regression'``,
+                ``'interior'``, ``'interior_smooth'``}, \
+            default= ``'asymp'``
         The method of support estimation:
 
-        * ``'range'``: no estimation; the support is the range of the eigenvalues
+        * ``'range'``: no estimation; the support is the range of the
+            eigenvalues.
+        * ``'asymp'``: assume the relative error in the min/max estimator is
+            1/n.
         * ``'jackknife'``: estimates the support using Quenouille's [1]
-            jackknife estimator. Fast and simple, more accurate than the range.
-        * ``'regression'``: estimates the support by performing a regression under
-            the assumption that the edge behavior is of square-root type. Often
-            most accurate.
+            jackknife estimator. Fast and simple, more accurate than the
+            range.
+        * ``'regression'``: estimates the support by performing a regression
+            under the assumption that the edge behavior is of square-root
+            type. Often most accurate.
         * ``'interior'``: estimates a support assuming the range overestimates;
             uses quantiles (p, 1-p).
-        * ``'interior_smooth'``: same as ``'interior'`` but using kernel density
-            estimation.
+        * ``'interior_smooth'``: same as ``'interior'`` but using kernel
+            density estimation.
 
     k : int, default = None
-        Number of extreme order statistics to use for ``method='regression'``. 
-    
+        Number of extreme order statistics to use for ``method='regression'``.
+
     p : float, default=0.001
         The edges of the support of the distribution is detected by the
         :math:`p`-quantile on the left and :math:`(1-p)`-quantile on the right
@@ -36,28 +131,33 @@ def detect_support(eigs, method='interior_smooth', k = None, p = 0.001, **kwargs
     References
     ----------
 
-    .. [1] Quenouille, M. H. (1949, July). Approximate tests of correlation in time-series. 
-        In Mathematical Proceedings of the Cambridge Philosophical Society (Vol. 45, No. 3, 
-        pp. 483-484). Cambridge University Press.
+    .. [1] Quenouille, M. H. (1949, July). Approximate tests of correlation in
+           time-series. In Mathematical Proceedings of the Cambridge
+           Philosophical Society (Vol. 45, No. 3, pp. 483-484). Cambridge
+           University Press.
     """
 
-    if method=='range':
+    if method == 'range':
         lam_m = eigs.min()
         lam_p = eigs.max()
 
-    elif method=='jackknife':
+    elif method == 'asymp':
+        lam_m = eigs.min() - abs(eigs.min()) / len(eigs)
+        lam_p = eigs.max() + abs(eigs.max()) / len(eigs)
+
+    elif method == 'jackknife':
         x, n = numpy.sort(eigs), len(eigs)
-        lam_m = x[0]  - (n - 1)/n * (x[1]  - x[0])
+        lam_m = x[0] - (n - 1)/n * (x[1] - x[0])
         lam_p = x[-1] + (n - 1)/n * (x[-1] - x[-2])
 
-    elif method=='regression':
+    elif method == 'regression':
         x, n = numpy.sort(eigs), len(eigs)
         if k is None:
             k = int(round(n ** (2/3)))
             k = max(5, min(k, n // 2))
 
         # The theoretical cdf near the edge behaves like const*(x - a)^{3/2},
-        # so (i/n) ≈ (x - a)^{3/2}  ⇒  x ≈ a + const*(i/n)^{2/3}.
+        # so (i/n) ~ (x - a)^{3/2}  ->  x ~ a + const*(i/n)^{2/3}.
         y = ((numpy.arange(1, k + 1) - 0.5) / n) ** (2 / 3)
 
         # Left edge: regress x_{(i)} on y
@@ -66,10 +166,10 @@ def detect_support(eigs, method='interior_smooth', k = None, p = 0.001, **kwargs
         # Right edge: regress x_{(n-i+1)} on y
         _, lam_p = numpy.polyfit(y, x[-k:][::-1], 1)
 
-    elif method=='interior':
+    elif method == 'interior':
         lam_m, lam_p = numpy.quantile(eigs, [p, 1-p])
-    
-    elif method=='interior_smooth':
+
+    elif method == 'interior_smooth':
         kde = gaussian_kde(eigs)
         xs = numpy.linspace(eigs.min(), eigs.max(), 1000)
         fs = kde(xs)
@@ -79,6 +179,7 @@ def detect_support(eigs, method='interior_smooth', k = None, p = 0.001, **kwargs
 
         lam_m = numpy.interp(p, cdf, xs)
         lam_p = numpy.interp(1-p, cdf, xs)
+
     else:
         raise NotImplementedError("Unknown method")