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

sparse_ir/__init__.py

@@ -1,21 +1,39 @@
-
 """
-Intermediate representation (IR) for many-body propagators
-==========================================================
-
-This library provides routines for constructing and working with the
-intermediate representation of correlation functions.  It provides:
+SparseIR Python bindings
 
- - on-the-fly computation of basis functions for arbitrary cutoff Λ
- - basis functions and singular values are accurate to full precision
- - routines for sparse sampling
+This package provides Python bindings for the SparseIR C library.
 """
-__copyright__ = "2020-2025 Markus Wallerberger, Hiroshi Shinaoka, and others"
-__license__ = "MIT"
-__version__ = "1.1.7"
 
-from .kernel import RegularizedBoseKernel, LogisticKernel
-from .sve import compute as compute_sve, SVEResult
+from .abstract import AbstractBasis
 from .basis import FiniteTempBasis, finite_temp_bases
-from .basis_set import FiniteTempBasisSet
 from .sampling import TauSampling, MatsubaraSampling
+from .kernel import LogisticKernel, RegularizedBoseKernel
+from .sve import SVEResult, compute
+from .basis_set import FiniteTempBasisSet
+
+# New augmented functionality
+from .augment import (
+    AugmentedBasis, AugmentedTauFunction, AugmentedMatsubaraFunction,
+    AbstractAugmentation, TauConst, TauLinear, MatsubaraConst
+)
+
+# DLR functionality
+from .dlr import (
+    DiscreteLehmannRepresentation
+)
+
+# Export list for better documentation
+__all__ = [
+    # Core functionality
+    'AbstractBasis', 'FiniteTempBasis', 'finite_temp_bases',
+    'TauSampling', 'MatsubaraSampling', 'FiniteTempBasisSet',
+    'LogisticKernel', 'RegularizedBoseKernel',
+    'SVEResult', 'compute',
+
+    # Augmented functionality
+    'AugmentedBasis', 'AugmentedTauFunction', 'AugmentedMatsubaraFunction',
+    'AbstractAugmentation', 'TauConst', 'TauLinear', 'MatsubaraConst',
+
+    # DLR functionality
+    'DiscreteLehmannRepresentation', 'TauPoles', 'MatsubaraPoles',
+]

sparse_ir/abstract.py

@@ -1,184 +1,172 @@
-# Copyright (C) 2020-2022 Markus Wallerberger, Hiroshi Shinaoka, and others
-# SPDX-License-Identifier: MIT
+"""
+Abstract base class for basis objects.
 
-class AbstractBasis:
+This module provides the abstract interface that all basis types should implement.
+"""
+
+from abc import ABC, abstractmethod
+
+class AbstractKernel(ABC):
+    """Abstract base class for kernels."""
+    pass
+
+class AbstractBasis(ABC):
     r"""Abstract base class for bases on the imaginary-time axis.
 
-    This class stores a set of basis functions.  We can then expand a two-point
-    propagator  `G(τ)`, where `τ` is imaginary time:
+    This class stores a set of basis functions. We can then expand a two-point
+    propagator G(τ), where τ is imaginary time:
 
-    .. math::    G(\tau) \approx \sum_{l=0}^{L-1} g_l U_l(\tau)
+        G(τ) ≈ Σ_{l=0}^{L-1} g_l U_l(τ)
 
-    where `U` is now the `l`-th basis function, stored in :py:attr:`u` and
-    `g` denote the expansion coefficients. Similarly, the Fourier transform
-    `Ĝ(n)`, where `n` is a reduced Matsubara frequency, can be expanded as
-    follows:
+    where U is now the l-th basis function, stored in u and g denote the
+    expansion coefficients. Similarly, the Fourier transform Ĝ(n), where n
+    is a reduced Matsubara frequency, can be expanded as follows:
 
-    .. math::    \hat G(n) \approx \sum_{l=0}^{L-1} g_l \hat U_l(n)
+        Ĝ(n) ≈ Σ_{l=0}^{L-1} g_l Û_l(n)
 
-    where `Û` is the Fourier transform of the `l`-th basis function, stored
-    in :py:attr:`uhat`.
+    where Û is the Fourier transform of the l-th basis function, stored
+    in uhat.
 
-    Assuming that ``basis`` is an instance of some abstract basis, ``g``
-    is a vector of expansion coefficients, ``tau`` is some imaginary time and
-    ``n`` some frequency, we can write this in the library as follows::
+    Assuming that basis is an instance of some abstract basis, g is a vector
+    of expansion coefficients, tau is some imaginary time and n some frequency,
+    we can write this in the library as follows:
 
         G_tau = basis.u(tau).T @ gl
         G_n = basis.uhat(n).T @ gl
-
     """
+
     @property
+    @abstractmethod
     def u(self):
         r"""Basis functions on the imaginary time axis.
 
         Set of IR basis functions on the imaginary time (tau) axis, where tau
-        is a real number between zero and :py:attr:`beta`.  To get the ``l``-th
-        basis function at imaginary time ``tau`` of some basis ``basis``, use::
+        is a real number between zero and beta. To get the l-th basis function
+        at imaginary time tau of some basis, use:
 
             ultau = basis.u[l](tau)        # l-th basis function at time tau
 
-        Note that ``u`` supports vectorization both over ``l`` and ``tau``.
-        In particular, omitting the subscript yields a vector with all basis
-        functions, evaluated at that position::
-
-            basis.u(tau) == [basis.u[l](tau) for l in range(basis.size)]
-
-        Similarly, supplying a vector of `tau` points yields a matrix ``A``,
-        where ``A[l,n]`` corresponds to the ``l``-th basis function evaluated
-        at ``tau[n]``::
-
-            tau = [0.5, 1.0]
-            basis.u(tau) == \
-                [[basis.u[l](t) for t in tau] for l in range(basis.size)]
+        Note that u supports vectorization both over l and tau.
         """
         raise NotImplementedError()
 
     @property
+    @abstractmethod
     def uhat(self):
-        r"""Basis functions on the reduced Matsubara frequency (``wn``) axis.
+        r"""Basis functions on the reduced Matsubara frequency (wn) axis.
 
         Set of IR basis functions reduced Matsubara frequency (wn) axis, where
-        wn is an integer.  These are related to :py:attr:`u` by the following
-        Fourier transform:
-
-        .. math::
+        wn is an integer. These are related to u by the following Fourier transform:
 
-           \hat u(n) = \int_0^\beta d\tau \exp(i\pi n \tau/\beta) u(\tau)
+           û(n) = ∫₀^β dτ exp(iπnτ/β) u(τ)
 
-        To get the ``l``-th basis function at some reduced frequency ``wn`` of
-        some basis ``basis``, use::
+        To get the l-th basis function at some reduced frequency wn of
+        some basis, use:
 
             uln = basis.uhat[l](wn)        # l-th basis function at freq wn
 
-        ``uhat`` supports vectorization both over ``l`` and ``wn``.
-        In particular, omitting the subscript yields a vector with all basis
-        functions, evaluated at that position::
-
-            basis.uhat(wn) == [basis.uhat[l](wn) for l in range(basis.size)]
-
-        Similarly, supplying a vector of `wn` points yields a matrix ``A``,
-        where ``A[l,n]`` corresponds to the ``l``-th basis function evaluated
-        at ``wn[n]``::
-
-            wn = [1, 3]
-            basis.uhat(wn) == \\
-                [[basis.uhat[l](wi) for wi in wn] for l in range(basis.size)]
-
         Note:
             Instead of the value of the Matsubara frequency, these functions
             expect integers corresponding to the prefactor of pi over beta.
             For example, the first few positive fermionic frequencies would
-            be specified as ``[1, 3, 5, 7]``, and the first bosonic frequencies
-            are ``[0, 2, 4, 6]``.  This is also distinct to an index!
+            be specified as [1, 3, 5, 7], and the first bosonic frequencies
+            are [0, 2, 4, 6]. This is also distinct to an index!
         """
         raise NotImplementedError()
 
     @property
+    @abstractmethod
     def statistics(self):
-        """Quantum statistic (`"F"` for fermionic, `"B"` for bosonic)"""
+        """Quantum statistic ("F" for fermionic, "B" for bosonic)"""
         raise NotImplementedError()
 
     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]`.
+        singular values: basis[:3].
         """
         raise NotImplementedError()
 
     @property
     def shape(self):
         """Shape of the basis function set"""
-        raise NotImplementedError()
+        return (self.size,)
 
     @property
+    @abstractmethod
     def size(self):
         """Number of basis functions / singular values"""
         raise NotImplementedError()
 
     @property
+    @abstractmethod
     def significance(self):
         """Significances of the basis functions
 
-        Vector of significance values, one for each basis function.  Each
-        value is a number between 0 and 1 which is a a-priori bound on the
+        Vector of significance values, one for each basis function. Each
+        value is a number between 0 and 1 which is an a-priori bound on the
         (relative) error made by discarding the associated coefficient.
         """
-        return NotImplementedError()
+        raise NotImplementedError()
 
     @property
     def accuracy(self):
         """Accuracy of the basis.
 
-        Upper bound to the relative error of reprensenting a propagator with
+        Upper bound to the relative error of representing a propagator with
         the given number of basis functions (number between 0 and 1).
         """
         return self.significance[-1]
 
     @property
+    @abstractmethod
     def lambda_(self):
-        """Basis cutoff parameter, `Λ == β * wmax`, or None if not present"""
+        """Basis cutoff parameter, Λ = β * wmax, or None if not present"""
         raise NotImplementedError()
 
     @property
+    @abstractmethod
     def beta(self):
         """Inverse temperature"""
         raise NotImplementedError()
 
     @property
     def wmax(self):
-        """Real frequency cutoff or `None` if not present"""
-        raise NotImplementedError()
+        """Real frequency cutoff or None if not present"""
+        if self.lambda_ is None or self.beta is None:
+            return None
+        return self.lambda_ / self.beta
 
+    @abstractmethod
     def default_tau_sampling_points(self, *, npoints=None):
         """Default sampling points on the imaginary time axis
 
-        Arguments:
-            npoints (int):
-                Minimum number of sampling points to return.
-
-                .. versionadded: 1.1
+        Parameters
+        ----------
+        npoints : int, optional
+            Minimum number of sampling points to return.
         """
         raise NotImplementedError()
 
+    @abstractmethod
     def default_matsubara_sampling_points(self, *, npoints=None,
                                           positive_only=False):
         """Default sampling points on the imaginary frequency axis
 
-        Arguments:
-            npoints (int):
-                Minimum number of sampling points to return.
-
-                .. versionadded: 1.1
-            positive_only (bool):
-                Only return non-negative frequencies.  This is useful if the
-                object to be fitted is symmetric in Matsubura frequency,
-                ``ghat(w) == ghat(-w).conj()``, or, equivalently, real in
-                imaginary time.
+        Parameters
+        ----------
+        npoints : int, optional
+            Minimum number of sampling points to return.
+        positive_only : bool
+            Only return non-negative frequencies. This is useful if the
+            object to be fitted is symmetric in Matsubara frequency,
+            ghat(w) == ghat(-w).conj(), or, equivalently, real in
+            imaginary time.
         """
         raise NotImplementedError()
 
     @property
     def is_well_conditioned(self):
         """Returns True if the sampling is expected to be well-conditioned"""
-        return True
+        return True

sparse_ir/augment.py

@@ -1,11 +1,12 @@
 # Copyright (C) 2020-2021 Markus Wallerberger, Hiroshi Shinaoka, and others
 # SPDX-License-Identifier: MIT
-import numpy as np
-
 from . import _util
+import numpy as np
+from ctypes import c_int, byref
 from . import abstract
 from . import basis
-
+from pylibsparseir.core import basis_get_default_tau_sampling_points_ext, basis_get_n_default_matsus_ext, basis_get_default_matsus_ext
+from pylibsparseir.core import COMPUTATION_SUCCESS
 
 class AugmentedBasis(abstract.AbstractBasis):
     """Augmented basis on the imaginary-time/frequency axis.
@@ -59,6 +60,10 @@ class AugmentedBasis(abstract.AbstractBasis):
         self._uhat = AugmentedMatsubaraFunction(
                         self._basis.uhat, [aug.hat for aug in augmentations])
 
+    @property
+    def basis(self):
+        return self._basis
+
     @property
     def u(self):
         return self._u
@@ -69,7 +74,7 @@ class AugmentedBasis(abstract.AbstractBasis):
 
     @property
     def statistics(self):
-        raise self._basis.statistics
+        return self._basis.statistics
 
     def __getitem__(self, index):
         stop = basis._slice_to_size(index)
@@ -113,14 +118,19 @@ class AugmentedBasis(abstract.AbstractBasis):
         # Return the sampling points of the underlying basis, but since we
         # use the size of self, we add two further points.  One then has to
         # hope that these give good sampling points.
-        return self._basis.default_tau_sampling_points(npoints=npoints)
 
-    def default_matsubara_sampling_points(self, *, npoints=None,
-                                          positive_only=False):
-        if npoints is None:
-            npoints = self.size
-        return self._basis.default_matsubara_sampling_points(
-                                npoints=npoints, positive_only=positive_only)
+        return basis_get_default_tau_sampling_points_ext(self._basis._ptr, npoints)
+
+    def default_matsubara_sampling_points(self, *, positive_only=False):
+        """Get default Matsubara sampling points for augmented basis.
+        
+        This method provides default sampling points for Matsubara frequencies
+        when using an augmented basis.
+        """
+        n_points_returned = basis_get_n_default_matsus_ext(self._basis._ptr, self.size, positive_only)
+        points = np.zeros(n_points_returned, dtype=np.int64)
+        basis_get_default_matsus_ext(self._basis._ptr, positive_only, points)
+        return points
 
     @property
     def is_well_conditioned(self):
@@ -132,8 +142,8 @@ class AugmentedBasis(abstract.AbstractBasis):
 
 class _AugmentedFunction:
     def __init__(self, fbasis, faug):
-        if fbasis.ndim != 1:
-            raise ValueError("must have vector of functions as fbasis")
+        #if fbasis.ndim != 1:
+        #    raise ValueError("must have vector of functions as fbasis")
         self._fbasis = fbasis
         self._faug = faug
         self._naug = len(faug)
@@ -236,7 +246,7 @@ class TauConst(AbstractAugmentation):
         self._beta = beta
 
     def __call__(self, tau):
-        tau = _util.check_range(tau, 0, self._beta)
+        tau = _util.check_range(tau, -self._beta, self._beta)
         return np.broadcast_to(1 / np.sqrt(self._beta), tau.shape)
 
     def deriv(self, n=1):
@@ -264,7 +274,7 @@ class TauLinear(AbstractAugmentation):
         self._norm = np.sqrt(3/beta)
 
     def __call__(self, tau):
-        tau = _util.check_range(tau, 0, self._beta)
+        tau = _util.check_range(tau, -self._beta, self._beta)
         x = 2/self._beta * tau - 1
         return self._norm * x
 
@@ -296,7 +306,7 @@ class MatsubaraConst(AbstractAugmentation):
         self._beta = beta
 
     def __call__(self, tau):
-        tau = _util.check_range(tau, 0, self._beta)
+        tau = _util.check_range(tau, -self._beta, self._beta)
         return np.broadcast_to(np.nan, tau.shape)
 
     def deriv(self, n=1):
@@ -321,4 +331,4 @@ def _check_bosonic_statistics(statistics):
     elif statistics == 'F':
         raise ValueError("term only allowed for bosonic basis")
     else:
-        raise ValueError("invalid statistics")
+        raise ValueError("invalid statistics")