configurable print streams

.gitignore

@@ -3,11 +3,20 @@ rust_wrapper/target
 rust_wrapper/headers
 rust_wrapper/Cargo.lock
 
-# CMake build directory
-build
+# CMake build directory and other cruft
+build/*
+*.cmake 
+Makefile
+CmakeFiles/*
 
 .*/
 !.vscode/
 !.github
 
 CMakePresets.json
+
+# compiled examples, but not source
+examples/cpp/*
+examples/c/*
+!examples/c/*.c
+!examples/cpp/*.cpp

examples/c/CMakeLists.txt

@@ -10,6 +10,7 @@ set(C_EXAMPLES
   example_socp
   example_sdp
   example_json
+  example_print_stream
 )
 
 # Compile utils.c as a library

examples/c/example_json.c

@@ -19,14 +19,14 @@ int main(void)
     strcpy(filename, TO_STRING(EXAMPLES_ROOT_DIR));
     strcat(filename, "/data/hs35.json");
 
-    ClarabelDefaultSolver* solver = clarabel_DefaultSolver_read_from_file(filename);
+    ClarabelDefaultSolver* solver = clarabel_DefaultSolver_load_from_file(filename);
     clarabel_DefaultSolver_solve(solver);
 
     // write it back to a file
     // char filename_out[1024];
     // strcpy(filename_out, TO_STRING(EXAMPLES_ROOT_DIR));
     // strcat(filename_out, "/data/output_c.json");
-    // clarabel_DefaultSolver_write_to_file(solver, filename_out);
+    // clarabel_DefaultSolver_save_to_file(solver, filename_out);
 
     clarabel_DefaultSolver_free(solver);
     return 0;

examples/c/example_print_stream.c

@@ -0,0 +1,75 @@
+// #define FEATURE_SDP
+#include "utils.h"
+#include <string.h>
+#include <Clarabel.h>
+#include <math.h>
+#include <stdio.h>
+
+
+int main(void)
+{
+
+    ClarabelCscMatrix P;
+    clarabel_CscMatrix_init(
+        &P,
+        2,                          // row
+        2,                          // col
+        (uintptr_t[]){ 0, 1, 2 },   // colptr
+        (uintptr_t[]){ 0, 1 },      // rowval
+        (ClarabelFloat[]){ 6., 4. } // nzval
+    );
+
+    ClarabelFloat q[2] = { -1., -4. };
+    ClarabelCscMatrix A;
+    clarabel_CscMatrix_init(
+        &A,
+        5,                                             // row
+        2,                                             // col
+        (uintptr_t[]){ 0, 3, 6 },                      // colptr
+        (uintptr_t[]){ 0, 1, 3, 0, 2, 4 },             // rowval
+        (ClarabelFloat[]){ 1., 1., -1., -2., 1., -1. } // nzval
+    );
+
+    ClarabelFloat b[5] = { 0., 1., 1., 1., 1. };
+
+    ClarabelSupportedConeT cones[2] = { ClarabelZeroConeT(1), ClarabelNonnegativeConeT(4) };
+
+    // Settings
+    ClarabelDefaultSettings settings = clarabel_DefaultSettings_default();
+
+    // Build solver
+    ClarabelDefaultSolver *solver = clarabel_DefaultSolver_new(
+        &P, // P
+        q,  // q
+        &A, // A
+        b,  // b
+        2,  // n_cones
+        cones, &settings
+    );
+
+    // redirect progress output to a file 
+    printf("Printing to file ....\n");
+    clarabel_DefaultSolver_print_to_file(solver,"clarabel_example_print_stream.txt");
+
+    // solve
+    clarabel_DefaultSolver_solve(solver);
+
+    // redirect progress output to a buffer
+    printf("Printing to buffer ....\n");
+    clarabel_DefaultSolver_print_to_buffer(solver);
+
+    // solve again 
+    clarabel_DefaultSolver_solve(solver);
+
+    // fetch and print the buffer 
+    printf("Recovering from buffer ....\n");
+    const char* buffer = clarabel_DefaultSolver_get_print_buffer(solver);
+    printf("%s\n", buffer);
+    clarabel_free_print_buffer(buffer);
+
+    // restore the buffer to stdout
+    printf("Printing to stdout ....\n");
+    clarabel_DefaultSolver_print_to_stdout(solver);
+    clarabel_DefaultSolver_solve(solver);
+
+}

examples/cpp/CMakeLists.txt

@@ -9,6 +9,7 @@ set(CPP_EXAMPLES
   example_sdp
   example_faer
   example_json
+  example_print_stream
 )
 
 # Define an executable target for each example

examples/cpp/example_json.cpp

@@ -23,13 +23,13 @@ int main(void)
     std::string filename = rootdir + filepath; 
     std::cout << "Read from file: " << filename << endl;
 
-    DefaultSolver<double> solver = DefaultSolver<double>::read_from_file(filename);
+    DefaultSolver<double> solver = DefaultSolver<double>::load_from_file(filename);
     solver.solve();
 
     // write it back to a file 
     // std::string outpath = "/data/output.json";
     // std::string filename_out = rootdir + outpath;
-    // solver.write_to_file(filename_out);
+    // solver.save_to_file(filename_out);
 
     return 0;
 

examples/cpp/example_print_stream.cpp

@@ -0,0 +1,73 @@
+#include "utils.h"
+
+#include <Clarabel>
+#include <Eigen/Eigen>
+#include <vector>
+#include <iostream>
+
+using namespace clarabel;
+using namespace std;
+using namespace Eigen;
+
+int main(void)
+{
+    /* From dense matrix:
+     * [[6., 0.],
+     *  [0., 4.]]
+     */
+    MatrixXd P_dense(2, 2);
+    P_dense <<
+        6., 0.,
+        0., 4.;
+
+    SparseMatrix<double> P = P_dense.sparseView();
+    P.makeCompressed();
+
+    Vector<double, 2> q = { -1., -4. };
+
+    MatrixXd A_dense(5, 2);
+    A_dense <<
+         1., -2., // <-- LHS of equality constraint (lower bound)
+         1.,  0., // <-- LHS of inequality constraint (upper bound)
+         0.,  1., // <-- LHS of inequality constraint (upper bound)
+        -1.,  0., // <-- LHS of inequality constraint (lower bound)
+         0., -1.; // <-- LHS of inequality constraint (lower bound)
+
+    SparseMatrix<double> A = A_dense.sparseView();
+    A.makeCompressed();
+
+    Vector<double, 5> b = { 0., 1., 1., 1., 1. };
+
+    vector<SupportedConeT<double>> cones
+    {
+        ZeroConeT<double>(1),
+        NonnegativeConeT<double>(4),
+    };
+
+    // Settings
+    DefaultSettings<double> settings = DefaultSettings<double>::default_settings();
+
+    // Build solver
+    DefaultSolver<double> solver(P, q, A, b, cones, settings);
+
+    // redirect progress output to a file 
+    std::cout << "Printing to file ...." << std::endl;
+    solver.print_to_file("clarabel_example_print_stream.txt");
+    solver.solve();
+
+    // redirect progress output to a buffer
+    std::cout << "Printing to buffer ...." << std::endl;
+    solver.print_to_buffer();
+    solver.solve();
+
+    std::cout << "Recovering from buffer ...." << std::endl;
+    std::string bufstr = solver.get_print_buffer();
+    std::cout << bufstr << std::endl;
+
+    // restore the buffer to stdout
+    std::cout << "Printing to stdout ...." << std::endl;
+    solver.print_to_stdout();
+    solver.solve();
+
+    return 0;
+}

include/c/DefaultSolver.h

@@ -58,37 +58,101 @@ static inline ClarabelDefaultSolver *clarabel_DefaultSolver_new(const ClarabelCs
 }
 
 #ifdef FEATURE_SERDE 
-// DefaultSolver::read_from_file
-ClarabelDefaultSolver_f64 *clarabel_DefaultSolver_f64_read_from_file(const char *filename);
-ClarabelDefaultSolver_f32 *clarabel_DefaultSolver_f32_read_from_file(const char *filename);
+// DefaultSolver::load_from_file
+ClarabelDefaultSolver_f64 *clarabel_DefaultSolver_f64_load_from_file(const char *filename);
+ClarabelDefaultSolver_f32 *clarabel_DefaultSolver_f32_load_from_file(const char *filename);
     #ifdef CLARABEL_USE_FLOAT
-    static inline ClarabelDefaultSolver *clarabel_DefaultSolver_read_from_file(const char *filename)
+    static inline ClarabelDefaultSolver *clarabel_DefaultSolver_load_from_file(const char *filename)
     {
-        return clarabel_DefaultSolver_f32_read_from_file(filename);
+        return clarabel_DefaultSolver_f32_load_from_file(filename);
     }
     #else
-    static inline ClarabelDefaultSolver *clarabel_DefaultSolver_read_from_file(const char *filename)
+    static inline ClarabelDefaultSolver *clarabel_DefaultSolver_load_from_file(const char *filename)
     {
-        return clarabel_DefaultSolver_f64_read_from_file(filename);
+        return clarabel_DefaultSolver_f64_load_from_file(filename);
     }
     #endif // CLARABEL_USE_FLOAT
 
-// DefaultSolver::write_to_file
-void clarabel_DefaultSolver_f64_write_to_file(ClarabelDefaultSolver_f64 *solver, const char *filename);
-void clarabel_DefaultSolver_f32_write_to_file(ClarabelDefaultSolver_f32 *solver, const char *filename);
+// DefaultSolver::save_to_file
+void clarabel_DefaultSolver_f64_save_to_file(ClarabelDefaultSolver_f64 *solver, const char *filename);
+void clarabel_DefaultSolver_f32_save_to_file(ClarabelDefaultSolver_f32 *solver, const char *filename);
     #ifdef CLARABEL_USE_FLOAT
-    static inline void clarabel_DefaultSolver_write_to_file(ClarabelDefaultSolver *solver, const char *filename)
+    static inline void clarabel_DefaultSolver_save_to_file(ClarabelDefaultSolver *solver, const char *filename)
     {
-        clarabel_DefaultSolver_f32_write_to_file(solver,filename);
+        clarabel_DefaultSolver_f32_save_to_file(solver,filename);
     }
     #else
-    static inline void clarabel_DefaultSolver_write_to_file(ClarabelDefaultSolver *solver, const char *filename)
+    static inline void clarabel_DefaultSolver_save_to_file(ClarabelDefaultSolver *solver, const char *filename)
     {
-        clarabel_DefaultSolver_f64_write_to_file(solver,filename);
+        clarabel_DefaultSolver_f64_save_to_file(solver,filename);
     }
     #endif // CLARABEL_USE_FLOAT
 #endif // FEATURE_SERDE
 
+// DefaultSolver::print_to_stdout
+void clarabel_DefaultSolver_f64_print_to_stdout(ClarabelDefaultSolver_f64 *solver);
+void clarabel_DefaultSolver_f32_print_to_stdout(ClarabelDefaultSolver_f32 *solver);
+#ifdef CLARABEL_USE_FLOAT
+    static inline void clarabel_DefaultSolver_print_to_stdout(ClarabelDefaultSolver *solver)
+    {
+        clarabel_DefaultSolver_f32_print_to_stdout(solver);
+    }
+#else
+    static inline void clarabel_DefaultSolver_print_to_stdout(ClarabelDefaultSolver *solver)
+    {
+        clarabel_DefaultSolver_f64_print_to_stdout(solver);
+    }
+#endif // CLARABEL_USE_FLOAT
+
+// DefaultSolver::print_to_file
+void clarabel_DefaultSolver_f64_print_to_file(ClarabelDefaultSolver_f64 *solver, const char *filename);
+void clarabel_DefaultSolver_f32_print_to_file(ClarabelDefaultSolver_f32 *solver, const char *filename);
+#ifdef CLARABEL_USE_FLOAT
+    static inline void clarabel_DefaultSolver_print_to_file(ClarabelDefaultSolver *solver, const char *filename)
+    {
+        clarabel_DefaultSolver_f32_print_to_file(solver, const char *filename);
+    }
+#else
+    static inline void clarabel_DefaultSolver_print_to_file(ClarabelDefaultSolver *solver, const char *filename)
+    {
+        clarabel_DefaultSolver_f64_print_to_file(solver, filename);
+    }
+#endif // CLARABEL_USE_FLOAT
+
+// DefaultSolver::print_to_buffer
+void clarabel_DefaultSolver_f64_print_to_buffer(ClarabelDefaultSolver_f64 *solver);
+void clarabel_DefaultSolver_f32_print_to_buffer(ClarabelDefaultSolver_f32 *solver);
+#ifdef CLARABEL_USE_FLOAT
+    static inline void clarabel_DefaultSolver_print_to_buffer(ClarabelDefaultSolver *solver)
+    {
+        clarabel_DefaultSolver_f32_print_to_buffer(solver);
+    }
+#else
+    static inline void clarabel_DefaultSolver_print_to_buffer(ClarabelDefaultSolver *solver)
+    {
+        clarabel_DefaultSolver_f64_print_to_buffer(solver);
+    }
+#endif // CLARABEL_USE_FLOAT
+
+// DefaultSolver::print_to_buffer
+// NB: The buffer is owned by rust and should not be freed by the C side caller.
+// Call clarabel_free_print_buffer to free the buffer.  Failure to do so will
+// result in a memory leak.
+const char* clarabel_DefaultSolver_f64_get_print_buffer(ClarabelDefaultSolver_f64 *solver);
+const char* clarabel_DefaultSolver_f32_get_print_buffer(ClarabelDefaultSolver_f32 *solver);
+void clarabel_free_print_buffer(const char* buffer);
+
+#ifdef CLARABEL_USE_FLOAT
+    static inline const char* clarabel_DefaultSolver_get_print_buffer(ClarabelDefaultSolver *solver)
+    {
+        return clarabel_DefaultSolver_f32_get_print_buffer(solver);
+    }
+    #else
+static inline const char* clarabel_DefaultSolver_get_print_buffer(ClarabelDefaultSolver *solver)
+    {
+        return clarabel_DefaultSolver_f64_get_print_buffer(solver);
+    }
+#endif // CLARABEL_USE_FLOAT
 
 
 // DefaultSolver::solve

include/cpp/DefaultInfo.h

@@ -28,6 +28,7 @@ struct DefaultInfo
     T ktratio;
     double solve_time;
     clarabel::SolverStatus status;
+    // NB : `PrintStream stream` not passed to C++ API
 };
 
 // Instantiate the templates