pylibsparseir 0.1.0__cp313-cp313-musllinux_1_2_x86_64.whl

pylibsparseir/clean_build_artifacts.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+"""
+Clean build artifacts and files copied by setup_build.py and included via MANIFEST.in
+"""
+
+import os
+import shutil
+import glob
+
+def clean_build_artifacts():
+    """Remove build artifacts and copied files."""
+    current_dir = os.getcwd()
+
+    # Directories and files to remove (from setup_build.py and build artifacts)
+    items_to_remove = [
+        'build',
+        'dist',
+        '*.egg-info',
+        'include',
+        'src',
+        'fortran',
+        'cmake',
+        'CMakeLists.txt'
+    ]
+
+    # Files in pylibsparseir to remove
+    pylibsparseir_patterns = [
+        'pylibsparseir/*.so',
+        'pylibsparseir/*.dylib',
+        'pylibsparseir/*.dll',
+        'pylibsparseir/__pycache__'
+    ]
+
+    print(f"Cleaning build artifacts in: {current_dir}")
+
+    # Remove main items
+    for item in items_to_remove:
+        if '*' in item:
+            # Handle glob patterns
+            for path in glob.glob(item):
+                if os.path.exists(path):
+                    if os.path.isdir(path):
+                        shutil.rmtree(path)
+                        print(f"Removed directory: {path}")
+                    else:
+                        os.remove(path)
+                        print(f"Removed file: {path}")
+        else:
+            # Handle direct paths
+            if os.path.exists(item):
+                if os.path.isdir(item):
+                    shutil.rmtree(item)
+                    print(f"Removed directory: {item}")
+                else:
+                    os.remove(item)
+                    print(f"Removed file: {item}")
+
+    # Remove pylibsparseir artifacts
+    for pattern in pylibsparseir_patterns:
+        for path in glob.glob(pattern):
+            if os.path.exists(path):
+                if os.path.isdir(path):
+                    shutil.rmtree(path)
+                    print(f"Removed directory: {path}")
+                else:
+                    os.remove(path)
+                    print(f"Removed file: {path}")
+
+    print("Clean completed!")
+
+if __name__ == "__main__":
+    clean_build_artifacts()

pylibsparseir/constants.py

@@ -0,0 +1,39 @@
+"""
+Constants used in the SparseIR C API.
+"""
+
+# Status codes
+COMPUTATION_SUCCESS = 0
+GET_IMPL_FAILED = -1
+INVALID_DIMENSION = -2
+INPUT_DIMENSION_MISMATCH = -3
+OUTPUT_DIMENSION_MISMATCH = -4
+NOT_SUPPORTED = -5
+INVALID_ARGUMENT = -6
+INTERNAL_ERROR = -7
+
+# SPIR prefixed constants for compatibility
+SPIR_COMPUTATION_SUCCESS = 0
+SPIR_GET_IMPL_FAILED = -1
+SPIR_INVALID_DIMENSION = -2
+SPIR_INPUT_DIMENSION_MISMATCH = -3
+SPIR_OUTPUT_DIMENSION_MISMATCH = -4
+SPIR_NOT_SUPPORTED = -5
+SPIR_INVALID_ARGUMENT = -6
+SPIR_INTERNAL_ERROR = -7
+
+# Statistics type constants
+SPIR_STATISTICS_FERMIONIC = 1
+SPIR_STATISTICS_BOSONIC = 0
+
+# Order type constants
+SPIR_ORDER_COLUMN_MAJOR = 1
+SPIR_ORDER_ROW_MAJOR = 0
+
+# Make sure these are available at module level
+SPIR_ORDER_ROW_MAJOR = 0
+SPIR_ORDER_COLUMN_MAJOR = 1
+
+# SVE Twork constants
+SPIR_TWORK_FLOAT64 = 0
+SPIR_TWORK_FLOAT64X2 = 1

pylibsparseir/core.py

@@ -0,0 +1,609 @@
+"""
+Core functionality for the SparseIR Python bindings.
+"""
+
+import os
+import sys
+import ctypes
+from ctypes import c_int, c_double, c_int64, c_size_t, c_bool, POINTER, byref
+from ctypes import CDLL
+import numpy as np
+
+from .ctypes_wrapper import spir_kernel, spir_sve_result, spir_basis, spir_funcs, spir_sampling
+from pylibsparseir.constants import COMPUTATION_SUCCESS, SPIR_ORDER_ROW_MAJOR, SPIR_ORDER_COLUMN_MAJOR, SPIR_TWORK_FLOAT64, SPIR_TWORK_FLOAT64X2, SPIR_STATISTICS_FERMIONIC, SPIR_STATISTICS_BOSONIC
+
+def _find_library():
+    """Find the SparseIR shared library."""
+    if sys.platform == "darwin":
+        libname = "libsparseir.dylib"
+    elif sys.platform == "win32":
+        libname = "sparseir.dll"
+    else:
+        libname = "libsparseir.so"
+
+    # Try to find the library in common locations
+    search_paths = [
+        os.path.dirname(os.path.abspath(__file__)),
+        os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "build"),
+        os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "build"),
+    ]
+
+    for path in search_paths:
+        libpath = os.path.join(path, libname)
+        if os.path.exists(libpath):
+            return libpath
+
+    raise RuntimeError(f"Could not find {libname} in {search_paths}")
+
+# Load the library
+try:
+    _lib = CDLL(_find_library())
+except Exception as e:
+    raise RuntimeError(f"Failed to load SparseIR library: {e}")
+
+class c_double_complex(ctypes.Structure):
+    """complex is a c structure
+    https://docs.python.org/3/library/ctypes.html#module-ctypes suggests
+    to use ctypes.Structure to pass structures (and, therefore, complex)
+    See: https://stackoverflow.com/questions/13373291/complex-number-in-ctypes
+    """
+    _fields_ = [("real", ctypes.c_double),("imag", ctypes.c_double)]
+    @property
+    def value(self):
+        return self.real+1j*self.imag # fields declared above
+
+# Set up function prototypes
+def _setup_prototypes():
+    # Kernel functions
+    _lib.spir_logistic_kernel_new.argtypes = [c_double, POINTER(c_int)]
+    _lib.spir_logistic_kernel_new.restype = spir_kernel
+
+    _lib.spir_reg_bose_kernel_new.argtypes = [c_double, POINTER(c_int)]
+    _lib.spir_reg_bose_kernel_new.restype = spir_kernel
+
+    _lib.spir_kernel_domain.argtypes = [
+        spir_kernel, POINTER(c_double), POINTER(c_double),
+        POINTER(c_double), POINTER(c_double)
+    ]
+    _lib.spir_kernel_domain.restype = c_int
+
+    # SVE result functions
+    _lib.spir_sve_result_new.argtypes = [spir_kernel, c_double, c_double, c_int, c_int, c_int, POINTER(c_int)]
+    _lib.spir_sve_result_new.restype = spir_sve_result
+
+    _lib.spir_sve_result_get_size.argtypes = [spir_sve_result, POINTER(c_int)]
+    _lib.spir_sve_result_get_size.restype = c_int
+
+    _lib.spir_sve_result_get_svals.argtypes = [spir_sve_result, POINTER(c_double)]
+    _lib.spir_sve_result_get_svals.restype = c_int
+
+    # Basis functions
+    _lib.spir_basis_new.argtypes = [
+        c_int, c_double, c_double, spir_kernel, spir_sve_result, c_int, POINTER(c_int)
+    ]
+    _lib.spir_basis_new.restype = spir_basis
+
+    _lib.spir_basis_get_size.argtypes = [spir_basis, POINTER(c_int)]
+    _lib.spir_basis_get_size.restype = c_int
+
+    _lib.spir_basis_get_svals.argtypes = [spir_basis, POINTER(c_double)]
+    _lib.spir_basis_get_svals.restype = c_int
+
+    _lib.spir_basis_get_stats.argtypes = [spir_basis, POINTER(c_int)]
+    _lib.spir_basis_get_stats.restype = c_int
+
+    # Basis function objects
+    _lib.spir_basis_get_u.argtypes = [spir_basis, POINTER(c_int)]
+    _lib.spir_basis_get_u.restype = spir_funcs
+
+    _lib.spir_basis_get_v.argtypes = [spir_basis, POINTER(c_int)]
+    _lib.spir_basis_get_v.restype = spir_funcs
+
+    _lib.spir_basis_get_uhat.argtypes = [spir_basis, POINTER(c_int)]
+    _lib.spir_basis_get_uhat.restype = spir_funcs
+
+    _lib.spir_funcs_get_slice.argtypes = [spir_funcs, c_int, POINTER(c_int), POINTER(c_int)]
+    _lib.spir_funcs_get_slice.restype = spir_funcs
+
+    # Function evaluation
+    _lib.spir_funcs_get_size.argtypes = [spir_funcs, POINTER(c_int)]
+    _lib.spir_funcs_get_size.restype = c_int
+
+    _lib.spir_funcs_eval.argtypes = [spir_funcs, c_double, POINTER(c_double)]
+    _lib.spir_funcs_eval.restype = c_int
+
+    _lib.spir_funcs_eval_matsu.argtypes = [spir_funcs, c_int64, POINTER(c_double_complex)]
+    _lib.spir_funcs_eval_matsu.restype = c_int
+
+    _lib.spir_funcs_batch_eval.argtypes = [
+        spir_funcs, c_int, c_size_t, POINTER(c_double), POINTER(c_double)
+    ]
+    _lib.spir_funcs_batch_eval.restype = c_int
+
+    _lib.spir_funcs_batch_eval_matsu.argtypes = [
+        spir_funcs, c_int, c_int, POINTER(c_int64), POINTER(c_double)
+    ]
+    _lib.spir_funcs_batch_eval_matsu.restype = c_int
+
+    _lib.spir_funcs_get_n_roots.argtypes = [spir_funcs, POINTER(c_int)]
+    _lib.spir_funcs_get_n_roots.restype = c_int
+
+    _lib.spir_funcs_get_roots.argtypes = [spir_funcs, POINTER(c_double)]
+    _lib.spir_funcs_get_roots.restype = c_int
+
+    # Default sampling points
+    _lib.spir_basis_get_n_default_taus.argtypes = [spir_basis, POINTER(c_int)]
+    _lib.spir_basis_get_n_default_taus.restype = c_int
+
+    _lib.spir_basis_get_default_taus.argtypes = [spir_basis, POINTER(c_double)]
+    _lib.spir_basis_get_default_taus.restype = c_int
+
+    _lib.spir_basis_get_default_taus_ext.argtypes = [spir_basis, c_int, POINTER(c_double), POINTER(c_int)]
+    _lib.spir_basis_get_default_taus_ext.restype = c_int
+
+    _lib.spir_basis_get_n_default_ws.argtypes = [spir_basis, POINTER(c_int)]
+    _lib.spir_basis_get_n_default_ws.restype = c_int
+
+    _lib.spir_basis_get_default_ws.argtypes = [spir_basis, POINTER(c_double)]
+    _lib.spir_basis_get_default_ws.restype = c_int
+
+    _lib.spir_basis_get_n_default_matsus.argtypes = [spir_basis, c_bool, POINTER(c_int)]
+    _lib.spir_basis_get_n_default_matsus.restype = c_int
+
+    _lib.spir_basis_get_n_default_matsus_ext.argtypes = [spir_basis, c_bool, c_int, POINTER(c_int)]
+    _lib.spir_basis_get_n_default_matsus_ext.restype = c_int
+
+    _lib.spir_basis_get_default_matsus.argtypes = [spir_basis, c_bool, POINTER(c_int64)]
+    _lib.spir_basis_get_default_matsus.restype = c_int
+
+    _lib.spir_basis_get_default_matsus_ext.argtypes = [spir_basis, c_bool, c_int, POINTER(c_int64), POINTER(c_int)]
+    _lib.spir_basis_get_default_matsus_ext.restype = c_int
+
+    # Sampling objects
+    _lib.spir_tau_sampling_new.argtypes = [spir_basis, c_int, POINTER(c_double), POINTER(c_int)]
+    _lib.spir_tau_sampling_new.restype = spir_sampling
+
+    _lib.spir_tau_sampling_new_with_matrix.argtypes = [c_int, c_int, c_int, c_int, POINTER(c_double), POINTER(c_double), POINTER(c_int)]
+    _lib.spir_tau_sampling_new_with_matrix.restype = spir_sampling
+
+    _lib.spir_matsu_sampling_new.argtypes = [spir_basis, c_bool, c_int, POINTER(c_int64), POINTER(c_int)]
+    _lib.spir_matsu_sampling_new.restype = spir_sampling
+
+    _lib.spir_matsu_sampling_new_with_matrix.argtypes = [
+        c_int,                          # order
+        c_int,                          # statistics
+        c_int,                          # basis_size
+        c_bool,                         # positive_only
+        c_int,                          # num_points
+        POINTER(c_int64),              # points
+        POINTER(c_double_complex),     # matrix
+        POINTER(c_int)                 # status
+    ]
+    _lib.spir_matsu_sampling_new_with_matrix.restype = spir_sampling
+
+    # Sampling operations
+    _lib.spir_sampling_eval_dd.argtypes = [
+        spir_sampling, c_int, c_int, POINTER(c_int), c_int,
+        POINTER(c_double), POINTER(c_double)
+    ]
+    _lib.spir_sampling_eval_dd.restype = c_int
+
+    _lib.spir_sampling_fit_dd.argtypes = [
+        spir_sampling, c_int, c_int, POINTER(c_int), c_int,
+        POINTER(c_double), POINTER(c_double)
+    ]
+    _lib.spir_sampling_fit_dd.restype = c_int
+
+    # Additional sampling functions
+    _lib.spir_sampling_get_npoints.argtypes = [spir_sampling, POINTER(c_int)]
+    _lib.spir_sampling_get_npoints.restype = c_int
+
+    _lib.spir_sampling_get_taus.argtypes = [spir_sampling, POINTER(c_double)]
+    _lib.spir_sampling_get_taus.restype = c_int
+
+    _lib.spir_sampling_get_matsus.argtypes = [spir_sampling, POINTER(c_int64)]
+    _lib.spir_sampling_get_matsus.restype = c_int
+
+    _lib.spir_sampling_get_cond_num.argtypes = [spir_sampling, POINTER(c_double)]
+    _lib.spir_sampling_get_cond_num.restype = c_int
+
+    # Multi-dimensional sampling evaluation functions
+    _lib.spir_sampling_eval_dz.argtypes = [
+        spir_sampling, c_int, c_int, POINTER(c_int), c_int,
+        POINTER(c_double), POINTER(c_double_complex)
+    ]
+    _lib.spir_sampling_eval_dz.restype = c_int
+
+    _lib.spir_sampling_eval_zz.argtypes = [
+        spir_sampling, c_int, c_int, POINTER(c_int), c_int,
+        POINTER(c_double_complex), POINTER(c_double_complex)
+    ]
+    _lib.spir_sampling_eval_zz.restype = c_int
+
+    _lib.spir_sampling_fit_zz.argtypes = [
+        spir_sampling, c_int, c_int, POINTER(c_int), c_int,
+        POINTER(c_double_complex), POINTER(c_double_complex)
+    ]
+    _lib.spir_sampling_fit_zz.restype = c_int
+
+    # DLR functions
+    _lib.spir_dlr_new.argtypes = [spir_basis, POINTER(c_int)]
+    _lib.spir_dlr_new.restype = spir_basis
+
+    _lib.spir_dlr_new_with_poles.argtypes = [spir_basis, c_int, POINTER(c_double), POINTER(c_int)]
+    _lib.spir_dlr_new_with_poles.restype = spir_basis
+
+    _lib.spir_dlr_get_npoles.argtypes = [spir_basis, POINTER(c_int)]
+    _lib.spir_dlr_get_npoles.restype = c_int
+
+    _lib.spir_dlr_get_poles.argtypes = [spir_basis, POINTER(c_double)]
+    _lib.spir_dlr_get_poles.restype = c_int
+
+    _lib.spir_dlr2ir_dd.argtypes = [
+        spir_basis, c_int, c_int, POINTER(c_int), c_int,
+        POINTER(c_double), POINTER(c_double)
+    ]
+    _lib.spir_dlr2ir_dd.restype = c_int
+
+    _lib.spir_dlr2ir_zz.argtypes = [
+        spir_basis, c_int, c_int, POINTER(c_int), c_int,
+        POINTER(c_double), POINTER(c_double)
+    ]
+    _lib.spir_dlr2ir_zz.restype = c_int
+
+    # Release functions
+    _lib.spir_kernel_release.argtypes = [spir_kernel]
+    _lib.spir_kernel_release.restype = None
+
+    _lib.spir_sve_result_release.argtypes = [spir_sve_result]
+    _lib.spir_sve_result_release.restype = None
+
+    _lib.spir_basis_release.argtypes = [spir_basis]
+    _lib.spir_basis_release.restype = None
+
+    _lib.spir_funcs_release.argtypes = [spir_funcs]
+    _lib.spir_funcs_release.restype = None
+
+    _lib.spir_sampling_release.argtypes = [spir_sampling]
+    _lib.spir_sampling_release.restype = None
+
+_setup_prototypes()
+
+# Python wrapper functions
+def logistic_kernel_new(lambda_val):
+    """Create a new logistic kernel."""
+    status = c_int()
+    kernel = _lib.spir_logistic_kernel_new(lambda_val, byref(status))
+    if status.value != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to create logistic kernel: {status.value}")
+    return kernel
+
+def reg_bose_kernel_new(lambda_val):
+    """Create a new regularized bosonic kernel."""
+    status = c_int()
+    kernel = _lib.spir_reg_bose_kernel_new(lambda_val, byref(status))
+    if status.value != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to create regularized bosonic kernel: {status.value}")
+    return kernel
+
+def sve_result_new(kernel, epsilon, cutoff=None, lmax=None, n_gauss=None, Twork=None):
+    """Create a new SVE result."""
+    # Validate epsilon
+    if epsilon <= 0:
+        raise RuntimeError(f"Failed to create SVE result: epsilon must be positive, got {epsilon}")
+
+    if cutoff is None:
+        cutoff = -1.0
+    if lmax is None:
+        lmax = -1
+    if n_gauss is None:
+        n_gauss = -1
+    if Twork is None:
+        Twork = SPIR_TWORK_FLOAT64X2
+
+    status = c_int()
+    sve = _lib.spir_sve_result_new(kernel, epsilon, cutoff, lmax, n_gauss, Twork, byref(status))
+    if status.value != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to create SVE result: {status.value}")
+    return sve
+
+def sve_result_get_size(sve):
+    """Get the size of an SVE result."""
+    size = c_int()
+    status = _lib.spir_sve_result_get_size(sve, byref(size))
+    if status != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to get SVE result size: {status}")
+    return size.value
+
+def sve_result_get_svals(sve):
+    """Get the singular values from an SVE result."""
+    size = sve_result_get_size(sve)
+    svals = np.zeros(size, dtype=np.float64)
+    status = _lib.spir_sve_result_get_svals(sve, svals.ctypes.data_as(POINTER(c_double)))
+    if status != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to get singular values: {status}")
+    return svals
+
+def basis_new(statistics, beta, omega_max, kernel, sve, max_size):
+    """Create a new basis."""
+    status = c_int()
+    basis = _lib.spir_basis_new(
+        statistics, beta, omega_max, kernel, sve, max_size, byref(status)
+    )
+    if status.value != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to create basis: {status.value}")
+    return basis
+
+def basis_get_size(basis):
+    """Get the size of a basis."""
+    size = c_int()
+    status = _lib.spir_basis_get_size(basis, byref(size))
+    if status != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to get basis size: {status}")
+    return size.value
+
+def basis_get_svals(basis):
+    """Get the singular values of a basis."""
+    size = basis_get_size(basis)
+    svals = np.zeros(size, dtype=np.float64)
+    status = _lib.spir_basis_get_svals(basis, svals.ctypes.data_as(POINTER(c_double)))
+    if status != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to get singular values: {status}")
+    return svals
+
+
+def basis_get_stats(basis):
+    """Get the statistics type of a basis."""
+    stats = c_int()
+    status = _lib.spir_basis_get_stats(basis, byref(stats))
+    if status != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to get basis statistics: {status}")
+    return stats.value
+
+def basis_get_u(basis):
+    """Get the imaginary-time basis functions."""
+    status = c_int()
+    funcs = _lib.spir_basis_get_u(basis, byref(status))
+    if status.value != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to get u basis functions: {status.value}")
+    return funcs
+
+def basis_get_v(basis):
+    """Get the real-frequency basis functions."""
+    status = c_int()
+    funcs = _lib.spir_basis_get_v(basis, byref(status))
+    if status.value != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to get v basis functions: {status.value}")
+    return funcs
+
+def basis_get_uhat(basis):
+    """Get the Matsubara frequency basis functions."""
+    status = c_int()
+    funcs = _lib.spir_basis_get_uhat(basis, byref(status))
+    if status.value != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to get uhat basis functions: {status.value}")
+    return funcs
+
+def funcs_get_size(funcs):
+    """Get the size of a basis function set."""
+    size = c_int()
+    status = _lib.spir_funcs_get_size(funcs, byref(size))
+    if status != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to get function size: {status}")
+    return size.value
+
+# TODO: Rename funcs_eval_single
+def funcs_eval_single_float64(funcs, x):
+    """Evaluate basis functions at a single point."""
+    # Get number of functions
+    size = c_int()
+    status = _lib.spir_funcs_get_size(funcs, byref(size))
+    if status != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to get function size: {status}")
+
+    # Prepare output array
+    out = np.zeros(size.value, dtype=np.float64)
+
+    # Evaluate
+    status = _lib.spir_funcs_eval(
+        funcs, c_double(x),
+        out.ctypes.data_as(POINTER(c_double))
+    )
+    if status != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to evaluate functions: {status}")
+
+    return out
+
+# TODO: Rename to funcs_eval_matsu_single
+def funcs_eval_single_complex128(funcs, x):
+    """Evaluate basis functions at a single point."""
+    # Get number of functions
+    size = c_int()
+    status = _lib.spir_funcs_get_size(funcs, byref(size))
+    if status != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to get function size: {status}")
+
+    # Prepare output array
+    out = np.zeros(size.value, dtype=np.complex128)
+
+    # Evaluate
+    status = _lib.spir_funcs_eval_matsu(
+        funcs, c_int64(x),
+        out.ctypes.data_as(POINTER(c_double_complex))
+    )
+    if status != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to evaluate functions: {status}")
+
+    return out
+
+def funcs_get_n_roots(funcs):
+    """Get the number of roots of the basis functions."""
+    n_roots = c_int()
+    status = _lib.spir_funcs_get_n_roots(funcs, byref(n_roots))
+    if status != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to get number of roots: {status}")
+    return n_roots.value
+
+def funcs_get_roots(funcs):
+    """Get the roots of the basis functions."""
+    n_roots = funcs_get_n_roots(funcs)
+    roots = np.zeros(n_roots, dtype=np.float64)
+    status = _lib.spir_funcs_get_roots(funcs, roots.ctypes.data_as(POINTER(c_double)))
+    if status != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to get roots: {status}")
+    return roots
+
+def basis_get_default_tau_sampling_points(basis):
+    """Get default tau sampling points for a basis."""
+    # Get number of points
+    n_points = c_int()
+    status = _lib.spir_basis_get_n_default_taus(basis, byref(n_points))
+    if status != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to get number of default tau points: {status}")
+
+    # Get the points
+    points = np.zeros(n_points.value, dtype=np.float64)
+    status = _lib.spir_basis_get_default_taus(basis, points.ctypes.data_as(POINTER(c_double)))
+    if status != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to get default tau points: {status}")
+
+    return points
+
+def basis_get_default_tau_sampling_points_ext(basis, n_points):
+    """Get default tau sampling points for a basis."""
+    points = np.zeros(n_points, dtype=np.float64)
+    n_points_returned = c_int()
+    status = _lib.spir_basis_get_default_taus_ext(basis, n_points, points.ctypes.data_as(POINTER(c_double)), byref(n_points_returned))
+    if status != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to get default tau points: {status}")
+    return points
+
+def basis_get_default_omega_sampling_points(basis):
+    """Get default omega (real frequency) sampling points for a basis."""
+    # Get number of points
+    n_points = c_int()
+    status = _lib.spir_basis_get_n_default_ws(basis, byref(n_points))
+    if status != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to get number of default omega points: {status}")
+
+    # Get the points
+    points = np.zeros(n_points.value, dtype=np.float64)
+    status = _lib.spir_basis_get_default_ws(basis, points.ctypes.data_as(POINTER(c_double)))
+    if status != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to get default omega points: {status}")
+
+    return points
+
+def basis_get_default_matsubara_sampling_points(basis, positive_only=False):
+    """Get default Matsubara sampling points for a basis."""
+    # Get number of points
+    n_points = c_int()
+    status = _lib.spir_basis_get_n_default_matsus(basis, c_bool(positive_only), byref(n_points))
+    if status != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to get number of default Matsubara points: {status}")
+
+    # Get the points
+    points = np.zeros(n_points.value, dtype=np.int64)
+    status = _lib.spir_basis_get_default_matsus(basis, c_bool(positive_only), points.ctypes.data_as(POINTER(c_int64)))
+    if status != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to get default Matsubara points: {status}")
+
+    return points
+
+def basis_get_n_default_matsus_ext(basis, n_points, positive_only):
+    """Get the number of default Matsubara sampling points for a basis."""
+    n_points_returned = c_int()
+    status = _lib.spir_basis_get_n_default_matsus_ext(basis, c_bool(positive_only), n_points, byref(n_points_returned))
+    if status != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to get number of default Matsubara points: {status}")
+    return n_points_returned.value
+
+def basis_get_default_matsus_ext(basis, positive_only, points):
+    n_points = len(points)
+    n_points_returned = c_int()
+    status = _lib.spir_basis_get_default_matsus_ext(basis, c_bool(positive_only), n_points, points.ctypes.data_as(POINTER(c_int64)), byref(n_points_returned))
+    if status != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to get default Matsubara points: {status}")
+    return points
+
+def tau_sampling_new(basis, sampling_points=None):
+    """Create a new tau sampling object."""
+    if sampling_points is None:
+        sampling_points = basis_get_default_tau_sampling_points(basis)
+
+    sampling_points = np.asarray(sampling_points, dtype=np.float64)
+    n_points = len(sampling_points)
+
+    status = c_int()
+    sampling = _lib.spir_tau_sampling_new(
+        basis, n_points,
+        sampling_points.ctypes.data_as(POINTER(c_double)),
+        byref(status)
+    )
+    if status.value != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to create tau sampling: {status.value}")
+
+    return sampling
+
+def _statistics_to_c(statistics):
+    """Convert statistics to c type."""
+    if statistics == "F":
+        return SPIR_STATISTICS_FERMIONIC
+    elif statistics == "B":
+        return SPIR_STATISTICS_BOSONIC
+    else:
+        raise ValueError(f"Invalid statistics: {statistics}")
+
+def tau_sampling_new_with_matrix(basis, statistics, sampling_points, matrix):
+    """Create a new tau sampling object with a matrix."""
+    status = c_int()
+    sampling = _lib.spir_tau_sampling_new_with_matrix(
+        SPIR_ORDER_ROW_MAJOR,
+        _statistics_to_c(statistics),
+        basis.size,
+        sampling_points.size,
+        sampling_points.ctypes.data_as(POINTER(c_double)),
+        matrix.ctypes.data_as(POINTER(c_double)),
+        byref(status)
+    )
+    if status.value != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to create tau sampling: {status.value}")
+
+    return sampling
+
+def matsubara_sampling_new(basis, positive_only=False, sampling_points=None):
+    """Create a new Matsubara sampling object."""
+    if sampling_points is None:
+        sampling_points = basis_get_default_matsubara_sampling_points(basis, positive_only)
+
+    sampling_points = np.asarray(sampling_points, dtype=np.int64)
+    n_points = len(sampling_points)
+
+    status = c_int()
+    sampling = _lib.spir_matsu_sampling_new(
+        basis, c_bool(positive_only), n_points,
+        sampling_points.ctypes.data_as(POINTER(c_int64)),
+        byref(status)
+    )
+    if status.value != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to create Matsubara sampling: {status.value}")
+
+    return sampling
+
+def matsubara_sampling_new_with_matrix(statistics, basis_size, positive_only, sampling_points, matrix):
+    """Create a new Matsubara sampling object with a matrix."""
+    status = c_int()
+    sampling = _lib.spir_matsu_sampling_new_with_matrix(
+        SPIR_ORDER_ROW_MAJOR,                           # order
+        _statistics_to_c(statistics),                   # statistics
+        c_int(basis_size),                              # basis_size
+        c_bool(positive_only),                          # positive_only
+        c_int(len(sampling_points)),                    # num_points
+        sampling_points.ctypes.data_as(POINTER(c_int64)), # points
+        matrix.ctypes.data_as(POINTER(c_double_complex)), # matrix
+        byref(status)                                   # status
+    )
+    if status.value != COMPUTATION_SUCCESS:
+        raise RuntimeError(f"Failed to create Matsubara sampling: {status.value}")
+
+    return sampling

pylibsparseir/ctypes_wrapper.py

@@ -0,0 +1,40 @@
+"""
+Type definitions for the SparseIR C API.
+"""
+
+from ctypes import *
+import numpy as np
+
+# Define complex type
+c_complex = c_double * 2
+
+# Opaque types
+class _spir_kernel(Structure):
+    _fields_ = []
+
+class _spir_funcs(Structure):
+    _fields_ = []
+
+class _spir_basis(Structure):
+    _fields_ = []
+
+class _spir_sampling(Structure):
+    _fields_ = []
+
+class _spir_sve_result(Structure):
+    _fields_ = []
+
+# Type aliases
+spir_kernel = POINTER(_spir_kernel)
+spir_funcs = POINTER(_spir_funcs)
+spir_basis = POINTER(_spir_basis)
+spir_sampling = POINTER(_spir_sampling)
+spir_sve_result = POINTER(_spir_sve_result)
+
+# Additional ctypes definitions
+c_int64 = c_longlong
+
+# NumPy dtype mappings
+COMPLEX_DTYPE = np.dtype(np.complex128)
+DOUBLE_DTYPE = np.dtype(np.float64)
+INT64_DTYPE = np.dtype(np.int64) 

pylibsparseir-0.1.0.dist-info/METADATA

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: pylibsparseir
+Version: 0.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/libsparseir
+Project-URL: Repository, https://github.com/SpM-lab/libsparseir
+Project-URL: Bug Tracker, https://github.com/SpM-lab/libsparseir/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
+Requires-Dist: numpy
+Requires-Dist: scipy
+
+# Python bindings for libsparseir
+
+This is a low-level binding for the [libsparseir](https://github.com/SpM-lab/libsparseir) library.
+
+## Requirements
+
+- Python >= 3.10
+- CMake (for building the C++ library)
+- C++11 compatible compiler
+- numpy
+
+### Optional Dependencies
+
+- **OpenBLAS** (recommended for better performance)
+  - macOS: `brew install openblas`
+  - Ubuntu/Debian: `sudo apt install libopenblas-dev`
+  - CentOS/RHEL: `sudo yum install openblas-devel`
+
+## Build
+
+### Install Dependencies and Build
+
+```bash
+uv sync
+```
+
+This will:
+- Install Python dependencies (numpy)
+- Build the C++ libsparseir library using CMake
+- Install the Python package in development mode
+
+### Build with OpenBLAS Support
+
+To enable OpenBLAS support for improved performance:
+
+```bash
+# Set environment variable to enable BLAS
+export SPARSEIR_USE_BLAS=1
+uv sync
+```
+
+Or for a single build:
+
+```bash
+SPARSEIR_USE_BLAS=1 uv sync
+```
+
+The build system will automatically detect OpenBLAS if it's installed in standard locations. If OpenBLAS is installed in a custom location, you may need to set additional environment variables:
+
+```bash
+export CMAKE_PREFIX_PATH="/path/to/openblas"
+export SPARSEIR_USE_BLAS=1
+uv sync
+```
+
+### Clean Build Artifacts
+
+To remove build artifacts and files copied from the parent directory:
+
+```bash
+uv run clean
+```
+
+This will remove:
+- Build directories: `build/`, `dist/`, `*.egg-info`
+- Copied source files: `include/`, `src/`, `fortran/`, `cmake/`, `CMakeLists.txt`
+- Compiled libraries: `pylibsparseir/*.so`, `pylibsparseir/*.dylib`, `pylibsparseir/*.dll`
+- Cache directories: `pylibsparseir/__pycache__`
+
+## Performance Notes
+
+### BLAS Support
+
+This package supports BLAS libraries for improved linear algebra performance:
+
+- **With OpenBLAS**: Significant performance improvements for matrix operations
+- **Without BLAS**: Uses Eigen's built-in implementations (still efficient, but slower for large matrices)
+
+The build system will automatically detect and use OpenBLAS if available. You can verify BLAS support by checking the build output for messages like:
+
+```
+BLAS support enabled
+Found OpenBLAS at: /opt/homebrew/opt/openblas
+```
+
+### Troubleshooting
+
+**Build fails with "Could NOT find BLAS":**
+```bash
+# Install OpenBLAS first
+brew install openblas  # macOS
+sudo apt install libopenblas-dev  # Ubuntu
+
+# Then force BLAS detection
+SPARSEIR_USE_BLAS=1 uv sync
+```
+
+**OpenBLAS not detected automatically:**
+```bash
+# Set CMake prefix path manually
+export CMAKE_PREFIX_PATH="/usr/local/opt/openblas"  # or your OpenBLAS path
+export SPARSEIR_USE_BLAS=1
+uv sync
+```
+
+**Verify BLAS support in built package:**
+```python
+import pylibsparseir
+# Check build logs or library dependencies to confirm BLAS linking
+```

pylibsparseir-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+pylibsparseir/clean_build_artifacts.py,sha256=Wbfe_zlZB5T04pXR8rvRAvsaLMYl6Y61p77W-eRKUME,2079
+pylibsparseir/constants.py,sha256=Ek3JnmgiDWy3LB8f_9QA7Gh0ReaEC-W2MlCBJG3cBYg,864
+pylibsparseir/core.py,sha256=37sGLY_Gbddf3x-kScoJtmyaLOeDOFaPbBCMPIMLOP0,23647
+pylibsparseir/ctypes_wrapper.py,sha256=G6_eraRUh9ON_2e_v4U_hc34HXirlotoawQDOkS0my0,798
+pylibsparseir/libsparseir.so,sha256=p9tMeYFBERToWxH5ooWPvP9yqQYtdLP1B0aHm9VxlHI,2713377
+pylibsparseir/libsparseir.so.0,sha256=p9tMeYFBERToWxH5ooWPvP9yqQYtdLP1B0aHm9VxlHI,2713377
+pylibsparseir/libsparseir.so.0.4.2,sha256=p9tMeYFBERToWxH5ooWPvP9yqQYtdLP1B0aHm9VxlHI,2713377
+pylibsparseir.libs/libgcc_s-0cd532bd.so.1,sha256=yPk0-VjyKzucjnkP3mvC0vVaua6Ln17qZUJbICcXgtA,181737
+pylibsparseir.libs/libstdc++-5d72f927.so.6.0.33,sha256=fogxHsmB1_D6C-a_-uHh8Ei_6Qh52a8vLlicJRM3ehk,3562401
+pylibsparseir-0.1.0.dist-info/METADATA,sha256=CItKxoGfymHNuwhCTxzA66svXd_uU4dgBHU-r8JYcVA,3585
+pylibsparseir-0.1.0.dist-info/WHEEL,sha256=4VbEOkf4fdBUBHdV24POjoH-zuik_eIDLSImZZCAQpQ,112
+pylibsparseir-0.1.0.dist-info/entry_points.txt,sha256=0XwdYIQ1lPtI8228zUo7BpvdnwOzqct0cc6gp3r18pA,84
+pylibsparseir-0.1.0.dist-info/top_level.txt,sha256=eKNiduo4CIO59083m_BjY8uBZ9Fp1D3t8hkU4-k2waA,14
+pylibsparseir-0.1.0.dist-info/RECORD,,

pylibsparseir-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp313-cp313-musllinux_1_2_x86_64
+

pylibsparseir-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+clean = pylibsparseir.clean_build_artifacts:clean_build_artifacts

pylibsparseir-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pylibsparseir