sparse-ir 1.1.6__tar.gz → 2.0.0a2__tar.gz

sparse_ir-2.0.0a2/MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+recursive-include src/sparse_ir *.py
+global-exclude *.pyc
+global-exclude __pycache__

sparse_ir-2.0.0a2/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: sparse-ir
+Version: 2.0.0a2
+Summary: Python bindings for the libsparseir library, providing efficient sparse intermediate representation for many-body physics calculations
+Author: SpM-lab
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/SpM-lab/sparse-r
+Project-URL: Repository, https://github.com/SpM-lab/sparse-r
+Project-URL: Bug Tracker, https://github.com/SpM-lab/sparse-r/issues
+Keywords: physics,many-body,green-functions,sparse-ir
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: pylibsparseir<0.2.0,>=0.1.0
+Requires-Dist: sphinx-rtd-theme>=3.0.2
+Dynamic: license-file

{sparse-ir-1.1.6 → sparse_ir-2.0.0a2}/README.rst

@@ -12,25 +12,37 @@ Installation
 ------------
 Install via `pip <https://pypi.org/project/sparse-ir>`_::
 
-    pip install sparse-ir[xprec]
-
-The above line is the recommended way to install `sparse-ir`.  It automatically
-installs the `xprec <https://github.com/tuwien-cms/xprec>`_ package, which
-allows one to compute the IR basis functions with greater accuracy.  If you do
-not want to do this, simply remove the string ``[xprec]`` from the above command.
+    pip install sparse-ir
 
 Install via `conda <https://anaconda.org/spm-lab/sparse-ir>`_::
 
-    conda install -c spm-lab sparse-ir xprec
+    conda install -c spm-lab sparse-ir
 
-Other than the optional xprec dependency, sparse-ir requires only
-`numpy <https://numpy.org/>`_ and `scipy <https://scipy.org/>`_.
+sparse-ir requires `numpy <https://numpy.org/>`_, `scipy <https://scipy.org/>`_,
+and `pylibsparseir <https://pypi.org/project/pylibsparseir>`_ (a thin Python wrapper
+for the `libsparseir <https://github.com/SpM-lab/libsparseir>`_ C API).
 
 To manually install the current development version, you can use the following::
 
    # Only recommended for developers - no automatic updates!
    git clone https://github.com/SpM-lab/sparse-ir
-   pip install -e sparse-ir/[xprec]
+   cd sparse-ir
+   uv sync
+
+Note: `uv` is a fast Python package manager. If you don't have it installed,
+you can install it with ``pip install uv`` or use ``pip install -e .`` instead.
+
+Building documentation
+----------------------
+To build the documentation locally, first install the development dependencies::
+
+   uv sync --group doc
+
+Then build the documentation::
+
+   uv run sphinx-build -M html doc _build/html
+
+The documentation will be available in ``_build/html/html/index.html``.
 
 Documentation and tutorial
 --------------------------
@@ -42,12 +54,12 @@ Refer to the `API documentation`_ for more details on how to work
 with the python library.
 
 There is also a `Julia library`_ and (currently somewhat restricted)
-`Fortran library`_ available for the IR basis and sparse sampling.
+`C library with Fortran bindings`_ available for the IR basis and sparse sampling.
 
 .. _comprehensive tutorial: https://spm-lab.github.io/sparse-ir-tutorial
 .. _API documentation: https://sparse-ir.readthedocs.io
 .. _Julia library: https://github.com/SpM-lab/SparseIR.jl
-.. _Fortran library: https://github.com/SpM-lab/sparse-ir-fortran
+.. _C library with Fortran bindings: https://github.com/SpM-lab/libsparseir
 
 Getting started
 ---------------

sparse_ir-2.0.0a2/pyproject.toml

@@ -0,0 +1,60 @@
+[project]
+name = "sparse-ir"
+version = "2.0.0a2"
+description = "Python bindings for the libsparseir library, providing efficient sparse intermediate representation for many-body physics calculations"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "numpy",
+    "scipy",
+    "pylibsparseir>=0.1.0,<0.2.0",
+    "sphinx-rtd-theme>=3.0.2",
+]
+authors = [
+    {name = "SpM-lab"}
+]
+license = "MIT"
+keywords = ["physics", "many-body", "green-functions", "sparse-ir"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Physics",
+]
+
+[project.urls]
+Homepage = "https://github.com/SpM-lab/sparse-r"
+Repository = "https://github.com/SpM-lab/sparse-r"
+"Bug Tracker" = "https://github.com/SpM-lab/sparse-r/issues"
+
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-dir]
+"" = "src"
+
+[dependency-groups]
+dev = [
+    "ipykernel>=6.29.5",
+    "jupytext>=1.17.2",
+    "matplotlib>=3.10.3",
+    "pytest>=8.4.1",
+    "sphinx>=8.0.0",
+    "sphinx-rtd-theme>=3.0.0",
+]
+doc = [
+    "sphinx>=8.0.0",
+    "sphinx-rtd-theme>=3.0.0",
+    "matplotlib>=3.10.3",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py", "*_tests.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]

sparse_ir-2.0.0a2/src/sparse_ir/__init__.py

@@ -0,0 +1,39 @@
+"""
+SparseIR Python bindings
+
+This package provides Python bindings for the SparseIR C library.
+"""
+
+from .abstract import AbstractBasis
+from .basis import FiniteTempBasis, finite_temp_bases
+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-2.0.0a2/src/sparse_ir/abstract.py

@@ -0,0 +1,172 @@
+"""
+Abstract base class for basis objects.
+
+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:
+
+        G(τ) ≈ Σ_{l=0}^{L-1} g_l U_l(τ)
+
+    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:
+
+        Ĝ(n) ≈ Σ_{l=0}^{L-1} g_l Û_l(n)
+
+    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:
+
+        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 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.
+        """
+        raise NotImplementedError()
+
+    @property
+    @abstractmethod
+    def uhat(self):
+        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 u by the following Fourier transform:
+
+           û(n) = ∫₀^β dτ exp(iπnτ/β) u(τ)
+
+        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
+
+        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!
+        """
+        raise NotImplementedError()
+
+    @property
+    @abstractmethod
+    def statistics(self):
+        """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].
+        """
+        raise NotImplementedError()
+
+    @property
+    def shape(self):
+        """Shape of the basis function set"""
+        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 an a-priori bound on the
+        (relative) error made by discarding the associated coefficient.
+        """
+        raise NotImplementedError()
+
+    @property
+    def accuracy(self):
+        """Accuracy of the basis.
+
+        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"""
+        raise NotImplementedError()
+
+    @property
+    @abstractmethod
+    def beta(self):
+        """Inverse temperature"""
+        raise NotImplementedError()
+
+    @property
+    def wmax(self):
+        """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
+
+        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
+
+        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

{sparse-ir-1.1.6 → sparse_ir-2.0.0a2}/src/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")