Adds "auto" option for ldlsolver selection

examples/c/example_qp.c

@@ -2,7 +2,7 @@
 // #define CLARABEL_USE_FLOAT
 
 #include "utils.h"
-
+#include <stdio.h>
 #include <Clarabel.h>
 
 int main(void)
@@ -66,6 +66,14 @@ int main(void)
     ClarabelDefaultSolution solution = clarabel_DefaultSolver_solution(solver);
     print_solution(&solution);
 
+    // Get some detailed solve information
+    ClarabelDefaultInfo_f64 info = clarabel_DefaultSolver_info(solver);
+    printf("primal residual = %e\n", info.res_primal);
+    printf("dual residual   = %e\n", info.res_dual);
+    printf("# of threads    = %d\n", info.linsolver.threads);
+    printf("KKT nonzeros    = %d\n", info.linsolver.nnzA);
+    printf("factor nonzeros = %d\n", info.linsolver.nnzL);
+
     // Free the matrices and the solver
     clarabel_DefaultSolver_free(solver);
 

examples/cpp/example_qp.cpp

@@ -1,5 +1,5 @@
 #include "utils.h"
-
+#include <iostream>
 #include <Clarabel>
 #include <Eigen/Eigen>
 #include <vector>
@@ -56,5 +56,13 @@ int main(void)
     DefaultSolution<double> solution = solver.solution();
     utils::print_solution(solution);
 
+    // Get some detailed solve information
+    DefaultInfo<double> info = solver.info();
+    std::cout << "primal residual = " << info.res_primal << std::endl;
+    std::cout << "dual residual   = " << info.res_dual << std::endl;
+    std::cout << "# of threads    = " << info.linsolver.threads << std::endl;
+    std::cout << "KKT nonzeros    = " << info.linsolver.nnzA << std::endl;
+    std::cout << "factor nonzeros = " << info.linsolver.nnzL << std::endl;
+
     return 0;
 }

examples/cpp/utils.h

@@ -33,6 +33,7 @@ namespace utils
         printf("Slacks (s)\t = ");
         print_array(solution.s);
     }
+
 }
 
 #endif /* UTILS_H */

include/Clarabel

@@ -2,8 +2,8 @@
 #define CLARABEL_H
 
 #include "cpp/CscMatrix.h"
-#include "cpp/DefaultInfo.h"
 #include "cpp/DefaultSettings.h"
+#include "cpp/DefaultInfo.h"
 #include "cpp/DefaultSolution.h"
 #include "cpp/DefaultSolver.h"
 #include "cpp/SupportedConeT.h"

include/Clarabel.h

@@ -2,8 +2,8 @@
 #define CLARABEL_H
 
 #include "c/CscMatrix.h"
-#include "c/DefaultInfo.h"
 #include "c/DefaultSettings.h"
+#include "c/DefaultInfo.h"
 #include "c/DefaultSolution.h"
 #include "c/DefaultSolver.h"
 #include "c/SupportedConeT.h"

include/c/DefaultInfo.h

@@ -2,10 +2,23 @@
 #define CLARABEL_DEFAULT_INFO_H
 
 #include "ClarabelTypes.h"
+#include "DefaultSettings.h"
 #include "DefaultSolution.h"
 
 #include <stdint.h>
 
+
+typedef struct ClarabelLinearSolverInfo
+{
+    ClarabelDirectSolveMethods name;
+    uint32_t threads;
+    bool direct;
+    uint32_t nnzA;
+    uint32_t nnzL;
+    enum ClarabelSolverStatus status;
+} ClarabelLinearSolverInfo;
+
+
 // ClarabelDefaultInfo types
 typedef struct ClarabelDefaultInfo_f64
 {
@@ -24,6 +37,8 @@ typedef struct ClarabelDefaultInfo_f64
     double ktratio;
     double solve_time;
     enum ClarabelSolverStatus status;
+    ClarabelLinearSolverInfo linsolver;
+    // NB : `PrintStream stream` not passed to C API
 } ClarabelDefaultInfo_f64;
 
 typedef struct ClarabelDefaultInfo_f32
@@ -43,6 +58,8 @@ typedef struct ClarabelDefaultInfo_f32
     float ktratio;
     double solve_time;
     enum ClarabelSolverStatus status;
+    ClarabelLinearSolverInfo linsolver;
+    // NB : `PrintStream stream` not passed to C API
 } ClarabelDefaultInfo_f32;
 
 #ifdef CLARABEL_USE_FLOAT

include/c/DefaultSettings.h

@@ -10,6 +10,7 @@
 // ClarabelDefaultSettings types
 typedef enum ClarabelDirectSolveMethods
 {
+    AUTO,
     QDLDL,
     #ifdef FEATURE_FAER_SPARSE
     FAER,

include/cpp/DefaultInfo.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "DefaultSettings.h"
 #include "DefaultSolution.h"
 
 #include <cstdint>
@@ -8,6 +9,16 @@
 namespace clarabel
 {
 
+
+struct LinearSolverInfo
+{
+    ClarabelDirectSolveMethods name;
+    uint32_t threads;
+    bool direct;
+    uint32_t nnzA;
+    uint32_t nnzL;
+};
+
 template<typename T = double>
 struct DefaultInfo
 {
@@ -28,6 +39,7 @@ struct DefaultInfo
     T ktratio;
     double solve_time;
     clarabel::SolverStatus status;
+    clarabel::LinearSolverInfo linsolver;
     // NB : `PrintStream stream` not passed to C++ API
 };
 

include/cpp/DefaultSettings.h

@@ -8,6 +8,7 @@ namespace clarabel
 
 enum class ClarabelDirectSolveMethods
 {
+    AUTO,
     QDLDL,
     #ifdef FEATURE_FAER_SPARSE
     FAER,

rust_wrapper/src/solver/implementations/default/info.rs

@@ -1,6 +1,30 @@
-use clarabel::{algebra::FloatT, solver::DefaultInfo};
+#![allow(non_snake_case)]
 
+use clarabel::{algebra::FloatT, solver::DefaultInfo};
+use clarabel::solver::LinearSolverInfo;
 use crate::solver::implementations::default::solver::ClarabelSolverStatus;
+use super::settings::ClarabelDirectSolveMethods;
+
+#[repr(C)]
+pub struct ClarabelLinearSolverInfo {
+        pub name: ClarabelDirectSolveMethods,
+        pub threads: u32,
+        pub direct: bool,
+        pub nnzA: u32, 
+        pub nnzL: u32, 
+}
+
+impl From<&LinearSolverInfo> for ClarabelLinearSolverInfo {
+    fn from(linsolver: &LinearSolverInfo) -> Self {
+        Self {
+            name: (&linsolver.name).into(),
+            threads: linsolver.threads as u32,
+            direct: linsolver.direct,
+            nnzA: linsolver.nnzA as u32,
+            nnzL: linsolver.nnzL as u32,
+        }
+    }
+}
 
 #[repr(C)]
 pub struct ClarabelDefaultInfo<T> {
@@ -20,10 +44,12 @@ pub struct ClarabelDefaultInfo<T> {
 
     pub solve_time: f64,
     pub status: ClarabelSolverStatus,
+
+    pub linsolver: ClarabelLinearSolverInfo,
 }
 
-impl<T: FloatT> From<&mut DefaultInfo<T>> for ClarabelDefaultInfo<T> {
-    fn from(info: &mut DefaultInfo<T>) -> Self {
+impl<T: FloatT> From<&DefaultInfo<T>> for ClarabelDefaultInfo<T> {
+    fn from(info: &DefaultInfo<T>) -> Self {
         Self {
             μ: info.μ,
             sigma: info.sigma,
@@ -39,7 +65,8 @@ impl<T: FloatT> From<&mut DefaultInfo<T>> for ClarabelDefaultInfo<T> {
             gap_rel: info.gap_rel,
             ktratio: info.ktratio,
             solve_time: info.solve_time,
-            status: ClarabelSolverStatus::from(&mut info.status),
+            status: ClarabelSolverStatus::from(&info.status),
+            linsolver: ClarabelLinearSolverInfo::from(&info.linsolver),
         }
     }
 }

rust_wrapper/src/solver/implementations/default/settings.rs

@@ -5,13 +5,38 @@ use clarabel::algebra::FloatT;
 #[allow(dead_code)]
 #[allow(clippy::upper_case_acronyms)]
 pub enum ClarabelDirectSolveMethods {
+    AUTO,
     QDLDL,
     #[cfg(feature = "faer-sparse")]
     FAER,
     // MKL, (not supported yet)
     // CHOLMOD, (not supported yet)
 }
 
+impl From<&ClarabelDirectSolveMethods> for String {
+    fn from(value: &ClarabelDirectSolveMethods) -> Self {
+        match value {
+            ClarabelDirectSolveMethods::AUTO => String::from("auto"),
+            ClarabelDirectSolveMethods::QDLDL => String::from("qdldl"),
+            #[cfg(feature = "faer-sparse")]
+            ClarabelDirectSolveMethods::FAER => String::from("faer"),
+        }
+    }
+}
+
+impl From<&String> for ClarabelDirectSolveMethods {
+    fn from(value: &String) -> Self {
+        match value.as_str() {
+            "auto" => ClarabelDirectSolveMethods::AUTO,
+            "qdldl" => ClarabelDirectSolveMethods::QDLDL,
+            #[cfg(feature = "faer-sparse")]
+            "faer" => ClarabelDirectSolveMethods::FAER,
+            _ => ClarabelDirectSolveMethods::AUTO,
+        }
+    }
+}
+
+
 #[allow(non_camel_case_types)]
 #[cfg(feature = "sdp")]
 #[repr(C)]
@@ -102,10 +127,11 @@ fn _internal_DefaultSettings_default<T: FloatT>() -> ClarabelDefaultSettings<T>
     let default = clarabel::solver::DefaultSettings::<T>::default();
 
     let default_direct_solver_setting = match default.direct_solve_method.as_str() {
+        "auto" => ClarabelDirectSolveMethods::AUTO, 
         "qdldl" => ClarabelDirectSolveMethods::QDLDL,
         //"mkl" => ClarabelDirectSolveMethods::MKL,
         //"cholmod" => ClarabelDirectSolveMethods::CHOLMOD,
-        _ => ClarabelDirectSolveMethods::QDLDL, // Default
+        _ => ClarabelDirectSolveMethods::AUTO, // Default
     };
 
     #[cfg(feature = "sdp")]

rust_wrapper/src/solver/implementations/default/solution.rs

@@ -31,7 +31,7 @@ impl<T: FloatT> DefaultSolution<T> {
             z_length: solution.z.len(),
             s: solution.s.as_mut_ptr(),
             s_length: solution.s.len(),
-            status: ClarabelSolverStatus::from(&mut solution.status),
+            status: ClarabelSolverStatus::from(&solution.status),
             obj_val: solution.obj_val,
             obj_val_dual: solution.obj_val_dual,
             solve_time: solution.solve_time,

rust_wrapper/src/solver/implementations/default/solver.rs

@@ -362,8 +362,8 @@ pub enum ClarabelSolverStatus {
     ClarabelInsufficientProgress,
 }
 
-impl From<&mut SolverStatus> for ClarabelSolverStatus {
-    fn from(value: &mut SolverStatus) -> Self {
+impl From<&SolverStatus> for ClarabelSolverStatus {
+    fn from(value: &SolverStatus) -> Self {
         match value {
             SolverStatus::Unsolved => ClarabelSolverStatus::ClarabelUnsolved,
             SolverStatus::Solved => ClarabelSolverStatus::ClarabelSolved,
@@ -418,7 +418,7 @@ fn _internal_DefaultSolver_info<T: FloatT>(solver: *mut c_void) -> ClarabelDefau
     let solver = unsafe { &mut *(solver as *mut lib::DefaultSolver<T>) };
 
     // Get the info field and convert it to a C struct.
-    ClarabelDefaultInfo::<T>::from(&mut solver.info)
+    ClarabelDefaultInfo::<T>::from(&solver.info)
 }
 
 #[no_mangle]

rust_wrapper/src/utils/mod.rs

@@ -41,14 +41,7 @@ pub fn get_solver_settings_from_c<T: FloatT>(
         min_terminate_step_length: value.min_terminate_step_length,
         max_threads: value.max_threads,
         direct_kkt_solver: value.direct_kkt_solver,
-        direct_solve_method: match value.direct_solve_method {
-            ClarabelDirectSolveMethods::QDLDL => String::from("qdldl"),
-            #[cfg(feature = "faer-sparse")]
-            ClarabelDirectSolveMethods::FAER => String::from("faer"),
-            // Not supported yet
-            //ClarabelDirectSolveMethods::MKL => String::from("mkl"),
-            //ClarabelDirectSolveMethods::CHOLMOD => String::from("cholmod"),
-        },
+        direct_solve_method: (&value.direct_solve_method).into(),
         static_regularization_enable: value.static_regularization_enable,
         static_regularization_constant: value.static_regularization_constant,
         static_regularization_proportional: value.static_regularization_proportional,

tests/CMakeLists.txt

@@ -30,6 +30,7 @@ add_executable(clarabel_cpp_tests
     mixed_conic.cpp
     data_updating.cpp
     sdp_chordal.cpp
+    get_info.cpp
 )
 target_link_libraries(clarabel_cpp_tests 
     libclarabel_c_shared