Solver multiobjective

.github/workflows/build_test.yml

@@ -0,0 +1,49 @@
+name: Build Debug (Ubuntu)
+on: [push, pull_request]
+
+env:
+  # CMake build types: Release, Debug, RelWithDebInfo
+  BUILD_TYPE: Debug
+
+jobs:
+  build:
+    # The CMake configure and build commands are platform agnostic and should work equally well on Windows or Mac.
+    # You can convert this to a matrix build if you need cross-platform coverage.
+    # See: https://docs.github.com/en/free-pro-team@latest/actions/learn-github-actions/managing-complex-workflows#using-a-build-matrix
+    strategy:
+      matrix:
+        compiler:
+            - g++-10
+            - g++-11
+            - g++-12
+            - g++-13
+            - clang-13
+            - clang-14
+            - clang-15
+            - clang-16
+            - clang-17
+        os:
+            - macos-latest
+            - ubuntu-latest
+    runs-on: ${{ matrix.os }}
+
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: true
+
+    - name: Configure
+      # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
+      # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
+      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}}
+
+    - name: Build
+      # Build your program with the given configuration
+      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
+
+    - name: Test
+      working-directory: ${{github.workspace}}/build
+      # Execute tests defined by the CMake configuration.
+      # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
+      run: ctest -C ${{env.BUILD_TYPE}}
+

.gitmodules

@@ -1,3 +1,9 @@
 [submodule "external/googletest"]
 	path = external/googletest
 	url = https://github.com/google/googletest.git
+[submodule "external/paradiseo"]
+	path = external/paradiseo
+	url = https://github.com/nojhan/paradiseo.git
+[submodule "external/clutchlog"]
+	path = external/clutchlog
+	url = https://github.com/nojhan/clutchlog.git

CMakeLists.txt

@@ -5,31 +5,88 @@ project(rHashGen)
 
 # Set the C++ standard to use
 set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_CXX_STANDARD_REQUIRED True)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+
+######################################################################################
+# Configurable user settings
+######################################################################################
+
+# Compilation options
+option(BUILD_DOCS "Enable building of documentation" OFF)
+option(BUILD_TESTING "Enable building of tests" OFF)
+option(BUILD_FOR_LOCAL "Whether to make the executables dependant on the environment of the building computer (enables CMake's build with RPATH), may be necessary on HPC clusters" OFF)
+option(USE_LOCAL_PARADISEO "Use a local version of Paradiseo rather than the one installed on the system" ON)
+
+# Common
+add_compile_options(-Wall -Wextra -pedantic)
+# Clang
+#add_compile_options( -Wno-c++98-compat-pedantic -Wno-old-style-cast -Wno-padded -Wno-extra-semi-stmt -Wno-weak-vtables)
+
+if(BUILD_FOR_LOCAL)
+    set(CMAKE_BUILD_WITH_INSTALL_RPATH ON)
+endif()
+
+
+######################################################################################
+# Dependencies
+######################################################################################
+
+# Own lib
+include_directories(include)
+
+# ParadisEO
+if(USE_LOCAL_PARADISEO)
+    set(PARADISEO_ROOT "${PROJECT_SOURCE_DIR}/external/paradiseo" CACHE PATH "Where to find ParadisEO")
+    set(PARADISEO_BUILD "${CMAKE_CURRENT_BINARY_DIR}" CACHE PATH "Build dir of ParadisEO")
+
+    include_directories(${PARADISEO_ROOT})
+    include_directories(${PARADISEO_ROOT}/eo/src)
+    include_directories(${PARADISEO_ROOT}/mo/src)
+    include_directories(${PARADISEO_ROOT}/moeo/src)
+    link_directories(${PARADISEO_BUILD}/lib)
+else()
+    include_directories($ENV{PARADISEO_ROOT}/include/paradiseo/eo)
+    include_directories($ENV{PARADISEO_ROOT}/include/paradiseo/mo)
+    link_directories($ENV{PARADISEO_ROOT}/lib64)
+endif()
+set(PARADISEO_LIBRARIES eoutils eo)
+
+# Single-header dependencies.
+include_directories(external/clutchlog)
 
 # Include the src directory
 include_directories(${PROJECT_SOURCE_DIR}/src/include)
 
+
+######################################################################################
+# Start building
+######################################################################################
+
 # Add subdirectories
 add_subdirectory(src)
 
 # Google Test
 add_subdirectory(external/googletest)
 include_directories(${gtest_SOURCE_DIR}/include ${gtest_SOURCE_DIR})
 
+# ParadisEO
+add_subdirectory(external/paradiseo)
+
+
 # Find all main files in the app directory
 file(GLOB APP_SOURCES ${PROJECT_SOURCE_DIR}/app/*.cpp)
 
 # For each main file, create an executable
 foreach(APP_SOURCE ${APP_SOURCES})
     # Get the file name without the extension
     get_filename_component(APP_NAME ${APP_SOURCE} NAME_WE)
-    
+
     # Add the executable
     add_executable(${APP_NAME} ${APP_SOURCE})
-    
+
     # Link the necessary libraries
-    target_link_libraries(${APP_NAME} PRIVATE rHashGenLib)
+    target_link_libraries(${APP_NAME} PRIVATE rHashGenLib ${PARADISEO_LIBRARIES})
 endforeach()
 
 # Add the test directory

README.md

@@ -12,22 +12,17 @@ git clone --recursive https://github.com/username/repo.git && cd repo
 mkdir build && cd build
 # Configure the build using CMake
 cmake ..
-# Compile an example binary
-make example
-# Compile the unit tests
-make rHashGen-tests
+# Compile the solver
+make search
+# See how to run the solver
+./search --help
 ```
 
-## Running the Binaries
+## Run tests
 
-To run the example and test binaries, use the following commands:
+To run the tests, use the following commands:
 
 ```bash
-# Run the example binary
-./example
-
-# Run the test binary
-make test
+mkdir -p build && cd build && cmake -CMAKE_BUILD_TYPE=Debug .. && make && make test
 ```
 
-

app/example.cpp

@@ -10,16 +10,27 @@
 #include "AddShift.hpp"
 #include "Masking.hpp"
 #include "Multiply.hpp"
+#include "moCombination.hpp"
+#include "moCombinationNeighbor.hpp"
+#include "moCombinationNeighborhood.hpp"
+#include "EvalFunc.hpp"
+#include "log.h"
 
 
 int main()
 {
+    CLUTCHLOG(progress, "Set config");
+    clutchlog_config(); // common config
+    auto& log = clutchlog::logger();
+    log.threshold("XDebug");
+
     // The size of the values to manipulate is 57 bits.
     size_t value_size{31};
     using myuint = uint32_t;
 
+    CLUTCHLOG(progress, "Try HashFunc");
     // Create an instance of HashFunction with a value size of 64 bits
-    HashFunction<myuint> hashFunc("hash", value_size);
+    HashFunction<myuint> hashFunc(value_size, "hash");
 
     // Add shift operators
     hashFunc.add_operator(std::make_unique<Multiply<myuint>>(9, value_size));
@@ -29,27 +40,64 @@ int main()
     hashFunc.add_operator(std::make_unique<XorRightShift<myuint>>(3, value_size));
     hashFunc.add_operator(std::make_unique<Multiply<myuint>>(9, value_size));
 
+    CLUTCHLOG(note, "Complete with masks");
     // Complete with masks if necessary
     hashFunc.complete_with_masks();
 
     // Print the string representation of the hash function
     std::cout << hashFunc.to_string() << std::endl;
 
+    CLUTCHLOG(note, "Invert");
     // Get the inverse function
     HashFunction<myuint> revHashFunc{hashFunc.invert()};
-    
+
     // Print the string representation of the inverted hash function
     std::cout << "Inverted function:" << std::endl;
     std::cout << revHashFunc.to_string() << std::endl;
 
+    CLUTCHLOG(progress, "Apply HashFunc");
     // Apply the hash function to a value
     myuint value {0xDADBEEF};
     myuint hashed {hashFunc.apply(value)};
     std::cout << hashFunc.get_name() << "(0x" << std::hex << value << ") = 0x" << hashed << std::endl;
-    
+
     // Apply the inverse function to the hashed value
     myuint recovered {revHashFunc.apply(hashed)};
     std::cout << revHashFunc.get_name() << "(0x" << std::hex << hashed << ") = 0x" << recovered << std::dec << std::endl;
 
+    CLUTCHLOG(progress, "Try solver");
+    using Min = eoMinimizingFitness;
+    using Combi = moCombination<Min>;
+
+    eoForgeVector< EvalFull<myuint,Combi>::OpItf > forge(/*always_reinstantiate*/true);
+        forge.add< Multiply     <myuint> >( 9, value_size);
+        forge.add< XorLeftShift <myuint> >(17, value_size);
+        forge.add< XorLeftShift <myuint> >( 5, value_size);
+        forge.add< AddShift     <myuint> >(19, value_size);
+        forge.add< XorRightShift<myuint> >( 3, value_size);
+        forge.add< Multiply     <myuint> >( 9, value_size);
+
+    CLUTCHLOG(note, "Try solutions");
+    Combi sol({0,1,2}, forge.size());
+    CLUTCHLOG(debug, "Solution: " << sol);
+
+    CLUTCHLOG(note, "Next in neighborhood");
+    moCombinationNeighbor<Combi> neighb;
+    moCombinationNeighborhood<Combi> hood;
+    hood.init(sol, neighb);
+    hood.next(sol, neighb);
+    CLUTCHLOG(debug, "Neighbor: " << neighb);
+
+    neighb.move(sol);
+    CLUTCHLOG(debug, "Solution: " << sol);
+
+    CLUTCHLOG(note, "Evaluate");
+    EvalFull<myuint,Combi> eval(value_size, forge);
+
+    eval(sol);
+
+    CLUTCHLOG(progress, "Final solution:");
+    std::cout << sol << std::endl;
+
     return 0;
-}
+}