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

sparse_ir/basis.py

@@ -1,16 +1,16 @@
-# Copyright (C) 2020-2022 Markus Wallerberger, Hiroshi Shinaoka, and others
-# SPDX-License-Identifier: MIT
-from typing import Tuple
+"""
+High-level Python classes for FiniteTempBasis
+"""
+from typing import Optional
 import numpy as np
-from warnings import warn
-
-from . import abstract
-from . import kernel as _kernel
-from . import poly
-from . import sve
-
-
-class FiniteTempBasis(abstract.AbstractBasis):
+from pylibsparseir.core import basis_new, basis_get_size, basis_get_svals, basis_get_u, basis_get_v, basis_get_uhat, basis_get_default_tau_sampling_points, basis_get_default_omega_sampling_points, basis_get_default_matsubara_sampling_points
+from pylibsparseir.constants import SPIR_STATISTICS_FERMIONIC, SPIR_STATISTICS_BOSONIC
+from .kernel import LogisticKernel
+from .abstract import AbstractBasis
+from .sve import SVEResult
+from .poly import PiecewiseLegendrePolyVector, PiecewiseLegendrePolyFTVector, FunctionSet, FunctionSetFT
+
+class FiniteTempBasis(AbstractBasis):
     r"""Intermediate representation (IR) basis for given temperature.
 
     For a continuation kernel from real frequencies, `ω` ∈ [-ωmax, ωmax], to
@@ -40,103 +40,89 @@ class FiniteTempBasis(abstract.AbstractBasis):
             gl = basis.s * basis.v(2.5)
             giw = gl @ basis.uhat([1, 3, 5, 7])
     """
-    def __init__(self, statistics, beta, wmax, eps=None, *,
-                 max_size=None, kernel=None, sve_result=None):
-        if not (beta > 0):
-            raise ValueError("inverse temperature beta must be positive")
-        if not (wmax >= 0):
-            raise ValueError("frequency cutoff must be non-negative")
-
-        if eps is None and sve_result is None and not sve.HAVE_XPREC:
-            warn("xprec package is not available:\n"
-                 "expect single precision (1.5e-8) only as both cutoff and\n"
-                 "accuracy of the basis functions")
-
-        # Calculate basis functions from truncated singular value expansion
-        self._kernel = _get_kernel(statistics, beta * wmax, kernel)
-        if sve_result is None:
-            sve_result = sve.compute(self._kernel, eps)
-        else:
-            # Sanity check of provided sve_result
-            # TODO: check for the kernel type/name or eps?
-            new_kernel_lambda = self._kernel.lambda_
-            sve_kernel_lambda = sve_result.K.lambda_
-            if not np.allclose(new_kernel_lambda, sve_kernel_lambda,
-                               atol=1e-12, rtol=4e-16):
-                raise ValueError("Kernel mismatch:\n"
-                                 "provided SVE result is incompatible with "
-                                 "kernel parameters (lambda_ == beta*wmax)")
-
-        self._sve_result = sve_result
+
+    def __init__(self, statistics: str, beta: float, wmax: float, eps: float, sve_result: Optional[SVEResult] = None, max_size: int =-1):
+        """
+        Initialize finite temperature basis.
+
+        Parameters:
+        -----------
+        statistics : str
+            'F' for fermions, 'B' for bosons
+        beta : float
+            Inverse temperature
+        wmax : float
+            Frequency cutoff
+        eps : float
+            Accuracy threshold
+        """
         self._statistics = statistics
         self._beta = beta
         self._wmax = wmax
+        self._lambda = beta * wmax
 
-        u, s, v = sve_result.part(eps, max_size)
-        if sve_result.s.size > s.size:
-            self._accuracy = sve_result.s[s.size] / s[0]
+        # Create kernel
+        if statistics == 'F' or statistics == 'B':
+            self._kernel = LogisticKernel(self._lambda)
         else:
-            self._accuracy = s[-1] / s[0]
-
-        # The polynomials are scaled to the new variables by transforming the
-        # knots according to: tau = beta/2 * (x + 1), w = wmax * y.  Scaling
-        # the data is not necessary as the normalization is inferred.
-        self._u = u.__class__(u.data, beta/2 * (u.knots + 1), beta/2 * u.dx, u.symm)
-        self._v = v.__class__(v.data, wmax * v.knots, wmax * v.dx, v.symm)
-
-        # The singular values are scaled to match the change of variables, with
-        # the additional complexity that the kernel may have an additional
-        # power of w.
-        self._s = np.sqrt(beta/2 * wmax) * (wmax**(-self.kernel.ypower)) * s
-
-        # HACK: as we don't yet support Fourier transforms on anything but the
-        # unit interval, we need to scale the underlying data.
-        uhat_base_full = poly.PiecewiseLegendrePoly(
-                            np.sqrt(beta) * sve_result.u.data, sve_result.u,
-                            symm=sve_result.u.symm)
-        conv_radius = 40 * self.kernel.lambda_
-        even_odd = {'F': 'odd', 'B': 'even'}[statistics]
-        self._uhat_full = poly.PiecewiseLegendreFT(uhat_base_full, even_odd,
-                                                   n_asymp=conv_radius)
-        self._uhat = self._uhat_full[:s.size]
+            raise ValueError(f"Invalid statistics: {statistics} expected 'F' or 'B'")
 
-    def __getitem__(self, index):
-        return FiniteTempBasis(
-                    self._statistics, self._beta, self._wmax, None,
-                    max_size=_slice_to_size(index), kernel=self._kernel,
-                    sve_result=self._sve_result)
+        # Compute SVE
+        if sve_result is None:
+            self._sve = SVEResult(self._kernel, eps)
+        else:
+            self._sve = sve_result
 
-    @property
-    def statistics(self): return self._statistics
+        # Create basis
+        stats_int = SPIR_STATISTICS_FERMIONIC if statistics == 'F' else SPIR_STATISTICS_BOSONIC
+        self._ptr = basis_new(stats_int, self._beta, self._wmax, self._kernel._ptr, self._sve._ptr, max_size)
 
-    @property
-    def beta(self): return self._beta
+        u_funcs = FunctionSet(basis_get_u(self._ptr))
+        v_funcs = FunctionSet(basis_get_v(self._ptr))
+        uhat_funcs = FunctionSetFT(basis_get_uhat(self._ptr))
 
-    @property
-    def wmax(self): return self._wmax
+        self._s = basis_get_svals(self._ptr)
+        self._u = PiecewiseLegendrePolyVector(u_funcs, 0, self._beta)
+        self._v = PiecewiseLegendrePolyVector(v_funcs, -self._wmax, self._wmax)
+        self._uhat = PiecewiseLegendrePolyFTVector(uhat_funcs)
 
     @property
-    def lambda_(self): return self._beta * self._wmax
+    def statistics(self):
+        """Quantum statistic ('F' for fermionic, 'B' for bosonic)"""
+        return self._statistics
 
     @property
-    def shape(self): return self._s.shape
+    def beta(self):
+        """Inverse temperature"""
+        return self._beta
 
     @property
-    def size(self): return self._s.size
+    def wmax(self):
+        """Real frequency cutoff"""
+        return self._wmax
 
     @property
-    def u(self) -> poly.PiecewiseLegendrePoly: return self._u
+    def lambda_(self):
+        """Basis cutoff parameter, Λ = β * wmax"""
+        return self._lambda
 
     @property
-    def uhat(self) -> poly.PiecewiseLegendreFT: return self._uhat
+    def size(self):
+        return self._s.size
 
     @property
-    def s(self) -> np.ndarray:
+    def s(self):
         """Vector of singular values of the continuation kernel"""
+        if self._s is None:
+            self._s = basis_get_svals(self._ptr)
         return self._s
 
     @property
-    def v(self) -> poly.PiecewiseLegendrePoly:
+    def u(self):
+        return self._u
+
+    @property
+    def v(self):
         r"""Basis functions on the real frequency axis.
 
         Set of IR basis functions on the real frequency (omega) axis, where
@@ -162,49 +148,67 @@ class FiniteTempBasis(abstract.AbstractBasis):
         """
         return self._v
 
+    @property
+    def uhat(self):
+        return self._uhat
+
     @property
     def significance(self):
-        return self._s / self._s[0]
+        """Relative significance of basis functions."""
+        return self.s / self.s[0]
 
     @property
     def accuracy(self):
-        return self._accuracy
+        """Overall accuracy bound."""
+        return self.s[-1] / self.s[0]
 
     @property
-    def kernel(self):
-        """Kernel of which this is the singular value expansion"""
-        return self._kernel
+    def shape(self):
+        """Shape of the basis function set"""
+        return self.s.shape
 
-    @property
-    def sve_result(self):
-        return self._sve_result
-
-    def default_tau_sampling_points(self, *, npoints=None):
-        if npoints is None:
-            npoints = self.size
-        x = _default_sampling_points(self._sve_result.u, npoints)
-        return self._beta/2 * (x + 1)
-
-    def default_matsubara_sampling_points(self, *, npoints=None,
-                                          positive_only=False):
-        if npoints is None:
-            npoints = self.size
-        return _default_matsubara_sampling_points(self._uhat_full, npoints,
-                                                  positive_only=positive_only)
-
-    def default_omega_sampling_points(self, *, npoints=None):
+    def default_tau_sampling_points(self, npoints=None):
+        """Get default tau sampling points."""
+        return basis_get_default_tau_sampling_points(self._ptr)
+
+    def default_omega_sampling_points(self, npoints=None):
         """Return default sampling points in imaginary time.
 
         Arguments:
             npoints (int):
                 Minimum number of sampling points to return.
 
-                .. versionadded: 1.1
+                .. versionadded:: 1.1
+        """
+        from pylibsparseir.core import basis_get_default_omega_sampling_points
+        return basis_get_default_omega_sampling_points(self._ptr)
+
+    def default_matsubara_sampling_points(self, npoints=None, positive_only=False):
+        """Get default Matsubara sampling points."""
+        return basis_get_default_matsubara_sampling_points(self._ptr, positive_only)
+
+    def __repr__(self):
+        return (f"FiniteTempBasis(statistics='{self.statistics}', "
+                f"beta={self.beta}, wmax={self.wmax}, size={self.size})")
+
+    def __getitem__(self, index):
+        """Return basis functions/singular values for given index/indices.
+
+        This can be used to truncate the basis to the n most significant
+        singular values: basis[:3].
         """
-        if npoints is None:
-            npoints = self.size
-        y = _default_sampling_points(self._sve_result.v, npoints)
-        return self._wmax * y
+        # TODO: Implement basis truncation when C API supports it
+        raise NotImplementedError("Basis truncation not yet implemented in C API")
+
+    @property
+    def kernel(self):
+        """The kernel used to generate the basis."""
+        return self._kernel
+
+    @property
+    def sve_result(self):
+        """The singular value expansion result."""
+        return self._sve
 
     def rescale(self, new_beta):
         """Return a basis for different temperature.
@@ -213,137 +217,24 @@ class FiniteTempBasis(abstract.AbstractBasis):
         temperature.  Note that this implies a different UV cutoff ``wmax``,
         since ``lambda_ == beta * wmax`` stays constant.
         """
-        new_wmax = self._kernel.lambda_ / new_beta
-        return FiniteTempBasis(self._statistics, new_beta, new_wmax, None,
-                               max_size=self.size, kernel=self._kernel,
-                               sve_result=self._sve_result)
+        # Calculate new beta and wmax that give the desired lambda
+        # We keep the ratio beta/wmax constant
+        ratio = self.beta / self.wmax
+        new_wmax = np.sqrt(new_lambda / ratio)
+        new_beta = new_lambda / new_wmax
+
+        # Get epsilon from the current basis accuracy
+        eps = self.accuracy
 
+        return FiniteTempBasis(self.statistics, new_beta, new_wmax, eps)
 
-def finite_temp_bases(
-            beta: float, wmax: float, eps: float = None,
-            sve_result: tuple = None
-        )-> Tuple[FiniteTempBasis, FiniteTempBasis]:
+
+def finite_temp_bases(beta, wmax, eps=None, sve_result=None):
     """Construct FiniteTempBasis objects for fermion and bosons
 
     Construct FiniteTempBasis objects for fermion and bosons using
     the same LogisticKernel instance.
     """
-    if sve_result is None:
-        sve_result = sve.compute(_kernel.LogisticKernel(beta*wmax), eps)
-    basis_f = FiniteTempBasis("F", beta, wmax, eps, sve_result=sve_result)
-    basis_b = FiniteTempBasis("B", beta, wmax, eps, sve_result=sve_result)
-    return basis_f, basis_b
-
-
-def _default_sampling_points(u, L):
-    if u.xmin != -1 or u.xmax != 1:
-        raise ValueError("expecting unscaled functions here")
-
-    if L < u.size:
-        # For orthogonal polynomials (the high-T limit of IR), we know that the
-        # ideal sampling points for a basis of size L are the roots of the L-th
-        # polynomial.  We empirically find that these stay good sampling points
-        # for our kernels (probably because the kernels are totally positive).
-        x0 = u[L].roots()
-    else:
-        # If we do not have enough polynomials in the basis, we approximate the
-        # roots of the L'th polynomial by the extrema of the (L-1)'st basis
-        # function, which is sensible due to the strong interleaving property
-        # of these functions' roots.
-        maxima = u[-1].deriv().roots()
-
-        # Putting the sampling points right at [0, beta], which would be the
-        # local extrema, is slightly worse conditioned than putting it in the
-        # middel.  This can be understood by the fact that the roots never
-        # occur right at the border.
-        left = .5 * (maxima[:1] + u.xmin)
-        right = .5 * (maxima[-1:] + u.xmax)
-        x0 = np.concatenate([left, maxima, right])
-
-    if x0.size != L:
-        warn(f"Requesting {L} sampling points for corresponding basis size,\n"
-             f"but {x0.size} were returned.  This may indiciate a problem "
-             f"with precision.", UserWarning, 3)
-    return x0
-
-
-def _default_matsubara_sampling_points(uhat, L, *, fence=False, positive_only=False):
-    l_requested = L
-
-    # The number of sign changes is always odd for bosonic basis (freq=='even')
-    # and even for fermionic basis (freq='odd').  So in order to get at least
-    # as many sign changes as basis functions.
-    if uhat.freq == 'odd' and l_requested % 2 == 1:
-        l_requested += 1
-    elif uhat.freq == 'even' and l_requested % 2 == 0:
-        l_requested += 1
-
-    if l_requested < uhat.size:
-        # As with the zeros, the sign changes provide excellent sampling points
-        wn = uhat[l_requested].sign_changes(positive_only=positive_only)
-    else:
-        # As a fallback, use the (discrete) extrema of the corresponding
-        # highest-order basis function in Matsubara.  This turns out to be okay.
-        polyhat = uhat[-1]
-        wn = polyhat.extrema(positive_only=positive_only)
-
-        # For bosonic bases, we must explicitly include the zero frequency,
-        # otherwise the condition number blows up.
-        if wn[0] % 2 == 0:
-            wn = np.unique(np.hstack((0, wn)))
-
-    expected_size = l_requested
-    if positive_only:
-        expected_size = (expected_size + 1) // 2
-
-    if wn.size != expected_size:
-        warn(f"Requesting {expected_size} {uhat.freq} sampling frequencies\n"
-             f"for basis size L={L}, but {wn.size} were returned.  This may\n"
-             f"indiciate a problem with precision.", UserWarning, 3)
-    if fence:
-        wn = _fence_matsubara_sampling(wn, positive_only)
-    return wn
-
-
-def _fence_matsubara_sampling(wn, positive_only):
-    # While the condition number for sparse sampling in tau saturates at a
-    # modest level, the conditioning in Matsubara steadily deteriorates due
-    # to the fact that we are not free to set sampling points continuously.
-    # At double precision, tau sampling is better conditioned than iwn
-    # by a factor of ~4 (still OK). To battle this, we fence the largest
-    # frequency with two carefully chosen oversampling points, which brings
-    # the two sampling problems within a factor of 2.
-    wn_outer = wn[-1:] if positive_only else wn[[0, -1]]
-    wn_diff = 2 * np.round(0.025 * wn_outer).astype(int)
-    if wn.size >= 20:
-        wn = np.hstack([wn, wn_outer - np.sign(wn_outer) * wn_diff])
-    if wn.size >= 42:
-        wn = np.hstack([wn, wn_outer + np.sign(wn_outer) * wn_diff])
-    return np.unique(wn)
-
-
-def _get_kernel(statistics, lambda_, kernel):
-    if statistics not in 'BF':
-        raise ValueError("statistics must either be 'B' (for bosonic basis) "
-                         "or 'F' (for fermionic basis)")
-    if kernel is None:
-        kernel = _kernel.LogisticKernel(lambda_)
-    else:
-        try:
-            lambda_kernel = kernel.lambda_
-        except AttributeError:
-            pass
-        else:
-            if not np.allclose(lambda_kernel, lambda_, atol=0, rtol=4e-16):
-                raise ValueError("lambda of kernel and basis mismatch")
-    return kernel
-
-
-def _slice_to_size(index):
-    if not isinstance(index, slice):
-        raise ValueError("argument must be a slice (`n:m`)")
-    if index.start is not None and index.start != 0:
-        raise ValueError("slice must start at zero")
-    if index.step is not None and index.step != 1:
-        raise ValueError("slice must step in ones")
-    return index.stop
+    fermion_basis = FiniteTempBasis('F', beta, wmax, eps, sve_result=sve_result)
+    boson_basis = FiniteTempBasis('B', beta, wmax, eps, sve_result=sve_result)
+    return fermion_basis, boson_basis

sparse_ir/basis_set.py

@@ -1,101 +1,143 @@
-# Copyright (C) 2020-2022 Markus Wallerberger, Hiroshi Shinaoka, and others
-# SPDX-License-Identifier: MIT
-from . import basis
-from . import sampling
+"""
+Basis set functionality for SparseIR.
 
+This module provides a convenience class that holds both fermionic and bosonic
+bases along with their associated sampling objects.
+"""
+
+from .basis import FiniteTempBasis, finite_temp_bases
+from .sampling import TauSampling, MatsubaraSampling
 
-class FiniteTempBasisSet:
-    """Class for holding IR bases and sparse-sampling objects.
 
+class FiniteTempBasisSet:
+    """
+    Class for holding IR bases and sparse-sampling objects.
+    
     An object of this class holds IR bases for fermions and bosons
     and associated sparse-sampling objects.
-
-    Attributes:
-        basis_f (FiniteTempBasis):
-            Fermion basis
-        basis_b (FiniteTempBasis):
-            Boson basis
-        smpl_tau_f (TauSampling):
-            Sparse sampling for tau & fermion
-        smpl_tau_b (TauSampling):
-            Sparse sampling for tau & boson
-        smpl_wn_f (MatsubaraSampling):
-            Sparse sampling for Matsubara frequency & fermion
-        smpl_wn_b (MatsubaraSampling):
-            Sparse sampling for Matsubara frequency & boson
+    
+    Attributes
+    ----------
+    basis_f : FiniteTempBasis
+        Fermion basis
+    basis_b : FiniteTempBasis
+        Boson basis
+    smpl_tau_f : TauSampling
+        Sparse sampling for tau & fermion
+    smpl_tau_b : TauSampling
+        Sparse sampling for tau & boson
+    smpl_wn_f : MatsubaraSampling
+        Sparse sampling for Matsubara frequency & fermion
+    smpl_wn_b : MatsubaraSampling
+        Sparse sampling for Matsubara frequency & boson
     """
-    def __init__(self, beta, wmax, eps=None, sve_result=None):
+    
+    def __init__(self, beta, wmax, eps=None, sve_result=None, use_positive_taus=False):
         """
-        Create basis sets for fermion and boson and
-        associated sampling objects.
+        Create basis sets for fermion and boson and associated sampling objects.
+        
         Fermion and bosonic bases are constructed by SVE of the logistic kernel.
+        
+        Parameters
+        ----------
+        beta : float
+            Inverse temperature
+        wmax : float
+            Cut-off frequency
+        eps : float, optional
+            Tolerance parameter for the basis construction.
+            If not provided, a default value will be used.
+        sve_result : SVEResult, optional
+            Pre-computed SVE result to use for basis construction.
+            If not provided, SVE will be computed internally.
+        use_positive_taus : bool, optional
+            If `use_positive_taus=False`, the sampling points are within
+            the range [-β/2, β/2] and the distribution is symmetric.
+            If `use_positive_taus=True`, the sampling points are
+            folded to the positive tau domain [0, β), which is
+            the default behavior of sparseir 1.x.x.
         """
         if sve_result is None:
             # Create bases by sve of the logistic kernel
-            self.basis_f, self.basis_b = basis.finite_temp_bases(beta, wmax, eps)
+            self.basis_f, self.basis_b = finite_temp_bases(beta, wmax, eps)
         else:
             # Create bases using the given sve results
-            self.basis_f = basis.FiniteTempBasis(
-                                "F", beta, wmax, eps, sve_result=sve_result)
-            self.basis_b = basis.FiniteTempBasis(
-                                "B", beta, wmax, eps, sve_result=sve_result)
-
+            self.basis_f = FiniteTempBasis(
+                "F", beta, wmax, eps, sve_result=sve_result
+            )
+            self.basis_b = FiniteTempBasis(
+                "B", beta, wmax, eps, sve_result=sve_result
+            )
+        
         # Tau sampling
-        self.smpl_tau_f = sampling.TauSampling(self.basis_f)
-        self.smpl_tau_b = sampling.TauSampling(self.basis_b)
-
+        self.smpl_tau_f = TauSampling(self.basis_f, use_positive_taus=use_positive_taus)
+        self.smpl_tau_b = TauSampling(self.basis_b, use_positive_taus=use_positive_taus)
+        
         # Matsubara sampling
-        self.smpl_wn_f = sampling.MatsubaraSampling(self.basis_f)
-        self.smpl_wn_b = sampling.MatsubaraSampling(self.basis_b)
-
+        self.smpl_wn_f = MatsubaraSampling(self.basis_f)
+        self.smpl_wn_b = MatsubaraSampling(self.basis_b)
+    
     @property
     def lambda_(self):
-        """Ultra-violet cutoff of the kernel"""
+        """Ultra-violet cutoff of the kernel."""
         return self.basis_f.lambda_
-
+    
     @property
     def beta(self):
-        """Inverse temperature"""
+        """Inverse temperature."""
         return self.basis_f.beta
-
+    
     @property
     def wmax(self):
-        """Cut-off frequency"""
+        """Cut-off frequency."""
         return self.basis_f.wmax
-
+    
     @property
     def accuracy(self):
-        """Accuracy of the bases"""
+        """Accuracy of the bases."""
         return self.basis_f.accuracy
-
+    
     @property
     def sve_result(self):
-        """Result of singular value expansion"""
+        """Result of singular value expansion."""
         return self.basis_f.sve_result
-
+    
     @property
     def tau(self):
-        """Sampling points in the imaginary-time domain"""
+        """Sampling points in the imaginary-time domain."""
         return self.smpl_tau_f.sampling_points
-
+    
     @property
     def wn_f(self):
-        """Sampling fermionic frequencies"""
+        """Sampling fermionic frequencies."""
         return self.smpl_wn_f.sampling_points
-
+    
     @property
     def wn_b(self):
-        """Sampling bosonic frequencies"""
+        """Sampling bosonic frequencies."""
         return self.smpl_wn_b.sampling_points
-
+    
     def rescale(self, new_beta):
-        """Return a basis set for a different temperature.
-
+        """
+        Return a basis set for a different temperature.
+        
         Uses the same kernel with the same ``eps``, but a different
-        temperature.  Note that this implies a different UV cutoff ``wmax``,
+        temperature. Note that this implies a different UV cutoff ``wmax``,
         since ``lambda_ == beta * wmax`` stays constant.
+        
+        Parameters
+        ----------
+        new_beta : float
+            New inverse temperature
+            
+        Returns
+        -------
+        FiniteTempBasisSet
+            New basis set for the different temperature
         """
         new_wmax = self.basis_f.lambda_ / new_beta
-        return FiniteTempBasisSet(new_beta, new_wmax,
-                                  eps=self.basis_f.sve_result.eps,
-                                  sve_result=self.basis_f.sve_result)
+        return FiniteTempBasisSet(
+            new_beta, new_wmax,
+            eps=self.basis_f.accuracy,  # Use accuracy instead of eps
+            sve_result=self.basis_f.sve_result
+        )