Merge branch 'trikiSA' of http://github.com/LPTK/paradiseo into trikisa

.github/workflows/build_ubuntu_debug.yml

@@ -1,47 +0,0 @@
-name: Build Debug (Ubuntu)
-on: [push, pull_request]
-
-env:
-  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
-  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
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        compiler: [g++-10, g++-9, g++-8, g++-7, clang-6, clang-7, clang-8, clang-9, clang-10, clang-11, clang-12] 
-
-    steps:
-    - uses: actions/checkout@v4
-    
-    - name: Caching objects
-      id: cache-objects
-      uses: actions/cache@v4
-      with:
-        path: ~/.cache/ccache
-        key: ${{ runner.os }}-${{env.BUILD_TYPE}}-${{ matrix.compiler }}-objects
-
-    - name: Install Dependencies
-      shell: bash
-      run: |
-        sudo apt-get install libeigen3-dev libboost-dev
-
-    - 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}} -DEDO=ON -DEDO_USE_LIB=Eigen3 -DENABLE_CMAKE_EXAMPLE=ON -DENABLE_CMAKE_TESTING=ON
-
-    - 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}}
-      

.gitignore

@@ -1,21 +1,11 @@
-# ignore generated files
+# ignore html files
 *.html
-*.pdf
 
 # ignore all textual files
 *.txt
-*.swp
-*.swo
-.kak_history
-*.log
-*.csv
-*.ods
 
 # ignore object and archive files
 *.[oa]
-*.bak
-*.tar*
-tags
 
 # ignore auto-saved files
 *~
@@ -38,7 +28,4 @@ debug/*
 build/*
 website/EO_star.png
 website/paradiseo_logo.png
-Release/*
-Debug/*
-Build/*
 

AUTHORS

@@ -1,52 +1,41 @@
 Current maintainers
 ===================
-
+Arnaud Liefooghe        <arnaud.liefooghe@univ-lille1.fr>
+Clive Canape            <clive.canape@inria.fr>
 Johann Dreo             <johann@dreo.fr>
+Sébastien Verel         <sebastien.verel@inria.fr>
 
+Active developpers
+==================
+Alexandre Quemy         <alexandre.quemy@inria.fr>
+Benjamin Bouvier        <bnjbouv@gmail.com>
+Caner Candan            <caner@candan.fr>
+Pierre Savéant          <pierre.saveant@thalesgroup.com>
 
 Past contributors
 =================
-
 atantar
-Alesandro Sidero
-Alexandre Quemy
-Alix Zheng
-Amine Aziz-Alaoui
-Arnaud Liefooghe
-Benjamin Bouvier
-Bahri
-Caner Candan
-Clive Canape
 fatene
 Gustavo Romero Lopez
 jboisson
 Jeroen Eggermont
 Jochen Küpper
-Joost
+Joost                   <joost@dsj.nl>
 Juan Julian Merelo Guervos
 Jérémie Humeau
-Jxtopher
 Karima Boufaras
-legillono
-Leo Bertheas
+legillon
 Louis Da Costa
 Loïc Jean David Arjanen
 Maarten Keijzer
-Mammar Amara
-Manu
 Marc Schoenauer
 Marie-Éleonore
 Mostepha Khouadjia
 Olivier König
-Pierre Savéant
 Pedro Angel Castillo Valdivieso
-Potalas
-Ronald Pinho
 Steve Madere
 Sébastien Cahon
-Sébastien Verel
 Thomas Legrand
-Thibault Lasnier
 Victor Manuel Rivas Santos
 wcancino
 xohm

CMakeLists.txt

@@ -1,36 +1,34 @@
 # ParadiseO
 
-
 ######################################################################################
 ### 0) Check the CMake version
 ######################################################################################
 
-cmake_minimum_required(VERSION 3.10 FATAL_ERROR)
+cmake_minimum_required(VERSION 2.8 FATAL_ERROR)
 
 ######################################################################################
 ### 1) Define the project
 ######################################################################################
 
 ## Name
-project("ParadisEO"
-    VERSION 3.1.3
-    DESCRIPTION "Evolutionary optimization framework"
-    LANGUAGES C CXX)
+project("ParadisEO")
 
 ## Language
-set(CMAKE_CXX_STANDARD 17)
+enable_language(CXX)
 
-## ccache
-find_program(CCACHE_PROGRAM ccache)
+## Test the presence of a compiler
+if("${CMAKE_CXX_COMPILER}" STREQUAL "" OR "${CMAKE_C_COMPILER}" STREQUAL "")
+    message(FATAL_ERROR "No compiler found!")
+endif()
 
-if (CCACHE_PROGRAM)
-    message(NOTICE "-- ccache is enabled (found here: ${CCACHE_PROGRAM})")
-    set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "\"${CCACHE_PROGRAM}\"")
-    set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK "\"${CCACHE_PROGRAM}\"")
-else ()
-    message(NOTICE "-- ccache has not been found")
-endif ()
+## Versioning
+set(VERSION_MAJOR 2 CACHE STRING "Major version number" )
+set(VERSION_MINOR 1 CACHE STRING "Minor version number" )
+set(VERSION_PATCH 0 CACHE STRING "Patch version number" )
 
+SET(PROJECT_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}" CACHE INTERNAL "Package version" FORCE)
+SET(VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}${PROJECT_VERSION_MISC}" CACHE INTERNAL "Global version" FORCE)
+SET(GLOBAL_VERSION "${VERSION}")
 
 ######################################################################################
 ### 2) Check dependencies
@@ -39,11 +37,6 @@ endif ()
 ## Optional
 set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/module" CACHE INTERNAL "Cmake module" FORCE)
 include(FindDoxygen OPTIONAL)
-if(NOT DOXYGEN_FOUND)
-    message(WARNING "Doxygen was not found, install it if you want to generate the documentation.")
-else()
-    message(STATUS "Doxygen found, use the target `doc` to generate the documentation.")
-endif()
 
 ######################################################################################
 ### 3) Include CMake files
@@ -63,16 +56,16 @@ include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/Target.cmake)
 ######################################################################################
 
 ## Paths to sources of modules
-set(  EO_SRC_DIR "${PROJECT_SOURCE_DIR}/eo"   CACHE INTERNAL "ParadisEO-EO   source directory" FORCE)
-set( EDO_SRC_DIR "${PROJECT_SOURCE_DIR}/edo"  CACHE INTERNAL "ParadisEO-EDO  source directory" FORCE)
-set(  MO_SRC_DIR "${PROJECT_SOURCE_DIR}/mo"   CACHE INTERNAL "ParadisEO-MO   source directory" FORCE)
-set(MOEO_SRC_DIR "${PROJECT_SOURCE_DIR}/moeo" CACHE INTERNAL "ParadisEO-MOEO source directory" FORCE)
-set( SMP_SRC_DIR "${PROJECT_SOURCE_DIR}/smp"  CACHE INTERNAL "ParadisEO-SMP  source directory" FORCE)
-set( MPI_SRC_DIR "${PROJECT_SOURCE_DIR}/eo/src/mpi"  CACHE INTERNAL "ParadisEO-MPI source directory" FORCE)
+set(  EO_SRC_DIR "${CMAKE_SOURCE_DIR}/eo"   CACHE INTERNAL "ParadisEO-EO   source directory" FORCE)
+set( EDO_SRC_DIR "${CMAKE_SOURCE_DIR}/edo"  CACHE INTERNAL "ParadisEO-EDO  source directory" FORCE)
+set(  MO_SRC_DIR "${CMAKE_SOURCE_DIR}/mo"   CACHE INTERNAL "ParadisEO-MO   source directory" FORCE)
+set(MOEO_SRC_DIR "${CMAKE_SOURCE_DIR}/moeo" CACHE INTERNAL "ParadisEO-MOEO source directory" FORCE)
+set( SMP_SRC_DIR "${CMAKE_SOURCE_DIR}/smp"  CACHE INTERNAL "ParadisEO-SMP  source directory" FORCE)
+set( MPI_SRC_DIR "${CMAKE_SOURCE_DIR}/eo/src/mpi"  CACHE INTERNAL "ParadisEO-MPI source directory" FORCE)
 
-set(PROBLEMS_SRC_DIR "${PROJECT_SOURCE_DIR}/problems" CACHE INTERNAL "Problems dependant source directory" FORCE)
+set(PROBLEMS_SRC_DIR "${CMAKE_SOURCE_DIR}/problems" CACHE INTERNAL "Problems dependant source directory" FORCE)
 
-set(CMAKE_BASE_SOURCE_DIR ${PROJECT_SOURCE_DIR})
+set(CMAKE_BASE_SOURCE_DIR ${CMAKE_SOURCE_DIR})
 
 # All libraries are built in <build_dir>/lib/
 set(  EO_BIN_DIR "${CMAKE_BINARY_DIR}" CACHE INTERNAL "ParadisEO-EO   binary directory" FORCE)
@@ -92,34 +85,31 @@ set(SMP "false" CACHE BOOL "Build the SMP module")
 set(MPI "false" CACHE BOOL "Build the MPI module")
 
 ## EO Module
-set(MODULE_NAME "Paradiseo")
-set(DOXYGEN_CONFIG_DIR ${CMAKE_CURRENT_SOURCE_DIR}/doxygen)
-# set(EO_MODULE_NAME "Evolving Objects")
+set(EO_MODULE_NAME "Evolving Object")
 set(CMAKE_SOURCE_DIR ${EO_SRC_DIR})
 add_subdirectory(${EO_SRC_DIR})
 
 if(NOT EO_ONLY)
     ## MO Module
-    # set(MO_MODULE_NAME "Moving Objects")
-    # set(MODULE_NAME "Moving Objects")
+    set(MO_MODULE_NAME "Moving objects")
     set(CMAKE_SOURCE_DIR ${MO_SRC_DIR})
     add_subdirectory(${MO_SRC_DIR})
 
     ## EDO Module
     if(EDO)
-        # set(EDO_MODULE_NAME "Evolving Distribution Objects")
+        set(EDO_MODULE_NAME "Evolving Distribution Objects")
         set(CMAKE_SOURCE_DIR ${EDO_SRC_DIR})
         add_subdirectory(${EDO_SRC_DIR})
     endif()
 
     ## MOEO Module
-    # set(MOEO_MODULE_NAME "Multi-Objectives EO")
+    set(MOEO_MODULE_NAME "Multi-Objectives EO")
     set(CMAKE_SOURCE_DIR ${MOEO_SRC_DIR})
     add_subdirectory(${MOEO_SRC_DIR})
 
     ## SMP Module
     if(SMP)
-        # set(SMP_MODULE_NAME "Symmetric Multi-Processing")
+        set(SMP_MODULE_NAME "Symmetric Multi-Processing")
         set(CMAKE_SOURCE_DIR ${SMP_SRC_DIR})
         add_subdirectory(${SMP_SRC_DIR})
     endif()
@@ -142,12 +132,3 @@ endif()
 if("${CMAKE_BUILD_TYPE}" STREQUAL "Release")
     include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/Package.cmake)
 endif()
-
-
-# Add all targets to the build-tree export set
-export(TARGETS eo FILE "${PROJECT_BINARY_DIR}/paradiseo-config.cmake")
-
-# Export the package for use from the build-tree
-# (this registers the build-tree with a global CMake-registry)
-export(PACKAGE paradiseo)
-

CONTRIBUTING.md

@@ -1,84 +0,0 @@
-
-Licenses
-========
-
-ParadisEO modules are using free software licenses,
-any contribution should be licensed under the same license.
-
-| Module | License | Version | Copyleft | Patent-left |
-|--------|---------|---------|----------|-------------|
-| EO     | LGPL    |  2      | Lib only | No          |
-| EDO    | LGPL    |  2      | Lib only | No          |
-| MO     | CeCILL  |  2.1    | Yes      | No          |
-| MOEO   | CeCILL  |  2.1    | Yes      | No          |
-| SMP    | CeCILL  |  2.1    | Yes      | No          |
-
-
-Contribution Workflow
-=====================
-
-The maintainer(s) will try to answer under a couple of weeks, if not, do not hesitate to send an e-mail.
-
-If you're not familiar with Git and merge requests, start by cloning one of the main repository:
-- `git clone https://github.com/nojhan/paradiseo.git`
-- `git clone https://scm.gforge.inria.fr/anonscm/git/paradiseo/paradiseo.git`
-
-
-Git workflow
-------------
-
-ParadisEO follows a classical Git workflow using merge requests.
-In order to fix a bug or add a feature yourself, you would follow this process.
-
-```bash
-cd paradiseo
-git pull origin master # Always start with an up-to-date version.
-git checkout -b <my_feature> # Always work on a dedicated branch.
-# [ make some modifications… ]
-git commit <whatever>
-mkdir build
-cd build
-cmake -DCMAKE_BUILD_TYPE=Debug -BUILD_TESTING=ON -DENABLE_CMAKE_TESTING=ON .. && make && ctest # Always test.
-cd ..
-git pull origin master # Always check that your modification still merges.
-```
-
-If everything went without error, you can either send the patch or submit a merge request.
-To do so, you can either:
-- submit a "pull request" on Github: [nojhan/paradiseo](https://github.com/nojhan/paradiseo),
-- or send a patch on the [ParadisEO mailing list](https://lists.gforge.inria.fr/cgi-bin/mailman/listinfo/paradiseo-users).
-
-See below for the details.
-
-
-Github pull request
--------------------
-
-Once logged in Github, go to the [maintainer repository](https://github.com/nojhan/paradiseo) and click the "fork" button.
-You should have your own copy of the ParadisEO project under your own name.
-Then add it as an additional "remote" to your ParadisEO Git tree: `git remote add me <your own URL>`.
-Then, checkout the branch holding the modifications you want to propose, check that it merges with the main repository
-and push it on your own repository:
-```bash
-git checkout <my_feature>
-git pull origin master
-git push me <my_feature>
-```
-
-Then go to the maintainer's repository page, click on the "Pull request" tab, and on the "New pull request" button.
-You should then select the maintainer's master branch on the left dropdown list, and your own `my_feature` on the right one.
-Explain why the maintainer should merge your modifications and click the "Submit" button.
-
-
-E-mail your patch
------------------
-
-Generate a patch file from the difference between your branch and a fresh master:
-```bash
-git pull origin master
-git diff master <my_feature> > my_feature.patch
-```
-
-Then send the `my_feature.patch` (along with your explanations about why the maintainer should merge your modifications)
-to the [mailing list](https://lists.gforge.inria.fr/cgi-bin/mailman/listinfo/paradiseo-users).
-

INSTALL

@@ -0,0 +1,200 @@
+
+==========================================================================================
+                       INSTALLING PARADISEO		
+==========================================================================================
+
+There is several ways to install ParadisEO, according to your needs.
+
+==========================================================================================
+                       WINDOWS		
+==========================================================================================
+
+On Windows, and for compatibility reason, ParadisEO supply support only for MinGW.
+Feel free to test with another compiler and to send us you report.
+
+------------------------------------------------------------------------------------------
+1) WITH EXE
+------------------------------------------------------------------------------------------
+
+The simpliest way ton install ParadisEO on Windows is to use the NSIS installer. 
+We would like to draw your attention on the fact that the PATH variable will not 
+be affected by the installation in order to allow anybody to install ParadisEO 
+without administration right. To have further information about how to use ParadisEO 
+in your project, see the tutorial on ParadisEO website (http://paradiseo.gforge.inria.fr/).
+
+------------------------------------------------------------------------------------------
+2) WITH CMAKE
+------------------------------------------------------------------------------------------
+
+You can also install ParadisEO using CMake. For that you must have a compiler installed, 
+and obviously cmake.
+Then, follow UNIX instructions.
+
+==========================================================================================
+                       UNIX		
+==========================================================================================
+------------------------------------------------------------------------------------------
+1. WITH CMAKE
+------------------------------------------------------------------------------------------
+1.0 DEPENDENCIES
+------------------------------------------------------------------------------------------
+Optionnal
+- Doxygen for documentation
+- lcov for coverage
+
+------------------------------------------------------------------------------------------
+1.1 FAST INSTALLATION
+------------------------------------------------------------------------------------------
+
+After getting ParadisEO sources from repository, you have to create a build directory in order to keep your file tree clean.
+
+> mkdir build
+> cd build
+
+To make the installation easier, ParadisEO propose you two installation types which are "Full" and "Min".
+Full corresponds examples / lessons, tests and obviously libraries. 
+Min corresponds to libraries and headers and it is the standard behavior.
+
+You can specified an installation type by adding the following declaration to cmake :
+
+> cmake .. -DINSTALL_TYPE=full
+> cmake .. -DINSTALL_TYPE=min
+which is equivalent to
+> cmake ..
+
+Actually, by default the generator will be "Unix Makefiles" and cmake will try to look for a C++ compiler. 
+Be sure you have make installed, or choose an alternative according to your configuration. 
+To know available generators on your computer, type cmake -help. If you are on Windows and you use MinGW, you have to specify it explicitly by adding -G "MinGW Makefiles".
+
+To compile ParadisEO simply compile sources using your generator. For instance, if you are using Unix Makefiles, type make.
+
+------------------------------------------------------------------------------------------
+1.2 BUILD TYPE
+------------------------------------------------------------------------------------------
+
+There are 2 types of build : Release or Debug.
+To explicitly change the type, add -DDEBUG=true, otherwise, it will be the Release type.
+
+------------------------------------------------------------------------------------------
+1.3 COMPILERS
+------------------------------------------------------------------------------------------
+
+You can change the compiler used by CMake with the following options :
+
+>-DCMAKE_C_COMPILER=/path/to/your/c/compiler
+
+>-DCMAKE_CXX_COMPILER=/path/to/your/c++/compiler
+
+------------------------------------------------------------------------------------------
+1.4 INSTALLATION
+------------------------------------------------------------------------------------------
+
+WARNING : This require administration rights.
+
+To install ParadisEO in standard paths (such as /usr/lib for lib and /usr/include for headers on UNIX-like) :
+
+> make install
+
+------------------------------------------------------------------------------------------
+2. SPECIFIC MODULE
+------------------------------------------------------------------------------------------
+2.1 EO MODULE ONLY
+------------------------------------------------------------------------------------------
+
+If you want to compile and install only the Evolving Objects module, you can add to CMake the following option :
+
+> cmake .. -DEO_ONLY
+
+------------------------------------------------------------------------------------------
+2.1 SMP MODULE
+------------------------------------------------------------------------------------------
+
+WARNING : The SMP module requires gcc 4.7 or higher. This is due to the fact that it uses the new C++ standard.
+
+WARNING : At the moment, the SMP module does not work on Windows or Mac OS X since MinGW does not provide support for std::thread 
+          and Apple does not supply a recent version of gcc (but you can try to compile gcc 4.7 by yourself).
+
+To enable the compilation of the SMP module, just add -DSMP=true to CMake :
+
+> cmake .. -DSMP=true
+
+Depending on your distribution, you might have to give to CMake the path of gcc and g++ 4.7.
+This is the case for Ubuntu 12.04 LTS for instance. Please, check installation guide on ParadisEO website for more details.
+
+If you are in that case and assuming you have a standard path for gcc et g++ 4.7 :
+
+> cmake .. -DSMP=true -DCMAKE_C_COMPILER=/usr/bin/gcc-4.7 -DCMAKE_CXX_COMPILER=/usr/bin/g++-4.7
+
+------------------------------------------------------------------------------------------
+2.2 PEO MODULE
+------------------------------------------------------------------------------------------
+
+WARNING : The PEO module requires libXML 2 and a MPI implementation such as MPICH2.
+
+To enable the compilation of the PEO module, just add -DPEO=true to CMake :
+
+> cmake .. -DPEO=true
+
+------------------------------------------------------------------------------------------
+2.3 EDO MODULE
+------------------------------------------------------------------------------------------
+
+WARNING : The EDO module requires either the Boost::ublas or the Eigen3 library.
+
+To enable the compilation of the EDO module, just add -DEDO=true to CMake :
+
+> cmake .. -DEDO=true
+
+
+------------------------------------------------------------------------------------------
+3. DOCUMENTATION
+------------------------------------------------------------------------------------------
+
+There is 2 ways to build ParadisEO documentation : module by module, or all the documentation.
+
+Targets are :
+doc for all documentations
+doc-eo for building EO documentation
+doc-mo for MO
+doc-edo for MO
+doc-moeo for MOEO
+doc-smp for SMP
+
+Each documentation are generated separatly in the module build folder. 
+For instance, after the generation of the MO documentation, you will find it in build/paradise-mo/doc.
+
+------------------------------------------------------------------------------------------
+4. LESSONS / EXAMPLES
+------------------------------------------------------------------------------------------
+
+Examples and lessons are generated by default. 
+If you want to disable lessons manually, you have to specify -DENABLE_CMAKE_TESTING=false to CMake.
+If you want to build a specific lesson or example, you can check the list of available targets with make help. 
+
+All lessons are build on the same pattern : <module>Lesson<number>.
+For instance, make moLesson4 will build the Lesson 4 from the MO module. 
+Easy, isn't it ?
+
+------------------------------------------------------------------------------------------
+5. TESTS
+------------------------------------------------------------------------------------------
+5.1 CTESTS
+------------------------------------------------------------------------------------------
+
+By performing tests, you can check your installation. 
+Testing is disable by default, except if you build with the full install type.
+To enable testing, define -DENABLE_TESTING when you launch cmake.
+
+To perform tests simply type ctest ou make test.
+
+------------------------------------------------------------------------------------------
+5.2 REPORTING
+------------------------------------------------------------------------------------------
+
+Feel free to send us reports about building, installation, tests and profiling in order to help us to improve compatibilty and installation process. Sending reports is very simple :
+
+> ctest -D Experimental
+
+WARNING : Reports are anonymous. CTest will also send informations about your configuration such as OS, CPU frequency, etc.
+
+

INSTALL.md

@@ -1,217 +0,0 @@
-
-Summary
-=======
-
-As Paradiseo is a development framework, you do not really need to install it on all your systems.
-Just put it somewhere on your development computer, compile it from here and indicate where to find it to your favorite build system.
-
-
-Build
------
-
-Paradiseo is mainly developed for Linux, on which it is straightforward to install a C++ build chain. For example, on Ubuntu 18.04:
-```bash
-sudo apt install g++-8 cmake make libeigen3-dev libopenmpi-dev doxygen graphviz libgnuplot-iostream-dev
-```
-
-Paradiseo use the CMake build system, so building it should be as simple as:
-```bash
-mkdir build ; cd build ; cmake -DEDO=ON .. && make -j
-```
-
-The file `howto_build_paradiseo.apptainer.def` shows you how to install and build from scratch.
-It is a definition file for the [Apptainer](https://apptainer.org/) container system,
-which is often used on HPC clusters.
-
-
-Develop
--------
-
-Download the quick start project template, edit the `CMakeLists.txt` file to indicate where to find Paradiseo and start developing your own solver.
-
-If you don't know CMake or a modern build system, you should still be able to build a stand-alone code from a `paradiseo/build` directory with something like:
-```bash
- c++ ../solver.cpp -I../eo/src -I../edo/src -DWITH_EIGEN=1 -I/usr/include/eigen3 -std=c++17 -L./lib/ -leo -leoutils -les -lga -o solver
-```
-
-
-Install
--------
-
-If you want to install ParadisEO system-wide anyway:
-```bash
-cmake -D CMAKE_BUILD_TYPE=Release .. && sudo make install
-```
-
-
-More details
-============
-
-As a templated framework, most of the ParadisEO code rely within headers and is thus compiled
-by you when you build your own solver.
-
-However, in order to save some compilation time,
-the EO and EDO modules are compiled within static libraries by the default build system.
-
-If you believe you have a working build chain and want to test if it works with ParadisEO,
-you can try to build the tests and the examples.
-Note that if some of them failed (but not all), you may still be able to build your own solver,
-as you will most probably not use all ParadisEO features anyway.
-
-
-Windows
--------
-
-Last time we checked, ParadisEO could only be built with MinGW.
-Feel free to test with another compiler and to send us your report.
-
-As of today, we cannot guarantee that it will be easy to
-install ParadisEO under Windows if you're a beginner.
-There is still some (possibly outdated) help about oldest version on the [Website](http://paradiseo.gforge.inria.fr/).
-
-If you know how to install a working compiler and the dependencies,
-you may follow the same steps than the Linux process below.
-
-If you are a beginner, we strongly suggest you install a Linux distribution
-(either as an OS, as a virtual machine or using the Windows 10 compatibility layer).
-
-
-Linux
------
-
-### Dependencies
-
-In order to build the latest version of Paradiseo, you will need a C++ compiler supporting C++17.
-So far, GCC and CLANG gave good results under Linux. You will also need the CMake and make build tools.
-
-Some features are only available if some dependencies are installed:
-- Most of the EDO module depends on either uBlas or Eigen3. The recommended package is Eigen3, which enables the adaptive algorithms.
-- Doxygen is needed to build the API documentation, and you should also install graphviz if you want the class relationship diagrams.
-- GNUplot is needed to have the… GNUplot graphs at checkpoints.
-
-To install all those dependencies at once under Ubuntu (18.04), just type:
-```bash
-sudo apt install g++-8 cmake make libeigen3-dev libopenmpi-dev doxygen graphviz libgnuplot-iostream-dev.
-```
-
-
-### Build
-
-The build chain uses the classical workflow of CMake.
-The recommended method is to build in a specific, separated directory and call `cmake ..` from here.
-CMake will prepare the compilation script for your system of choice which you can change with the `-G <generator-name>` option (see your CMake doc for the list of available generators).
-
-Under Linux, the default is `make`, and a build command is straitghtforward:
-```bash
-mkdir build ; cd build ; cmake .. && make -j
-```
-
-There is, however, several build options which you may want to switch.
-To see them, we recommend the use of a CMake gui, like ccmake or cmake-gui.
-On the command line, you can see the available options with: `cmake -LH ..`.
-Those options can be set with the `-D<option>=<value>` argument to cmake.
-
-The first option to consider is `CMAKE_BUILD_TYPE`,
-which you most probably want to set to "Debug" (during development/tests)
-or "Release" (for production/validation).
-
-
-### More compilation options
-
-Other important options are: `EDO` (which is false by default)
-and parallelization options: `ENABLE_OPENMP`, `MPI`, `SMP`.
-
-By default, the build script will build the Paradiseo libraries only.
-
-If you `ENABLE_CMAKE_TESTING` and `BUILD_TESTING`, it will build the tests,
-which you can run with the `ctest` command.
-
-If you `ENABLE_CMAKE_EXAMPLE`, it will also build the examples.
-
-You can change the compiler used by CMake with the following options:
-`CMAKE_CXX_COMPILER=/path/to/your/c++/compiler`.
-
-
-Even more details
-=================
-
-Evolving Objects (EO) module
-----------------------------
-
-If you want to compile and install only the core EO module, set `EO_ONLY`,
-this can be helpful if you don't need other modules with more complex dependencies.
-
-Shared Memory Processing (SMP) module
--------------------------------------
-
-The SMP module requires gcc 4.7 or higher. This is due to the fact that it uses the new C++ standard.
-
-At the moment, the SMP module does not work on Windows or Mac OS X since MinGW does not provide support for std::thread and Apple does not supply a recent version of gcc (but you can try to compile gcc 4.7 by yourself).  
-
-To enable the compilation of the SMP module, just set the `SMP` option.
-
-Depending on your distribution, you might have to give to CMake the path of gcc and g++ 4.7.
-This is the case for Ubuntu 12.04 LTS for instance.
-
-If you are in that case and assuming you have a standard path for gcc et g++ 4.7:
-```bash
-cmake .. -DSMP=true -DCMAKE_C_COMPILER=/usr/bin/gcc-4.7 -DCMAKE_CXX_COMPILER=/usr/bin/g++-4.7
-```
-
-Estimating Distribution Objects (EDO) module
---------------------------------------------
-
-To enable the compilation of the EDO module, just set the `EDO` option.
-
-The EDO module requires a linear algebra library.
-So far the core features are implemented in either [Boost::ublas](https://www.boost.org/doc/libs/release/libs/numeric/ublas) or the [Eigen3 library](https://eigen.tuxfamily.org).
-
-The adaptive algorithms are only implemented with Eigen3, which is thus the recommended package.
-
-
-Documentation
--------------
-
-There is 2 ways to build ParadisEO documentation: module by module, or all the documentation.
-
-Targets for the build system (usually `make`) are:
-- `doc` for all documentations,
-- `doc-eo` for building EO documentation,
-- `doc-mo` for MO,
-- `doc-edo` for MO,
-- `doc-moeo` for MOEO,
-- `doc-smp` for SMP.
-
-Each documentation are generated separatly in the module build folder.
-For instance, after the generation of the MO documentation, you will find it in `build/paradise-mo/doc`.
-
-Examples
---------
-
-Examples and lessons are generated when `ENABLE_CMAKE_EXAMPLE` is set.
-
-If you want to build a specific lesson or example, you can check the list of available targets with `make help`.
-
-All lessons are build on the same pattern: `<module>Lesson<number>`.
-For instance, make `moLesson4` will build the Lesson 4 from the MO module.
-Easy, isn't it ?
-
-Tests
------
-
-By performing tests, you can check your installation.
-Testing is disable by default, except if you build with the full install type.
-To enable testing, define `ENABLE_CMAKE_TESTING` when you run cmake.
-
-To perform tests simply type `ctest` or `make test`.
-
-Reporting
----------
-
-Feel free to send us reports about building, installation, tests and profiling in order to help us to improve compatibilty and installation process. Generate reports is very simple:
-```bash
-ctest -D Experimental
-```
-
-NOTE: Reports are anonymous, but CTest will also send informations about your configuration such as OS, CPU frequency, etc.
-

README

@@ -0,0 +1,83 @@
+
+==========================================================================================
+                       RELEASE		
+==========================================================================================
+
+The current release is paradisEO-2.0
+
+==========================================================================================
+                      INSTALLATION
+==========================================================================================
+The basic installation procedure must be done in a separatly folder in order to keep
+your file tree clean.
+
+1) mkdir build
+2) cd build
+3) cmake ..
+4) make
+5) Take a cofee.
+6) Congratulation, ParadiseEO is installed !
+
+Please refer to paradisEO website or INSTALL file for further information about
+installation types and options.
+
+==========================================================================================
+                       DIRECTORY STRUCTURE
+==========================================================================================
+After unpacking the archive file, you should end up with the following
+structure:
+
+.../                        
+   |
+   |
+   +-- AUTHORS				      Author list 
+   |
+   |
+   +-- cmake/				      CMake dir
+   |
+   |
+   +-- CMakeLists.txt			  For building process
+   |
+   |
+   +-- CTestConfig.cmake		  For testing process
+   |
+   |
+   +-- INSTALL                    INSTALL file
+   |
+   |
+   +-- LICENCE				      Licence contents
+   |
+   |
+   +-- paradiseo-eo 			  paradiseo-eo dir
+   |
+   |
+   +-- paradiseo-mo               paradiseo-mo dir 
+   |
+   |
+   +-- paradiseo-moeo             paradiseo-moeo  dir
+   |
+   |
+   +-- problems                    classical problems evaluation functions
+   |
+   |
+   +-- README				       README file
+
+==========================================================================================
+              NOTES
+==========================================================================================
+
+ParadisEO uses EO, a templates-based, ANSI-C++ compliant evolutionary computation library. 
+It contains classes for almost any kind of evolutionary computation you might come up to - at 
+least for the ones we could think of.
+EO Website: http://eodev.sourceforge.net/.
+EO is distributed under the GNU Lesser General Public License: http://www.gnu.org/copyleft/lesser.html
+
+Please read README file of each extracted directory if you have
+problems for the installation.
+
+==========================================================================================
+              CONTACT
+==========================================================================================
+For further information about ParadisEO, help or to report any
+problem : paradiseo-help@lists.gforge.inria.fr
+

README.md

@@ -1,273 +0,0 @@
-# Paradiseo: a Heuristic Optimization Framework
-
-Paradiseo is an open-source ***full-featured evolutionary computation framework*** which main purpose is to help you write ***your own stochastic optimization algorithms***, insanely fast.
-
-It focus on the efficiency of the implementation of solvers, by providing:
-- a ***modular design*** for several types of paradigms,
-- the ***largest codebase*** of existing components,
-- tools for ***automated design and selection*** of algorithms,
-- a focus on ***speed*** and several ***parallelization*** options.
-
-<div align="center">
-  <img width="640" alt="Paradiseo logo" src="https://raw.githubusercontent.com/nojhan/paradiseo/master/docs/img/paradiseo_logo_dark.svg"/>
-</div>
-
-# Quick Start
-
-# Very Quick Start
-
-1. Use a recent Linux, like an Ubuntu.
-2. `sudo apt install g++-8 cmake make libeigen3-dev libopenmpi-dev doxygen graphviz libgnuplot-iostream-dev`
-3. From the Paradiseo directory: `mkdir build ; cd build ; cmake -D CMAKE_BUILD_TYPE=Release -DEDO=ON .. && make -j`
-4. Copy-paste this CMA-ES code in `cmaes.cpp`:
-```cpp
-#include <eo>
-#include <edo>
-#include <es.h>
-#include <do/make_pop.h>
-#include <do/make_run.h>
-#include <do/make_continue.h>
-#include <do/make_checkpoint.h>
-
-using R = eoReal<eoMinimizingFitness>;
-using CMA = edoNormalAdaptive<R>;
-
-R::FitnessType sphere(const R& sol) {
-    double sum = 0;
-    for(auto x : sol) { sum += x * x; }
-    return sum;
-}
-
-int main(int argc, char** argv) {
-    eoParser parser(argc, argv);
-    eoState state;
-
-    size_t dim = parser.createParam<size_t>(10,
-            "dimension", "Dimension", 'd',
-            "Problem").value();
-
-    size_t max_eval = parser.getORcreateParam<size_t>(100 * dim,
-            "maxEval", "Maximum number of evaluations", 'E',
-            "Stopping criterion").value();
-
-    edoNormalAdaptive<R> gaussian(dim);
-
-    auto& obj_func = state.pack< eoEvalFuncPtr<R> >(sphere);
-    auto& eval     = state.pack< eoEvalCounterThrowException<R> >(obj_func, max_eval);
-    auto& pop_eval = state.pack< eoPopLoopEval<R> >(eval);
-
-    auto& gen  = state.pack< eoUniformGenerator<R::AtomType> >(-5, 5);
-    auto& init = state.pack< eoInitFixedLength<R> >(dim, gen);
-    auto& pop = do_make_pop(parser, state, init);
-    pop_eval(pop,pop);
-
-    auto& eo_continue  = do_make_continue(  parser, state, eval);
-    auto& pop_continue = do_make_checkpoint(parser, state, eval, eo_continue);
-    auto& best = state.pack< eoBestIndividualStat<R> >();
-    pop_continue.add( best );
-    auto& distrib_continue = state.pack< edoContAdaptiveFinite<CMA> >();
-
-    auto& selector  = state.pack< eoRankMuSelect<R> >(dim/2);
-    auto& estimator = state.pack< edoEstimatorNormalAdaptive<R> >(gaussian);
-    auto& bounder   = state.pack< edoBounderRng<R> >(R(dim, -5), R(dim, 5), gen);
-    auto& sampler   = state.pack< edoSamplerNormalAdaptive<R> >(bounder);
-    auto& replacor  = state.pack< eoCommaReplacement<R> >();
-
-    make_verbose(parser);
-    make_help(parser);
-
-    auto& algo = state.pack< edoAlgoAdaptive<CMA> >(
-         gaussian , pop_eval, selector,
-         estimator, sampler , replacor,
-         pop_continue, distrib_continue);
-
-    try {
-        algo(pop);
-    } catch (eoMaxEvalException& e) {
-        eo::log << eo::progress << "STOP" << std::endl;
-    }
-
-    std::cout << best.value() << std::endl;
-    return 0;
-}
-```
-
-5. Compile it with: `c++ cmaes.cpp -I../eo/src -I../edo/src -DWITH_EIGEN=1 -I/usr/include/eigen3 -std=c++17 -L./lib/ -leo -leoutils -les -o cmaes`
-6. `./cmaes -h`
-
-
-## Not-so-quick Start
-
-1. Use your system of choice, as soon as you know how to operate a C++ buildchain on it.
-2. Dependencies are: `libeigen3-dev libopenmpi-dev doxygen graphviz libgnuplot-iostream-dev` (or similar packagesnames, depending on your system)
-3. From the Paradiseo directory, within a `build` directory, call the equivalent of `cmake -D CMAKE_BUILD_TYPE=Release -DEDO=ON ..`, then call your system's favorite generator (see cmake's documentation for the `-G` option).
-4. Code your own algorithm, starting from one of the numerous examples (or tests) available around ParadisEO
-   (see the source code in `<module>/test/` or `<module>/tutorial/`, or see the website).
-5. Build it, indicating where to include the needed ParadisEO `<module>/src/` directories, and the `build/lib` directory for the library linker.
-
-
-# Rationale
-
-## Black-box and Gray-box Optimization Problems
-
-Paradiseo targets the development of solvers for mathematical optimization
-problems for which you cannot compute gradients.
-The classical use case is the automated design or configuration of
-some system which is simulated.
-
-## Metaheuristics / Evolutionary Algorithms
-
-Paradiseo targets the design of metaheuristics solvers using
-computational intelligence methods, a subdomain of artificial intelligence.
-
-## Why choosing Paradiseo?
-
-Learning a full-featured framework like Paradiseo very often seems overkill.
-However, we would like to stress out that you may forget some points
-while jumping to this conclusion.
-
-**Paradiseo provides the *largest mature codebase* of state-of-the-art algorithms, and is focused on (automatically) find the *most efficient solvers*.**
-
-The most classical impediment to the use of Paradiseo is that you just want to check if your problem can actually be solved with heuristics. You feel that it would be a loss of time to learn complex stuff if it ends being useless.
-
-However, you should keep in mind that:
-
-- Metaheuristics do seem very easy to implement in textbooks, but the state-of-the art versions of efficient algorithms can be a lot more complex.
-- It is usually easy to get something to actually run, but it is far more difficult to get an efficient solver.
-- Metaheuristics performances on a given problem are very sensitive to small variations in the parameter setting or the choice of some operators. Which render large experimental plans and algorithm selection compulsory to attain peak efficiency.
-
-**Fortunately, Paradiseo have the *largest codebase* of the market, hardened along 20 years of development of tens of solvers. Additionally, it provides the tools to rapidly search for the best combination of algorithms to solve your problem, even searching for this combination *automatically*.**
-
-Paradiseo is the fastest framework on the market, which is a crucial feature for modern and robust approach to solver design and validation.
-
-Another classical criticism against Paradiseo is that C++ is hard and that a fast language is useless because speed is not a concern when your objective function is dominating all the runtime.
-
-However, we argue that:
-
-- During the design phase of your solver, you will need to estimate its performance against synthetic benchmarks that are fast to compute. In that case, fast computation means fast design iterations. And it's even more true if you plan to use automated design to find the best solver for your problem.
-- Modern C++ makes use of the very same high-level abstractions you would find in more accepted languages like Python. Sure, the syntax is cumbersome, but you will not see it after a while, given that you will work at the algorithm level.
-- C++ provides full type checking and the largest set of tooling for any modern language, which are your first line of defense against long-term bugs. Sure, it sometimes gives you the impression that you fight against the compiler, but chasing subtle interface bugs across a complex Python code is even harder.
-
-# Features
-
-## Component-based Design
-
-Designing an algorithm with Paradiseo consists in choosing what components (called operators) you want to use for your specific needs, just as building a structure with Lego blocks.
-
-If you have a classical problem for which available code exists (for example if you have a black-box problem with real-valued variables), you will just choose operators to form an algorithm and connect it to your evaluation function (which computes the quality of a given solution).
-
-If your problem is a bit more exotic, you will have to code a class that encodes how solutions to your problem are represented, and perhaps a few more. For instance, you may want ad-hoc variations operators, but most of the other operators (selection, replacement, stopping criteria, command-line interface, etc.) are already available in Paradiseo.
-
-## Large Choice of Components
-
-Paradiseo is organized in several modules, either providing different "grammars" for different algorithms, either providing high-level features. All modules follows the same architecture design and are interoperable with the others, so that you can easily choose the subset of features you need.
-
-It is, for instance, easy to start with a simple local search, then add multi-objective capabilities, then shared-memory parallelization, then hybridization with an evolutionary algorithm and finally plug everything in an objective function so as to optimize the parameters with a particle swarm optimizer.
-
-## Portability
-
-Paradiseo is mainly developed under Linux operating systems, where its dependencies and the C++ toolchain are easy to install. Recent versions have been tested with gcc and clang compilers.
-
-Stable versions should however work on Windows and any Unix-like operating system with a standard-conforming C++ development system.
-
-
-# Code
-
-The latest stable version is on the official Git repository of INRIA: `git clone git://scm.gforge.inria.fr/paradiseo/paradiseo.git`
-
-## Dependencies
-
-In order to build the latest version of Paradiseo, you will need a C++ compiler supporting C++17. So far, GCC and CLANG gave good results under Linux. You will also need the CMake and make build tools.
-
-A free working build chain under Windows seems always difficult to find. Paradiseo 2.0.1 was successfully tested with MinGW (minus the PEO module), but it's unsure if it still work for recent versions. If you managed to build under Windows, your feedback would be appreciated.
-
-Some features are only available if some dependencies are installed:
-
-- Most of the EDO module depends on either uBlas or Eigen3. The recommended package is Eigen3, which enables the adaptive algorithms.
-- Doxygen is needed to build the API documentation, and you should also install graphviz if you want the class relationship diagrams.
-- GNUplot is needed to have the… GNUplot graphs at checkpoints.
-
-To install all those dependencies at once under Ubuntu (18.04), just type: `sudo apt install g++-8 cmake make libeigen3-dev libopenmpi-dev doxygen graphviz libgnuplot-iostream-dev`.
-
-## Compilation
-
-The build chain uses the classical workflow of CMake. The recommended method is to build in a specific, separated directory and call `cmake ..` from here. CMake will prepare the compilation script for your system of choice which you can change with the `-G <generator-name>` option (see the CMake doc for the list of available generators).
-
-Under Linux, the default is make, and a build command is straitghtforward: `mkdir build ; cd build ; cmake .. && make -j`.
-
-There is, however, several build options which you may want to switch. To see them, we recommend the use of a CMake gui, like ccmake or cmake-gui. On the command line, you can see the available options with: `cmake -LH ..` . Those options can be set with the `-D<option>=<value>` argument to cmake.
-
-**The first option to consider is `CMAKE_BUILD_TYPE`, which you most probably want to set to `Debug` (during development/tests) or `Release` (for production/validation).**
-
-
-Other important options are: `EDO` (which is false by default) and parallelization options: `ENABLE_OPENMP`, `MPI`, `SMP`.
-
-By default, the build script will build the Paradiseo libraries only.
-
-If you `ENABLE_CMAKE_TESTING` and `BUILD_TESTING`, it will be the tests, which you can run with the `ctest` command.
-
-If you `ENABLE_CMAKE_EXAMPLE`, it will also build the examples.
-
-If may want to make build scripts more verbose (especially when building the
-doc) by enabling `CMAKE_VERBOSE_MAKEFILE`.
-
-If `ccache` installed in your environment, it will try its best to re-use other compilations,
-which may speed-up your builds if you manage several compatible builds at the same time.
-To clear all cached objects, execute `ccache -C`.
-
-## Licenses
-
-Paradiseo is distributed under the GNU Lesser General Public License and the CeCILL license (depending on the modules).
-
-Note that those licenses places copyleft restrictions on a program created with Paradiseo, but does not apply these restrictions to other software that would links with the program.
-
-
-# Documentation
-
-Paradiseo has a lot of documentation! You will find in the source repository
-a lot of examples, the tutorials and you can generate the API documentation
-(`make doc`, then open
-`paradiseo/<build>/<module>/doc/html/index.html`).
-
-Tutorials are located in each module's directory. For example for the EO module:
-`paradiseo/eo/tutorial`.
-A lot of examples for (almost) each class are available in the test directories
-(e.g. `paradiseo/eo/test`). Example problems and bindings to external
-benchmark libraries are in `paradiseo/problems`.
-
-For academic articles, books, more tutorials, presentations slides,
-real life example of solvers and contact information,
-please see the web site (available in `paradiseo/website/index.html`).
-
-
-# Citing Paradiseo
-
-If you use Paradiseo, please cite the following publication:
-
-Johann Dreo, Arnaud Liefooghe, Sébastien Verel, Marc Schoenauer, Juan J. Merelo, Alexandre Quemy, Benjamin Bouvier, and Jan Gmys, [Paradiseo: from a modular framework for evolutionary computation to the automated design of metaheuristics —22 years of Paradiseo—](https://doi.org/10.1145/3449726.3463276), GECCO'21: Proceedings of the Genetic and Evolutionary Computation Conference Companion, 1522–1530 (2021).
-
-BiBTeX entry:
-
-```
-@inproceedings{Dreo-al_2021_Paradiseo,
-    author    = {Dreo, Johann and Liefooghe, Arnaud and Verel, S\'{e}bastien and Schoenauer, Marc and Merelo, Juan J. and Quemy, Alexandre and Bouvier, Benjamin and Gmys, Jan},
-    title     = {Paradiseo: From a Modular Framework for Evolutionary Computation to the Automated Design of Metaheuristics: 22 Years of Paradiseo},
-    year      = {2021},
-    isbn      = {9781450383516},
-    publisher = {Association for Computing Machinery},
-    address   = {Online conference},
-    url       = {https://doi.org/10.1145/3449726.3463276},
-    booktitle = {Proceedings of the Genetic and Evolutionary Computation Conference Companion},
-    pages     = {1522–1530},
-    numpages  = {9}
-}
-```
-
-# Contact
-
-For further information about ParadisEO, help or to report any
-problem, you can either:
-
-- Chat with us on our Matrix chatroom: https://app.element.io/#/room/#paradiseo:matrix.org
-- Post an issue: https://github.com/nojhan/paradiseo/issues
-

cmake/Package.cmake

@@ -47,8 +47,8 @@ set(CPACK_COMPONENT_DOC_INSTALL_TYPES Full)
 # For more details: http://www.cmake.org/Wiki/CMake:Component_Install_With_CPack
 
 #cpack package information
-set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/README.md")
-set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/README.md")
+set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/README")
+set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/README")
 set(CPACK_PACKAGE_DESCRIPTION "ParadisEO is a white-box object-oriented framework dedicated to the flexible design of metaheuristics. This template-based, ANSI-C++ compliant computation library is portable across both Windows system and sequential platforms (Unix, Linux, Mac OS X, etc.). ParadisEO is distributed under the CeCill license and can be used under several environments.")
 set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE")
 set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "A Software Framework for Metaheuristics")

cmake/Target.cmake

@@ -11,119 +11,22 @@ endif(UNIX)
 ######################################################################################
 
 if(DOXYGEN_FOUND AND DOXYGEN_EXECUTABLE)
-    # FIXME this would work in cmake 3.13
-    # set(DOC_EO "make doc-eo")
-    # if(NOT EO_ONLY)
-    #     set(DOC_MO "make doc-mo")
-    #     set(DOC_MOEO "make doc-moeo")
-    #     if(EDO)
-    #         set(DOC_EDO "make doc-edo")
-    #     else()
-    #         set(DOC_EDO "")
-    #     endif()
-    #     if(SMP)
-    #         set(DOC_SMP "make doc-smp")
-    #     else()
-    #         set(DOC_SMP "")
-    #     endif()
-    #     if(MPI)
-            # set(DOC_MPI "make doc-mpi")
-    #     else()
-    #         set(DOC_MPI "")
-    #     endif()
-    # endif()
-    #
-    # add_custom_target(doc
-    #     COMMAND ${DOC_EO}
-    #     COMMAND ${DOC_MO}
-    #     COMMAND ${DOC_MOEO}
-    #     COMMAND ${DOC_EDO}
-    #     COMMAND ${DOC_SMP}
-    #     COMMAND ${DOC_MPI}
-    # )
-    # FIXME in the meantime, we must enumerate...
-    if(EO_ONLY)
+    if(SMP)
         add_custom_target(doc
             COMMAND make doc-eo
+            COMMAND make doc-edo
+            COMMAND make doc-mo
+            COMMAND make doc-moeo
+            COMMAND make doc-smp
         )
     else()
-        # No optional module.
-        if(NOT EDO AND NOT SMP AND NOT MPI)
-            add_custom_target(doc
-                COMMAND make doc-eo
-                COMMAND make doc-mo
-                COMMAND make doc-moeo
-            )
-        endif()
-
-        # One optional module.
-        if(EDO AND NOT SMP AND NOT MPI)
-            add_custom_target(doc
-                COMMAND make doc-eo
-                COMMAND make doc-mo
-                COMMAND make doc-moeo
-                COMMAND make doc-edo
-            )
-        endif()
-        if(NOT EDO AND SMP AND NOT MPI)
-            add_custom_target(doc
-                COMMAND make doc-eo
-                COMMAND make doc-mo
-                COMMAND make doc-moeo
-                COMMAND make doc-smp
-            )
-        endif()
-        if(NOT EDO AND NOT SMP AND MPI)
-            add_custom_target(doc
-                COMMAND make doc-eo
-                COMMAND make doc-mo
-                COMMAND make doc-moeo
-                # COMMAND make doc-mpi
-            )
-        endif()
-
-        # Two optional modules.
-        if(NOT EDO AND SMP AND MPI)
-            add_custom_target(doc
-                COMMAND make doc-eo
-                COMMAND make doc-mo
-                COMMAND make doc-moeo
-                COMMAND make doc-smp
-                # COMMAND make doc-mpi
-            )
-        endif()
-        if(EDO AND NOT SMP AND MPI)
-            add_custom_target(doc
-                COMMAND make doc-eo
-                COMMAND make doc-mo
-                COMMAND make doc-moeo
-                COMMAND make doc-edo
-                # COMMAND make doc-mpi
-            )
-        endif()
-        if(EDO AND SMP AND NOT MPI)
-            add_custom_target(doc
-                COMMAND make doc-eo
-                COMMAND make doc-mo
-                COMMAND make doc-moeo
-                COMMAND make doc-edo
-                COMMAND make doc-smp
-            )
-        endif()
-
-        # Three optional modules
-        if(EDO AND SMP AND MPI)
-            add_custom_target(doc
-                COMMAND make doc-eo
-                COMMAND make doc-mo
-                COMMAND make doc-moeo
-                COMMAND make doc-edo
-                COMMAND make doc-smp
-                # COMMAND make doc-mpi
-            )
-        endif()
-
-    endif(EO_ONLY)
+        add_custom_target(doc
+            COMMAND make doc-eo
+            COMMAND make doc-edo
+            COMMAND make doc-mo
+            COMMAND make doc-moeo
+        )
+    endif()
 endif(DOXYGEN_FOUND AND DOXYGEN_EXECUTABLE)
 
 ######################################################################################
@@ -131,7 +34,7 @@ endif(DOXYGEN_FOUND AND DOXYGEN_EXECUTABLE)
 ######################################################################################
 
 if(PROFILING)
-    find_program(LCOV
+    find_program(LCOV 
         NAMES lcov
         PATHS
         "/usr/local/bin /usr/bin [HKEY_LOCAL_MACHINE\\SOFTWARE\\Rational Software\\Purify\\Setup;InstallFolder] [HKEY_CURRENT_USER\\Software]"

cmake/module/FindParadiseo.cmake

@@ -1,6 +1,3 @@
-# The script use the following variables as search paths, if they are defined:
-# - PARADISEO_ROOT : the project root
-# - PARADISEO_DIR : the build/install directory with libraries binaries
 #
 # The following variables are filled out:
 # - PARADISEO_INCLUDE_DIR : EO, MO and MOEO source dir
@@ -39,21 +36,15 @@ if(UNIX)
     set(INSTALL_SUB_DIR /paradiseo)
 endif()
 
-if(PARADISEO_DIR)
-    # CMake config module is case sensitive
-    set(Paradiseo_DIR ${PARADISEO_DIR})
-endif()
-
 # enabled components
-if (Paradiseo_FIND_COMPONENTS STREQUAL "")
+if ("${Paradiseo_FIND_COMPONENTS}" STREQUAL "")
     set(PARADISEO_LIBRARIES_TO_FIND eo eoutils cma es flowshop ga moeo)
 else()
     set(PARADISEO_LIBRARIES_TO_FIND ${Paradiseo_FIND_COMPONENTS})
 endif()
-message(STATUS "${PARADISEO_LIBRARIES_TO_FIND}")
 
 #set the build directory
-#set(BUILD_DIR build)
+set(BUILD_DIR build)
 
 # Path
 set(PARADISEO_SRC_PATHS
@@ -81,36 +72,32 @@ find_path(MOEO_INCLUDE_DIR moeo
           PATH_SUFFIXES include${INSTALL_SUB_DIR}/moeo moeo/src
           PATHS ${PARADISEO_SRC_PATHS})
 
-set(PARADISEO_INCLUDE_DIR ${EO_INCLUDE_DIR} ${MO_INCLUDE_DIR} ${MOEO_INCLUDE_DIR})
-
-# Specific for SMP, EDO and PEO
+# Specific for SMP and PEO
 foreach(COMP ${PARADISEO_LIBRARIES_TO_FIND})
     if(${COMP} STREQUAL "smp")
         set(SMP_FOUND true)
         find_path(SMP_INCLUDE_DIR smp
               PATH_SUFFIXES include${INSTALL_SUB_DIR}/smp smp/src
               PATHS ${PARADISEO_SRC_PATHS})
-    elseif(${COMP} STREQUAL "edo")
-        set(EDO_FOUND true)
+    elseif(${COMP} STREQUAL "peo")
+        set(PEO_FOUND true)
         find_path(EDO_INCLUDE_DIR edo
           PATH_SUFFIXES include${INSTALL_SUB_DIR}/edo edo/src
           PATHS ${PARADISEO_SRC_PATHS})
-    elseif(${COMP} STREQUAL "peo")
-        set(PEO_FOUND true)
-        find_path(PEO_INCLUDE_DIR peo
+    elseif(${COMP} STREQUAL "edo")
+        set(EDO_FOUND true)
+        find_path(EDO_INCLUDE_DIR peo
               PATH_SUFFIXES include${INSTALL_SUB_DIR}/peo peo/src
               PATHS ${PARADISEO_SRC_PATHS})
     endif()
 endforeach()
 
+set(PARADISEO_INCLUDE_DIR ${EO_INCLUDE_DIR} ${EDO_INCLUDE_DIR} ${MO_INCLUDE_DIR} ${MOEO_INCLUDE_DIR})
+
 if(SMP_FOUND)
     set(PARADISEO_INCLUDE_DIR ${PARADISEO_INCLUDE_DIR} ${SMP_INCLUDE_DIR})
 endif()
 
-if(EDO_FOUND)
-    set(PARADISEO_INCLUDE_DIR ${PARADISEO_INCLUDE_DIR} ${EDO_INCLUDE_DIR})
-endif()
-
 if(PEO_FOUND)
     set(PARADISEO_INCLUDE_DIR ${PARADISEO_INCLUDE_DIR} ${PEO_INCLUDE_DIR})
 endif()
@@ -119,14 +106,8 @@ endif()
 set(PARADISEO_FOUND true) # will be set to false if one of the required modules is not found
 
 set(FIND_PARADISEO_LIB_PATHS
-        # ${PARADISEO_ROOT}/${BUILD_DIR}
-        ${Paradiseo_DIR}
-        $ENV{PARADISEO_ROOT}/build
-        $ENV{PARADISEO_ROOT}/release
-        $ENV{PARADISEO_ROOT}/debug
-        ${PARADISEO_ROOT}/build
-        ${PARADISEO_ROOT}/release
-        ${PARADISEO_ROOT}/debug
+        ${PARADISEO_ROOT}/${BUILD_DIR}
+        $ENV{PARADISEO_ROOT}
         /usr/local/
         /usr/
         /sw # Fink
@@ -172,20 +153,18 @@ endforeach()
 
 # handle result
 if(PARADISEO_FOUND)
-    message(STATUS "Found the following ParadisEO include directories:")
-    message(STATUS "\tEO\t: " ${EO_INCLUDE_DIR})
-    message(STATUS "\tMO\t: " ${MO_INCLUDE_DIR})
-    message(STATUS "\tMOEO\t: " ${MOEO_INCLUDE_DIR})
+    message(STATUS "Found ParadisEO includes :")
+    message(${EO_INCLUDE_DIR})
+    message(${EDO_INCLUDE_DIR})
+    message(${MO_INCLUDE_DIR})
+    message(${MOEO_INCLUDE_DIR})
     if(SMP_FOUND)
-        message(STATUS "\tSMP\t: " ${SMP_INCLUDE_DIR})
-    endif()
-    if(EDO_FOUND)
-        message(STATUS "\tEDO\t: " ${EDO_INCLUDE_DIR})
+        message(${SMP_INCLUDE_DIR})
     endif()
     if(PEO_FOUND)
-        message(STATUS "\tPEO\t: " ${PEO_INCLUDE_DIR})
+        message(${PEO_INCLUDE_DIR})
     endif()
 else()
     # include directory or library not found
-    message(FATAL_ERROR "Could NOT find ParadisEO (missing \t: ${FIND_PARADISEO_MISSING})")
+    message(FATAL_ERROR "Could NOT find ParadisEO (missing : ${FIND_PARADISEO_MISSING})")
 endif()