[WIP] MATLAB interface

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

@@ -0,0 +1,97 @@
+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:
+        include:
+          - os: windows-latest
+            addpath: install/bin
+          - os: macos-14
+            addpath: install/lib
+
+    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"
+            if [[ "${{ matrix.os }}" == "windows-latest" ]]; then
+              PLATFORM="x86_64-w64-mingw32"
+              choco install wget
+            else
+              PLATFORM="aarch64-apple-darwin"
+            fi
+            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 to PATH (Windows)
+        if: matrix.os == 'windows-latest'
+        run: echo "C:\tools\msys64\mingw64\bin" >> "$GITHUB_PATH"
+
+      - name: Install Fortran compiler (MacOS)
+        if: matrix.os != 'windows-latest'
+        uses: fortran-lang/setup-fortran@main
+        with:
+          compiler: 'gcc'
+          version: '13'
+
+      - name: Configure CMake
+        shell: bash
+        run: |
+          if [[ "${{ matrix.os }}" == "windows-latest" ]]; then
+            cmake -G "MinGW Makefiles" -B "${{github.workspace}}/build" \
+              -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} \
+              -DBQPD="${{github.workspace}}/deps/lib/libbqpd.a"
+          else
+            cmake -B "${{github.workspace}}/build" \
+              -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} \
+              -DBQPD="${{github.workspace}}/deps/lib/libbqpd.a"
+          fi
+
+      - 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: Install unomex
+        run: cmake --install ${{github.workspace}}/build --prefix ${{github.workspace}}/install
+
+      - name: Run example (high-level interface)
+        uses: matlab-actions/run-command@v2
+        with:
+          command: |
+            addpath('${{ matrix.addpath }}'); 
+            run('interfaces/Matlab/example/example_uno.m');
+
+      - name: Run example (low-level interface)
+        uses: matlab-actions/run-command@v2
+        with:
+          command: |
+            addpath('${{ matrix.addpath }}');
+            run('interfaces/Matlab/example/example_hs015.m');
+

CMakeLists.txt

@@ -297,6 +297,58 @@ 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
+   )
+
+   # libut matlab library
+   # cf. https://undocumentedmatlab.com/articles/mex-ctrl-c-interrupt#:~:text=The%20relevant%20functions%20seem%20to,utLongjmpIfInterruptPending(?)
+   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()
+
+   # compile the Unomex source files once
+   add_library(compiled_unomex_files EXCLUDE_FROM_ALL OBJECT ${MATLAB_SOURCE_FILES})
+   set_property(TARGET compiled_unomex_files PROPERTY POSITION_INDEPENDENT_CODE ON)
+   target_include_directories(compiled_unomex_files PUBLIC ${DIRECTORIES} ${Matlab_INCLUDE_DIRS})
+
+   # uno_optimize
+   matlab_add_mex(NAME unomex-optimize SRC $<TARGET_OBJECTS:compiled_unomex_files> interfaces/Matlab/uno_optimize.cpp
+      EXCLUDE_FROM_ALL
+      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 $<TARGET_OBJECTS:compiled_unomex_files> interfaces/Matlab/uno_options.cpp
+      EXCLUDE_FROM_ALL
+      OUTPUT_NAME uno_options
+      LINK_TO ${DEFAULT_UNO_LIB} ${LIBRARIES} ${FORTRAN_LIBS} ${MXLIBUT})
+   target_include_directories(unomex-options PUBLIC ${DIRECTORIES})
+
+   # logical target to compile both mex
+   add_custom_target(unomex DEPENDS unomex-optimize unomex-options)
+
+   # cf. https://github.com/cvanaret/Uno/pull/360#issuecomment-3431367949
+   if(APPLE)
+      set(MEX_RPATH "@executable_path/../extern/bin/maci64;@executable_path/../extern/bin/maca64;@executable_path/../../extern/bin/maci64;@executable_path/../../extern/bin/maca64")
+      set_target_properties(unomex-optimize PROPERTIES BUILD_RPATH "${MEX_RPATH};${CMAKE_BUILD_RPATH}" INSTALL_RPATH "${MEX_RPATH};${CMAKE_INSTALL_RPATH}")
+      set_target_properties(unomex-options PROPERTIES BUILD_RPATH "${MEX_RPATH};${CMAKE_BUILD_RPATH}" INSTALL_RPATH "${MEX_RPATH};${CMAKE_INSTALL_RPATH}")
+   endif()
+endif()
+
 ##################################
 # optional GoogleTest unit tests #
 ##################################
@@ -327,6 +379,11 @@ endif()
 if(TARGET unopy)
    list(APPEND INSTALL_TARGETS unopy)
 endif()
+if(TARGET unomex)
+   list(APPEND INSTALL_TARGETS unomex-optimize unomex-options)
+   set(MATLAB_INSTALL_FILES "interfaces/Matlab/uno.m;interfaces/Matlab/uno_optimize.m;interfaces/Matlab/uno_options.m")
+   install(FILES ${MATLAB_INSTALL_FILES} DESTINATION $<IF:$<BOOL:${WIN32}>,bin,lib>)
+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"
@@ -371,75 +369,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;
@@ -759,15 +710,19 @@ bool uno_set_solver_callbacks(void* solver, NotifyAcceptableIterateUserCallback
 }
 
 bool 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);
    return true;
 }
 
 bool 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);
    return true;
 }