[WIP] MATLAB interface

.github/workflows/matlab-test-example.yml

@@ -0,0 +1,73 @@
+name: Test the Matlab interface on the example 
+
+on:
+  push:
+    branches: [ "main" ]
+    paths-ignore:
+      - '*.md'
+      - 'LICENSE'
+      - '*.cff'
+  pull_request:
+    branches: [ "main" ]
+    paths-ignore:
+      - '*.md'
+      - 'LICENSE'
+      - '*.cff'
+
+env:
+  BUILD_TYPE: Release
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+       matrix:
+        os: [windows-latest]
+        architecture: [x64]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up MATLAB
+        uses: matlab-actions/setup-matlab@v2
+
+      - name: Download dependency (BQPD)
+        shell: bash
+        run: |
+            VERSION_BQPD="1.0.0"
+            PLATFORM="x86_64-w64-mingw32"
+            choco install wget
+            wget https://github.com/leyffer/BQPD_jll.jl/releases/download/BQPD-v${VERSION_BQPD}%2B0/BQPD.v${VERSION_BQPD}.$PLATFORM-libgfortran5.tar.gz
+            mkdir deps
+            tar -xzvf BQPD.v${VERSION_BQPD}.$PLATFORM-libgfortran5.tar.gz -C deps
+
+      - name: add MinGW64 directory to path
+        run: echo "C:\tools\msys64\mingw64\bin" >> "$GITHUB_PATH"
+
+      - name: Configure Uno CMake
+        shell: cmd
+        run: |
+          cmake -G "MinGW Makefiles" -B ${{github.workspace}}\build ^
+          -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} ^
+          -DBQPD=${{github.workspace}}\deps\lib\libbqpd.a 
+
+      - name: Build uno
+        run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} -j4
+
+      - name: Build unomex
+        run: cmake --build ${{github.workspace}}/build --target unomex --config ${{env.BUILD_TYPE}} -j4
+
+      - name: Run example (high-level interface)
+        uses: matlab-actions/run-command@v2
+        with:
+          command: |
+            addpath('build'); 
+            run('interfaces/Matlab/example/example_uno.m')
+
+      - name: Run example (low-level interface)
+        uses: matlab-actions/run-command@v2
+        with:
+          command: |
+            addpath('build'); 
+            run('interfaces/Matlab/example/example_hs015.m')
+

CMakeLists.txt

@@ -297,6 +297,43 @@ if(pybind11_DIR)
    target_include_directories(unopy PUBLIC ${DIRECTORIES})
 endif()
 
+############################
+# optional Matlab bindings #
+############################
+
+find_package(Matlab COMPONENTS MAIN_PROGRAM MEX_COMPILER)
+if(Matlab_FOUND)
+   message(STATUS "Found Matlab")
+
+   file(GLOB MATLAB_SOURCE_FILES
+      interfaces/Matlab/cpp_classes/*.cpp
+      interfaces/Matlab/unomex/*.cpp
+   )
+
+   get_filename_component(Matlab_MX_LIBRARY_PATH ${Matlab_MX_LIBRARY} DIRECTORY )
+   find_library(MXLIBUT NAMES libut ut 
+                PATHS ${Matlab_MX_LIBRARY_PATH})
+   if(MXLIBUT)
+      add_definitions("-D HAS_MXLIBUT")
+   endif()
+
+   # uno_optimize
+   matlab_add_mex(NAME unomex-optimize SRC interfaces/Matlab/unomex_optimize.cpp ${MATLAB_SOURCE_FILES}
+      OUTPUT_NAME uno_optimize
+      LINK_TO ${DEFAULT_UNO_LIB} ${LIBRARIES} ${FORTRAN_LIBS} ${MXLIBUT})
+   target_include_directories(unomex-optimize PUBLIC ${DIRECTORIES})
+
+   # uno_options
+   matlab_add_mex(NAME unomex-options SRC interfaces/Matlab/unomex_options.cpp ${MATLAB_SOURCE_FILES}
+      OUTPUT_NAME uno_options
+      LINK_TO ${DEFAULT_UNO_LIB} ${LIBRARIES} ${FORTRAN_LIBS})
+   target_include_directories(unomex-options PUBLIC ${DIRECTORIES})
+
+   # logical target to compile both mex
+   add_custom_target(unomex DEPENDS unomex-optimize unomex-options)
+
+endif()
+
 ##################################
 # optional GoogleTest unit tests #
 ##################################
@@ -327,6 +364,9 @@ endif()
 if(TARGET unopy)
    list(APPEND INSTALL_TARGETS unopy)
 endif()
+if(TARGET unomex)
+   list(APPEND INSTALL_TARGETS unomex-optimize unomex-options)
+endif()
 install(TARGETS ${INSTALL_TARGETS}
    COMPONENT libuno
    EXPORT UnoTargets

interfaces/C/Uno_C_API.cpp

@@ -4,8 +4,6 @@
 #include <algorithm>
 #include <cassert>
 #include <cstring>
-#include <iostream>
-#include <streambuf>
 #include "Uno_C_API.h"
 #include "../UserModel.hpp"
 #include "Uno.hpp"
@@ -365,75 +363,28 @@ class CUserCallbacks: public UserCallbacks {
    void* user_data;
 };
 
-// std::streambuf wrapper around LoggerStreamUserCallback
-class CStreamBuffer : public std::streambuf {
-public:
-   explicit CStreamBuffer(LoggerStreamUserCallback logger_stream_callback, void* user_data, std::size_t buffer_size) :
-         logger_stream_callback(logger_stream_callback), user_data(user_data) {
-      // allocate output buffer and set stream buffer pointer
-      this->buffer = new char[buffer_size];
-      this->setp(this->buffer, this->buffer + buffer_size - 1);
-   }
-   ~CStreamBuffer() override {
-      // flush remaining data and release buffer memory
-      this->sync();
-      delete[] this->buffer;
-   }
+class CStreamCallback : public UserStreamCallback {
+public: 
+   CStreamCallback(LoggerStreamUserCallback logger_stream_callback, void* user_data) :
+   UserStreamCallback(), logger_stream_callback(logger_stream_callback), user_data(user_data) { }
+   ~CStreamCallback() override { }
 
-protected:
-   // called on buffer overflow
-   int overflow(int character) override {
-      if (character != EOF) {
-            // insert the character into the buffer
-            *this->pptr() = traits_type::to_char_type(character);
-            this->pbump(1);
+   int32_t operator()(const char* buf, int32_t len) const override {
+      if (this->logger_stream_callback) {
+         return this->logger_stream_callback(buf, len, this->user_data);
+      } 
+      else {
+         return 0;
       }
-      // return EOF for error
-      return (this->flush_buffer() == 0) ? character : EOF;
-   }
-
-   int sync() override {
-      return this->flush_buffer();
    }
 
 private:
    LoggerStreamUserCallback logger_stream_callback;
    void* user_data;
-   char* buffer;
-
-   // flush buffer to the logger callback
-   int flush_buffer() {
-      // check for invalid stream callback
-      if (!this->logger_stream_callback) {
-         return -1;
-      }
-      std::ptrdiff_t current_used_buffer_size = this->pptr() - this->pbase();
-      if (current_used_buffer_size > 0) {
-         // call user logger callback
-         const int32_t callback_result = this->logger_stream_callback(this->pbase(), static_cast<int32_t>(current_used_buffer_size),
-            this->user_data);
-         if (callback_result != static_cast<int32_t>(current_used_buffer_size)) {
-            return -1;
-         }
-         // move buffer pointer
-         this->pbump(static_cast<int>(-current_used_buffer_size));
-      }
-      return 0;
-   }
-};
-
-// std::ostream wrapper around LoggerStreamUserCallback
-class COStream : public std::ostream {
-public:
-   COStream(LoggerStreamUserCallback logger_stream_callback, void* user_data, std::size_t buffer_size = 1024) : // 1024 default buffer size
-      std::ostream(&this->buffer), buffer(logger_stream_callback, user_data, buffer_size) { }
-
-private:
-   // internal stream buffer that sends output to the LoggerStreamUserCallback
-   CStreamBuffer buffer;
 };
 
-COStream* c_ostream = nullptr;
+CStreamCallback* c_stream_callback = nullptr;
+UserOStream* ostream = nullptr;
 
 struct Solver {
    Uno* solver;
@@ -449,14 +400,18 @@ void uno_get_version(int32_t* major, int32_t* minor, int32_t* patch) {
 }
 
 void uno_set_logger_stream_callback(LoggerStreamUserCallback logger_stream_callback, void* user_data) {
-   delete c_ostream;
-   c_ostream = new COStream(logger_stream_callback, user_data);
-   Logger::set_stream(*c_ostream);
+   delete c_stream_callback;
+   delete ostream;
+   c_stream_callback = new CStreamCallback(logger_stream_callback, user_data);
+   ostream = new UserOStream(c_stream_callback);
+   Logger::set_stream(*ostream);
 }
 
 void uno_reset_logger_stream() {
-   delete c_ostream;
-   c_ostream = nullptr;
+   delete ostream;
+   delete c_stream_callback;
+   c_stream_callback = nullptr;
+   ostream = nullptr;
    Logger::set_stream(std::cout);
 }
 

interfaces/C/Uno_C_API.h

@@ -33,7 +33,7 @@ extern "C" {
    const char UNO_UPPER_TRIANGLE = 'U';
 
    // Option type: 0 = integer, 1 = double, 2 = boolean, 3 = string, -1 = not found
-   const int32_t UNO_OPTION_TYPE_INT = 0;
+   const int32_t UNO_OPTION_TYPE_INTEGER = 0;
    const int32_t UNO_OPTION_TYPE_DOUBLE = 1;
    const int32_t UNO_OPTION_TYPE_BOOL = 2;
    const int32_t UNO_OPTION_TYPE_STRING = 3;

interfaces/Julia/gen/prologue.jl

@@ -20,7 +20,7 @@ const UNO_LOWER_TRIANGLE = Cchar('L')
 const UNO_UPPER_TRIANGLE = Cchar('U')
 
 # Option type: 0 = integer, 1 = double, 2 = boolean, 3 = string, -1 = not found
-const UNO_OPTION_TYPE_INT       = Cint(0)
+const UNO_OPTION_TYPE_INTEGER   = Cint(0)
 const UNO_OPTION_TYPE_DOUBLE    = Cint(1)
 const UNO_OPTION_TYPE_BOOL      = Cint(2)
 const UNO_OPTION_TYPE_STRING    = Cint(3)

interfaces/Julia/src/libuno.jl

@@ -14,7 +14,7 @@ const UNO_ONE_BASED_INDEXING = Cint(1)
 const UNO_LOWER_TRIANGLE = Cchar('L')
 const UNO_UPPER_TRIANGLE = Cchar('U')
 
-const UNO_OPTION_TYPE_INT = Cint(0)
+const UNO_OPTION_TYPE_INTEGER = Cint(0)
 const UNO_OPTION_TYPE_DOUBLE = Cint(1)
 const UNO_OPTION_TYPE_BOOL = Cint(2)
 const UNO_OPTION_TYPE_STRING = Cint(3)