sparse-ir 1.1.7__py3-none-any.whl → 2.0.0a2__py3-none-any.whl

sparse_ir/_gauss.py

@@ -1,260 +0,0 @@
-# Copyright (C) 2020-2022 Markus Wallerberger, Hiroshi Shinaoka, and others
-# SPDX-License-Identifier: MIT
-import warnings
-import numpy as np
-
-import scipy.linalg as sp_linalg
-import numpy.polynomial.legendre as np_legendre
-
-
-class Rule:
-    """Quadrature rule.
-
-    Approximation of an integral by a weighted sum over discrete points:
-
-         ∫ f(x) * omega(x) * dx ~ sum(f(xi) * wi for (xi, wi) in zip(x, w))
-
-    where we generally have superexponential convergence for smooth ``f(x)``
-    with the number of quadrature points.
-    """
-    def __init__(self, x, w, x_forward=None, x_backward=None, a=-1, b=1):
-        x = np.asarray(x)
-        if x_forward is None:
-            x_forward = x - a
-        if x_backward is None:
-            x_backward = b - x
-
-        self.x = x
-        self.w = np.asarray(w)
-        self.x_forward = np.asarray(x_forward)
-        self.x_backward = np.asarray(x_backward)
-        self.a = a
-        self.b = b
-
-    def reseat(self, a, b):
-        """Reseat current quadrature rule to new domain"""
-        scaling = (b - a) / (self.b - self.a)
-        x = scaling * (self.x - (self.b + self.a)/2) + (b + a)/2
-        w = self.w * scaling
-        x_forward = self.x_forward * scaling
-        x_backward = self.x_backward * scaling
-        return Rule(x, w, x_forward, x_backward, a, b)
-
-    def scale(self, factor):
-        """Scale weights by factor"""
-        return Rule(self.x, self.w * factor, self.x_forward, self.x_backward,
-                    self.a, self.b)
-
-    def piecewise(self, edges):
-        """Piecewise quadrature with the same quadrature rule, but scaled"""
-        edges = np.asarray(edges)
-        start = edges[:-1]
-        stop = edges[1:]
-        if not (stop > start).all():
-            raise ValueError("segments ends must be ordered ascendingly")
-
-        return self.join(*(self.reseat(start_i, stop_i)
-                         for (start_i, stop_i) in zip(start, stop)))
-
-    def astype(self, dtype):
-        dtype = np.dtype(dtype)
-        return Rule(self.x.astype(dtype), self.w.astype(dtype),
-                    self.x_forward.astype(dtype), self.x_backward.astype(dtype),
-                    dtype.type(self.a), dtype.type(self.b))
-
-    @staticmethod
-    def join(*gauss_list):
-        """Join multiple Gauss quadratures together"""
-        if not gauss_list:
-            return Rule((), ())
-
-        a = gauss_list[0].a
-        b = gauss_list[-1].b
-        prev_b = a
-        parts = []
-
-        for curr in gauss_list:
-            if curr.a != prev_b:
-                raise ValueError("Gauss rules must be ascending")
-            prev_b = curr.b
-            x_forward = curr.x_forward + (curr.a - a)
-            x_backward = curr.x_backward + (b - curr.b)
-            parts.append((curr.x, curr.w, x_forward, x_backward))
-
-        x, w, x_forward, x_backward = map(np.hstack, zip(*parts))
-        return Rule(x, w, x_forward, x_backward, a, b)
-
-
-def legendre(n, dtype=float):
-    """Gauss-Legendre quadrature"""
-    return rule_from_recurrence(*_legendre_recurrence(n, dtype))
-
-
-def legendre_collocation(rule, n=None):
-    """Generate collocation matrix from Gauss-Legendre rule"""
-    if n is None:
-        n = rule.x.size
-
-    res = np_legendre.legvander(rule.x, n - 1).T.copy()
-    res *= rule.w
-
-    invnorm = np.arange(0.5, n + 0.5, dtype=rule.x.dtype)
-    res *= invnorm[:,None]
-    return res
-
-
-def rule_from_recurrence(alpha, beta, a, b):
-    """Make new Gauss scheme based on recurrence coefficients.
-
-    Given a set of polynomials ``P[n]`` defined by the following three-term
-    recurrence relation::
-
-        P[0](x)   == 1
-        P[1](x)   == x - alpha[0]
-        P[n+1](x) == (x - alpha[n]) * P[n] - beta[n] * P[n-1]
-
-    we construct both a set of quadrature points ``x`` and weights ``w`` for
-    Gaussian quadrature.  It is usually a good idea to work in extended
-    precision for extra acccuracy in the quadrature rule.
-    """
-    dtype = np.result_type(alpha, beta)
-
-    # First approximation of roots by finding eigenvalues of tridiagonal system
-    # corresponding to the recursion
-    beta[0] = b - a
-    beta_is_pos = beta >= 0
-    if not beta_is_pos.all():
-        raise NotImplementedError("scipy solver cannot handle complex")
-
-    sqrt_beta = np.sqrt(beta[1:])
-    x = sp_linalg.eigvalsh_tridiagonal(alpha, sqrt_beta)
-    x = x.astype(dtype)
-
-    # These roots are usually only accurate to 100 ulps or so, so we improve
-    # on them using a few iterations of the Newton method.
-    prevdiff = 1.0
-    maxiter = 5
-    for _ in range(maxiter):
-        p, dp, _, _ = _polyvalderiv(x, alpha, beta)
-        diff = p / dp
-        x -= diff
-
-        # check convergence without relying on ATOL
-        currdiff = np.abs(diff).max()
-        #print(currdiff)
-        if not (2 * currdiff <= prevdiff):
-            break
-        prevdiff = currdiff
-    else:
-        warnings.warn("Newton iteration did not converge, error = {.2g}"
-                      .format(currdiff))
-
-    # Now we know that the weights are proportional to the following:
-    _, dp1, p0, _ = _polyvalderiv(x, alpha, beta)
-    with np.errstate(over='ignore'):
-        w = 1 / (dp1 * p0)
-    w *= beta[0] / w.sum(initial=dtype.type(0))
-    return Rule(x, w, x - a, b - x, a, b)
-
-
-def _polyvalderiv(x, alpha, beta):
-    """Return value and derivative of polynomial.
-
-    Given a set of polynomials ``P[n]`` defined by a three-term recurrence,
-    we evaluate both value and derviative for the highest polynomial and
-    the second highest one.
-    """
-    n = len(alpha)
-    p0 = np.ones_like(x)
-    p1 = x - alpha[0] * p0
-    dp0 = np.zeros_like(x)
-    dp1 = p0
-    for k in range(1, n):
-        x_minus_alpha = x - alpha[k]
-        p2 = x_minus_alpha * p1 - beta[k] * p0
-        dp2 = p1 + x_minus_alpha * dp1 - beta[k] * dp0
-        p0 = p1
-        p1 = p2
-        dp0 = dp1
-        dp1 = dp2
-
-    return p1, dp1, p0, dp0
-
-
-def _legendre_recurrence(n, dtype=float):
-    """Returns the alpha, beta for Gauss-Legendre integration"""
-    # The Legendre polynomials are defined by the following recurrence:
-    #
-    #     (n + 1) * P[n+1](x) == (2 * n + 1) * x * P[n](x) - n * P[n-1](x)
-    #
-    # To normalize this, we realize that the prefactor of the highest power
-    # of P[n] is (2n -1)!! / n!, which we divide by to obtain the "scaled"
-    # beta values.
-    dtype = np.dtype(dtype)
-    k = np.arange(n, dtype=dtype)
-    ksq = k**2
-    alpha = np.zeros_like(k)
-    beta = ksq / (4 * ksq - 1)
-    beta[0] = 2
-    one = dtype.type(1)
-    return alpha, beta, -one, one
-
-
-class NestedRule(Rule):
-    """Nested Gauss quadrature rule."""
-    def __init__(self, x, w, v, x_forward=None, x_backward=None, a=-1, b=1):
-        super().__init__(x, w, x_forward, x_backward, a, b)
-        self.v = np.asarray(v)
-        self.vsel = slice(1, None, 2)
-
-    def reseat(self, a, b):
-        """Reseat current quadrature rule to new domain"""
-        res = super().reseat(a, b)
-        new_v = (b - a) / (self.b - self.a) * self.v
-        return NestedRule(res.x, res.w, new_v, res.x_forward, res.x_backward,
-                          res.a, res.b)
-
-    def scale(self, factor):
-        """Scale weights by factor"""
-        res = super().scale(factor)
-        new_v = factor * self.v
-        return NestedRule(res.x, res.w, new_v, res.x_forward, res.x_backward,
-                          res.a, res.b)
-
-    def astype(self, dtype):
-        dtype = np.dtype(dtype)
-        res = super().astype(dtype)
-        new_v = self.v.astype(dtype)
-        return NestedRule(res.x, res.w, new_v, res.x_forward, res.x_backward,
-                          res.a, res.b)
-
-
-def kronrod_31_15():
-    x = (-0.99800229869339710, -0.98799251802048540, -0.96773907567913910,
-         -0.93727339240070600, -0.89726453234408190, -0.84820658341042720,
-         -0.79041850144246600, -0.72441773136017010, -0.65099674129741700,
-         -0.57097217260853880, -0.48508186364023970, -0.39415134707756340,
-         -0.29918000715316884, -0.20119409399743451, -0.10114206691871750,
-         +0.00000000000000000, +0.10114206691871750, +0.20119409399743451,
-         +0.29918000715316884, +0.39415134707756340, +0.48508186364023970,
-         +0.57097217260853880, +0.65099674129741700, +0.72441773136017010,
-         +0.79041850144246600, +0.84820658341042720, +0.89726453234408190,
-         +0.93727339240070600, +0.96773907567913910, +0.98799251802048540,
-         +0.99800229869339710)
-    w = (0.005377479872923349, 0.015007947329316122, 0.025460847326715320,
-         0.035346360791375850, 0.044589751324764880, 0.053481524690928090,
-         0.062009567800670640, 0.069854121318728260, 0.076849680757720380,
-         0.083080502823133020, 0.088564443056211760, 0.093126598170825320,
-         0.096642726983623680, 0.099173598721791960, 0.100769845523875590,
-         0.101330007014791540, 0.100769845523875590, 0.099173598721791960,
-         0.096642726983623680, 0.093126598170825320, 0.088564443056211760,
-         0.083080502823133020, 0.076849680757720380, 0.069854121318728260,
-         0.062009567800670640, 0.053481524690928090, 0.044589751324764880,
-         0.035346360791375850, 0.025460847326715320, 0.015007947329316122,
-         0.005377479872923349)
-    v = (0.03075324199611727, 0.07036604748810812, 0.10715922046717194,
-         0.13957067792615432, 0.16626920581699392, 0.18616100001556220,
-         0.19843148532711158, 0.20257824192556130, 0.19843148532711158,
-         0.18616100001556220, 0.16626920581699392, 0.13957067792615432,
-         0.10715922046717194, 0.07036604748810812, 0.03075324199611727)
-    return NestedRule(np.array(x), np.array(w), np.array(v))

sparse_ir/_roots.py

@@ -1,140 +0,0 @@
-# Copyright (C) 2020-2022 Markus Wallerberger, Hiroshi Shinaoka, and others
-# SPDX-License-Identifier: MIT
-"""
-Auxiliary module for root finding routines.
-"""
-import numpy as np
-
-
-def find_all(f, xgrid, type='continuous'):
-    """Find all roots of function between gridpoints"""
-    xgrid = np.asarray(xgrid)
-    if xgrid.ndim != 1:
-        raise ValueError("grid must be a one-dimensional array")
-
-    # First, extract roots that lie directly on the grid points
-    fx = f(xgrid)
-    hit = fx == 0
-    x_hit = xgrid[hit]
-
-    # Next, find out where the sign changes (sign bit flips) remove the
-    # previously found points from consideration (we need to remove both
-    # directions for transitions + -> - and - -> +)
-    sign_change = np.signbit(fx[:-1]) != np.signbit(fx[1:])
-    sign_change &= ~hit[:-1] & ~hit[1:]
-    if not sign_change.any():
-        return x_hit
-
-    # sign_change[i] being set means that the sign changes from xgrid[i] to
-    # xgrid[i+1].  This means a corresponds to those xgrid[i] and b to those
-    # xgrid[i+1] where sign_change[i] is set.
-    where_a = np.hstack((sign_change, False))
-    where_b = np.hstack((False, sign_change))
-    a = xgrid[where_a]
-    b = xgrid[where_b]
-    fa = fx[where_a]
-    fb = fx[where_b]
-
-    # Depending on whether we have a discrete or continuous function, do
-    # this.
-    if type == 'continuous':
-        xeps = np.finfo(xgrid.dtype).eps * np.abs(xgrid).max()
-        x_bisect = _bisect_cont(f, a, b, fa, fb, xeps)
-    elif type == 'discrete':
-        x_bisect = _bisect_discr(f, a, b, fa, fb)
-    else:
-        raise ValueError("invalid type")
-    return np.sort(np.hstack([x_hit, x_bisect]))
-
-
-def _bisect_cont(f, a, b, fa, fb, xeps):
-    """Bisect roots already found"""
-    while True:
-        mid = 0.5 * (a + b)
-        fmid = f(mid)
-        towards_a = np.signbit(fa) != np.signbit(fmid)
-        a = np.where(towards_a, a, mid)
-        fa = np.where(towards_a, fa, fmid)
-        b = np.where(towards_a, mid, b)
-        fb = np.where(towards_a, fmid, fb)
-        found = b - a < xeps
-        if found.any():
-            break
-
-    roots = mid[found]
-    if found.all():
-        return roots
-    more = _bisect_cont(f, a[~found], b[~found], fa[~found], fb[~found], xeps)
-    return np.hstack([roots, more])
-
-
-def _bisect_discr(f, a, b, fa, fb):
-    """Bisect roots already found"""
-    while True:
-        mid = (a + b) // 2
-        found = a == mid
-        if found.any():
-            break
-
-        fmid = f(mid)
-        towards_a = np.signbit(fa) != np.signbit(fmid)
-        a = np.where(towards_a, a, mid)
-        fa = np.where(towards_a, fa, fmid)
-        b = np.where(towards_a, mid, b)
-        fb = np.where(towards_a, fmid, fb)
-
-    roots = mid[found]
-    if found.all():
-        return roots
-    more = _bisect_discr(f, a[~found], b[~found], fa[~found], fb[~found])
-    return np.hstack([roots, more])
-
-
-def discrete_extrema(f, xgrid):
-    """Find extrema of Bessel-like discrete function"""
-    fx = f(xgrid)
-    absfx = np.abs(fx)
-
-    # Forward differences: where[i] now means that the secant changes sign
-    # fx[i+1]. This means that the extremum is STRICTLY between x[i] and
-    # x[i+2]
-    gx = fx[1:] - fx[:-1]
-    sgx = np.signbit(gx)
-    where = sgx[:-1] != sgx[1:]
-    where_a = np.hstack([where, False, False])
-    where_b = np.hstack([False, False, where])
-
-    a = xgrid[where_a]
-    b = xgrid[where_b]
-    absf_a = absfx[where_a]
-    absf_b = absfx[where_b]
-    res = [_bisect_discr_extremum(f, *args)
-           for args in zip(a, b, absf_a, absf_b)]
-
-    # We consider the outer point to be extremua if there is a decrease
-    # in magnitude or a sign change inwards
-    sfx = np.signbit(fx)
-    if absfx[0] > absfx[1] or sfx[0] != sfx[1]:
-        res.insert(0, xgrid[0])
-    if absfx[-1] > absfx[-2] or sfx[-1] != sfx[-2]:
-        res.append(xgrid[-1])
-
-    return np.array(res)
-
-
-def _bisect_discr_extremum(f, a, b, absf_a, absf_b):
-    """Bisect extremum of f on the set {a+1, ..., b-1}"""
-    d = b - a
-    if d <= 1:
-        return a if absf_a > absf_b else b
-    if d == 2:
-        return a + 1
-
-    m = (a + b) // 2
-    n = m + 1
-    absf_m = np.abs(f(m))
-    absf_n = np.abs(f(n))
-    if absf_m > absf_n:
-        return _bisect_discr_extremum(f, a, n, absf_a, absf_n)
-    else:
-        return _bisect_discr_extremum(f, m, b, absf_m, absf_b)

sparse_ir/adapter.py

@@ -1,267 +0,0 @@
-# Copyright (C) 2020-2022 Markus Wallerberger, Hiroshi Shinaoka, and others
-# SPDX-License-Identifier: MIT
-"""
-Drop-in replacement for the irbasis module.
-
-This is designed to be a drop-in replacement for ``irbasis``, where the basis
-can be computed on-the-fly for arbitrary values of Lambda.  In other words,
-you should be able to replace ``irbasis`` with ``sparse_ir.adapter`` and
-everything should hopefully still work.
-
-Note however that on-the-fly computation typically has lower accuracy unless
-xprec is available. Thus, by default we only populate the basis down to
-singular values of ~1e-9 and emit a warning. You can squelch the warning by
-setting `WARN_ACCURACY` to false.
-"""
-# Do not import additional public symbols into this namespace, always use
-# underscores - this module should look as much as possible like `irbasis`!
-import numpy as _np
-from warnings import warn as _warn
-
-from . import sve as _sve
-from . import poly as _poly
-from . import kernel as _kernel
-
-try:
-    import xprec as _xprec
-except ImportError:
-    ACCURACY = 1.0e-9
-    WARN_ACCURACY = True
-else:
-    ACCURACY = 1.0e-15
-    WARN_ACCURACY = False
-
-
-def load(statistics, Lambda, h5file=None):
-    if WARN_ACCURACY:
-        _warn("xprec package is not found - expect degraded accuracy!\n"
-              "To squelch this warning, set WARN_ACCURACY to False.")
-
-    kernel_type = {"F": _kernel.LogisticKernel,
-                   "B": _kernel.RegularizedBoseKernel}[statistics]
-    kernel = kernel_type(float(Lambda))
-    sve_result = _sve.compute(kernel)
-    return Basis(statistics, Lambda, sve_result)
-
-
-class Basis:
-    def __init__(self, statistics, Lambda, sve_result):
-        u, s, v = sve_result.part()
-        self._statistics = statistics
-        self._Lambda = Lambda
-        self._u = u
-        self._s = s
-        self._v = v
-
-        conv_radius = 40 * Lambda
-        even_odd = {'F': 'odd', 'B': 'even'}[statistics]
-        self._uhat = _poly.PiecewiseLegendreFT(u, even_odd, conv_radius)
-
-    @property
-    def Lambda(self):
-        """Dimensionless parameter of IR basis"""
-        return self._Lambda
-
-    @property
-    def statistics(self):
-        """Statistics, either "F" for fermions or "B" for bosons"""
-        return self._statistics
-
-    def dim(self):
-        """Return dimension of basis"""
-        return self._s.size
-
-    def sl(self, l=None):
-        """Return the singular value for the l-th basis function"""
-        return _select(self._s, l)
-
-    def ulx(self, l, x):
-        """Return value of basis function for x"""
-        return _selectvals(self._u, l, x)
-
-    def d_ulx(self, l, x, order, section=None):
-        """Return (higher-order) derivatives of u_l(x)"""
-        return _selectvals(self._u.deriv(order), l, x)
-
-    def vly(self, l, y):
-        """Return value of basis function for y"""
-        return _selectvals(self._v, l, y)
-
-    def d_vly(self, l, y, order):
-        """Return (higher-order) derivatives of v_l(y)"""
-        return _selectvals(self._v.deriv(order), l, y)
-
-    def compute_unl(self, n, whichl=None):
-        """Compute transformation matrix from IR to Matsubara frequencies"""
-        n = _np.ravel(n)
-        nn = 2 * n + self._uhat.zeta
-        return _np.squeeze(_select(self._uhat, whichl)(nn).T)
-
-    def num_sections_x(self):
-        "Number of sections of piecewise polynomial representation of u_l(x)"
-        return self._u.nsegments
-
-    @property
-    def section_edges_x(self):
-        """End points of sections for u_l(x)"""
-        return self._u.knots
-
-    def num_sections_y(self):
-        "Number of sections of piecewise polynomial representation of v_l(y)"
-        return self._v.nsegments
-
-    @property
-    def section_edges_y(self):
-        """End points of sections for v_l(y)"""
-        return self._v.knots
-
-    def sampling_points_x(self, whichl):
-        """Computes "optimal" sampling points in x space for given basis"""
-        return sampling_points_x(self, whichl)
-
-    def sampling_points_y(self, whichl):
-        """Computes "optimal" sampling points in y space for given basis"""
-        return sampling_points_y(self, whichl)
-
-    def sampling_points_matsubara(self, whichl):
-        """Computes sampling points in Matsubara domain for given basis"""
-        return sampling_points_matsubara(self, whichl)
-
-
-
-def _select(p, l):
-    return p if l is None else p[l]
-
-
-def _selectvals(p, l, x):
-    return p(x) if l is None else p.value(l, x)
-
-
-"""" CODE BELOW IS TAKEN FROM IRBAIS FOR COMPATIBLITITY"""
-def _find_roots(ulx):
-    """Find all roots in (-1, 1) using double exponential mesh + bisection"""
-    Nx = 10000
-    eps = 1e-14
-    tvec = _np.linspace(-3, 3, Nx)  # 3 is a very safe option.
-    xvec = _np.tanh(0.5 * _np.pi * _np.sinh(tvec))
-
-    zeros = []
-    for i in range(Nx - 1):
-        if ulx(xvec[i]) * ulx(xvec[i + 1]) < 0:
-            a = xvec[i + 1]
-            b = xvec[i]
-            u_a = ulx(a)
-            while a - b > eps:
-                half_point = 0.5 * (a + b)
-                if ulx(half_point) * u_a > 0:
-                    a = half_point
-                else:
-                    b = half_point
-            zeros.append(0.5 * (a + b))
-    return _np.array(zeros)
-
-
-def _start_guesses(n=1000):
-    "Construct points on a logarithmically extended linear interval"
-    x1 = _np.arange(n)
-    x2 = _np.array(_np.exp(_np.linspace(_np.log(n), _np.log(1E+8), n)), dtype=int)
-    x = _np.unique(_np.hstack((x1, x2)))
-    return x
-
-
-def _get_unl_real(basis_xy, x, l):
-    "Return highest-order basis function on the Matsubara axis"
-    unl = basis_xy.compute_unl(x, l)
-
-    # Purely real functions
-    zeta = 1 if basis_xy.statistics == 'F' else 0
-    if l % 2 == zeta:
-        assert _np.allclose(unl.imag, 0)
-        return unl.real
-    else:
-        assert _np.allclose(unl.real, 0)
-        return unl.imag
-
-
-def _sampling_points(fn):
-    "Given a discretized 1D function, return the location of the extrema"
-    fn = _np.asarray(fn)
-    fn_abs = _np.abs(fn)
-    sign_flip = fn[1:] * fn[:-1] < 0
-    sign_flip_bounds = _np.hstack((0, sign_flip.nonzero()[0] + 1, fn.size))
-    points = []
-    for segment in map(slice, sign_flip_bounds[:-1], sign_flip_bounds[1:]):
-        points.append(fn_abs[segment].argmax() + segment.start)
-    return _np.asarray(points)
-
-
-def _full_interval(sample, stat):
-    if stat == 'F':
-        return _np.hstack((-sample[::-1]-1, sample))
-    else:
-        # If we have a bosonic basis and even order (odd maximum), we have a
-        # root at zero. We have to artifically add that zero back, otherwise
-        # the condition number will blow up.
-        if sample[0] == 0:
-            sample = sample[1:]
-        return _np.hstack((-sample[::-1], 0, sample))
-
-
-def _get_mats_sampling(basis_xy, lmax=None):
-    "Generate Matsubara sampling points from extrema of basis functions"
-    if lmax is None:
-        lmax = basis_xy.dim()-1
-
-    x = _start_guesses()
-    y = _get_unl_real(basis_xy, x, lmax)
-    x_idx = _sampling_points(y)
-
-    sample = x[x_idx]
-    return _full_interval(sample, basis_xy.statistics)
-
-
-def sampling_points_x(b, whichl):
-    """Computes "optimal" sampling points in x space for given basis"""
-    xroots = _find_roots(b._u[whichl])
-    xroots_ex = _np.hstack((-1.0, xroots, 1.0))
-    return 0.5 * (xroots_ex[:-1] + xroots_ex[1:])
-
-
-def sampling_points_y(b, whichl):
-    """Computes "optimal" sampling points in y space for given basis"""
-
-    roots_positive_half = 0.5 * _find_roots(lambda y: b.vly(whichl, (y + 1)/2)) + 0.5
-    if whichl % 2 == 0:
-        roots_ex = _np.sort(
-            _np.hstack([-1, -roots_positive_half, roots_positive_half, 1]))
-    else:
-        roots_ex = _np.sort(
-            _np.hstack([-1, -roots_positive_half, 0, roots_positive_half, 1]))
-    return 0.5 * (roots_ex[:-1] + roots_ex[1:])
-
-
-def sampling_points_matsubara(b, whichl):
-    """
-    Computes "optimal" sampling points in Matsubara domain for given basis
-
-    Parameters
-    ----------
-    b :
-        basis object
-    whichl: int
-        Index of reference basis function "l"
-
-    Returns
-    -------
-    sampling_points: 1D array of int
-        sampling points in Matsubara domain
-
-    """
-    stat = b.statistics
-
-    assert stat == 'F' or stat == 'B' or stat == 'barB'
-
-    if whichl > b.dim()-1:
-        raise RuntimeError("Too large whichl")
-
-    return _get_mats_sampling(b, whichl)