Merge branch 'main' into rename-c-api-kernel-domain

Author: terasakisatoshi

backend/cxx/include/sparseir/sparseir.h

@@ -123,6 +123,25 @@ spir_kernel *spir_logistic_kernel_new(double lambda, int *status);
  */
 spir_kernel *spir_reg_bose_kernel_new(double lambda, int *status);
 
+/**
+ * @brief Retrieves the cutoff parameter lambda used to construct the kernel.
+ *
+ * This function extracts the lambda value (Λ) associated with the provided kernel object.
+ * The lambda parameter typically determines the cutoff scale in the analytic continuation kernels.
+ *
+ * @param kernel      Pointer to the kernel object. Must not be NULL.
+ * @param lambda_out  Pointer to a double where the lambda value will be written. Must not be NULL.
+ *
+ * @return An integer status code:
+ *         - SPIR_COMPUTATION_SUCCESS (0) on success
+ *         - SPIR_INVALID_ARGUMENT if either `kernel` or `lambda_out` is NULL
+ *         - SPIR_INTERNAL_ERROR if an unexpected error occurs internally
+ *
+ * @note The lambda value is specific to the type of kernel and corresponds
+ *       to the cutoff parameter provided at kernel construction.
+ */
+int spir_kernel_get_lambda(const spir_kernel *kernel, double *lambda_out);
+
 /**
  * @brief Retrieves the domain boundaries of a kernel function.
  *
@@ -145,6 +164,29 @@ spir_kernel *spir_reg_bose_kernel_new(double lambda, int *status);
 int spir_kernel_get_domain(const spir_kernel *k, double *xmin, double *xmax,
                        double *ymin, double *ymax);
 
+/**
+ * @brief Computes the value of the kernel function K(x, y).
+ *
+ * This function evaluates the kernel associated with the provided kernel object
+ * at the specified coordinates (x, y), and stores the result at the memory location
+ * pointed to by `out`.
+ *
+ * @param kernel Pointer to a kernel object (must not be NULL).
+ * @param x      First coordinate for evaluation (typically in [-1, 1]; domain may vary by kernel).
+ * @param y      Second coordinate for evaluation (typically in [-1, 1]; domain may vary by kernel).
+ * @param out    Pointer to a double where the computed result will be stored (must not be NULL).
+ *
+ * @return An integer status code:
+ *         - 0 (SPIR_COMPUTATION_SUCCESS) on success
+ *         - SPIR_INVALID_ARGUMENT if `kernel` or `out` is NULL
+ *         - SPIR_INTERNAL_ERROR if an internal error occurs
+ *
+ * @note The function does not check if (x, y) is within the valid domain of the kernel;
+ *       callers should ensure that inputs are valid.
+ * @note The kernel object must have been created by one of the kernel constructor functions.
+ */
+int spir_kernel_compute(const spir_kernel *kernel, double x, double y, double *out);
+
 /**
  * @brief Get x-segments for SVE discretization hints from a kernel.
  *

backend/cxx/src/cinterface.cpp

@@ -110,6 +110,25 @@ int spir_kernel_get_domain(const spir_kernel *k, double *xmin, double *xmax,
     }
 }
 
+int spir_kernel_compute(const spir_kernel *kernel, double x, double y, double *out)
+{
+    try {
+        auto impl = get_impl_kernel(kernel);
+        if (!impl) {
+            DEBUG_LOG("Failed to get kernel implementation");
+            return SPIR_GET_IMPL_FAILED;
+        }
+        *out = impl->compute(x, y);
+        return SPIR_COMPUTATION_SUCCESS;
+    } catch (const std::exception &e) {
+        DEBUG_LOG("Exception in spir_kernel_compute: " + std::string(e.what()));
+        return SPIR_INVALID_ARGUMENT;
+    } catch (...) {
+        DEBUG_LOG("Unknown exception in spir_kernel_compute");
+        return SPIR_INVALID_ARGUMENT;
+    }
+}
+
 int spir_kernel_get_sve_hints_segments_x(const spir_kernel *k, double epsilon,
                                          double *segments, int *n_segments)
 {

backend/cxx/test/cinterface_core.cxx

@@ -37,6 +37,19 @@ TEST_CASE("Kernel Accuracy Tests", "[cinterface]")
         REQUIRE(kernel != nullptr);
     }
 
+    SECTION("Kernel Get Lambda")
+    {
+        int kernel_status;
+        spir_kernel *kernel = spir_logistic_kernel_new(9, &kernel_status);
+        REQUIRE(kernel_status == SPIR_COMPUTATION_SUCCESS);
+        REQUIRE(kernel != nullptr);
+        double lambda;
+        int lambda_status = spir_kernel_get_lambda(kernel, &lambda);
+        REQUIRE(lambda_status == SPIR_COMPUTATION_SUCCESS);
+        REQUIRE(lambda == 9);
+        spir_kernel_release(kernel);
+    }
+
     SECTION("Kernel Domain")
     {
         // Create a kernel through C API
@@ -67,6 +80,26 @@ TEST_CASE("Kernel Accuracy Tests", "[cinterface]")
         // Clean up
         spir_kernel_release(kernel);
     }
+
+    SECTION("Kernel Compute")
+    {
+        auto cpp_kernel = sparseir::LogisticKernel(9);
+        double x = 0.5;
+        double y = 0.5;
+        double out;
+
+        // Create a kernel through C API
+        int kernel_status;
+        spir_kernel *kernel = spir_logistic_kernel_new(9, &kernel_status);
+        REQUIRE(kernel_status == SPIR_COMPUTATION_SUCCESS);
+        REQUIRE(kernel != nullptr);
+        int compute_status = spir_kernel_compute(kernel, x, y, &out);
+        REQUIRE(compute_status == SPIR_COMPUTATION_SUCCESS);
+        REQUIRE(out == Approx(cpp_kernel.compute(x, y)));
+
+        // Clean up
+        spir_kernel_release(kernel);
+    }
 }
 
 template <typename S>