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

{sparse_ir-2.1.2/src/sparse_ir.egg-info → sparse_ir-2.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sparse-ir
-Version: 2.1.2
+Version: 2.1.3
 Summary: Python bindings for the libsparseir library, providing efficient sparse intermediate representation for many-body physics calculations
 Author: SpM-lab
 License-Expression: MIT

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

@@ -1,6 +1,6 @@
 [project]
 name = "sparse-ir"
-version = "2.1.2"
+version = "2.1.3"
 description = "Python bindings for the libsparseir library, providing efficient sparse intermediate representation for many-body physics calculations"
 readme = "README.rst"
 requires-python = ">=3.10"

{sparse_ir-2.1.2 → sparse_ir-2.1.3}/src/sparse_ir/dlr.py

@@ -11,7 +11,12 @@ import ctypes
 import numpy as np
 from .abstract import AbstractBasis
 from pylibsparseir.core import basis_get_default_omega_sampling_points
-from pylibsparseir.core import _lib, COMPUTATION_SUCCESS, get_default_blas_backend
+from pylibsparseir.core import (
+    _lib,
+    COMPUTATION_SUCCESS,
+    get_default_blas_backend,
+    c_double_complex,
+)
 from pylibsparseir.constants import SPIR_ORDER_ROW_MAJOR
 
 class DiscreteLehmannRepresentation(AbstractBasis):
@@ -116,7 +121,6 @@ class DiscreteLehmannRepresentation(AbstractBasis):
 
         output_dims = list(gl.shape)
         output_dims[axis] = self.size
-        output = np.zeros(output_dims, dtype=gl.dtype)
 
         ndim = len(gl.shape)
         input_dims = np.asarray(gl.shape, dtype=np.int32)
@@ -124,6 +128,7 @@ class DiscreteLehmannRepresentation(AbstractBasis):
         order = SPIR_ORDER_ROW_MAJOR
 
         if gl.dtype.kind == 'f':
+            output = np.zeros(output_dims, dtype=np.float64)
             ret = _lib.spir_ir2dlr_dd(
                 self._ptr,
                 self._backend,
@@ -135,6 +140,8 @@ class DiscreteLehmannRepresentation(AbstractBasis):
                 output.ctypes.data_as(ctypes.POINTER(ctypes.c_double)),
             )
         elif gl.dtype.kind == 'c':
+            gl = np.ascontiguousarray(gl, dtype=np.complex128)
+            output_c = np.zeros(output_dims, dtype=c_double_complex)
             ret = _lib.spir_ir2dlr_zz(
                 self._ptr,
                 self._backend,
@@ -142,10 +149,10 @@ class DiscreteLehmannRepresentation(AbstractBasis):
                 ndim,
                 input_dims.ctypes.data_as(ctypes.POINTER(ctypes.c_int32)),
                 target_dim,
-                # TODO: use complex data
-                gl.ctypes.data_as(ctypes.POINTER(ctypes.c_double)),
-                output.ctypes.data_as(ctypes.POINTER(ctypes.c_double)),
+                gl.ctypes.data_as(ctypes.POINTER(c_double_complex)),
+                output_c.ctypes.data_as(ctypes.POINTER(c_double_complex)),
             )
+            output = output_c['real'] + 1j * output_c['imag']
         else:
             raise ValueError(f"Unsupported dtype: {gl.dtype}")
         if ret != COMPUTATION_SUCCESS:
@@ -174,13 +181,13 @@ class DiscreteLehmannRepresentation(AbstractBasis):
             raise ValueError(f"Input array has wrong size along dimension {axis}")
         output_dims = np.asarray(g_dlr.shape, dtype=np.int32)
         output_dims[axis] = self.basis.size
-        output = np.zeros(output_dims, dtype=g_dlr.dtype)
         ndim = len(g_dlr.shape)
         input_dims = np.asarray(g_dlr.shape, dtype=np.int32)
         target_dim = axis
         order = SPIR_ORDER_ROW_MAJOR
 
         if g_dlr.dtype.kind == 'f':
+            output = np.zeros(output_dims, dtype=np.float64)
             ret = _lib.spir_dlr2ir_dd(
                 self._ptr,
                 self._backend,
@@ -192,6 +199,8 @@ class DiscreteLehmannRepresentation(AbstractBasis):
                 output.ctypes.data_as(ctypes.POINTER(ctypes.c_double)),
             )
         elif g_dlr.dtype.kind == 'c':
+            g_dlr = np.ascontiguousarray(g_dlr, dtype=np.complex128)
+            output_c = np.zeros(output_dims, dtype=c_double_complex)
             ret = _lib.spir_dlr2ir_zz(
                 self._ptr,
                 self._backend,
@@ -199,10 +208,10 @@ class DiscreteLehmannRepresentation(AbstractBasis):
                 ndim,
                 input_dims.ctypes.data_as(ctypes.POINTER(ctypes.c_int)),
                 target_dim,
-                # TODO: use complex data
-                g_dlr.ctypes.data_as(ctypes.POINTER(ctypes.c_double)),
-                output.ctypes.data_as(ctypes.POINTER(ctypes.c_double)),
+                g_dlr.ctypes.data_as(ctypes.POINTER(c_double_complex)),
+                output_c.ctypes.data_as(ctypes.POINTER(c_double_complex)),
             )
+            output = output_c['real'] + 1j * output_c['imag']
         else:
             raise ValueError(f"Unsupported dtype: {g_dlr.dtype}")
         if ret != COMPUTATION_SUCCESS:

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

@@ -313,7 +313,16 @@ class MatsubaraSampling:
         """
         Fit basis coefficients from Matsubara frequency values.
         """
-        ax = np.ascontiguousarray(ax)
+        ax = np.asarray(ax)
+        if ax.dtype.kind not in ("f", "c"):
+            raise ValueError(f"Unsupported dtype: {ax.dtype}")
+        # The underlying C entry point (spir_sampling_fit_zz) always expects
+        # complex128 data. Real-valued input must be normalized to
+        # complex128 here; otherwise the raw buffer of a float64 array would
+        # be reinterpreted as complex128 (reading twice as many bytes as
+        # were allocated), producing an out-of-bounds read and silent
+        # garbage output instead of a clear error.
+        ax = np.ascontiguousarray(ax, dtype=np.complex128)
         ndim = len(ax.shape)
         input_dims = np.asarray(ax.shape, dtype=np.int32)
         output_dims = list(ax.shape)

{sparse_ir-2.1.2 → sparse_ir-2.1.3/src/sparse_ir.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sparse-ir
-Version: 2.1.2
+Version: 2.1.3
 Summary: Python bindings for the libsparseir library, providing efficient sparse intermediate representation for many-body physics calculations
 Author: SpM-lab
 License-Expression: MIT

{sparse_ir-2.1.2 → sparse_ir-2.1.3}/tests/test_dlr.py

@@ -76,3 +76,37 @@ def test_boson():
     gl_pole2 = sp.to_IR(coeff)
 
     np.testing.assert_allclose(gl_pole, gl_pole2, atol=300*eps, rtol=0)
+
+
+def test_complex_roundtrip():
+    """Regression test: from_IR/to_IR must support complex128 coefficients
+    (e.g. off-diagonal Green's functions) instead of raising a ctypes
+    TypeError when the complex path is exercised.
+
+    Mirrors test_compression's poles-based construction (so that the IR
+    coefficients actually lie in the DLR's representable subspace and the
+    round trip is expected to be near-exact), but with complex coefficients.
+    """
+    beta = 10_000
+    wmax = 1
+    eps = 1e-12
+    basis = FiniteTempBasis("F", beta, wmax, eps=eps)
+
+    dlr = DiscreteLehmannRepresentation(basis)
+
+    rng = np.random.default_rng(42)
+    num_poles = 10
+    poles = wmax * (2 * rng.random(num_poles) - 1)
+    coeffs = (2 * rng.random(num_poles) - 1) + 1j * (2 * rng.random(num_poles) - 1)
+
+    Gl = DiscreteLehmannRepresentation(basis, poles).to_IR(coeffs)
+    assert np.iscomplexobj(Gl)
+
+    g_dlr = dlr.from_IR(Gl)
+    assert np.iscomplexobj(g_dlr)
+
+    Gl_recovered = dlr.to_IR(g_dlr)
+    assert np.iscomplexobj(Gl_recovered)
+
+    np.testing.assert_allclose(Gl, Gl_recovered, atol=300 * eps, rtol=0)
+    np.testing.assert_allclose(Gl.imag, Gl_recovered.imag, atol=300 * eps, rtol=0)

{sparse_ir-2.1.2 → sparse_ir-2.1.3}/tests/test_sampling.py

@@ -56,6 +56,21 @@ class TestTauSampling:
             error = np.max(np.abs(al_original - al_recovered))
             assert error < 1e-12, f"Roundtrip error too large: {error}"
 
+    def test_evaluate_fit_roundtrip_complex(self, basis):
+        """Complex coefficients (e.g. off-diagonal G) must roundtrip with
+        their imaginary part intact."""
+        sampling = sparse_ir.TauSampling(basis)
+        rng = np.random.default_rng(42)
+        al_original = rng.normal(size=basis.size) + 1j * rng.normal(size=basis.size)
+
+        ax = sampling.evaluate(al_original)
+        assert np.iscomplexobj(ax)
+        al_recovered = sampling.fit(ax)
+
+        assert np.iscomplexobj(al_recovered)
+        assert np.max(np.abs(al_original - al_recovered)) < 1e-12
+        assert np.max(np.abs(al_original.imag - al_recovered.imag)) < 1e-12
+
     def test_evaluate_shape(self, basis):
         """Test evaluate output shape."""
         sampling = sparse_ir.TauSampling(basis)
@@ -114,6 +129,41 @@ class TestMatsubaraSampling:
         assert len(sampling.wn) == len(custom_wn)
         np.testing.assert_array_equal(sampling.wn, custom_wn)
 
+    def test_evaluate_fit_roundtrip_complex(self, basis):
+        """Complex coefficients (e.g. off-diagonal G) must roundtrip with
+        their imaginary part intact."""
+        sampling = sparse_ir.MatsubaraSampling(basis)
+        rng = np.random.default_rng(42)
+        al_original = rng.normal(size=basis.size) + 1j * rng.normal(size=basis.size)
+
+        ax = sampling.evaluate(al_original)
+        al_recovered = sampling.fit(ax)
+
+        assert np.iscomplexobj(al_recovered)
+        assert np.max(np.abs(al_original - al_recovered)) < 1e-12
+        assert np.max(np.abs(al_original.imag - al_recovered.imag)) < 1e-12
+
+    def test_fit_real_input_matches_complex_reference(self, basis):
+        """Regression test: MatsubaraSampling.fit with real float64 input
+        must not be silently misread as complex128 data (out-of-bounds
+        read producing garbage). The real-input result must agree with
+        the complex128 reference obtained by fitting the same values cast
+        to complex128."""
+        sampling = sparse_ir.MatsubaraSampling(basis)
+        rng = np.random.default_rng(42)
+        al_original = rng.normal(size=basis.size)
+
+        ax = sampling.evaluate(al_original)
+        # ax is complex (Matsubara values are always complex); take the
+        # real part to exercise the real-dtype input code path of fit().
+        ax_real = np.ascontiguousarray(ax.real)
+        ax_complex_ref = np.ascontiguousarray(ax_real, dtype=np.complex128)
+
+        al_from_real = sampling.fit(ax_real)
+        al_from_complex_ref = sampling.fit(ax_complex_ref)
+
+        assert np.max(np.abs(al_from_real - al_from_complex_ref)) < 1e-12
+
     def test_repr(self, basis):
         """Test string representation."""
         sampling = sparse_ir.MatsubaraSampling(basis)