[WIP] MATLAB interface

.github/workflows/build-python-wheels.yml

@@ -148,7 +148,6 @@ jobs:
             CMAKE_Fortran_COMPILER=C:/mingw64/bin/gfortran.exe
           CIBW_CONFIG_SETTINGS_WINDOWS: >
             cmake.define.METIS_LIBRARY=dependencies/bin/libmetis.dll
-            cmake.define.BLAS_LIBRARIES="dependencies/lib/libblas.a;dependencies/lib/libcblas.a"
             cmake.define.AUXILIARY_LIBRARIES=dependencies/lib/libstdc++.a
 
       - name: Store artifacts
@@ -287,4 +286,4 @@ jobs:
 
       - name: Run example
         working-directory: ${{github.workspace}}/interfaces/Python/example
-        run: python example_hs015.py
+        run: python example_hs015.py

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

@@ -0,0 +1,104 @@
+name: Test the Matlab interface on the example 
+
+on:
+  push:
+    branches: [ "main" ]
+    paths-ignore:
+      - '*.md'
+      - 'LICENSE'
+      - '*.cff'
+      - '*.yml'
+      - '*.yaml'
+      - 'docs/**'
+  pull_request:
+    branches: [ "main" ]
+    paths-ignore:
+      - '*.md'
+      - 'LICENSE'
+      - '*.cff'
+      - '*.yml'
+      - '*.yaml'
+      - 'docs/**'
+
+env:
+  BUILD_TYPE: Debug
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-latest
+            addpath: install/bin
+          - os: macos-latest
+            addpath: install/lib
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up MATLAB
+        uses: matlab-actions/setup-matlab@v2
+
+      - name: Install Fortran compiler (macOS)
+        if: startsWith(matrix.os, 'macos')
+        uses: fortran-lang/setup-fortran@main
+        with:
+          compiler: 'gcc'
+          version: '14'
+
+      - name: Setup MSYS2 (Windows)
+        if: startsWith(matrix.os, 'windows')
+        uses: msys2/setup-msys2@v2
+        with:
+          path-type: inherit
+          msystem: MINGW64
+          update: true
+          install: |
+            mingw-w64-x86_64-gcc-fortran
+            mingw-w64-x86_64-cmake
+            mingw-w64-x86_64-make
+
+      - name: Download dependencies
+        run: bash dependencies/scripts/download_dependencies.sh
+
+      - name: Configure (macOS)
+        if: startsWith(matrix.os, 'macos')
+        run: |
+          cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} \
+            -DBQPD=${{github.workspace}}/dependencies/lib/libbqpd.a \
+            -DLAPACK_LIBRARIES=${{github.workspace}}/dependencies/lib/liblapack.a \
+            -DBLAS_LIBRARIES="${{github.workspace}}/dependencies/lib/libblas.a;${{github.workspace}}/dependencies/lib/libcblas.a"
+
+      - name: Configure (Windows)
+        if: startsWith(matrix.os, 'windows')
+        shell: cmd
+        run: |
+          cmake -G "MinGW Makefiles" -B "${{github.workspace}}/build" ^
+            -DBQPD=${{github.workspace}}/dependencies/lib/libbqpd.a ^
+            -DLAPACK_LIBRARIES=${{github.workspace}}/dependencies/lib/liblapack.a ^
+            -DBLAS_LIBRARIES="${{github.workspace}}/dependencies/lib/libblas.a;${{github.workspace}}/dependencies/lib/libcblas.a"
+
+      - name: Build
+        run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} --parallel
+
+      - name: Build unomex
+        run: cmake --build ${{github.workspace}}/build --target unomex --config ${{env.BUILD_TYPE}} --parallel
+
+      - 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

@@ -370,18 +370,70 @@ if(SKBUILD)
       target_compile_definitions(unopy PRIVATE PYBIND11_DETAILED_ERROR_MESSAGES)
    endif()
 
-   if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-      # link-time optimization
-      target_compile_options(unopy PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-flto=auto>)
-      target_link_options(unopy PRIVATE -flto=auto)
-   endif()
-
    install(TARGETS unopy
            LIBRARY DESTINATION unopy    # Linux/macOS: unopy/unopy.so
            RUNTIME DESTINATION unopy    # Windows: unopy/unopy.pyd
    )
 endif()
 
+############################
+# optional Matlab bindings #
+############################
+
+find_package(Matlab 23.2 COMPONENTS MAIN_PROGRAM MEX_COMPILER) # >=23.2 = R2023b
+if(Matlab_FOUND)
+   message(STATUS "Found Matlab ${Matlab_VERSION}")
+
+   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})
+   target_link_libraries(compiled_unomex_files PUBLIC uno_dependencies)
+   set_property(TARGET compiled_unomex_files PROPERTY POSITION_INDEPENDENT_CODE ON)
+   target_include_directories(compiled_unomex_files PUBLIC ${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} uno_dependencies ${MXLIBUT})
+
+   # 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} uno_dependencies ${MXLIBUT})
+   target_include_directories(unomex-options PUBLIC ${directory})
+
+   # 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()
+
+   # install
+   set(MATLAB_INSTALL_FILES "interfaces/Matlab/uno.m;interfaces/Matlab/uno_optimize.m;interfaces/Matlab/uno_options.m")
+   install(TARGETS unomex-optimize LIBRARY DESTINATION ${CMAKE_INSTALL_BINDIR})
+   install(TARGETS unomex-options LIBRARY DESTINATION ${CMAKE_INSTALL_BINDIR})
+   install(FILES ${MATLAB_INSTALL_FILES} DESTINATION $<IF:$<PLATFORM_ID:Windows>,bin,lib>)
+endif()
+
 # ======================
 # GoogleTest unit tests
 # ======================
@@ -434,4 +486,4 @@ install(TARGETS ${INSTALL_TARGETS}
    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}  # static libraries
    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}  # shared libraries
    PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/uno # headers
-)
+)

interfaces/C/Uno_C_API.cpp

@@ -3,8 +3,6 @@
 
 #include <algorithm>
 #include <cstring>
-#include <iostream>
-#include <streambuf>
 #include "Uno_C_API.h"
 #include "../UserModel.hpp"
 #include "Uno.hpp"
@@ -379,75 +377,29 @@ class CUserCallbacks: public UserCallbacks {
    void* user_data;
 };
 
-// std::streambuf wrapper around uno_logger_stream_callback
-class CStreamBuffer : public std::streambuf {
-public:
-   explicit CStreamBuffer(uno_logger_stream_callback 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(uno_logger_stream_callback 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:
    uno_logger_stream_callback 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 uno_int callback_result = this->logger_stream_callback(this->pbase(), static_cast<uno_int>(current_used_buffer_size),
-            this->user_data);
-         if (callback_result != static_cast<uno_int>(current_used_buffer_size)) {
-            return -1;
-         }
-         // move buffer pointer
-         this->pbump(static_cast<int>(-current_used_buffer_size));
-      }
-      return 0;
-   }
-};
-
-// std::ostream wrapper around uno_logger_stream_callback
-class COStream : public std::ostream {
-public:
-   COStream(uno_logger_stream_callback 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 uno_logger_stream_callback
-   CStreamBuffer buffer;
 };
 
-COStream* c_ostream = nullptr;
+CStreamCallback* c_stream_callback = nullptr;
+UserOStream* ostream = nullptr;
 
 struct Solver {
    Uno* solver;
@@ -939,15 +891,19 @@ bool uno_set_solver_callbacks(void* solver, uno_notify_acceptable_iterate_callba
 }
 
 bool uno_set_logger_stream_callback(uno_logger_stream_callback 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;
 }