sparse-ir 1.0.0__tar.gz → 1.1.1__tar.gz

sparse-ir-1.1.1/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2020-2021 Markus Wallerberger and others
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

sparse-ir-1.1.1/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.1
+Name: sparse-ir
+Version: 1.1.1
+Summary: intermediate representation (IR) basis for electronic propagator
+Home-page: https://github.com/SpM-lab/sparse-ir
+Author: ['Markus Wallerberger', 'Hiroshi Shinaoka', 'Kazuyoshi Yoshimi', 'Junya Otsuki', 'Chikano Naoya']
+Author-email: markus.wallerberger@tuwien.ac.at
+License: UNKNOWN
+Keywords: irbasis many-body propagator svd
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3
+Description-Content-Type: text/x-rst
+Provides-Extra: doc
+Provides-Extra: test
+Provides-Extra: xprec
+License-File: LICENSE.txt
+
+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[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.
+
+Install via `conda <https://anaconda.org/spm-lab/sparse-ir>`_::
+
+    conda install -c spm-lab sparse-ir xprec
+
+Other than the optional xprec dependency, sparse-ir requires only
+`numpy <https://numpy.org/>`_ and `scipy <https://scipy.org/>`_.
+
+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]
+
+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)
+`Fortran library`_ 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
+
+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
+
+

{sparse-ir-1.0.0 → sparse-ir-1.1.1}/README.rst

@@ -112,7 +112,7 @@ 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., `arXiv 2206.11762`_ (2022)
+ - 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
@@ -121,5 +121,5 @@ MINIMAX isometry method (Merzuk Kaltak and Georg Kresse,
 
 .. _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
-.. _arXiv 2206.11762: https://doi.org/10.48550/arXiv.2206.11762
+.. _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

{sparse-ir-1.0.0 → sparse-ir-1.1.1}/src/sparse_ir/__init__.py

@@ -10,9 +10,9 @@ intermediate representation of correlation functions.  It provides:
  - basis functions and singular values are accurate to full precision
  - routines for sparse sampling
 """
-__copyright__ = "2020-2022 Markus Wallerberger, Hiroshi Shinaoka, and others"
+__copyright__ = "2020-2024 Markus Wallerberger, Hiroshi Shinaoka, and others"
 __license__ = "MIT"
-__version__ = "1.0.0"
+__version__ = "1.1.1"
 
 from .kernel import RegularizedBoseKernel, LogisticKernel
 from .sve import compute as compute_sve, SVEResult

{sparse-ir-1.0.0 → sparse-ir-1.1.1}/src/sparse_ir/abstract.py

@@ -150,14 +150,26 @@ class AbstractBasis:
         """Real frequency cutoff or `None` if not present"""
         raise NotImplementedError()
 
-    def default_tau_sampling_points(self):
-        """Default sampling points on the imaginary time axis"""
+    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
+        """
         raise NotImplementedError()
 
-    def default_matsubara_sampling_points(self, *, positive_only=False):
+    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,

{sparse-ir-1.0.0 → sparse-ir-1.1.1}/src/sparse_ir/augment.py

@@ -106,13 +106,21 @@ class AugmentedBasis(abstract.AbstractBasis):
     def wmax(self):
         return self._basis.wmax
 
-    def default_tau_sampling_points(self):
-        x = basis._default_sampling_points(self._basis.sve_result.u, self.size)
-        return self.beta/2 * (x + 1)
-
-    def default_matsubara_sampling_points(self, *, positive_only=False):
-        return basis._default_matsubara_sampling_points(
-                    self._basis._uhat_full, self.size, positive_only=positive_only)
+    def default_tau_sampling_points(self, *, npoints=None):
+        if npoints is None:
+            npoints = self.size
+
+        # 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)
 
     @property
     def is_well_conditioned(self):

{sparse-ir-1.0.0 → sparse-ir-1.1.1}/src/sparse_ir/basis.py

@@ -169,16 +169,31 @@ class FiniteTempBasis(abstract.AbstractBasis):
     def sve_result(self):
         return self._sve_result
 
-    def default_tau_sampling_points(self):
-        x = _default_sampling_points(self._sve_result.u, self.size)
+    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, *, positive_only=False):
-        return _default_matsubara_sampling_points(self._uhat_full, self.size,
+    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):
-        y = _default_sampling_points(self._sve_result.v, self.size)
+    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
+        """
+        if npoints is None:
+            npoints = self.size
+        y = _default_sampling_points(self._sve_result.v, npoints)
         return self._wmax * y
 
     def rescale(self, new_beta):

{sparse-ir-1.0.0 → sparse-ir-1.1.1}/src/sparse_ir/poly.py

@@ -208,7 +208,7 @@ class PiecewiseLegendreFT:
     ``n`` must be odd.
     """
     _DEFAULT_GRID = np.hstack([np.arange(2**6),
-                        (2**np.linspace(6, 25, 16*(25-6)+1)).astype(int)])
+                        (2**np.linspace(6, 35, 16*(35-6)+1)).astype(int)])
 
     def __init__(self, poly, freq='even', n_asymp=None, power_model=None):
         if poly.xmin != -1 or poly.xmax != 1:

{sparse-ir-1.0.0 → sparse-ir-1.1.1}/src/sparse_ir/sampling.py

@@ -20,13 +20,74 @@ class AbstractSampling:
             |________________|      fit        |___________________|
 
     """
-    def evaluate(self, al, axis=None):
-        """Evaluate the basis coefficients at the sparse sampling points"""
+    def evaluate(self, al, axis=None, *, points=None):
+        """Evaluate the basis coefficients at sampling points.
+
+        Arguments:
+            al (array):
+                Array where the `l`-th item along `axis` corresponds to the
+                `l`-th basis coefficient
+            axis (integer):
+                Axis or dimension of `al` along which to evaluate the function.
+                Defaults to the last, i.e., rightmost axis.
+            points (vector):
+                Points on which the results should be evaluated.  Defaults
+                to the sampling points for which the sampling objects was
+                created.
+
+                .. versionadded:: 1.1
+
+        Return:
+            Array where the `n`-th item along `axis` corresponds to the
+            value on the `n`-th sampling point (or value on `point[n]`, if
+            given.)
+
+        Note:
+            If `points` is given, a new sampling is created at each invocation,
+            which can result in a performance hit.  Consider caching sampling
+            objects or simply using the `.u()` and `.uhat()` methods of the
+            underlying basis.
+        """
+        if points is not None:
+            return self._for_sampling_points(points).evaluate(al, axis)
+
         return self.matrix.matmul(al, axis)
 
-    def fit(self, ax, axis=None):
-        """Fit basis coefficients from the sparse sampling points"""
-        return self.matrix.lstsq(ax, axis)
+    def fit(self, ax, axis=None, *, points=None):
+        """Fit the basis coefficients from the sampling points.
+
+        Arguments:
+            ax (array):
+                Array where the `n`-th item along `axis` corresponds to the
+                value on the `n`-th sampling point (or value on `point[n]`, if
+                given.)
+            axis (integer):
+                Axis or dimension of `ax` along which to fit the function.
+                Defaults to the last, i.e., rightmost axis.
+            points (vector):
+                Points on which the `ax` is given.  Defaults to the sampling
+                points for which the sampling objects was created.
+
+                .. versionadded:: 1.1
+
+        Return:
+            Array where the `l`-th item along `axis` corresponds to the
+            `l`-th basis coefficient
+
+        Note:
+            If `points` is given, a new sampling is created at each invocation,
+            which can result in a performance hit.  Consider caching sampling
+            objects.
+        """
+        if points is not None:
+            return self._for_sampling_points(points).fit(ax, axis)
+
+        matrix = self.matrix
+        if self.basis.is_well_conditioned and not (matrix.cond <= 1e8):
+            warn(f"Sampling matrix is poorly conditioned "
+                 f"(kappa = {matrix.cond:.2g})", ConditioningWarning)
+
+        return matrix.lstsq(ax, axis)
 
     @property
     def cond(self):
@@ -48,6 +109,9 @@ class AbstractSampling:
         """Basis instance"""
         raise NotImplementedError()
 
+    def _for_sampling_points(self, x):
+        raise RuntimeError("Changing sampling points is not possible")
+
 
 class TauSampling(AbstractSampling):
     """Sparse sampling in imaginary time.
@@ -68,10 +132,6 @@ class TauSampling(AbstractSampling):
         self._sampling_points = sampling_points
         self._matrix = DecomposedMatrix(matrix)
 
-        if basis.is_well_conditioned and self._matrix.cond > 1e8:
-            warn(f"Sampling matrix is poorly conditioned "
-                 f"(kappa = {self._matrix.cond:.2g})", ConditioningWarning)
-
     @property
     def basis(self): return self._basis
 
@@ -86,6 +146,10 @@ class TauSampling(AbstractSampling):
         """Sampling points in (reduced) imaginary time"""
         return self._sampling_points
 
+    def _for_sampling_points(self, x):
+        x = np.asarray(x)
+        return TauSampling(self._basis, x)
+
 
 class MatsubaraSampling(AbstractSampling):
     """Sparse sampling in Matsubara frequencies.
@@ -125,10 +189,6 @@ class MatsubaraSampling(AbstractSampling):
         else:
             self._matrix = DecomposedMatrix(matrix)
 
-        if basis.is_well_conditioned and self._matrix.cond > 1e8:
-            warn(f"Sampling matrix is poorly conditioned "
-                 f"(kappa = {self._matrix.cond:.2g})", ConditioningWarning)
-
     @property
     def basis(self): return self._basis
 
@@ -148,6 +208,11 @@ class MatsubaraSampling(AbstractSampling):
         """Sampling points as (reduced) Matsubara frequencies"""
         return self._sampling_points
 
+    def _for_sampling_points(self, x):
+        x = np.asarray(x)
+        return MatsubaraSampling(self._basis, x,
+                                 positive_only=self._positive_only)
+
 
 class DecomposedMatrix:
     """Matrix in SVD decomposed form for fast and accurate fitting.
@@ -314,6 +379,13 @@ class SplitDecomposedMatrix:
 
 
 class ConditioningWarning(RuntimeWarning):
+    """Warns about a poorly conditioned problem.
+
+    This warning is issued if the library detects a poorly conditioned fitting
+    problem.  This essentially means there is a high degree of ambiguity in how
+    to choose the solution.  One must therefore expect to lose significant
+    precision in the parameter values.
+    """
     pass
 
 

sparse-ir-1.1.1/src/sparse_ir.egg-info/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.1
+Name: sparse-ir
+Version: 1.1.1
+Summary: intermediate representation (IR) basis for electronic propagator
+Home-page: https://github.com/SpM-lab/sparse-ir
+Author: ['Markus Wallerberger', 'Hiroshi Shinaoka', 'Kazuyoshi Yoshimi', 'Junya Otsuki', 'Chikano Naoya']
+Author-email: markus.wallerberger@tuwien.ac.at
+License: UNKNOWN
+Keywords: irbasis many-body propagator svd
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3
+Description-Content-Type: text/x-rst
+Provides-Extra: doc
+Provides-Extra: test
+Provides-Extra: xprec
+License-File: LICENSE.txt
+
+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[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.
+
+Install via `conda <https://anaconda.org/spm-lab/sparse-ir>`_::
+
+    conda install -c spm-lab sparse-ir xprec
+
+Other than the optional xprec dependency, sparse-ir requires only
+`numpy <https://numpy.org/>`_ and `scipy <https://scipy.org/>`_.
+
+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]
+
+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)
+`Fortran library`_ 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
+
+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
+
+

{sparse-ir-1.0.0 → sparse-ir-1.1.1}/src/sparse_ir.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+LICENSE.txt
 README.rst
 setup.py
 src/sparse_ir/__init__.py

{sparse-ir-1.0.0 → sparse-ir-1.1.1}/test/test_sampling.py

@@ -100,3 +100,36 @@ def test_wn_noise(sve_logistic, stat, lambda_, positive_only):
     Gl_n = smpl.fit(Giw_n)
     np.testing.assert_allclose(Gl, Gl_n,
                 atol=12 * np.sqrt(1 + positive_only) * noise * Gl_magn, rtol=0)
+
+
+@pytest.mark.parametrize("stat, lambda_", [('F', 42)])
+@pytest.mark.parametrize("positive_only", [False, True])
+def test_wn_eval_other(sve_logistic, stat, lambda_, positive_only):
+    basis = sparse_ir.FiniteTempBasis(stat, 1, lambda_,
+                                      sve_result=sve_logistic[lambda_])
+    smpl = sparse_ir.MatsubaraSampling(basis, positive_only=positive_only)
+
+    n2 = [1, 3, 7]
+    smpl2 = sparse_ir.MatsubaraSampling(basis, sampling_points=n2)
+
+    rhol = basis.v([+.998, -.01, .5]) @ [0.8, -.2, 0.5]
+    Gl = basis.s * rhol
+    Gl_magn = np.linalg.norm(Gl)
+    np.testing.assert_allclose(smpl.evaluate(Gl, points=n2), smpl2.evaluate(Gl),
+                               rtol=1e-15 * Gl_magn)
+
+
+@pytest.mark.parametrize("stat, lambda_", [('F', 42)])
+def test_tau_eval_other(sve_logistic, stat, lambda_):
+    basis = sparse_ir.FiniteTempBasis(stat, 1, lambda_,
+                                      sve_result=sve_logistic[lambda_])
+    smpl = sparse_ir.TauSampling(basis)
+
+    n2 = (0.1, 0.4)
+    smpl2 = sparse_ir.TauSampling(basis, sampling_points=n2)
+
+    rhol = basis.v([+.998, -.01, .5]) @ [0.8, -.2, 0.5]
+    Gl = basis.s * rhol
+    Gl_magn = np.linalg.norm(Gl)
+    np.testing.assert_allclose(smpl.evaluate(Gl, points=n2), smpl2.evaluate(Gl),
+                               rtol=1e-15 * Gl_magn)

sparse-ir-1.0.0/PKG-INFO

@@ -1,147 +0,0 @@
-Metadata-Version: 2.1
-Name: sparse-ir
-Version: 1.0.0
-Summary: intermediate representation (IR) basis for electronic propagator
-Home-page: https://github.com/SpM-lab/sparse-ir
-Author: ['Markus Wallerberger', 'Hiroshi Shinaoka', 'Kazuyoshi Yoshimi', 'Junya Otsuki', 'Chikano Naoya']
-Author-email: markus.wallerberger@tuwien.ac.at
-License: UNKNOWN
-Description: 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[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.
-        
-        Install via `conda <https://anaconda.org/spm-lab/sparse-ir>`_::
-        
-            conda install -c spm-lab sparse-ir xprec
-        
-        Other than the optional xprec dependency, sparse-ir requires only
-        `numpy <https://numpy.org/>`_ and `scipy <https://scipy.org/>`_.
-        
-        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]
-        
-        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)
-        `Fortran library`_ 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
-        
-        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., `arXiv 2206.11762`_ (2022)
-        
-        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
-        .. _arXiv 2206.11762: https://doi.org/10.48550/arXiv.2206.11762
-        .. _Phys. Rev. B 101, 205145: https://doi.org/10.1103/PhysRevB.101.205145
-        
-Keywords: irbasis many-body propagator svd
-Platform: UNKNOWN
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Science/Research
-Classifier: Topic :: Scientific/Engineering :: Physics
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3
-Description-Content-Type: text/x-rst
-Provides-Extra: doc
-Provides-Extra: test
-Provides-Extra: xprec

sparse-ir-1.0.0/src/sparse_ir.egg-info/PKG-INFO

@@ -1,147 +0,0 @@
-Metadata-Version: 2.1
-Name: sparse-ir
-Version: 1.0.0
-Summary: intermediate representation (IR) basis for electronic propagator
-Home-page: https://github.com/SpM-lab/sparse-ir
-Author: ['Markus Wallerberger', 'Hiroshi Shinaoka', 'Kazuyoshi Yoshimi', 'Junya Otsuki', 'Chikano Naoya']
-Author-email: markus.wallerberger@tuwien.ac.at
-License: UNKNOWN
-Description: 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[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.
-        
-        Install via `conda <https://anaconda.org/spm-lab/sparse-ir>`_::
-        
-            conda install -c spm-lab sparse-ir xprec
-        
-        Other than the optional xprec dependency, sparse-ir requires only
-        `numpy <https://numpy.org/>`_ and `scipy <https://scipy.org/>`_.
-        
-        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]
-        
-        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)
-        `Fortran library`_ 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
-        
-        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., `arXiv 2206.11762`_ (2022)
-        
-        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
-        .. _arXiv 2206.11762: https://doi.org/10.48550/arXiv.2206.11762
-        .. _Phys. Rev. B 101, 205145: https://doi.org/10.1103/PhysRevB.101.205145
-        
-Keywords: irbasis many-body propagator svd
-Platform: UNKNOWN
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Science/Research
-Classifier: Topic :: Scientific/Engineering :: Physics
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3
-Description-Content-Type: text/x-rst
-Provides-Extra: doc
-Provides-Extra: test
-Provides-Extra: xprec