draft of bindings, same structure as presolver

Author: dance858

.gitignore

@@ -0,0 +1,75 @@
+# Prerequisites
+*.d
+
+# Object files
+*.o
+*.ko
+*.obj
+*.elf
+
+# Linker output
+*.ilk
+*.map
+*.exp
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Libraries
+*.lib
+*.a
+*.la
+*.lo
+
+# Shared objects (inc. Windows DLLs)
+*.dll
+*.so
+*.so.*
+*.dylib
+
+# Executables
+*.exe
+*.out
+*.app
+*.i*86
+*.x86_64
+*.hex
+
+# Debug files
+*.dSYM/
+*.su
+*.idb
+*.pdb
+
+# Kernel Module Compile Results
+*.mod*
+*.cmd
+.tmp_versions/
+modules.order
+Module.symvers
+Mkfile.old
+dkms.conf
+
+# CMake
+CMakeCache.txt
+CMakeFiles/
+CMakeScripts/
+Testing/
+Makefile
+cmake_install.cmake
+install_manifest.txt
+compile_commands.json
+CTestTestfile.cmake
+_deps
+build/
+Build/
+out/
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store

python/CMakeLists.txt

@@ -0,0 +1,57 @@
+cmake_minimum_required(VERSION 3.20)
+project(DNLP_diff_engine LANGUAGES C VERSION 0.1.0
+  DESCRIPTION "Python bindings for DNLP diff engine")
+
+if(DEFINED ENV{VIRTUAL_ENV})
+    set(Python3_EXECUTABLE "$ENV{VIRTUAL_ENV}/bin/python3")
+endif()
+
+# Find Python3 and NumPy
+find_package(Python3 REQUIRED COMPONENTS Interpreter Development NumPy)
+message(STATUS "Python3 executable: ${Python3_EXECUTABLE}")
+message(STATUS "Python3 version: ${Python3_VERSION}")
+message(STATUS "NumPy include dirs: ${Python3_NumPy_INCLUDE_DIRS}")
+
+# Verify NumPy version
+execute_process(
+  COMMAND ${Python3_EXECUTABLE} -c "import numpy; print(numpy.__version__)"
+  OUTPUT_VARIABLE NUMPY_VERSION
+  OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+message(STATUS "NumPy version: ${NUMPY_VERSION}")
+
+# Build core project from source
+add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/.. ${CMAKE_BINARY_DIR}/core_build)
+
+# create Python module
+add_library(bindings MODULE  ${CMAKE_CURRENT_LIST_DIR}/bindings.c)
+target_include_directories(bindings
+  PRIVATE
+    ${Python3_INCLUDE_DIRS}
+    ${Python3_NumPy_INCLUDE_DIRS}
+    ${CMAKE_CURRENT_LIST_DIR}/../include
+    ${CMAKE_CURRENT_LIST_DIR}/../src
+    ${CMAKE_CURRENT_LIST_DIR}/../src/utils
+)
+
+# Link against core and Python libraries
+target_link_libraries(bindings
+  PRIVATE
+    dnlp_diff
+    Python3::Python
+    Python3::NumPy
+)
+
+# Place the module in the python source folder alongside example.py
+set(PY_MODULE_OUTPUT_DIR ${CMAKE_CURRENT_LIST_DIR})
+file(MAKE_DIRECTORY ${PY_MODULE_OUTPUT_DIR})
+
+set_target_properties(bindings PROPERTIES
+  PREFIX ""
+  OUTPUT_NAME "DNLP_diff_engine"
+  SUFFIX ".${Python3_SOABI}.so"
+
+    # All configs → same folder
+    LIBRARY_OUTPUT_DIRECTORY ${PY_MODULE_OUTPUT_DIR}
+    RUNTIME_OUTPUT_DIRECTORY ${PY_MODULE_OUTPUT_DIR}  # Critical for Windows .pyd
+)

python/bindings.c

@@ -0,0 +1,119 @@
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <numpy/arrayobject.h>
+#include <stdbool.h>
+
+#include "affine.h"
+#include "elementwise_univariate.h"
+#include "expr.h"
+
+// Capsule name for expr* pointers
+#define EXPR_CAPSULE_NAME "DNLP_EXPR"
+
+static int ensure_numpy(void)
+{
+    import_array();
+    return 0;
+}
+
+static void expr_capsule_destructor(PyObject *capsule)
+{
+    expr *node = (expr *) PyCapsule_GetPointer(capsule, EXPR_CAPSULE_NAME);
+    if (node)
+    {
+        free_expr(node);
+    }
+}
+
+static PyObject *py_make_variable(PyObject *self, PyObject *args)
+{
+    int d1, d2, var_id, n_vars;
+    if (!PyArg_ParseTuple(args, "iiii", &d1, &d2, &var_id, &n_vars))
+    {
+        return NULL;
+    }
+
+    expr *node = new_variable(d1, d2, var_id, n_vars);
+    if (!node)
+    {
+        PyErr_SetString(PyExc_RuntimeError, "failed to create variable node");
+        return NULL;
+    }
+    return PyCapsule_New(node, EXPR_CAPSULE_NAME, expr_capsule_destructor);
+}
+
+static PyObject *py_make_log(PyObject *self, PyObject *args)
+{
+    PyObject *child_capsule;
+    if (!PyArg_ParseTuple(args, "O", &child_capsule))
+    {
+        return NULL;
+    }
+    expr *child = (expr *) PyCapsule_GetPointer(child_capsule, EXPR_CAPSULE_NAME);
+    if (!child)
+    {
+        PyErr_SetString(PyExc_ValueError, "invalid child capsule");
+        return NULL;
+    }
+
+    expr *node = new_log(child);
+    if (!node)
+    {
+        PyErr_SetString(PyExc_RuntimeError, "failed to create log node");
+        return NULL;
+    }
+    return PyCapsule_New(node, EXPR_CAPSULE_NAME, expr_capsule_destructor);
+}
+
+static PyObject *py_forward(PyObject *self, PyObject *args)
+{
+    PyObject *node_capsule;
+    PyObject *u_obj;
+    if (!PyArg_ParseTuple(args, "OO", &node_capsule, &u_obj))
+    {
+        return NULL;
+    }
+
+    expr *node = (expr *) PyCapsule_GetPointer(node_capsule, EXPR_CAPSULE_NAME);
+    if (!node)
+    {
+        PyErr_SetString(PyExc_ValueError, "invalid node capsule");
+        return NULL;
+    }
+
+    PyArrayObject *u_array =
+        (PyArrayObject *) PyArray_FROM_OTF(u_obj, NPY_DOUBLE, NPY_ARRAY_IN_ARRAY);
+    if (!u_array)
+    {
+        return NULL;
+    }
+
+    node->forward(node, (const double *) PyArray_DATA(u_array));
+
+    npy_intp size = node->size;
+    PyObject *out = PyArray_SimpleNew(1, &size, NPY_DOUBLE);
+    if (!out)
+    {
+        Py_DECREF(u_array);
+        return NULL;
+    }
+    memcpy(PyArray_DATA((PyArrayObject *) out), node->value, size * sizeof(double));
+
+    Py_DECREF(u_array);
+    return out;
+}
+
+static PyMethodDef DNLPMethods[] = {
+    {"make_variable", py_make_variable, METH_VARARGS, "Create variable node"},
+    {"make_log", py_make_log, METH_VARARGS, "Create log node"},
+    {"forward", py_forward, METH_VARARGS, "Run forward pass and return values"},
+    {NULL, NULL, 0, NULL}};
+
+static struct PyModuleDef dnlp_module = {PyModuleDef_HEAD_INIT, "DNLP_diff_engine",
+                                         NULL, -1, DNLPMethods};
+
+PyMODINIT_FUNC PyInit_DNLP_diff_engine(void)
+{
+    if (ensure_numpy() < 0) return NULL;
+    return PyModule_Create(&dnlp_module);
+}

python/example.py

@@ -0,0 +1,9 @@
+import numpy as np
+import DNLP_diff_engine as dnlp
+
+x = dnlp.make_variable(3, 1, 0, 3)
+log_x = dnlp.make_log(x)
+
+u = np.array([1.0, 2.0, 3.0])
+out = dnlp.forward(log_x, u)
+print("log(x) forward:", out)