add state to callbacks

goulart-paul · goulart-paul · commit 05374a528e59 · 2025-05-09T15:01:25.000+01:00
diff --git a/Clarabel.rs b/Clarabel.rs
@@ -1 +1 @@
-Subproject commit 8b45558e40b9bb4773140462ce1c25b45d3274a7
+Subproject commit cbfa4a5efc536b35a59e812b7938baa7754ef609
diff --git a/examples/c/CMakeLists.txt b/examples/c/CMakeLists.txt
@@ -12,6 +12,7 @@ set(C_EXAMPLES
   example_json
   example_print_stream
   example_callback
+  example_callback_with_state
   example_pardiso_mkl
 )
 
diff --git a/examples/c/example_callback.c b/examples/c/example_callback.c
@@ -3,7 +3,7 @@
 #include <Clarabel.h>
 
 
-int custom_callback(ClarabelDefaultInfo *info)
+int custom_callback(ClarabelDefaultInfo *info, void* _userdata)
 {
     // This function is called at each iteration of the solver.
     // You can use it to monitor the progress of the solver or
@@ -71,7 +71,7 @@ int main(void)
     );
 
     // configure a custom callback function 
-    clarabel_DefaultSolver_set_termination_callback(solver,custom_callback);
+    clarabel_DefaultSolver_set_termination_callback(solver,custom_callback, NULL);
 
     // Solve
     clarabel_DefaultSolver_solve(solver);
diff --git a/examples/c/example_callback_with_state.c b/examples/c/example_callback_with_state.c
@@ -0,0 +1,100 @@
+#include "utils.h"
+#include <stdio.h>
+#include <Clarabel.h>
+
+
+typedef struct 
+{
+    int count;
+} CallbackData;
+
+
+int custom_callback(ClarabelDefaultInfo *info, void* userdata)
+{
+    // Cast the userdata pointer back to our struct type
+    CallbackData* data = (CallbackData*)userdata;
+    
+    // Access and modify the state
+    data->count++;
+    
+    // Return 0 to continue. Anything else to stop.
+    if (data->count < 3) {
+        printf("tick\n");
+        return 0; //continue
+    }
+    else {
+        printf("BOOM!\n");
+        return 1; // stop
+    }
+}
+
+int main(void)
+{
+    // 2 x 2 zero matrix
+    ClarabelCscMatrix P;
+    clarabel_CscMatrix_init(
+        &P,
+        2,                        // row
+        2,                        // col
+        (uintptr_t[]){ 0, 0, 0 }, // colptr
+        NULL,                     // rowval
+        NULL                      // nzval
+    );
+
+    ClarabelFloat q[2] = { 1.0, -1.0 };
+
+    // a 2-d box constraint, separated into 4 inequalities.
+    // A = [I; -I]
+    ClarabelCscMatrix A;
+    clarabel_CscMatrix_init(
+        &A,
+        4,                                        // row
+        2,                                        // col
+        (uintptr_t[]){ 0, 2, 4 },                 // colptr
+        (uintptr_t[]){ 0, 2, 1, 3 },              // rowval
+        (ClarabelFloat[]){ 1.0, -1.0, 1.0, -1.0 } // nzval
+    );
+
+    ClarabelFloat b[4] = { 1.0, 1.0, 1.0, 1.0 };
+
+    ClarabelSupportedConeT cones[1] = { ClarabelNonnegativeConeT(4) };
+
+    // Settings
+    ClarabelDefaultSettings settings = clarabel_DefaultSettings_default();
+    settings.equilibrate_enable = true;
+    settings.equilibrate_max_iter = 50;
+
+    // Build solver
+    ClarabelDefaultSolver *solver = clarabel_DefaultSolver_new(
+        &P, // P
+        q,  // q
+        &A, // A
+        b,  // b
+        1,  // n_cones
+        cones, &settings
+    );
+
+
+    // configure a custom callback function 
+    CallbackData userdata = {-1};
+    clarabel_DefaultSolver_set_termination_callback(solver,custom_callback,&userdata);
+
+    // Solve
+    clarabel_DefaultSolver_solve(solver);
+
+    // turn off the callback
+    clarabel_DefaultSolver_unset_termination_callback(solver);
+
+    // Solve again
+    clarabel_DefaultSolver_solve(solver);
+
+    // Get solution
+    ClarabelDefaultSolution solution = clarabel_DefaultSolver_solution(solver);
+    print_solution(&solution);
+
+    // Free the solver
+    clarabel_DefaultSolver_free(solver);
+
+    return 0;
+}
+
diff --git a/examples/cpp/CMakeLists.txt b/examples/cpp/CMakeLists.txt
@@ -10,6 +10,7 @@ set(CPP_EXAMPLES
   example_json
   example_print_stream
   example_callback
+    example_callback_with_state
   example_faer
   example_pardiso_mkl
 )
diff --git a/examples/cpp/example_callback.cpp b/examples/cpp/example_callback.cpp
@@ -8,7 +8,7 @@ using namespace clarabel;
 using namespace std;
 using namespace Eigen;
 
-int custom_callback(DefaultInfo<double> &info)
+int custom_callback(DefaultInfo<double> &info, void* _userdata)
 {
     // This function is called at each iteration of the solver.
     // You can use it to monitor the progress of the solver or
@@ -67,7 +67,7 @@ int main()
     DefaultSolver<double> solver(P, q, A, b, cones, settings);
 
     // configure a custom callback function
-    solver.set_termination_callback(custom_callback); 
+    solver.set_termination_callback(custom_callback, nullptr); 
 
     // Solve
     solver.solve();
diff --git a/examples/cpp/example_callback_with_state.cpp b/examples/cpp/example_callback_with_state.cpp
@@ -0,0 +1,95 @@
+#include "utils.h"
+
+#include <Clarabel>
+#include <Eigen/Eigen>
+#include <vector>
+
+using namespace clarabel;
+using namespace std;
+using namespace Eigen;
+
+
+typedef struct 
+{
+    int count;
+} CallbackData;
+
+
+int custom_callback(DefaultInfo<double> &info, void* userdata)
+{
+    // Cast the userdata pointer back to our struct type
+    CallbackData* data = (CallbackData*)userdata;
+    
+    // Access and modify the state
+    data->count++;
+    
+    // Return 0 to continue. Anything else to stop.
+    if (data->count < 3) {
+        printf("tick\n");
+        return 0; //continue
+    }
+    else {
+        printf("BOOM!\n");
+        return 1; // stop
+    }
+}
+
+int main()
+{
+    MatrixXd P_dense = MatrixXd::Zero(2, 2);
+    SparseMatrix<double> P = P_dense.sparseView();
+    P.makeCompressed();
+    
+    Vector<double, 2> q = {1.0, -1.0};
+
+    // a 2-d box constraint, separated into 4 inequalities.
+    // A = [I; -I]
+    MatrixXd A_dense(4, 2);
+    A_dense <<
+         1.,  0.,
+         0.,  1.,
+        -1.,  0.,
+         0., -1.;
+        
+    SparseMatrix<double> A = A_dense.sparseView();
+    A.makeCompressed();
+
+    Vector<double, 4> b = { 1.0, 1.0, 1.0, 1.0 };
+
+    vector<SupportedConeT<double>> cones
+    {
+        NonnegativeConeT<double>(4),
+        // {.tag = SupportedConeT<double>::Tag::NonnegativeConeT, .nonnegative_cone_t = {._0 = 4 }}
+    };
+
+    // Settings
+    DefaultSettings<double> settings = DefaultSettingsBuilder<double>::default_settings()
+                                           .equilibrate_enable(true)
+                                           .equilibrate_max_iter(50)
+                                           .build();
+
+    // Build solver
+    DefaultSolver<double> solver(P, q, A, b, cones, settings);
+
+
+
+    // configure a custom callback function
+    CallbackData userdata = {-1};
+    solver.set_termination_callback(custom_callback, &userdata); 
+
+    // Solve
+    solver.solve();
+
+    // turn off the callback
+    solver.unset_termination_callback(); 
+
+    // Solve again
+    solver.solve();
+    
+
+    // Get solution
+    DefaultSolution<double> solution = solver.solution();
+    utils::print_solution(solution);
+
+    return 0;
+}
diff --git a/include/c/DefaultSolver.h b/include/c/DefaultSolver.h
@@ -212,24 +212,24 @@ static inline ClarabelDefaultInfo clarabel_DefaultSolver_info(ClarabelDefaultSol
 }
 
 // DefaultSolver callbacks
-typedef int (*ClarabelCallbackFcn_f32)(ClarabelDefaultInfo_f32 *info);
-typedef int (*ClarabelCallbackFcn_f64)(ClarabelDefaultInfo_f64 *info);
+typedef int (*ClarabelCallbackFcn_f32)(ClarabelDefaultInfo_f32 *info, void* userdata);
+typedef int (*ClarabelCallbackFcn_f64)(ClarabelDefaultInfo_f64 *info, void* userdata);
 
 #ifdef CLARABEL_USE_FLOAT
 typedef ClarabelCallbackFcn_f32 ClarabelCallbackFcn;
 #else
 typedef ClarabelCallbackFcn_f64 ClarabelCallbackFcn;
 #endif
 
-void clarabel_DefaultSolver_f64_set_termination_callback(ClarabelDefaultSolver_f64 *solver, ClarabelCallbackFcn_f64 callback);
-void clarabel_DefaultSolver_f32_set_termination_callback(ClarabelDefaultSolver_f32 *solver, ClarabelCallbackFcn_f32 callback);
+void clarabel_DefaultSolver_f64_set_termination_callback(ClarabelDefaultSolver_f64 *solver, ClarabelCallbackFcn_f64 callback, void* userdata);
+void clarabel_DefaultSolver_f32_set_termination_callback(ClarabelDefaultSolver_f32 *solver, ClarabelCallbackFcn_f32 callback, void* userdata);
 
-static inline void clarabel_DefaultSolver_set_termination_callback(ClarabelDefaultSolver *solver, ClarabelCallbackFcn callback)
+static inline void clarabel_DefaultSolver_set_termination_callback(ClarabelDefaultSolver *solver, ClarabelCallbackFcn callback, void* userdata)
 {
 #ifdef CLARABEL_USE_FLOAT
-    clarabel_DefaultSolver_f32_set_termination_callback(solver,callback);
+    clarabel_DefaultSolver_f32_set_termination_callback(solver,callback, userdata);
 #else
-    clarabel_DefaultSolver_f64_set_termination_callback(solver,callback);
+    clarabel_DefaultSolver_f64_set_termination_callback(solver,callback, userdata);
 #endif
 }
 
diff --git a/include/cpp/DefaultSolver.h b/include/cpp/DefaultSolver.h
@@ -122,7 +122,7 @@ class DefaultSolver
     // termination callbacks 
     // -------------------------------
     void set_termination_callback(
-        int (*callback)(clarabel::DefaultInfo<T>&));
+        int (*callback)(clarabel::DefaultInfo<T>&,void*), void* userdata);
     
     void unset_termination_callback();
 
@@ -233,8 +233,8 @@ DefaultInfo<double> clarabel_DefaultSolver_f64_info(RustDefaultSolverHandle_f64
 
 DefaultInfo<float> clarabel_DefaultSolver_f32_info(RustDefaultSolverHandle_f32 solver);
 
-void clarabel_DefaultSolver_f64_set_termination_callback(RustDefaultSolverHandle_f64 solver, int (*callback)(DefaultInfo<double>&));
-void clarabel_DefaultSolver_f32_set_termination_callback(RustDefaultSolverHandle_f32 solver, int (*callback)(DefaultInfo<float>&));
+void clarabel_DefaultSolver_f64_set_termination_callback(RustDefaultSolverHandle_f64 solver, int (*callback)(DefaultInfo<double>& ,void*),void* userdata);
+void clarabel_DefaultSolver_f32_set_termination_callback(RustDefaultSolverHandle_f32 solver, int (*callback)(DefaultInfo<float>&, void*),void* userdata);
 void clarabel_DefaultSolver_f64_unset_termination_callback(RustDefaultSolverHandle_f64 solver);
 void clarabel_DefaultSolver_f32_unset_termination_callback(RustDefaultSolverHandle_f32 solver);
 
@@ -392,13 +392,13 @@ inline DefaultInfo<float> DefaultSolver<float>::info() const
 
 
 template<>
-inline void DefaultSolver<double>::set_termination_callback(int (*callback)(DefaultInfo<double>&)) {
-    clarabel_DefaultSolver_f64_set_termination_callback(this->handle, callback);
+inline void DefaultSolver<double>::set_termination_callback(int (*callback)(DefaultInfo<double>&, void*), void* userdata) {
+    clarabel_DefaultSolver_f64_set_termination_callback(this->handle, callback,userdata);
 }
 
 template<>
-inline void DefaultSolver<float>::set_termination_callback(int (*callback)(DefaultInfo<float>&)) {
-    clarabel_DefaultSolver_f32_set_termination_callback(this->handle, callback);
+inline void DefaultSolver<float>::set_termination_callback(int (*callback)(DefaultInfo<float>&, void*), void* userdata) {
+    clarabel_DefaultSolver_f32_set_termination_callback(this->handle, callback, userdata);
 }
 
 template<>
diff --git a/rust_wrapper/src/solver/implementations/default/callbacks.rs b/rust_wrapper/src/solver/implementations/default/callbacks.rs
@@ -7,36 +7,40 @@ use clarabel::algebra::FloatT;
 use clarabel::solver::{self as lib};
 use std::ffi::{c_int, c_void};
 
-pub(crate) type CallbackFcnFFI<T> = extern "C" fn(info: *const ClarabelDefaultInfo<T>) -> c_int;
+pub(crate) type CallbackFcnFFI<T> =
+    extern "C" fn(info: *const ClarabelDefaultInfo<T>, userdata: *mut std::ffi::c_void) -> c_int;
 pub type ClarabelCallbackFcn_f32 = CallbackFcnFFI<f32>;
 pub type ClarabelCallbackFcn_f64 = CallbackFcnFFI<f64>;
 
 /// Set the termination callback
 fn _internal_DefaultSolver_set_termination_callback<T: FloatT>(
     solver: *mut c_void,
     callback: CallbackFcnFFI<T>,
+    userdata: *mut std::ffi::c_void,
 ) {
     // Recover the solver object from the opaque pointer
     let solver = unsafe { &mut *(solver as *mut lib::DefaultSolver<T>) };
 
     // Set the termination callback
-    solver.set_termination_callback_c(callback);
+    solver.set_termination_callback_c(callback, userdata);
 }
 
 #[no_mangle]
 pub extern "C" fn clarabel_DefaultSolver_f64_set_termination_callback(
     solver: *mut ClarabelDefaultSolver_f64,
     callback: ClarabelCallbackFcn_f64,
+    userdata: *mut std::ffi::c_void,
 ) {
-    _internal_DefaultSolver_set_termination_callback::<f64>(solver, callback)
+    _internal_DefaultSolver_set_termination_callback::<f64>(solver, callback, userdata)
 }
 
 #[no_mangle]
 pub extern "C" fn clarabel_DefaultSolver_f32_set_termination_callback(
     solver: *mut ClarabelDefaultSolver_f32,
     callback: ClarabelCallbackFcn_f32,
+    userdata: *mut std::ffi::c_void,
 ) {
-    _internal_DefaultSolver_set_termination_callback::<f32>(solver, callback)
+    _internal_DefaultSolver_set_termination_callback::<f32>(solver, callback, userdata)
 }
 
 /// Turn off the termination callback

Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@ set(C_EXAMPLES`
`12`	`12`	`example_json`
`13`	`13`	`example_print_stream`
`14`	`14`	`example_callback`
	`15`	`+ example_callback_with_state`
`15`	`16`	`example_pardiso_mkl`
`16`	`17`	`)`
`17`	`18`
Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@ set(CPP_EXAMPLES`
`10`	`10`	`example_json`
`11`	`11`	`example_print_stream`
`12`	`12`	`example_callback`
	`13`	`+ example_callback_with_state`
`13`	`14`	`example_faer`
`14`	`15`	`example_pardiso_mkl`
`15`	`16`	`)`