sparse-ir 2.1.0__tar.gz → 2.1.2__tar.gz

{sparse_ir-2.1.0 → sparse_ir-2.1.2}/MANIFEST.in

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

sparse_ir-2.1.2/PKG-INFO

@@ -0,0 +1,249 @@
+Metadata-Version: 2.4
+Name: sparse-ir
+Version: 2.1.2
+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 :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.10
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: pylibsparseir<0.10.0,>=0.8.3
+Dynamic: license-file
+
+sparse-ir - A library for the intermediate representation of propagators
+========================================================================
+This library provides routines for constructing and working with the
+intermediate representation of correlation functions.  It provides:
+
+ - on-the-fly computation of basis functions for arbitrary cutoff Λ
+ - basis functions and singular values are accurate to full precision
+ - routines for sparse sampling
+
+
+Installation
+------------
+Install via `pip <https://pypi.org/project/sparse-ir>`_::
+
+    pip install sparse-ir
+
+Install via `conda <https://anaconda.org/spm-lab/sparse-ir>`_::
+
+    conda install -c spm-lab sparse-ir
+
+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
+   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
+--------------------------
+Check out our `comprehensive tutorial`_, where we self-contained
+notebooks for several many-body methods - GF(2), GW, Eliashberg equations,
+Lichtenstein formula, FLEX, ... - are presented.
+
+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)
+`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
+.. _C library with Fortran bindings: https://github.com/SpM-lab/libsparseir
+
+Getting started
+---------------
+Here is a full second-order perturbation theory solver (GF(2)) in a few
+lines of Python code::
+
+    # Construct the IR basis and sparse sampling for fermionic propagators
+    import sparse_ir, numpy as np
+    basis = sparse_ir.FiniteTempBasis('F', beta=10, wmax=8, eps=1e-6)
+    stau = sparse_ir.TauSampling(basis)
+    siw = sparse_ir.MatsubaraSampling(basis, positive_only=True)
+
+    # Solve the single impurity Anderson model coupled to a bath with a
+    # semicircular states with unit half bandwidth.
+    U = 1.2
+    def rho0w(w):
+        return np.sqrt(1-w.clip(-1,1)**2) * 2/np.pi
+
+    # Compute the IR basis coefficients for the non-interacting propagator
+    rho0l = basis.v.overlap(rho0w)
+    G0l = -basis.s * rho0l
+
+    # Self-consistency loop: alternate between second-order expression for the
+    # self-energy and the Dyson equation until convergence.
+    Gl = G0l
+    Gl_prev = 0
+    while np.linalg.norm(Gl - Gl_prev) > 1e-6:
+        Gl_prev = Gl
+        Gtau = stau.evaluate(Gl)
+        Sigmatau = U**2 * Gtau**3
+        Sigmal = stau.fit(Sigmatau)
+        Sigmaiw = siw.evaluate(Sigmal)
+        G0iw = siw.evaluate(G0l)
+        Giw = 1/(1/G0iw - Sigmaiw)
+        Gl = siw.fit(Giw)
+
+You may want to start with reading up on the `intermediate representation`_.
+It is tied to the analytic continuation of bosonic/fermionic spectral
+functions from (real) frequencies to imaginary time, a transformation mediated
+by a kernel ``K``.  The kernel depends on a cutoff, which you should choose to
+be ``lambda_ >= beta * W``, where ``beta`` is the inverse temperature and ``W``
+is the bandwidth.
+
+One can now perform a `singular value expansion`_ on this kernel, which
+generates two sets of orthonormal basis functions, one set ``v[l](w)`` for
+real frequency side ``w``, and one set ``u[l](tau)`` for the same obejct in
+imaginary (Euclidean) time ``tau``, together with a "coupling" strength
+``s[l]`` between the two sides.
+
+By this construction, the imaginary time basis can be shown to be *optimal* in
+terms of compactness.
+
+.. _intermediate representation: https://arxiv.org/abs/2106.12685
+.. _singular value expansion: https://w.wiki/3poQ
+
+License and citation
+--------------------
+This software is released under the MIT License.  See LICENSE.txt for details.
+
+If you find the intermediate representation, sparse sampling, or this software
+useful in your research, please consider citing the following papers:
+
+ - Hiroshi Shinaoka et al., `Phys. Rev. B 96, 035147`_  (2017)
+ - Jia Li et al., `Phys. Rev. B 101, 035144`_ (2020)
+ - Markus Wallerberger et al., `SoftwareX 21, 101266`_ (2023)
+
+If you are discussing sparse sampling in your research specifically, please
+also consider citing an independently discovered, closely related approach, the
+MINIMAX isometry method (Merzuk Kaltak and Georg Kresse,
+`Phys. Rev. B 101, 205145`_, 2020).
+
+.. _Phys. Rev. B 96, 035147: https://doi.org/10.1103/PhysRevB.96.035147
+.. _Phys. Rev. B 101, 035144: https://doi.org/10.1103/PhysRevB.101.035144
+.. _SoftwareX 21, 101266: https://doi.org/10.1016/j.softx.2022.101266
+.. _Phys. Rev. B 101, 205145: https://doi.org/10.1103/PhysRevB.101.205145
+
+Development
+-----------
+
+Updating pylibsparseir Dependency
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+When updating the ``pylibsparseir`` dependency version, you must update it in
+**both** ``pyproject.toml`` and ``.conda/meta.yaml`` to maintain consistency:
+
+1. **Update pyproject.toml**::
+
+       # Edit dependencies in pyproject.toml
+       dependencies = [
+           "pylibsparseir>=0.8.0,<0.9.0",  # Update version range
+       ]
+
+2. **Update .conda/meta.yaml**::
+
+       # Edit both host and run requirements in .conda/meta.yaml
+       requirements:
+         host:
+           - spm-lab::pylibsparseir >=0.8.0,<0.9.0
+         run:
+           - spm-lab::pylibsparseir >=0.8.0,<0.9.0
+
+3. **Verify consistency**::
+
+       python check_libsparseir_version_consistency.py
+
+   This should output ``✅ Version specifications are consistent!``
+
+4. **Commit changes**::
+
+       git add pyproject.toml .conda/meta.yaml
+       git commit -m "chore: update pylibsparseir dependency to >=0.8.0,<0.9.0"
+
+Version Consistency Check
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+This repository includes a tool to ensure consistency between different package managers:
+
+- **Version Consistency Check**: Ensures that ``pylibsparseir`` version
+  specifications in ``pyproject.toml`` and ``.conda/meta.yaml`` are consistent.
+
+  Run the check manually::
+
+      python check_libsparseir_version_consistency.py
+
+  Or install as a pre-commit hook::
+
+      pip install pre-commit
+      pre-commit install
+
+Release Process
+~~~~~~~~~~~~~~~
+To release a new version (e.g., ``2.0.0a10``):
+
+1. **Create a working branch for version bump**::
+
+       git checkout mainline
+       git pull origin mainline
+       git checkout -b bump-to-2.0.0a10
+
+2. **Update version in pyproject.toml**::
+
+       # Edit pyproject.toml: version = "2.0.0a10"
+
+3. **Commit and push**::
+
+       git add pyproject.toml
+       git commit -m "Bump to v2.0.0a10"
+       git push --set-upstream origin bump-to-2.0.0a10
+
+4. **Create Pull Request and merge to mainline**
+
+5. **Create and push tag**::
+
+       git checkout mainline
+       git pull origin mainline
+       git tag v2.0.0a10
+       git push origin v2.0.0a10
+
+6. **Automated builds** (triggered by tag push):
+
+   - PyPI: ``wheel.yml`` workflow builds and uploads to PyPI
+   - conda: ``conda.yml`` workflow builds and uploads to SpM-lab channel
+
+Both workflows are automatically triggered when a tag starting with ``v`` is pushed.

{sparse_ir-2.1.0 → sparse_ir-2.1.2}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "sparse-ir"
-version = "2.1.0"
+version = "2.1.2"
 description = "Python bindings for the libsparseir library, providing efficient sparse intermediate representation for many-body physics calculations"
-readme = "README.md"
+readme = "README.rst"
 requires-python = ">=3.10"
 dependencies = [
     "numpy",
     "scipy",
-    "pylibsparseir>=0.8.0,<0.9.0",
+    "pylibsparseir>=0.8.3,<0.10.0",
 ]
 authors = [
     {name = "SpM-lab"}
@@ -15,10 +15,12 @@ authors = [
 license = "MIT"
 keywords = ["physics", "many-body", "green-functions", "sparse-ir"]
 classifiers = [
-    "Development Status :: 3 - Alpha",
+    "Development Status :: 5 - Production/Stable",
     "Intended Audience :: Science/Research",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Topic :: Scientific/Engineering :: Physics",
 ]
 

{sparse_ir-2.1.0 → sparse_ir-2.1.2}/src/sparse_ir/basis.py

@@ -5,12 +5,28 @@ High-level Python classes for FiniteTempBasis
 """
 from typing import Optional
 import numpy as np
-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 pylibsparseir.core import (
+    basis_new,
+    basis_get_svals,
+    basis_get_u,
+    basis_get_v,
+    basis_get_uhat,
+    basis_get_default_tau_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 .abstract import AbstractBasis, AbstractKernel
 from .sve import SVEResult
-from .poly import PiecewiseLegendrePolyVector, PiecewiseLegendrePolyFTVector, FunctionSet, FunctionSetFT
+from .poly import (
+    PiecewiseLegendrePolyVector,
+    PiecewiseLegendrePolyFTVector,
+    FunctionSet,
+    FunctionSetFT,
+)
 
 class FiniteTempBasis(AbstractBasis):
     r"""Intermediate representation (IR) basis for given temperature.
@@ -43,7 +59,17 @@ class FiniteTempBasis(AbstractBasis):
             giw = gl @ basis.uhat([1, 3, 5, 7])
     """
 
-    def __init__(self, statistics: str, beta: float, wmax: float, eps: float = np.finfo(np.float64).eps, sve_result: Optional[SVEResult] = None, max_size: int =-1):
+    def __init__(
+        self,
+        statistics: str,
+        beta: float,
+        wmax: float,
+        eps: Optional[float] = None,
+        *,
+        max_size: Optional[int] = None,
+        kernel: Optional[AbstractKernel] = None,
+        sve_result: Optional[SVEResult] = None,
+    ):
         """
         Initialize finite temperature basis.
 
@@ -55,31 +81,65 @@ class FiniteTempBasis(AbstractBasis):
             Inverse temperature
         wmax : float
             Frequency cutoff
-        eps : float
-            Relative truncation threshold for the singular values,
-            defaulting to the machine epsilon (2.2e-16)
+        eps : float, optional
+            Relative truncation threshold for the singular values.
+            Defaults to machine epsilon (~2.2e-16).
+        max_size : int, optional
+            Maximum basis size. If given, only at most the ``max_size`` most
+            significant singular values and associated basis functions are
+            retained.
+        kernel : AbstractKernel, optional
+            Kernel to use for the basis. If not given, a LogisticKernel is
+            created from beta * wmax. (Deprecated: kernel is inferred from
+            statistics.)
+        sve_result : SVEResult, optional
+            Precomputed SVE result. If not given, the SVE is computed.
         """
+        if not (beta > 0):
+            raise ValueError("inverse temperature beta must be positive")
+        if not (wmax >= 0):
+            raise ValueError("frequency cutoff must be non-negative")
+
         self._statistics = statistics
         self._beta = beta
         self._wmax = wmax
         self._lambda = beta * wmax
+
+        # Handle eps default
+        if eps is None:
+            eps = np.finfo(np.float64).eps
         self._eps = eps
 
-        # Create kernel
-        if statistics == 'F' or statistics == 'B':
+        # Handle max_size
+        if max_size is None:
+            max_size = -1
+
+        # Create or use provided kernel
+        if kernel is not None:
+            # Backward compatibility: use provided kernel
+            self._kernel = kernel
+        elif statistics in ('F', 'B'):
             self._kernel = LogisticKernel(self._lambda)
         else:
-            raise ValueError(f"Invalid statistics: {statistics} expected 'F' or 'B'")
+            raise ValueError(
+                f"Invalid statistics: {statistics}, expected 'F' or 'B'"
+            )
 
-        # Compute SVE
+        # Compute SVE if not provided
         if sve_result is None:
             self._sve = SVEResult(self._kernel, eps)
         else:
             self._sve = sve_result
 
         # 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._eps, self._kernel._ptr, self._sve._ptr, max_size)
+        stats_int = (
+            SPIR_STATISTICS_FERMIONIC if statistics == 'F'
+            else SPIR_STATISTICS_BOSONIC
+        )
+        self._ptr = basis_new(
+            stats_int, self._beta, self._wmax, self._eps,
+            self._kernel._ptr, self._sve._ptr, max_size
+        )
 
         u_funcs = FunctionSet(basis_get_u(self._ptr))
         v_funcs = FunctionSet(basis_get_v(self._ptr))
@@ -168,8 +228,11 @@ class FiniteTempBasis(AbstractBasis):
 
     @property
     def accuracy(self):
-        """Overall accuracy bound."""
-        return self.s[-1] / self.s[0]
+        """Overall truncation error bound."""
+        sve_s = self.sve_result.s
+        if sve_s.size > self.size:
+            return sve_s[self.size] / sve_s[0]
+        return sve_s[-1] / sve_s[0]
 
     @property
     def shape(self):
@@ -260,4 +323,4 @@ def finite_temp_bases(beta, wmax, eps=None, sve_result=None):
     """
     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
+    return fermion_basis, boson_basis

{sparse_ir-2.1.0 → sparse_ir-2.1.2}/src/sparse_ir/sampling.py

@@ -332,7 +332,7 @@ class MatsubaraSampling:
         )
         if status != COMPUTATION_SUCCESS:
             raise RuntimeError(f"Failed to fit sampling: {status}")
-        return output['real']
+        return output['real'] + 1j * output['imag']
 
     @property
     def cond(self):

{sparse_ir-2.1.0 → sparse_ir-2.1.2}/src/sparse_ir/sve.py

@@ -1,4 +1,5 @@
-# Copyright (C) 2020-2025 Satoshi Terasaki, Markus Wallerberger, Hiroshi Shinaoka, and others
+# Copyright (C) 2020-2025 Satoshi Terasaki, Markus Wallerberger,
+# Hiroshi Shinaoka, and others
 # SPDX-License-Identifier: MIT
 """
 SVE (Singular Value Expansion) functionality for SparseIR.
@@ -7,10 +8,40 @@ This module provides Python wrappers for SVE computation and results.
 """
 import numpy as np
 
-from pylibsparseir.core import _lib, sve_result_new, sve_result_get_svals, sve_result_get_size
+from pylibsparseir.constants import (
+    SPIR_TWORK_FLOAT64,
+    SPIR_TWORK_FLOAT64X2,
+)
+from pylibsparseir.core import (
+    _lib,
+    sve_result_new,
+    sve_result_get_svals,
+    sve_result_get_size,
+)
 from .abstract import AbstractKernel
 from .kernel import LogisticKernel, RegularizedBoseKernel
 
+
+def _resolve_work_dtype(work_dtype):
+    if work_dtype is None:
+        return None
+
+    if isinstance(work_dtype, str):
+        work_dtype = work_dtype.lower()
+        if work_dtype in {"float64", "double"}:
+            return SPIR_TWORK_FLOAT64
+        if work_dtype in {"float64x2", "ddouble"}:
+            return SPIR_TWORK_FLOAT64X2
+        raise TypeError(f"unexpected work_dtype string {work_dtype!r}")
+
+    dtype = np.dtype(work_dtype)
+    if dtype == np.float64:
+        return SPIR_TWORK_FLOAT64
+    if dtype.itemsize > np.dtype(np.float64).itemsize:
+        return SPIR_TWORK_FLOAT64X2
+    raise TypeError(f"unsupported work_dtype {dtype}")
+
+
 class SVEResult:
     """
     Result of a singular value expansion (SVE).
@@ -19,7 +50,14 @@ class SVEResult:
     the SVE of an integral kernel.
     """
 
-    def __init__(self, kernel: AbstractKernel, eps: float, cutoff: float=-1, n_sv: int=-1):
+    def __init__(
+        self,
+        kernel: AbstractKernel,
+        eps: float,
+        cutoff: float = -1,
+        n_sv: int = -1,
+        work_dtype=None,
+    ):
         """
         Compute SVE of the given kernel.
 
@@ -37,14 +75,23 @@ class SVEResult:
             returned.
         """
         if not isinstance(kernel, (LogisticKernel, RegularizedBoseKernel)):
-            raise TypeError("kernel must be LogisticKernel or RegularizedBoseKernel")
+            raise TypeError(
+                "kernel must be LogisticKernel or RegularizedBoseKernel"
+            )
 
         self._kernel = kernel  # Store kernel for later use
         self._eps = eps
         self._cutoff = cutoff
         self._n_sv = n_sv
 
-        self._ptr = sve_result_new(kernel._ptr, eps, cutoff=cutoff, lmax=n_sv)
+        twork = _resolve_work_dtype(work_dtype)
+        self._ptr = sve_result_new(
+            kernel._ptr,
+            eps,
+            cutoff=cutoff,
+            lmax=n_sv,
+            Twork=twork,
+        )
 
     def __len__(self):
         return sve_result_get_size(self._ptr)
@@ -59,7 +106,12 @@ class SVEResult:
             _lib.spir_sve_result_release(self._ptr)
 
 
-def compute(kernel, eps=np.finfo(np.float64).eps, n_sv=-1):
+def compute(
+    kernel,
+    eps=np.finfo(np.float64).eps,
+    n_sv=-1,
+    work_dtype=None,
+):
     """Perform truncated singular value expansion of a kernel.
 
     Perform a truncated singular value expansion (SVE) of an integral
@@ -85,8 +137,12 @@ def compute(kernel, eps=np.finfo(np.float64).eps, n_sv=-1):
         n_sv (int):
             Maximum basis size. If given, only at most the ``n_sv`` most
             significant singular values and associated singular functions are
+            returned. Defaults to -1, which means all singular values are
             returned.
-            Defaulting to -1, which means all singular values are returned.
+        work_dtype (dtype-like or str, optional):
+            Working data type used during the SVE / SVD computation. Accepts
+            ``numpy.float64``, ``float``, or strings such as ``"float64"`` or
+            ``"float64x2"``. Defaults to ``float64x2`` for maximal precision.
 
     Returns:
         An ``SVEResult`` containing the truncated singular value expansion.
@@ -94,8 +150,14 @@ def compute(kernel, eps=np.finfo(np.float64).eps, n_sv=-1):
 
     if eps is None:
         eps = np.finfo(np.float64).eps
-    return SVEResult(kernel, eps=eps, cutoff=-1, n_sv=n_sv)
+    return SVEResult(
+        kernel,
+        eps=eps,
+        cutoff=-1,
+        n_sv=n_sv,
+        work_dtype=work_dtype,
+    )
 
 
 # Backward compatibility
-compute_sve = compute
+compute_sve = compute

sparse_ir-2.1.2/src/sparse_ir.egg-info/PKG-INFO

@@ -0,0 +1,249 @@
+Metadata-Version: 2.4
+Name: sparse-ir
+Version: 2.1.2
+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 :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.10
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: pylibsparseir<0.10.0,>=0.8.3
+Dynamic: license-file
+
+sparse-ir - A library for the intermediate representation of propagators
+========================================================================
+This library provides routines for constructing and working with the
+intermediate representation of correlation functions.  It provides:
+
+ - on-the-fly computation of basis functions for arbitrary cutoff Λ
+ - basis functions and singular values are accurate to full precision
+ - routines for sparse sampling
+
+
+Installation
+------------
+Install via `pip <https://pypi.org/project/sparse-ir>`_::
+
+    pip install sparse-ir
+
+Install via `conda <https://anaconda.org/spm-lab/sparse-ir>`_::
+
+    conda install -c spm-lab sparse-ir
+
+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
+   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
+--------------------------
+Check out our `comprehensive tutorial`_, where we self-contained
+notebooks for several many-body methods - GF(2), GW, Eliashberg equations,
+Lichtenstein formula, FLEX, ... - are presented.
+
+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)
+`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
+.. _C library with Fortran bindings: https://github.com/SpM-lab/libsparseir
+
+Getting started
+---------------
+Here is a full second-order perturbation theory solver (GF(2)) in a few
+lines of Python code::
+
+    # Construct the IR basis and sparse sampling for fermionic propagators
+    import sparse_ir, numpy as np
+    basis = sparse_ir.FiniteTempBasis('F', beta=10, wmax=8, eps=1e-6)
+    stau = sparse_ir.TauSampling(basis)
+    siw = sparse_ir.MatsubaraSampling(basis, positive_only=True)
+
+    # Solve the single impurity Anderson model coupled to a bath with a
+    # semicircular states with unit half bandwidth.
+    U = 1.2
+    def rho0w(w):
+        return np.sqrt(1-w.clip(-1,1)**2) * 2/np.pi
+
+    # Compute the IR basis coefficients for the non-interacting propagator
+    rho0l = basis.v.overlap(rho0w)
+    G0l = -basis.s * rho0l
+
+    # Self-consistency loop: alternate between second-order expression for the
+    # self-energy and the Dyson equation until convergence.
+    Gl = G0l
+    Gl_prev = 0
+    while np.linalg.norm(Gl - Gl_prev) > 1e-6:
+        Gl_prev = Gl
+        Gtau = stau.evaluate(Gl)
+        Sigmatau = U**2 * Gtau**3
+        Sigmal = stau.fit(Sigmatau)
+        Sigmaiw = siw.evaluate(Sigmal)
+        G0iw = siw.evaluate(G0l)
+        Giw = 1/(1/G0iw - Sigmaiw)
+        Gl = siw.fit(Giw)
+
+You may want to start with reading up on the `intermediate representation`_.
+It is tied to the analytic continuation of bosonic/fermionic spectral
+functions from (real) frequencies to imaginary time, a transformation mediated
+by a kernel ``K``.  The kernel depends on a cutoff, which you should choose to
+be ``lambda_ >= beta * W``, where ``beta`` is the inverse temperature and ``W``
+is the bandwidth.
+
+One can now perform a `singular value expansion`_ on this kernel, which
+generates two sets of orthonormal basis functions, one set ``v[l](w)`` for
+real frequency side ``w``, and one set ``u[l](tau)`` for the same obejct in
+imaginary (Euclidean) time ``tau``, together with a "coupling" strength
+``s[l]`` between the two sides.
+
+By this construction, the imaginary time basis can be shown to be *optimal* in
+terms of compactness.
+
+.. _intermediate representation: https://arxiv.org/abs/2106.12685
+.. _singular value expansion: https://w.wiki/3poQ
+
+License and citation
+--------------------
+This software is released under the MIT License.  See LICENSE.txt for details.
+
+If you find the intermediate representation, sparse sampling, or this software
+useful in your research, please consider citing the following papers:
+
+ - Hiroshi Shinaoka et al., `Phys. Rev. B 96, 035147`_  (2017)
+ - Jia Li et al., `Phys. Rev. B 101, 035144`_ (2020)
+ - Markus Wallerberger et al., `SoftwareX 21, 101266`_ (2023)
+
+If you are discussing sparse sampling in your research specifically, please
+also consider citing an independently discovered, closely related approach, the
+MINIMAX isometry method (Merzuk Kaltak and Georg Kresse,
+`Phys. Rev. B 101, 205145`_, 2020).
+
+.. _Phys. Rev. B 96, 035147: https://doi.org/10.1103/PhysRevB.96.035147
+.. _Phys. Rev. B 101, 035144: https://doi.org/10.1103/PhysRevB.101.035144
+.. _SoftwareX 21, 101266: https://doi.org/10.1016/j.softx.2022.101266
+.. _Phys. Rev. B 101, 205145: https://doi.org/10.1103/PhysRevB.101.205145
+
+Development
+-----------
+
+Updating pylibsparseir Dependency
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+When updating the ``pylibsparseir`` dependency version, you must update it in
+**both** ``pyproject.toml`` and ``.conda/meta.yaml`` to maintain consistency:
+
+1. **Update pyproject.toml**::
+
+       # Edit dependencies in pyproject.toml
+       dependencies = [
+           "pylibsparseir>=0.8.0,<0.9.0",  # Update version range
+       ]
+
+2. **Update .conda/meta.yaml**::
+
+       # Edit both host and run requirements in .conda/meta.yaml
+       requirements:
+         host:
+           - spm-lab::pylibsparseir >=0.8.0,<0.9.0
+         run:
+           - spm-lab::pylibsparseir >=0.8.0,<0.9.0
+
+3. **Verify consistency**::
+
+       python check_libsparseir_version_consistency.py
+
+   This should output ``✅ Version specifications are consistent!``
+
+4. **Commit changes**::
+
+       git add pyproject.toml .conda/meta.yaml
+       git commit -m "chore: update pylibsparseir dependency to >=0.8.0,<0.9.0"
+
+Version Consistency Check
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+This repository includes a tool to ensure consistency between different package managers:
+
+- **Version Consistency Check**: Ensures that ``pylibsparseir`` version
+  specifications in ``pyproject.toml`` and ``.conda/meta.yaml`` are consistent.
+
+  Run the check manually::
+
+      python check_libsparseir_version_consistency.py
+
+  Or install as a pre-commit hook::
+
+      pip install pre-commit
+      pre-commit install
+
+Release Process
+~~~~~~~~~~~~~~~
+To release a new version (e.g., ``2.0.0a10``):
+
+1. **Create a working branch for version bump**::
+
+       git checkout mainline
+       git pull origin mainline
+       git checkout -b bump-to-2.0.0a10
+
+2. **Update version in pyproject.toml**::
+
+       # Edit pyproject.toml: version = "2.0.0a10"
+
+3. **Commit and push**::
+
+       git add pyproject.toml
+       git commit -m "Bump to v2.0.0a10"
+       git push --set-upstream origin bump-to-2.0.0a10
+
+4. **Create Pull Request and merge to mainline**
+
+5. **Create and push tag**::
+
+       git checkout mainline
+       git pull origin mainline
+       git tag v2.0.0a10
+       git push origin v2.0.0a10
+
+6. **Automated builds** (triggered by tag push):
+
+   - PyPI: ``wheel.yml`` workflow builds and uploads to PyPI
+   - conda: ``conda.yml`` workflow builds and uploads to SpM-lab channel
+
+Both workflows are automatically triggered when a tag starting with ``v`` is pushed.

sparse_ir-2.1.2/src/sparse_ir.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy
+scipy
+pylibsparseir<0.10.0,>=0.8.3

{sparse_ir-2.1.0 → sparse_ir-2.1.2}/tests/test_sve.py

@@ -19,14 +19,36 @@ class TestSVEAccuracy:
         """Test that basis accuracy meets expected bounds."""
         eps = 1e-6
         basis = sparse_ir.FiniteTempBasis(stat, beta, wmax, eps)
+        sve_s = basis.sve_result.s
 
-        # Basic properties
-        assert 0 < basis.accuracy <= basis.significance[-1]
+        # Accuracy is the relative significance of the first singular value
+        # excluded from the basis.
+        assert sve_s.size > basis.size
+        expected_accuracy = sve_s[basis.size] / sve_s[0]
+        assert basis.accuracy == expected_accuracy
         assert basis.significance[0] == 1.0
-        assert basis.accuracy <= basis.s[-1] / basis.s[0]
+        assert basis.accuracy < eps <= basis.significance[-1]
 
-        # Accuracy should be better than requested epsilon (with some tolerance)
-        assert basis.accuracy <= 10 * eps, f"Accuracy {basis.accuracy} should be close to eps {eps}"
+    def test_accuracy_with_max_size(self):
+        """Test accuracy when max_size, rather than epsilon, truncates."""
+        eps = 1e-6
+        basis = sparse_ir.FiniteTempBasis(
+            'F', 1.0, 42.0, eps, max_size=5
+        )
+        sve_s = basis.sve_result.s
+
+        assert basis.size == 5
+        assert basis.accuracy == sve_s[basis.size] / sve_s[0]
+        assert basis.accuracy > eps
+        assert basis.accuracy < basis.significance[-1]
+
+    def test_accuracy_without_excluded_singular_value(self):
+        """Test the fallback when the SVE contains no excluded value."""
+        basis = sparse_ir.FiniteTempBasis('F', 1e-3, 1e-3, 1e-100)
+        sve_s = basis.sve_result.s
+
+        assert sve_s.size == basis.size
+        assert basis.accuracy == sve_s[-1] / sve_s[0]
 
     @pytest.mark.parametrize("stat,beta,wmax", BASIS_PARAMS)
     def test_singular_value_properties(self, stat, beta, wmax):
@@ -133,4 +155,3 @@ class TestBasisConsistency:
         assert 5 <= f_basis.size <= 100
         assert 5 <= b_basis.size <= 100
 
-

sparse_ir-2.1.0/PKG-INFO

@@ -1,22 +0,0 @@
-Metadata-Version: 2.4
-Name: sparse-ir
-Version: 2.1.0
-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.9.0,>=0.8.0
-Dynamic: license-file

sparse_ir-2.1.0/src/sparse_ir.egg-info/PKG-INFO

@@ -1,22 +0,0 @@
-Metadata-Version: 2.4
-Name: sparse-ir
-Version: 2.1.0
-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.9.0,>=0.8.0
-Dynamic: license-file

sparse_ir-2.1.0/src/sparse_ir.egg-info/requires.txt

@@ -1,3 +0,0 @@
-numpy
-scipy
-pylibsparseir<0.9.0,>=0.8.0