add lesson1

git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@229 331e1502-861f-0410-8da2-ba01fb791d7f

branches/paradiseo-moeo-1.0/tutorials/lesson1/FlowShop.h

@@ -0,0 +1,114 @@
+// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+//-----------------------------------------------------------------------------
+// FlowShop.h
+// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
+/*
+    This library...
+
+    Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
+ */
+//-----------------------------------------------------------------------------
+
+#ifndef FLOWSHOP_H_
+#define FLOWSHOP_H_
+
+#include <MOEO.h>
+#include <moeoObjectiveVector.h>
+#include <moeoObjectiveVectorTraits.h>
+
+
+/**
+ * definition of the objective vector for multi-objective flow-shop problems
+ */
+typedef moeoObjectiveVectorDouble<moeoObjectiveVectorTraits> FlowShopObjectiveVector;
+
+
+/** 
+ *  Structure of the genotype for the flow-shop scheduling problem
+ */
+class FlowShop: public MOEO<FlowShopObjectiveVector, double, double> {
+
+public:
+
+  /** 
+   * default constructor
+   */
+  FlowShop() {}
+
+  /** 
+   * destructor
+   */
+  virtual ~FlowShop() {}
+  
+  /** 
+   * class name
+   */
+  virtual string className() const { 
+    return "FlowShop";
+  }
+
+  /** 
+   * set scheduling vector
+   * @param vector<unsigned> & _scheduling  the new scheduling to set 
+   */
+  void setScheduling(vector<unsigned> & _scheduling) {
+    scheduling = _scheduling;
+  }
+  
+  /** 
+   * get scheduling vector
+   */
+  const vector<unsigned> & getScheduling() const {
+    return scheduling;
+  }
+  
+  /**
+   * printing...
+   */
+  void printOn(ostream& _os) const {
+    // fitness
+    MOEO<FlowShopObjectiveVector, double, double>::printOn(_os);    
+    // size
+    _os << scheduling.size() << "\t" ;
+    // scheduling
+    for (unsigned i=0; i<scheduling.size(); i++)
+      _os << scheduling[i] << ' ' ;
+  }
+  
+  /**
+   * reading...
+   */
+  void readFrom(istream& _is) {
+    // fitness
+    MOEO<FlowShopObjectiveVector, double, double>::readFrom(_is);
+    // size
+    unsigned size;
+    _is >> size;
+    // scheduling
+    scheduling.resize(size);
+    bool tmp;
+    for (unsigned i=0; i<size; i++) {
+      _is >> tmp;
+      scheduling[i] = tmp;
+    }
+  }
+  
+  
+  bool operator==(const FlowShop& _other) const { return scheduling == _other.getScheduling(); }
+  bool operator!=(const FlowShop& _other) const { return scheduling != _other.getScheduling(); }
+  bool operator< (const FlowShop& _other) const { return scheduling <  _other.getScheduling(); }
+  bool operator> (const FlowShop& _other) const { return scheduling >  _other.getScheduling(); }
+  bool operator<=(const FlowShop& _other) const { return scheduling <= _other.getScheduling(); }
+  bool operator>=(const FlowShop& _other) const { return scheduling >= _other.getScheduling(); }
+
+
+private:
+
+  /** scheduling (order of operations) */
+  std::vector<unsigned> scheduling;
+
+};
+
+
+#endif /*FLOWSHOP_H_*/

branches/paradiseo-moeo-1.0/tutorials/lesson1/FlowShopBenchmarkParser.h

@@ -0,0 +1,140 @@
+// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+//-----------------------------------------------------------------------------
+// FlowShopBenchmarkParser.h
+// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
+/*
+    This library...
+
+    Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
+ */
+//-----------------------------------------------------------------------------
+
+#ifndef FLOWSHOPBENCHMARKPARSER_H_
+#define FLOWSHOPBENCHMARKPARSER_H_
+#include <stdexcept>
+#include <fstream>
+
+/** Web site to download benchmarks  */
+const static std::string BENCHMARKS_WEB_SITE = "www.lifl.fr/~basseur/BenchsUncertain/";
+
+
+/** 
+ * Class to handle parameters of a flow-shop instance from a benchmark file
+ * benchmark files are available at www.lifl.fr/~basseur/BenchsUncertain/
+ */
+class FlowShopBenchmarkParser {
+
+public:
+
+  /**
+   * constructor
+   * @param const string _benchmarkFileName  the name of the benchmark file
+   */
+  FlowShopBenchmarkParser(const string _benchmarkFileName) {
+    init(_benchmarkFileName);
+  }
+  
+  /**
+   * the number of machines
+   */
+  const unsigned getM() {
+    return M;
+  }
+
+  /**
+   * the number of jobs
+   */
+  const unsigned getN() {
+    return N;
+  }
+
+  /**
+   * the processing times
+   */
+  const std::vector< std::vector<unsigned> > getP() {
+    return p;
+  }
+
+  /**
+   * the due-dates
+   */
+  const std::vector<unsigned> getD() {
+    return d;
+  }
+
+  /** 
+   * printing...
+   */
+  void printOn(ostream& _os) const { 
+    _os << "M=" << M << " N=" << N << endl;
+    _os << "*** processing times" << endl;
+    for (unsigned i=0; i<M; i++) {
+      for (unsigned j=0; j<N; j++) {
+	_os << p[i][j] << " ";
+      }
+      _os << endl;
+    }
+    _os << "*** due-dates" << endl;
+    for (unsigned j=0; j<N; j++) {
+      _os << d[j] << " ";
+    }
+    _os << endl << endl;
+  }
+
+private:
+  /** number of machines */
+  unsigned M; 
+  /** number of jobs */
+  unsigned N;
+  /** p[i][j] = processing time of job j on machine i */
+  std::vector< std::vector<unsigned> > p;
+  /** d[j] = due-date of the job j */
+  std::vector<unsigned> d;
+
+
+  /**
+   * Initialisation of the parameters with the data contained in the benchmark file
+   * @param const string _benchmarkFileName  the name of the benchmark file
+   */
+  void init(const string _benchmarkFileName) {
+    string buffer;
+    string::size_type start, end;
+    ifstream inputFile(_benchmarkFileName.data(), ios::in);
+    // opening of the benchmark file
+    if (! inputFile)
+      cerr << "*** ERROR : Unable to open the benchmark file '" << _benchmarkFileName << "'" << endl;
+    // number of jobs (N)
+    getline(inputFile, buffer, '\n');
+    N = atoi(buffer.data());
+    // number of machines M
+    getline(inputFile, buffer, '\n');
+    M = atoi(buffer.data());
+    // initial and current seeds (not used)
+    getline(inputFile, buffer, '\n');
+    // processing times and due-dates
+    p = std::vector< std::vector<unsigned> > (M,N);
+    d = std::vector<unsigned> (N);
+    // for each job...
+    for (unsigned j=0 ; j<N ; j++) {
+      // index of the job (<=> j)
+      getline(inputFile, buffer, '\n');
+      // due-date of the job j
+      getline(inputFile, buffer, '\n');
+      d[j] = atoi(buffer.data());
+      // processing times of the job j on each machine
+      getline(inputFile, buffer, '\n');
+      start = buffer.find_first_not_of(" ");
+      for (unsigned i=0 ; i<M ; i++) {
+	end = buffer.find_first_of(" ", start);
+	p[i][j] = atoi(buffer.substr(start, end-start).data());
+	start = buffer.find_first_not_of(" ", end);
+      }
+    }
+    // closing of the input file
+    inputFile.close();
+  }
+  
+};
+
+#endif /*FLOWSHOPBENCHMARKPARSER_H_*/

branches/paradiseo-moeo-1.0/tutorials/lesson1/FlowShopEA.cpp

@@ -0,0 +1,118 @@
+// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+//-----------------------------------------------------------------------------
+// FlowShopEA.cpp
+// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
+/*
+    This library...
+
+    Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
+ */
+//-----------------------------------------------------------------------------
+
+// Miscilaneous include and declaration 
+using namespace std;
+
+
+/* EO + MOEO */
+// moeo general include
+#include <moeo>
+// for the creation of an evaluator
+#include "make_eval_FlowShop.h"
+// for the creation of an initializer
+#include "make_genotype_FlowShop.h"
+// for the creation of the variation operators
+#include "make_op_FlowShop.h"
+// how to initialize the population
+#include <do/make_pop.h>
+// the stopping criterion
+#include <do/make_continue_moeo.h>
+// outputs (stats, population dumps, ...)
+#include <do/make_checkpoint_moeo.h>
+// evolution engine (selection and replacement)
+#include <do/make_ea_moeo.h>
+// simple call to the algo
+#include <do/make_run.h>
+// checks for help demand, and writes the status file and make_help; in libutils
+void make_help(eoParser & _parser);
+/* FLOW-SHOP */
+// definition of representation
+#include "FlowShop.h"
+
+
+int main(int argc, char* argv[]) {
+  try {
+        
+    eoParser parser(argc, argv);  // for user-parameter reading
+    eoState state;                // to keep all things allocated
+
+
+
+
+
+    /*** the representation-dependent things ***/
+
+    // The fitness evaluation
+    eoEvalFuncCounter<FlowShop>& eval = do_make_eval(parser, state);
+    // the genotype (through a genotype initializer)
+    eoInit<FlowShop>& init = do_make_genotype(parser, state);
+    // the variation operators
+    eoGenOp<FlowShop>& op = do_make_op(parser, state);
+
+
+
+
+
+    /*** the representation-independent things ***/
+
+    // initialization of the population   
+    eoPop<FlowShop>& pop = do_make_pop(parser, state, init);
+    // definition of the archive
+    moeoArchive<FlowShop> arch;
+    // stopping criteria
+    eoContinue<FlowShop>& term = do_make_continue_moeo(parser, state, eval);
+    // output
+    eoCheckPoint<FlowShop>& checkpoint = do_make_checkpoint_moeo(parser, state, eval, term, pop, arch);
+    // algorithm    
+    eoAlgo<FlowShop>& algo = do_make_ea_moeo(parser, state, eval, checkpoint, op, arch);
+       
+
+
+
+
+    /*** Go ! ***/
+
+    // help ?
+    make_help(parser);
+
+    // first evalution
+    apply<FlowShop>(eval, pop);
+    
+    pop.sort();
+    arch.update(pop);
+
+    // printing of the initial population
+    cout << "Initial Population\n";
+    pop.sortedPrintOn(cout);
+    cout << endl;
+
+    // run the algo
+    do_run(algo, pop);
+    
+    // printing of the final population
+    cout << "Final Population\n";
+    pop.sortedPrintOn(cout);
+    cout << endl;
+
+    // printing of the final archive
+    cout << "Final Archive\n";
+    arch.sortedPrintOn(cout);
+    cout << endl;
+
+
+
+  } catch(exception& e) {
+    cout << e.what() << endl;
+  }
+  return EXIT_SUCCESS;
+}

branches/paradiseo-moeo-1.0/tutorials/lesson1/FlowShopEval.h

@@ -0,0 +1,129 @@
+// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+//-----------------------------------------------------------------------------
+// FlowShopEval.h
+// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
+/*
+    This library...
+
+    Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
+ */
+//-----------------------------------------------------------------------------
+
+#ifndef FLOWSHOPEVAL_H_
+#define FLOWSHOPEVAL_H_
+
+#include "FlowShop.h"
+#include <moeoEvalFunc.h>
+
+/**
+ * Functor
+ * Computation of the multi-objective evaluation of a FlowShop object
+ */
+class FlowShopEval : public moeoEvalFunc<FlowShop> {
+
+public:
+
+  /**
+   * constructor
+   * @param _M the number of machines 
+   * @param _N the number of jobs to schedule
+   * @param _p the processing times
+   * @param _d the due dates
+   */
+  FlowShopEval(const unsigned _M, const unsigned _N, const vector< vector<unsigned> > & _p, const vector<unsigned> & _d) : 
+    M(_M), N (_N), p(_p), d(_d){
+
+    unsigned nObjs = 2;
+    std::vector<bool> bObjs(nObjs, true);
+    moeoObjectiveVectorTraits::setup(nObjs, bObjs);
+  }
+  
+
+
+  /**
+   * computation of the multi-objective evaluation of an eoFlowShop object
+   * @param FlowShop & _eo  the FlowShop object to evaluate
+   */
+  void operator()(FlowShop & _eo) {
+      FlowShopObjectiveVector objVector;
+      objVector[0] = tardiness(_eo);
+      objVector[1] = makespan(_eo);      
+      _eo.objectiveVector(objVector);  
+  }
+  
+
+
+
+
+private: 
+
+  /** number of machines */
+  unsigned M; 
+  /** number of jobs */
+  unsigned N;
+  /** p[i][j] = processing time of job j on machine i */
+  std::vector< std::vector<unsigned> > p;
+  /** d[j] = due-date of the job j */
+  std::vector<unsigned> d;
+ 
+
+
+  /**
+   * computation of the makespan
+   * @param FlowShop _eo  the FlowShop object to evaluate
+   */
+  double makespan(FlowShop _eo) {
+    // the scheduling to evaluate
+    vector<unsigned> scheduling = _eo.getScheduling();     
+    // completion times computation for each job on each machine
+    // C[i][j] = completion of the jth job of the scheduling on the ith machine
+    std::vector< std::vector<unsigned> > C = completionTime(_eo);
+    // fitness == C[M-1][scheduling[N-1]];     
+    return C[M-1][scheduling[N-1]];  
+  }
+
+
+
+  /**
+   * computation of the tardiness
+   * @param _eo  the FlowShop object to evaluate
+   */
+  double tardiness(FlowShop _eo) { 
+    // the scheduling to evaluate
+    vector<unsigned> scheduling = _eo.getScheduling();
+    // completion times computation for each job on each machine
+    // C[i][j] = completion of the jth job of the scheduling on the ith machine
+    std::vector< std::vector<unsigned> > C = completionTime(_eo);      
+    // tardiness computation
+    unsigned long sum = 0;
+    for (unsigned j=0 ; j<N ; j++)
+      sum += (unsigned) std::max (0, (int) (C[M-1][scheduling[j]] - d[scheduling[j]]));
+    // fitness == sum
+    return sum;    
+  }
+
+
+ 
+  /**
+   * computation of the completion times of a scheduling (for each job on each machine)
+   * C[i][j] = completion of the jth job of the scheduling on the ith machine
+   * @param const FlowShop _eo  the genotype to evaluate
+   */
+  std::vector< std::vector<unsigned> > completionTime(FlowShop _eo) {
+    vector<unsigned> scheduling = _eo.getScheduling();
+    std::vector< std::vector<unsigned> > C(M,N);
+    C[0][scheduling[0]] = p[0][scheduling[0]];
+    for (unsigned j=1; j<N; j++)
+      C[0][scheduling[j]] = C[0][scheduling[j-1]] + p[0][scheduling[j]];
+    for (unsigned i=1; i<M; i++)
+      C[i][scheduling[0]] = C[i-1][scheduling[0]] + p[i][scheduling[0]];
+    for (unsigned i=1; i<M; i++)
+      for (unsigned j=1; j<N; j++)
+	C[i][scheduling[j]] = std::max(C[i][scheduling[j-1]], C[i-1][scheduling[j]]) + p[i][scheduling[j]];
+    return C;    
+  }
+
+};
+
+#endif /*FLOWSHOPEVAL_H_*/

branches/paradiseo-moeo-1.0/tutorials/lesson1/FlowShopInit.h

@@ -0,0 +1,64 @@
+// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+//-----------------------------------------------------------------------------
+// FlowShopInit.h
+// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
+/*
+    This library...
+
+    Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
+ */
+//-----------------------------------------------------------------------------
+
+#ifndef FLOWSHOPINIT_H_
+#define FLOWSHOPINIT_H_
+
+#include <eoInit.h>
+#include "FlowShop.h"
+
+/**
+ * Functor
+ * Initialisation of a random genotype built by the default constructor of the eoFlowShop class
+ */
+class FlowShopInit: public eoInit<FlowShop> {
+
+public:
+
+  /** 
+   * constructor
+   * @param const unsigned _N  the number of jobs to schedule
+   */
+  FlowShopInit(const unsigned _N) {
+    N = _N;
+  }
+  
+  /**
+   * randomize a genotype
+   * @param FlowShop & _genotype  a genotype that has been default-constructed
+   */
+  void operator()(FlowShop & _genotype) {
+    // scheduling vector
+    vector<unsigned> scheduling(N);
+    // initialisation of possible values
+    vector<unsigned> possibles(N);
+    for(unsigned i=0 ; i<N ; i++)
+      possibles[i] = i;
+    // random initialization
+    unsigned rInd;     // random index
+    for (unsigned i=0; i<N; i++) {
+      rInd = (unsigned) rng.uniform(N-i);
+      scheduling[i] = possibles[rInd];
+      possibles[rInd] = possibles[N-i-1];
+    }
+    _genotype.setScheduling(scheduling);
+    _genotype.invalidate();	   // IMPORTANT in case the _genotype is old
+  }
+
+
+private:
+  /** the number of jobs (size of a scheduling vector) */
+  unsigned N;
+ 
+};
+
+#endif /*FLOWSHOPINIT_H_*/

branches/paradiseo-moeo-1.0/tutorials/lesson1/FlowShopOpCrossoverQuad.h

@@ -0,0 +1,120 @@
+// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+//-----------------------------------------------------------------------------
+// FlowShopOpCrossoverQuad.h
+// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
+/*
+    This library...
+
+    Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
+ */
+//-----------------------------------------------------------------------------
+
+#ifndef FLOWSHOPOPCROSSOVERQUAD_H_
+#define FLOWSHOPOPCROSSOVERQUAD_H_
+
+#include <eoOp.h>
+#include "FlowShop.h"
+
+/**
+ * Functor
+ * Quadratic crossover operator for flow-shop (modify the both genotypes)
+ */
+class FlowShopOpCrossoverQuad: public eoQuadOp<FlowShop> {
+  
+public:  
+  
+  /**
+   * default constructor
+   */  
+  FlowShopOpCrossoverQuad() {}
+  
+  /**
+   * the class name (used to display statistics)
+   */
+  string className() const { 
+    return "FlowShopOpCrossoverQuad";
+  }
+  
+  /**
+   * eoQuad crossover - _genotype1 and _genotype2 are the (future) offspring, i.e. _copies_ of the parents
+   * @param FlowShop & _genotype1  the first parent
+   * @param FlowShop & _genotype2  the second parent
+   */
+  bool operator()(FlowShop & _genotype1, FlowShop & _genotype2) {
+    bool oneAtLeastIsModified;
+   
+    // parents
+    vector<unsigned> parent1 = _genotype1.getScheduling();
+    vector<unsigned> parent2 = _genotype2.getScheduling();
+    
+    // computation of the 2 random points
+    unsigned point1, point2;
+    do {
+      point1 =  rng.random(min(parent1.size(), parent2.size()));
+      point2 =  rng.random(min(parent1.size(), parent2.size()));
+	} while (fabs((double) point1-point2) <= 2);
+   
+    // computation of the offspring
+    vector<unsigned> offspring1 = generateOffspring(parent1, parent2, point1, point2);
+    vector<unsigned> offspring2 = generateOffspring(parent2, parent1, point1, point2);
+    
+    // does at least one genotype has been modified ?
+    if ((parent1 != offspring1) || (parent2 != offspring2)) {
+      // update
+      _genotype1.setScheduling(offspring1);
+      _genotype2.setScheduling(offspring2);
+      // at least one genotype has been modified
+      oneAtLeastIsModified = true;
+    }
+    else {
+      // no genotype has been modified
+      oneAtLeastIsModified = false;
+    }
+
+    // return 'true' if at least one genotype has been modified
+    return oneAtLeastIsModified;
+  }
+  
+  
+private:
+  
+  /**
+   * generation of an offspring by a 2 points crossover
+   * @param vector<unsigned> _parent1  the first parent
+   * @param vector<unsigned> _parent2  the second parent
+   * @param unsigned_point1  the first point
+   * @param unsigned_point2  the second point
+   */
+  vector<unsigned> generateOffspring(vector<unsigned> _parent1, vector<unsigned> _parent2, unsigned _point1, unsigned _point2) {
+    vector<unsigned> result = _parent1;
+    vector<bool> taken_values(result.size(), false);
+    if (_point1 > _point2) swap(_point1, _point2);
+ 
+    /* first parent */
+    for (unsigned i=0 ; i<=_point1 ; i++) {
+      // result[i] == _parent1[i]
+      taken_values[_parent1[i]] = true;
+    }
+    for (unsigned i=_point2 ; i<result.size() ; i++) {
+      // result[i] == _parent1[i]
+      taken_values[_parent1[i]] = true;
+    }
+   
+    /* second parent */
+    unsigned i = _point1+1;
+    unsigned j = 0;
+    while (i<_point2 && j<_parent2.size()) {
+      if(! taken_values[_parent2[j]]) {
+	result[i] = _parent2[j];
+	i++;
+      }
+      j++;
+    }
+    
+    return result;
+  }
+
+};
+
+#endif /*FLOWSHOPOPCROSSOVERQUAD_H_*/

branches/paradiseo-moeo-1.0/tutorials/lesson1/FlowShopOpMutationExchange.h

@@ -0,0 +1,78 @@
+// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+//-----------------------------------------------------------------------------
+// FlowShopOpCrossoverQuad.h
+// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
+/*
+    This library...
+
+    Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
+ */
+//-----------------------------------------------------------------------------
+
+#ifndef FLOWSHOPOPMUTATIONEXCHANGE_H_
+#define FLOWSHOPOPMUTATIONEXCHANGE_H_
+
+#include <eoOp.h>
+#include "FlowShop.h"
+
+/**
+ * Functor
+ * Exchange mutation operator for flow-shop
+ */
+class FlowShopOpMutationExchange: public eoMonOp<FlowShop> {
+
+public:
+
+  /**
+   * default constructor
+   */  
+  FlowShopOpMutationExchange() {}
+  
+  /**
+   * the class name (used to display statistics)
+   */
+  string className() const { 
+    return "FlowShopOpMutationExchange";
+  }
+
+  /**
+   * modifies the parent with an exchange mutation
+   * @param FlowShop & _genotype  the parent genotype (will be modified)
+   */
+  bool operator()(FlowShop & _genotype) {
+    bool isModified;
+   
+    // schedulings
+    vector<unsigned> initScheduling   = _genotype.getScheduling();
+    vector<unsigned> resultScheduling = _genotype.getScheduling();
+    
+    // computation of the 2 random points
+    unsigned point1, point2;
+    do {
+      point1 = rng.random(resultScheduling.size());
+      point2 = rng.random(resultScheduling.size());
+    } while (point1 == point2);
+    
+    // swap
+    swap (resultScheduling[point1], resultScheduling[point2]);
+    
+    // update (if necessary)
+    if (resultScheduling != initScheduling) {
+      // update
+      _genotype.setScheduling(resultScheduling);
+      // the genotype has been modified
+      isModified = true;
+    }
+    else {
+      // the genotype has not been modified
+      isModified = false;     
+    }
+
+    // return 'true' if the genotype has been modified
+    return isModified;
+  }
+
+};
+
+#endif /*FLOWSHOPOPMUTATIONEXCHANGE_H_*/

branches/paradiseo-moeo-1.0/tutorials/lesson1/FlowShopOpMutationShift.h

@@ -0,0 +1,86 @@
+// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+//-----------------------------------------------------------------------------
+// FlowShopOpMutationShift.h
+// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
+/*
+    This library...
+
+    Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
+ */
+//-----------------------------------------------------------------------------
+
+#ifndef FLOWSHOPOPMUTATIONSHIFT_H_
+#define FLOWSHOPOPMUTATIONSHIFT_H_
+
+#include <eoOp.h>
+#include "FlowShop.h"
+
+/**
+ * Functor
+ * Shift mutation operator for flow-shop
+ */
+class FlowShopOpMutationShift: public eoMonOp<FlowShop> {
+
+public:
+  
+  /**
+   * default constructor
+   */
+  FlowShopOpMutationShift() {}
+  
+  /**
+   * the class name (used to display statistics)
+   */
+  string className() const { 
+    return "FlowShopOpMutationShift";
+  }
+
+  /**
+   * modifies the parent with a shift mutation
+   * @param FlowShop & _genotype  the parent genotype (will be modified)
+   */
+  bool operator()(FlowShop & _genotype) {
+    bool isModified;
+    int direction;
+    unsigned tmp;
+    
+    // schedulings
+    vector<unsigned> initScheduling   = _genotype.getScheduling();
+    vector<unsigned> resultScheduling = initScheduling;
+    
+    // computation of the 2 random points
+    unsigned point1, point2;
+    do {
+      point1 = rng.random(resultScheduling.size());
+      point2 = rng.random(resultScheduling.size());
+    } while (point1 == point2);
+    
+    // direction
+    if (point1 < point2) direction = 1;
+    else direction = -1;
+    // mutation
+    tmp = resultScheduling[point1];
+    for(unsigned i=point1 ; i!=point2 ; i+=direction)
+      resultScheduling[i] = resultScheduling[i+direction];
+    resultScheduling[point2] = tmp;
+    
+    // update (if necessary)
+    if (resultScheduling != initScheduling) {
+      // update
+      _genotype.setScheduling(resultScheduling);
+      // the genotype has been modified
+      isModified = true;
+    }
+    else {
+      // the genotype has not been modified
+      isModified = false;     
+    }
+
+    // return 'true' if the genotype has been modified
+    return isModified;
+  }
+
+};
+
+#endif /*FLOWSHOPOPMUTATIONSHIFT_H_*/

branches/paradiseo-moeo-1.0/tutorials/lesson1/Makefile.am

@@ -0,0 +1,9 @@
+
+noinst_PROGRAMS		= FlowShopEA
+
+FlowShopEA_SOURCES	= FlowShopEA.cpp
+
+LDADD			= -L$(top_builddir)/src ${EO_DIR}/src/libeo.a ${EO_DIR}/src/utils/libeoutils.a
+
+INCLUDES		= -I${EO_DIR}/src/ -I${MO_DIR}/src/ -I$(top_srcdir)/src
+

branches/paradiseo-moeo-1.0/tutorials/lesson1/make_eval_FlowShop.h

@@ -0,0 +1,55 @@
+// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+//-----------------------------------------------------------------------------
+// make_eval_FlowShop.h
+// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
+/*
+    This library...
+
+    Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
+ */
+//-----------------------------------------------------------------------------
+
+#ifndef MAKE_EVAL_FLOWSHOP_H_
+#define MAKE_EVAL_FLOWSHOP_H_
+
+
+#include <utils/eoParser.h>
+#include <utils/eoState.h>
+#include "FlowShop.h"
+#include "FlowShopBenchmarkParser.h"
+#include "FlowShopEval.h"
+
+/*
+ * This function creates an eoEvalFuncCounter<eoFlowShop> that can later be used to evaluate an individual.
+ * @param eoParser& _parser  to get user parameters
+ * @param eoState& _state  to store the memory 
+ */
+eoEvalFuncCounter<FlowShop> & do_make_eval(eoParser& _parser, eoState& _state) {
+ 
+  // benchmark file name
+  string benchmarkFileName = _parser.getORcreateParam(string(), "BenchmarkFile", "Benchmark file name (benchmarks are available at " + BENCHMARKS_WEB_SITE + ")", 'B',"Representation", true).value();
+  if (benchmarkFileName == "") {
+    std::string stmp = "*** Missing name of the benchmark file\n";
+    stmp += "    Type '-B=the_benchmark_file_name' or '--BenchmarkFile=the_benchmark_file_name'\n";
+    stmp += "    Benchmarks files are available at " + BENCHMARKS_WEB_SITE;
+    throw std::runtime_error(stmp.c_str());
+  }
+  // reading of the parameters contained in the benchmark file
+  FlowShopBenchmarkParser fParser(benchmarkFileName);
+  unsigned M = fParser.getM(); 
+  unsigned N = fParser.getN();
+  std::vector< std::vector<unsigned> > p = fParser.getP();
+  std::vector<unsigned> d = fParser.getD();
+   
+  // build of the initializer (a pointer, stored in the eoState)
+  FlowShopEval* plainEval = new FlowShopEval(M, N, p, d);  
+  // turn that object into an evaluation counter
+  eoEvalFuncCounter<FlowShop>* eval = new eoEvalFuncCounter<FlowShop> (* plainEval);
+  // store in state
+  _state.storeFunctor(eval);
+  // and return a reference
+  return *eval;
+}
+
+#endif /*MAKE_EVAL_FLOWSHOP_H_*/

branches/paradiseo-moeo-1.0/tutorials/lesson1/make_genotype_FlowShop.h

@@ -0,0 +1,49 @@
+// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+//-----------------------------------------------------------------------------
+// make_genotype_FlowShop.h
+// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
+/*
+    This library...
+
+    Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
+ */
+//-----------------------------------------------------------------------------
+
+#ifndef MAKE_GENOTYPE_FLOWSHOP_H_
+#define MAKE_GENOTYPE_FLOWSHOP_H_
+
+#include <utils/eoParser.h>
+#include <utils/eoState.h>
+#include "FlowShop.h"
+#include "FlowShopInit.h"
+#include "FlowShopBenchmarkParser.h"
+
+/*
+ * This function creates an eoInit<eoFlowShop> that can later be used to initialize the population (see make_pop.h).
+ * @param eoParser& _parser  to get user parameters
+ * @param eoState& _state  to store the memory
+ */
+eoInit<FlowShop> & do_make_genotype(eoParser& _parser, eoState& _state) {
+ 
+  // benchmark file name
+  string benchmarkFileName = _parser.getORcreateParam(string(), "BenchmarkFile", "Benchmark file name (benchmarks are available at " + BENCHMARKS_WEB_SITE + ")", 'B',"Representation", true).value();
+  if (benchmarkFileName == "") {
+    std::string stmp = "*** Missing name of the benchmark file\n";
+    stmp += "   Type '-B=the_benchmark_file_name' or '--BenchmarkFile=the_benchmark_file_name'\n";
+    stmp += "   Benchmarks files are available at " + BENCHMARKS_WEB_SITE;
+    throw std::runtime_error(stmp.c_str());
+  }
+  // reading of number of jobs to schedule contained in the benchmark file   
+  FlowShopBenchmarkParser fParser(benchmarkFileName);
+  unsigned N = fParser.getN();
+
+  // build of the initializer (a pointer, stored in the eoState)
+  eoInit<FlowShop>* init = new FlowShopInit(N);
+  // store in state
+  _state.storeFunctor(init);
+  // and return a reference
+  return *init;
+}
+
+#endif /*MAKE_GENOTYPE_FLOWSHOP_H_*/

branches/paradiseo-moeo-1.0/tutorials/lesson1/make_op_FlowShop.h

@@ -0,0 +1,106 @@
+// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+//-----------------------------------------------------------------------------
+// make_op_FlowShop.h
+// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
+/*
+    This library...
+
+    Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
+ */
+//-----------------------------------------------------------------------------
+
+#ifndef MAKE_OP_FLOWSHOP_H_
+#define MAKE_OP_FLOWSHOP_H_
+
+#include <utils/eoParser.h>
+#include <utils/eoState.h>
+#include <eoOp.h>
+#include <eoGenOp.h>
+#include <eoCloneOps.h>
+#include <eoOpContainer.h>
+#include <eoProportionalCombinedOp.h>
+#include "FlowShopOpCrossoverQuad.h"
+#include "FlowShopOpMutationShift.h"
+#include "FlowShopOpMutationExchange.h"
+
+/*
+ * This function builds the operators that will be applied to the eoFlowShop
+ * @param eoParameterLoader& _parser to get user parameters
+ * @param eoState& _state to store the memory
+ */
+eoGenOp<FlowShop> & do_make_op(eoParameterLoader& _parser, eoState& _state) {
+ 
+  /////////////////////////////
+  // Variation operators
+  ////////////////////////////
+   
+  // the crossover
+  ////////////////
+
+  // a first crossover   
+  eoQuadOp<FlowShop> *cross = new FlowShopOpCrossoverQuad;
+  // store in the state
+  _state.storeFunctor(cross);
+  
+  // relative rate in the combination
+  double cross1Rate = _parser.createParam(1.0, "crossRate", "Relative rate for the only crossover", 0, "Variation Operators").value();
+  // creation of the combined operator with this one
+  eoPropCombinedQuadOp<FlowShop> *propXover = new eoPropCombinedQuadOp<FlowShop>(*cross, cross1Rate);
+  // store in the state
+  _state.storeFunctor(propXover);
+  
+
+  // the mutation
+  ///////////////
+   
+  // a first mutation : the shift mutation
+  eoMonOp<FlowShop> *mut = new FlowShopOpMutationShift;
+  _state.storeFunctor(mut);
+  // its relative rate in the combination
+  double mut1Rate = _parser.createParam(0.5, "shiftMutRate", "Relative rate for shift mutation", 0, "Variation Operators").value();
+  // creation of the combined operator with this one
+  eoPropCombinedMonOp<FlowShop> *propMutation = new eoPropCombinedMonOp<FlowShop>(*mut, mut1Rate);
+  _state.storeFunctor(propMutation);
+  
+  // a second mutation : the exchange mutation
+  mut = new FlowShopOpMutationExchange;
+  _state.storeFunctor(mut);
+  // its relative rate in the combination
+  double mut2Rate = _parser.createParam(0.5, "exchangeMutRate", "Relative rate for exchange mutation", 0, "Variation Operators").value();
+  // addition of this one to the combined operator
+  propMutation -> add(*mut, mut2Rate); 
+
+  // end of crossover and mutation definitions
+  ////////////////////////////////////////////
+ 
+  // First read the individual level parameters
+  eoValueParam<double>& pCrossParam = _parser.createParam(0.25, "pCross", "Probability of Crossover", 'c', "Variation Operators" );  
+  // minimum check
+  if ( (pCrossParam.value() < 0) || (pCrossParam.value() > 1) )
+    throw runtime_error("Invalid pCross");
+
+  eoValueParam<double>& pMutParam = _parser.createParam(0.35, "pMut", "Probability of Mutation", 'm', "Variation Operators" );
+  // minimum check
+  if ( (pMutParam.value() < 0) || (pMutParam.value() > 1) )
+    throw runtime_error("Invalid pMut");
+ 
+  // the crossover - with probability pCross
+  eoProportionalOp<FlowShop> * propOp = new eoProportionalOp<FlowShop> ;
+  _state.storeFunctor(propOp);
+  eoQuadOp<FlowShop> *ptQuad = new eoQuadCloneOp<FlowShop>;
+  _state.storeFunctor(ptQuad);
+  propOp -> add(*propXover, pCrossParam.value()); // crossover, with proba pcross
+  propOp -> add(*ptQuad, 1-pCrossParam.value()); // nothing, with proba 1-pcross
+  
+  // now the sequential
+  eoSequentialOp<FlowShop> *op = new eoSequentialOp<FlowShop>;
+  _state.storeFunctor(op);
+  op -> add(*propOp, 1.0);	 // always do combined crossover
+  op -> add(*propMutation, pMutParam.value()); // then mutation, with proba pmut
+
+  // return a reference
+  return *op;
+}
+
+#endif /*MAKE_OP_FLOWSHOP_H_*/