* New tree configuration of the project:

.../
   ...           + -- EO
   |             |
   |             |
   +-- src ----- + -- EDO
   |             |
   |             |
   +-- test      + -- MO
   |             |
   |             |
   +-- tutorial  + -- MOEO
   |             |
   |             |
   +-- doc       + -- SMP
   |             |
   |             |
   ...           + -- EOMPI
                 |
                 |
                 + -- EOSERIAL

Question for current maintainers: ./README: new release?

Also:

* Moving out eompi & eoserial modules (issue #2).

* Correction of the errors when executing "make doc" command.

* Adding a solution for the conflicting headers problem (see the two CMake Cache
 Values: PROJECT_TAG & PROJECT_HRS_INSTALL_SUBPATH) (issue #1)

* Header inclusions:
        ** src: changing absolute paths into relative paths ('#include <...>' -> '#include "..."')
        ** test, tutorial: changing relative paths into absolute paths ('#include "..."' -> '#include <...>')

* Moving out some scripts from EDO -> to the root

* Add a new script for compilation and installation (see build_gcc_linux_install)

* Compilation with uBLAS library or EDO module: now ok

* Minor modifications on README & INSTALL files

* Comment eompi failed tests with no end

*** TODO: CPack (debian (DEB) & RedHat (RPM) packages) (issues #6 & #7) ***

tutorial/smp/BaseLesson.h

@@ -0,0 +1,272 @@
+#ifndef _BASELESSON_H
+#define _BASELESSON_H
+#include <stdlib.h>
+#include <iostream>
+#include <fstream>
+#include <vector>
+#include <thread>
+#include <chrono>
+
+using namespace std;
+
+int n = 10;
+int** a;
+int** b;
+
+int bkv; //best known value
+
+struct parameters
+{
+  unsigned seed ;
+  int popSize;
+  int tSize;
+  string inst;
+  string loadName;
+  string schema;
+  double pCross;
+  double pMut;
+  int minGen;
+  int maxGen;
+};
+
+class Indi : public EO<eoMinimizingFitness> { 
+
+public:   
+ 
+  int* solution; 
+  int evalNb = 0;
+
+  Indi () {
+    solution = new int[n];
+    create();
+  } 
+
+  Indi (const Indi & _problem){ // copy constructor
+    solution = new int[n];
+    for (int i = 0; i < n ; i++){
+      solution[i] = _problem.solution[i];
+    }
+    if (!_problem.invalid()) // if the solution has already been evaluated
+      fitness(_problem.fitness()); // copy the fitness 
+  }
+
+  ~Indi(){ // destructor
+    delete[] solution;
+  }
+
+  void operator= (const Indi & _problem){ // copy assignment operator
+    for (int i = 0; i < n ; i++){
+      solution[i] = _problem.solution[i];
+    }
+    fitness(_problem.fitness()); // copy the fitness 
+  }  
+  
+  int& operator[] (unsigned i)
+  {
+  	return solution[i];	
+  }
+
+ 
+  void create(){ // create and initialize a solution
+    int random, temp;
+    for (int i=0; i< n; i++) 
+      solution[i]=i;
+    
+    // we want a random permutation so we shuffle
+    for (int i = 0; i < n; i++){
+      random = rand()%(n-i) + i;
+      temp = solution[i];
+      solution[i] = solution[random];
+      solution[random] = temp;
+    }
+  }
+
+  int evaluate() { // evaluate the solution
+    int cost=0;
+    for (int i=0; i<n; i++)
+      for (int j=0; j<n; j++)
+	      cost += a[i][j] * b[solution[i]][solution[j]];
+        evalNb++;
+        //std::this_thread::sleep_for(std::chrono::milliseconds(1));
+	    //std::cout << "Evaluation " << evalNb << std::endl;
+	    
+    return cost;
+  }
+
+
+  void printSolution() {
+   for (int i = 0; i < n ; i++)
+     std::cout << solution[i] << " " ;
+ 
+   std::cout << std::endl;
+  }
+ 
+ 
+};
+class IndiInit : public eoInit<Indi>
+{
+public:
+
+  void operator()(Indi & _problem)
+  {
+    _problem.create();
+  }
+};
+
+class IndiEvalFunc : public eoEvalFunc<Indi>
+{
+public:
+
+  void operator()(Indi & _problem)
+  {
+    _problem.fitness(_problem.evaluate());
+      
+  }
+};
+
+class IndiXover : public eoQuadOp<Indi> {
+public:
+
+  /* The two parameters in input are the parents.
+     The first parameter is also the output ie the child 
+  */
+  bool operator()(Indi & _problem1, Indi & _problem2)
+  {
+    int i;
+    int random, temp;
+    std::vector<int> unassigned_positions(n);
+    std::vector<int> remaining_items(n);
+    int j = 0;
+				
+    /* 1) find the items assigned in different positions for the 2 parents */
+    for (i = 0 ; i < n ; i++){
+      if (_problem1.solution[i] != _problem2.solution[i]){
+	unassigned_positions[j] = i;
+	remaining_items[j] = _problem1.solution[i];
+	j++;
+      }
+    }
+    
+    /* 2) shuffle the remaining items to ensure that remaining items 
+       will be assigned at random positions */
+    for (i = 0; i < j; i++){
+      random = rand()%(j-i) + i;
+      temp = remaining_items[i];
+      remaining_items[i] = remaining_items[random];
+      remaining_items[random] = temp;
+    }
+						    					   
+    /* 3) copy the shuffled remaining items at unassigned positions */
+    for (i = 0; i < j ; i++)
+      _problem1.solution[unassigned_positions[i]] = remaining_items[i];
+
+    // crossover in our case is always possible
+    return true; 
+  }
+};
+
+class IndiSwapMutation: public eoMonOp<Indi> {
+public:
+ 
+  bool operator()(Indi& _problem)  {
+    int i,j;
+    int temp;
+
+    // generate two different indices
+    i=rand()%n;
+    do 
+      j = rand()%n; 
+    while (i == j);  
+		   
+    // swap
+    temp = _problem.solution[i];
+    _problem.solution[i] = _problem.solution[j];
+    _problem.solution[j] = temp;
+
+    return true;
+    
+  }
+
+};
+
+void parseFile(eoParser & parser, parameters & param)
+{
+
+  // For each parameter, you can in on single line
+  // define the parameter, read it through the parser, and assign it
+
+  param.seed = parser.createParam(unsigned(time(0)), "seed", "Random number seed", 'S').value(); // will be in default section General
+
+  // init and stop
+  param.loadName = parser.createParam(string(""), "Load","A save file to restart from",'L', "Persistence" ).value();
+  
+  param.inst = parser.createParam(string(""), "inst","a dat file to read instances from",'i', "Persistence" ).value();
+  
+  param.schema = parser.createParam(string(""), "schema","an xml file mapping process",'s', "Persistence" ).value();
+
+  param.popSize = parser.createParam(unsigned(10), "popSize", "Population size",'P', "Evolution engine" ).value();
+  
+  param.tSize = parser.createParam(unsigned(2), "tSize", "Tournament size",'T', "Evolution Engine" ).value();
+  
+  param.minGen = parser.createParam(unsigned(100), "minGen", "Minimum number of iterations",'g', "Stopping criterion" ).value();
+
+  param.maxGen = parser.createParam(unsigned(300), "maxGen", "Maximum number of iterations",'G', "Stopping criterion" ).value();
+  
+  param.pCross = parser.createParam(double(0.6), "pCross", "Probability of Crossover", 'C', "Genetic Operators" ).value();
+  
+  param.pMut = parser.createParam(double(0.1), "pMut", "Probability of Mutation", 'M', "Genetic Operators" ).value();
+
+
+  // the name of the "status" file where all actual parameter values will be saved
+  string str_status = parser.ProgramName() + ".status"; // default value
+  string statusName = parser.createParam(str_status, "status","Status file",'S', "Persistence" ).value();
+
+  // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
+  // i.e. in case you need parameters somewhere else, postpone these
+  if (parser.userNeedsHelp())
+    {
+      parser.printHelp(cout);
+      exit(1);
+    }
+  if (statusName != "")
+    {
+      ofstream os(statusName.c_str());
+      os << parser;		// and you can use that file as parameter file
+    }
+}
+
+void loadInstances(const char* filename, int& n, int& bkv, int** & a, int** & b) 
+{
+	
+  ifstream data_file;       
+  int i, j;
+  data_file.open(filename);
+  if (! data_file.is_open())
+    {
+      cout << "\n Error while reading the file " << filename << ". Please check if it exists !" << endl;
+      exit (1);
+    }
+  data_file >> n;
+  data_file >> bkv; // best known value
+  // ****************** dynamic memory allocation ****************** /
+  a = new int* [n];
+  b = new int* [n];
+  for (i = 0; i < n; i++) 
+  {
+    a[i] = new int[n];
+    b[i] = new int[n];
+  }
+
+  // ************** read flows and distanceMatrixs matrices ************** /
+  for (i = 0; i < n; i++) 
+    for (j = 0; j < n; j++)
+      data_file >> a[i][j];
+
+  for (i = 0; i < n; i++) 
+    for (j = 0; j < n; j++)
+      data_file >> b[i][j];
+
+  data_file.close();
+}
+
+#endif