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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sparse-ir
-Version: 2.1.2
+Version: 2.1.4
 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.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sparse-ir"
-version = "2.1.2"
+version = "2.1.4"
 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.4}/src/sparse_ir/__init__.py

@@ -30,12 +30,12 @@ __all__ = [
     'AbstractBasis', 'FiniteTempBasis', 'finite_temp_bases',
     'TauSampling', 'MatsubaraSampling', 'FiniteTempBasisSet',
     'LogisticKernel', 'RegularizedBoseKernel',
-    'SVEResult', 'compute',
+    'SVEResult', 'compute', 'compute_sve',
 
     # Augmented functionality
     'AugmentedBasis', 'AugmentedTauFunction', 'AugmentedMatsubaraFunction',
     'AbstractAugmentation', 'TauConst', 'TauLinear', 'MatsubaraConst',
 
     # DLR functionality
-    'DiscreteLehmannRepresentation', 'TauPoles', 'MatsubaraPoles',
+    'DiscreteLehmannRepresentation',
 ]

sparse_ir-2.1.4/src/sparse_ir/_util.py

@@ -0,0 +1,298 @@
+# Copyright (C) 2020-2025 Satoshi Terasaki, Markus Wallerberger, Hiroshi Shinaoka, and others
+# SPDX-License-Identifier: MIT
+import functools
+import numpy as np
+
+
+def ravel_argument(last_dim=False):
+    """Wrap function operating on 1-D numpy array to allow arbitrary shapes.
+
+    This decorator allows to write functions which only need to operate over
+    one-dimensional (ravelled) arrays.  This often simplifies the "shape logic"
+    of the computation.
+    """
+    return lambda fn: RavelArgumentDecorator(fn, last_dim)
+
+
+class RavelArgumentDecorator(object):
+    def __init__(self, inner, last_dim=False):
+        self.instance = None
+        self.inner = inner
+        self.last_dim = last_dim
+        functools.update_wrapper(self, inner)
+
+    def __get__(self, instance, _owner=None):
+        self.instance = instance
+        return self
+
+    def __call__(self, x):
+        x = np.asarray(x)
+        if self.instance is None:
+            res = self.inner(x.ravel())
+        else:
+            res = self.inner(self.instance, x.ravel())
+        if self.last_dim:
+            return res.reshape(res.shape[:-1] + x.shape)
+        else:
+            return res.reshape(x.shape + res.shape[1:])
+
+
+# Element-type kinds that can be widened to float64 without losing
+# information about what the caller meant: bool, signed/unsigned integer,
+# and floating point.  Complex is deliberately excluded.
+_REAL_KINDS = "biuf"
+
+
+def check_reduced_matsubara(n, zeta=None):
+    """Checks that ``n`` is a reduced Matsubara frequency.
+
+    Check that the argument is a reduced Matsubara frequency, which is an
+    integer obtained by scaling the freqency `w[n]` as follows::
+
+        beta / np.pi * w[n] == 2 * n + zeta
+
+    Note that this means that instead of a fermionic frequency (``zeta == 1``),
+    we expect an odd integer, while for a bosonic frequency (``zeta == 0``),
+    we expect an even one.  If ``zeta`` is omitted, any one is fine.
+
+    Raises:
+        TypeError: if ``n`` is complex.
+        ValueError: if ``n`` is not integral (naming the offending value) or
+            has the wrong parity.
+    """
+    n = np.asarray(n)
+    if n.dtype.kind == 'c':
+        raise TypeError(
+            f"reduced Matsubara frequency must be real, got dtype {n.dtype}")
+    if not np.issubdtype(n.dtype, np.integer):
+        if n.dtype.kind not in _REAL_KINDS:
+            raise TypeError(
+                f"reduced Matsubara frequency must be numeric, "
+                f"got dtype {n.dtype}")
+        nfloat = np.asarray(n, dtype=np.float64)
+        if not np.all(np.isfinite(nfloat)):
+            raise ValueError(
+                "reduced Matsubara frequency must be finite, got "
+                f"{nfloat[~np.isfinite(nfloat)][0]!r}")
+        n = np.rint(nfloat).astype(np.int64)
+        bad = n != nfloat
+        if bad.any():
+            offending = np.atleast_1d(nfloat)[np.atleast_1d(bad)][0]
+            raise ValueError(
+                "reduced Matsubara frequency must be an integer, got "
+                f"{offending!r} (no truncation is performed)")
+    if zeta is not None:
+        parity = np.asarray(n) & 1
+        if not (parity == zeta).all():
+            expected = "odd" if zeta else "even"
+            offending = np.atleast_1d(n)[np.atleast_1d(parity != zeta)][0]
+            raise ValueError(
+                f"reduced Matsubara frequency must be {expected} for "
+                f"zeta={zeta}, got {offending!r}")
+    return n
+
+
+def _check_finite(arr, name):
+    if arr.size and not np.all(np.isfinite(arr)):
+        pos = tuple(int(i) for i in np.argwhere(~np.isfinite(arr))[0])
+        raise ValueError(
+            f"{name} must be finite, but contains {arr[pos]!r} at index "
+            f"{pos[0] if arr.ndim == 1 else pos}")
+    return arr
+
+
+def as_boundary_real(a, name="array", check_finite=True):
+    """Normalize ``a`` into a C-contiguous ``float64`` array for the C boundary.
+
+    The returned object is the one whose pointer must be handed to C: a
+    pointer taken from the *original* array would be a defect if a copy was
+    made here (see ``rules/ffi-boundary.md``, Pointer Provenance).
+
+    Raises:
+        TypeError: if ``a`` is complex or of a non-numeric element type.
+        ValueError: if ``a`` contains a non-finite value.
+    """
+    arr = np.asarray(a)
+    if arr.dtype.kind == 'c':
+        raise TypeError(
+            f"{name} must be real-valued, got dtype {arr.dtype}; "
+            "the C entry point takes a double pointer")
+    if arr.dtype.kind not in _REAL_KINDS:
+        raise TypeError(f"{name} has unsupported dtype {arr.dtype}")
+    out = np.ascontiguousarray(arr, dtype=np.float64)
+    if check_finite:
+        _check_finite(out, name)
+    return out
+
+
+def as_boundary_complex(a, name="array", check_finite=True):
+    """Normalize ``a`` into a C-contiguous ``complex128`` array.
+
+    ``complex64`` is *not* ``complex128``: passing its buffer through a
+    ``c_double_complex`` pointer would read twice as many bytes per element
+    as were allocated, so the conversion here is explicit and the pointer
+    must be taken from the returned object.
+    """
+    arr = np.asarray(a)
+    if arr.dtype.kind not in _REAL_KINDS + "c":
+        raise TypeError(f"{name} has unsupported dtype {arr.dtype}")
+    out = np.ascontiguousarray(arr, dtype=np.complex128)
+    if check_finite:
+        _check_finite(out, name)
+    return out
+
+
+def as_boundary_matsubara(n, name="Matsubara indices", zeta=None):
+    """Normalize reduced Matsubara indices into a C-contiguous ``int64`` array.
+
+    Validates integrality (and, if ``zeta`` is given, parity) *before* the
+    conversion, so a non-integral index raises instead of being truncated.
+    """
+    checked = check_reduced_matsubara(n, zeta=zeta)
+    return np.ascontiguousarray(checked, dtype=np.int64)
+
+
+def normalize_axis(axis, ndim):
+    """Resolve a possibly negative ``axis`` against ``ndim`` and range-check it.
+
+    The C API takes a non-negative target dimension; a negative Python axis
+    must be resolved here rather than handed through.
+    """
+    axis = int(axis)
+    resolved = axis + ndim if axis < 0 else axis
+    if not 0 <= resolved < ndim:
+        raise IndexError(
+            f"axis {axis} is out of bounds for an array of dimension {ndim} "
+            f"(valid: {-ndim} .. {ndim - 1})")
+    return resolved
+
+
+def resolve_function_indices(index, size):
+    """Resolve a basis-function index, list of indices, or slice.
+
+    Negative indices are resolved explicitly (Python semantics); an index
+    outside ``[-size, size)`` raises :class:`IndexError` naming the requested
+    index and the valid range.  No modulo wrap-around is performed.
+    """
+    if isinstance(index, slice):
+        return list(range(*index.indices(size)))
+
+    idx = np.asarray(index)
+    if idx.dtype.kind == 'c':
+        raise TypeError(
+            f"basis-function index must be an integer, got dtype {idx.dtype}")
+    if idx.dtype.kind not in _REAL_KINDS:
+        raise TypeError(
+            f"basis-function index must be an integer, got dtype {idx.dtype}")
+    if idx.dtype.kind == 'f':
+        rounded = np.rint(idx)
+        if not np.array_equal(rounded, idx):
+            offending = np.atleast_1d(idx)[np.atleast_1d(rounded != idx)][0]
+            raise ValueError(
+                f"basis-function index must be an integer, got {offending!r} "
+                "(no truncation is performed)")
+        idx = rounded.astype(np.int64)
+
+    flat = np.atleast_1d(idx).ravel()
+    resolved = []
+    for i in flat.tolist():
+        j = i + size if i < 0 else i
+        if not 0 <= j < size:
+            raise IndexError(
+                f"basis-function index {i} is out of range for a function set "
+                f"of size {size} (valid: {-size} .. {size - 1})")
+        resolved.append(int(j))
+    return resolved
+
+
+def check_range(x, xmin, xmax):
+    """Checks each element is in range [xmin, xmax]"""
+    x = np.asarray(x)
+    if not (x >= xmin).all():
+        raise ValueError(f"Some x violate lower bound {xmin}")
+    if not (x <= xmax).all():
+        raise ValueError(f"Some x violate upper bound {xmax}")
+    return x
+
+
+def normalize_tau(statistics, tau, beta):
+    """Normalize τ to [0, β] with statistics-dependent periodicity.
+    
+    Handles boundary conditions based on statistics:
+    - Fermions ('F'): Anti-periodic G(τ + β) = -G(τ)
+    - Bosons ('B'): Periodic G(τ + β) = G(τ)
+    
+    This function maps τ values from the range [-β, β] to [0, β] with
+    appropriate sign factors, following the periodicity rules.
+    
+    Arguments:
+        statistics (str):
+            'F' for Fermionic or 'B' for Bosonic statistics.
+        tau (array_like):
+            Imaginary time value(s) in range [-β, β].
+        beta (float):
+            Inverse temperature.
+            
+    Returns:
+        tuple[ndarray, ndarray]:
+            (tau_normalized, sign) where:
+            - tau_normalized: τ values mapped to [0, β]
+            - sign: Sign factor (±1) for periodicity
+            
+    Raises:
+        ValueError: If tau is outside [-β, β] or statistics is invalid.
+        
+    Special cases:
+        - Negative zero (τ = -0.0) is treated as τ = β with appropriate sign
+        - For τ in [0, β]: returns (τ, +1)
+        - For τ in [-β, 0): returns (τ + β, sign) where sign depends on statistics
+        
+    .. versionadded:: 1.2
+    """
+    tau = np.asarray(tau, dtype=np.float64)
+    beta = float(beta)
+    
+    if statistics not in ('F', 'B'):
+        raise ValueError("statistics must be 'F' (Fermionic) or 'B' (Bosonic)")
+    
+    if np.any(tau < -beta) or np.any(tau > beta):
+        raise ValueError(f"τ must be in [-β, β] = [{-beta}, {beta}]")
+    
+    # Handle negative zero: τ = -0.0 → τ = β
+    is_neg_zero = (tau == 0.0) & np.signbit(tau)
+    
+    tau_normalized = np.where(is_neg_zero, beta, tau)
+    sign = np.ones_like(tau, dtype=np.float64)
+    
+    if statistics == 'F':
+        # Fermionic: anti-periodic
+        sign = np.where(is_neg_zero, -1.0, sign)
+    else:  # statistics == 'B'
+        # Bosonic: periodic
+        sign = np.where(is_neg_zero, 1.0, sign)
+    
+    # Normalize negative tau to [0, β]
+    mask_neg = tau_normalized < 0
+    tau_normalized = np.where(mask_neg, tau_normalized + beta, tau_normalized)
+    
+    if statistics == 'F':
+        sign = np.where(mask_neg, -sign, sign)
+    
+    return tau_normalized, sign
+
+
+def check_svd_result(svd_result, matrix_shape=None):
+    """Checks that argument is a valid SVD triple (u, s, vH)"""
+    u, s, vH = map(np.asarray, svd_result)
+    m_u, k_u = u.shape
+    k_s, = s.shape
+    k_v, n_v = vH.shape
+    if k_u != k_s or k_s != k_v:
+        raise ValueError("shape mismatch between SVD elements:"
+                         f"({m_u}, {k_u}) x ({k_s}) x ({k_v}, {n_v})")
+    if matrix_shape is not None:
+        m, n = matrix_shape
+        if m_u != m or n_v != n:
+            raise ValueError(f"shape mismatch between SVD ({m_u}, {n_v}) "
+                             f"and matrix ({m}, {n})")
+    return u, s, vH

{sparse_ir-2.1.2 → sparse_ir-2.1.4}/src/sparse_ir/augment.py

@@ -77,7 +77,7 @@ class AugmentedBasis(abstract.AbstractBasis):
         return self._basis.statistics
 
     def __getitem__(self, index):
-        stop = basis._slice_to_size(index)
+        stop = _slice_to_size(index, self.size)
         if stop <= self._naug:
             raise ValueError("Cannot truncate to only augmentation")
         return AugmentedBasis(self._basis[:stop - self._naug],
@@ -202,7 +202,7 @@ class _AugmentedFunction:
     def __getitem__(self, l):
         # TODO make this more general
         if isinstance(l, slice):
-            stop = basis._slice_to_size(l)
+            stop = _slice_to_size(l, self.size)
             if stop <= self._naug:
                 raise NotImplementedError("Don't truncate to only augmentation")
             return _AugmentedFunction(self._fbasis[:stop-self._naug], self._faug)
@@ -221,13 +221,13 @@ class AugmentedTauFunction(_AugmentedFunction):
 
     @property
     def xmax(self):
-        return self._fbasis.xmin
+        return self._fbasis.xmax
 
     def deriv(self, n=1):
         """Get polynomial for the n'th derivative"""
         dbasis = self._fbasis.deriv(n)
         daug = [faug_l.deriv(n) for faug_l in self._faug]
-        return AugmentedTauFunction(dbasis, *daug)
+        return AugmentedTauFunction(dbasis, daug)
 
 
 class AugmentedMatsubaraFunction(_AugmentedFunction):
@@ -291,6 +291,12 @@ class TauConst(AbstractAugmentation):
             raise ValueError("temperature must be positive")
         if statistics not in ('F', 'B'):
             raise ValueError("statistics must be 'F' or 'B'")
+        # A fermionic TauConst is not merely ill-conditioned, it is useless:
+        # its Fourier transform is sqrt(beta) * (n == 0), and fermionic reduced
+        # frequencies are odd, so the augmentation column vanishes identically
+        # and the augmented basis is rank-deficient.  Refuse instead of
+        # silently returning a singular fit.
+        _check_bosonic_statistics(statistics)
         self._beta = beta
         self._statistics = statistics
 
@@ -406,6 +412,31 @@ class MatsubaraConst(AbstractAugmentation):
         return np.broadcast_to(1.0, n.shape)
 
 
+def _slice_to_size(index, size):
+    """Return the number of basis functions selected by ``index``.
+
+    Only ``basis[:stop]``-style truncation is supported, mirroring
+    :py:meth:`FiniteTempBasis.__getitem__`.
+    """
+    if not isinstance(index, slice):
+        raise TypeError(
+            f"only slice truncation is supported, got {index!r}")
+    if index.start not in (None, 0):
+        raise ValueError(
+            f"basis truncation must start at 0, got {index.start!r}")
+    if index.step not in (None, 1):
+        raise ValueError(
+            f"basis truncation must have unit step, got {index.step!r}")
+    if index.stop is None:
+        return size
+    stop = int(index.stop)
+    if not 0 < stop <= size:
+        raise IndexError(
+            f"truncation to {stop} functions is out of range for a basis of "
+            f"size {size}")
+    return stop
+
+
 def _augmentation_factory(basis, *augs):
     for aug in augs:
         if isinstance(aug, AbstractAugmentation):
@@ -418,6 +449,10 @@ def _check_bosonic_statistics(statistics):
     if statistics == 'B':
         return
     elif statistics == 'F':
-        raise ValueError("term only allowed for bosonic basis")
+        raise ValueError(
+            "TauConst augmentation is only allowed for a bosonic basis: for "
+            "fermionic statistics its Fourier transform vanishes at every "
+            "(odd) reduced Matsubara frequency, which makes the augmented "
+            "basis rank-deficient")
     else:
-        raise ValueError("invalid statistics")
+        raise ValueError(f"invalid statistics {statistics!r}, expected 'F' or 'B'")

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

@@ -303,16 +303,16 @@ class FiniteTempBasis(AbstractBasis):
         temperature.  Note that this implies a different UV cutoff ``wmax``,
         since ``lambda_ == beta * wmax`` stays constant.
         """
-        # Calculate new beta and wmax that give the desired lambda
-        # We keep the ratio beta/wmax constant
-        ratio = self.beta / self.wmax
-        new_wmax = np.sqrt(new_lambda / ratio)
-        new_beta = new_lambda / new_wmax
-
-        # Get epsilon from the current basis accuracy
-        eps = self.accuracy
+        new_beta = float(new_beta)
+        if not new_beta > 0:
+            raise ValueError(
+                f"inverse temperature must be positive, got {new_beta!r}")
 
-        return FiniteTempBasis(self.statistics, new_beta, new_wmax, eps)
+        # lambda_ == beta * wmax is held fixed, so the SVE (which depends only
+        # on lambda_ and eps) can be reused as is.
+        new_wmax = self._lambda / new_beta
+        return FiniteTempBasis(self.statistics, new_beta, new_wmax, self._eps,
+                               kernel=self._kernel, sve_result=self._sve)
 
 
 def finite_temp_bases(beta, wmax, eps=None, sve_result=None):

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

@@ -11,8 +11,22 @@ 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,
+    basis_get_u,
+    basis_get_uhat,
+)
 from pylibsparseir.constants import SPIR_ORDER_ROW_MAJOR
+from . import _util
+from .poly import (
+    FunctionSet,
+    FunctionSetFT,
+    PiecewiseLegendrePolyVector,
+    PiecewiseLegendrePolyFTVector,
+)
 
 class DiscreteLehmannRepresentation(AbstractBasis):
     """Discrete Lehmann representation (DLR), with poles being extrema of IR.
@@ -41,18 +55,65 @@ class DiscreteLehmannRepresentation(AbstractBasis):
         status = ctypes.c_int()
         if poles is None:
             poles = basis_get_default_omega_sampling_points(basis._ptr)
+        # Normalize first, then take the pointer from the *normalized* object.
+        # Taking it from the caller's array instead silently hands C the
+        # buffer of a non-contiguous or non-float64 array.
+        poles = _util.as_boundary_real(poles, "poles")
+        if poles.ndim != 1:
+            raise ValueError(
+                f"poles must be one-dimensional, got shape {poles.shape}")
+        if poles.size == 0:
+            raise ValueError("poles must not be empty")
         self._basis = basis
-        self._poles = np.ascontiguousarray(poles)
+        self._poles = poles
+        self._u = None
+        self._uhat = None
         self._backend = get_default_blas_backend()
-        self._ptr = _lib.spir_dlr_new_with_poles(basis._ptr, len(poles), poles.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), status)
+        self._ptr = _lib.spir_dlr_new_with_poles(
+            basis._ptr,
+            poles.size,
+            poles.ctypes.data_as(ctypes.POINTER(ctypes.c_double)),
+            status,
+        )
         if status.value != COMPUTATION_SUCCESS:
             raise RuntimeError(f"Failed to create DLR basis: {status.value}")
+        if not self._ptr:
+            raise RuntimeError("Failed to create DLR basis: null handle")
 
     @property
-    def u(self): return self._basis._u
+    def u(self):
+        r"""DLR basis functions on the imaginary-time axis.
+
+        These are the *DLR* basis functions, i.e. ``u[i](tau)`` is the
+        imaginary-time kernel evaluated at the ``i``-th pole, so that::
+
+            gtau == g_dlr @ dlr.u(tau)
+
+        holds for DLR coefficients ``g_dlr``.  They are **not** the basis
+        functions of the underlying IR basis.
+        """
+        if self._u is None:
+            beta = self._basis.beta
+            self._u = PiecewiseLegendrePolyVector(
+                FunctionSet(basis_get_u(self._ptr)),
+                -beta, beta, beta, default_overlap_range=(0, beta))
+        return self._u
 
     @property
-    def uhat(self): return self._basis._uhat
+    def uhat(self):
+        r"""DLR basis functions on the reduced Matsubara frequency axis.
+
+        ``uhat[i](n)`` is the Fourier transform of :py:attr:`u`, so that::
+
+            giv == g_dlr @ dlr.uhat(n)
+
+        holds for DLR coefficients ``g_dlr``.  They are **not** the Matsubara
+        basis functions of the underlying IR basis.
+        """
+        if self._uhat is None:
+            self._uhat = PiecewiseLegendrePolyFTVector(
+                FunctionSetFT(basis_get_uhat(self._ptr)))
+        return self._uhat
 
     @property
     def statistics(self):
@@ -110,20 +171,26 @@ class DiscreteLehmannRepresentation(AbstractBasis):
         array_like
             Expansion coefficients in DLR
         """
-        gl = np.ascontiguousarray(gl)
+        gl = np.asarray(gl)
+        if gl.ndim == 0:
+            raise ValueError("IR coefficients must be at least one-dimensional")
+        axis = _util.normalize_axis(axis, gl.ndim)
         if gl.shape[axis] != self.basis.size:
-            raise ValueError(f"Input array has wrong size along dimension {axis}")
+            raise ValueError(
+                f"IR coefficients have length {gl.shape[axis]} along axis "
+                f"{axis}, expected {self.basis.size}")
 
         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)
+        ndim = gl.ndim
+        input_dims = np.ascontiguousarray(gl.shape, dtype=np.int32)
         target_dim = axis
         order = SPIR_ORDER_ROW_MAJOR
 
-        if gl.dtype.kind == 'f':
+        if gl.dtype.kind != 'c':
+            gl = _util.as_boundary_real(gl, "IR coefficients")
+            output = np.zeros(output_dims, dtype=np.float64)
             ret = _lib.spir_ir2dlr_dd(
                 self._ptr,
                 self._backend,
@@ -134,7 +201,9 @@ class DiscreteLehmannRepresentation(AbstractBasis):
                 gl.ctypes.data_as(ctypes.POINTER(ctypes.c_double)),
                 output.ctypes.data_as(ctypes.POINTER(ctypes.c_double)),
             )
-        elif gl.dtype.kind == 'c':
+        else:
+            gl = _util.as_boundary_complex(gl, "IR coefficients")
+            output_c = np.zeros(output_dims, dtype=c_double_complex)
             ret = _lib.spir_ir2dlr_zz(
                 self._ptr,
                 self._backend,
@@ -142,12 +211,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)),
             )
-        else:
-            raise ValueError(f"Unsupported dtype: {gl.dtype}")
+            output = output_c['real'] + 1j * output_c['imag']
         if ret != COMPUTATION_SUCCESS:
             raise RuntimeError(f"Failed to convert IR to DLR: {ret}")
         return output
@@ -169,18 +236,24 @@ class DiscreteLehmannRepresentation(AbstractBasis):
         array_like
             Expansion coefficients in IR
         """
-        g_dlr = np.ascontiguousarray(g_dlr)
+        g_dlr = np.asarray(g_dlr)
+        if g_dlr.ndim == 0:
+            raise ValueError("DLR coefficients must be at least one-dimensional")
+        axis = _util.normalize_axis(axis, g_dlr.ndim)
         if g_dlr.shape[axis] != self.size:
-            raise ValueError(f"Input array has wrong size along dimension {axis}")
-        output_dims = np.asarray(g_dlr.shape, dtype=np.int32)
+            raise ValueError(
+                f"DLR coefficients have length {g_dlr.shape[axis]} along axis "
+                f"{axis}, expected {self.size}")
+        output_dims = list(g_dlr.shape)
         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)
+        ndim = g_dlr.ndim
+        input_dims = np.ascontiguousarray(g_dlr.shape, dtype=np.int32)
         target_dim = axis
         order = SPIR_ORDER_ROW_MAJOR
 
-        if g_dlr.dtype.kind == 'f':
+        if g_dlr.dtype.kind != 'c':
+            g_dlr = _util.as_boundary_real(g_dlr, "DLR coefficients")
+            output = np.zeros(output_dims, dtype=np.float64)
             ret = _lib.spir_dlr2ir_dd(
                 self._ptr,
                 self._backend,
@@ -191,7 +264,9 @@ class DiscreteLehmannRepresentation(AbstractBasis):
                 g_dlr.ctypes.data_as(ctypes.POINTER(ctypes.c_double)),
                 output.ctypes.data_as(ctypes.POINTER(ctypes.c_double)),
             )
-        elif g_dlr.dtype.kind == 'c':
+        else:
+            g_dlr = _util.as_boundary_complex(g_dlr, "DLR coefficients")
+            output_c = np.zeros(output_dims, dtype=c_double_complex)
             ret = _lib.spir_dlr2ir_zz(
                 self._ptr,
                 self._backend,
@@ -199,12 +274,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)),
             )
-        else:
-            raise ValueError(f"Unsupported dtype: {g_dlr.dtype}")
+            output = output_c['real'] + 1j * output_c['imag']
         if ret != COMPUTATION_SUCCESS:
             raise RuntimeError(f"Failed to convert DLR to IR: {ret}")
         return output