Ajout de la fitness max SAT (avec incr eval)

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

trunk/paradiseo-mo/src/mo.h

@@ -90,6 +90,7 @@
 #include <eval/moFullEvalByModif.h>
 #include <eval/moDummyEval.h>
 #include <eval/moEvalCounter.h>
+#include <eval/moMaxSATincrEval.h>
 
 #include <explorer/moFirstImprHCexplorer.h>
 #include <explorer/moNeutralHCexplorer.h>

trunk/paradiseo-mo/src/problems/eval/moMaxSATincrEval.h

@@ -0,0 +1,121 @@
+/*
+<moMaxSATincrEval.h>
+Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2010
+
+Sebastien Verel, Arnaud Liefooghe, Jeremie Humeau
+
+This software is governed by the CeCILL license under French law and
+abiding by the rules of distribution of free software.  You can  ue,
+modify and/ or redistribute the software under the terms of the CeCILL
+license as circulated by CEA, CNRS and INRIA at the following URL
+"http://www.cecill.info".
+
+In this respect, the user's attention is drawn to the risks associated
+with loading,  using,  modifying and/or developing or reproducing the
+software by the user in light of its specific status of free software,
+that may mean  that it is complicated to manipulate,  and  that  also
+therefore means  that it is reserved for developers  and  experienced
+professionals having in-depth computer knowledge. Users are therefore
+encouraged to load and test the software's suitability as regards their
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and,  more generally, to use and operate it in the
+same conditions as regards security.
+The fact that you are presently reading this means that you have had
+knowledge of the CeCILL license and that you accept its terms.
+
+ParadisEO WebSite : http://paradiseo.gforge.inria.fr
+Contact: paradiseo-help@lists.gforge.inria.fr
+*/
+
+#ifndef _moMaxSATincrEval_h
+#define _moMaxSATincrEval_h
+
+#include <eval/moEval.h>
+#include <eval/maxSATeval.h>
+
+/**
+ * Incremental evaluation Function for the max SAT problem
+ */
+template <class Neighbor>
+class moMaxSATincrEval : public moEval <Neighbor> {
+public :
+  typedef typename Neighbor::EOT EOT;
+  
+  moMaxSATincrEval(MaxSATeval<EOT> & _fulleval) : fulleval(_fulleval) { 
+    nbClauses = _fulleval.nbClauses;
+    nbVar     = _fulleval.nbVar;
+
+    clauses   =  _fulleval.clauses;
+    variables = _fulleval.variables;
+  }
+
+  /*
+   * incremental evaluation of the neighbor for the max SAT problem
+   * @param _solution the solution (of type bit string) to move 
+   * @param _neighbor the neighbor (of type moBitNeigbor) to consider 
+   */
+  virtual void operator()(EOT & _solution, Neighbor & _neighbor) {
+    // the difference of fitness
+    int delta = 0;
+
+    // the flipped bit
+    unsigned int bit = _neighbor.index();
+
+    // clauses which can be modified by the flipped bit
+    const vector<int> & modifiedClauses = variables[bit + 1] ; // remember that the variables start at index 1 and not 0
+    unsigned int size = modifiedClauses.size();
+
+    int nc;
+    bool litt;
+
+    for(unsigned int k = 0; k < size; k++) {
+      // number of the clause
+      nc = modifiedClauses[k];
+      
+      // negative means that the not(variable) is in the clause 
+      if (nc < 0) {
+	nc = - nc;
+	litt = !_solution[bit];
+      } else
+	litt = _solution[bit];
+
+      if (litt) { 
+	// the litteral was true and becomes false
+	_solution[bit] = !_solution[bit];
+	
+	if (!fulleval.clauseEval(nc, _solution))
+	  // the clause was true and becomes false
+	  delta--;
+	
+	_solution[bit] = !_solution[bit];
+      } else { 
+	// the litteral was false and becomes true
+	if (!fulleval.clauseEval(nc, _solution))
+	  // the clause was false and becomes true
+	  delta++;
+      }	  
+    }
+    
+    _neighbor.fitness(_solution.fitness() + delta);
+  }
+
+protected:
+  // number of variables
+  unsigned int nbVar; 
+  // number of clauses
+  unsigned int nbClauses;
+
+  // list of clauses: 
+  //   each clause has the number of the variable (from 1 to nbVar) 
+  //   when the value, litteral = not(variable)
+  vector<int> * clauses;
+
+  // list of variables:
+  //   for each variable, the list of clauses
+  vector<int> * variables;
+  
+  //full eval of the max SAT
+  MaxSATeval<EOT> & fulleval;
+};
+
+#endif

trunk/paradiseo-mo/src/problems/eval/moRoyalRoadIncrEval.h

@@ -44,7 +44,7 @@ public:
 
   /**
    * Default constructor
-   * @param _k size of a block
+   * @param _rr full evaluation of the Royal Road (to have the same block size)
    */
   moRoyalRoadIncrEval(RoyalRoadEval<EOT> & _rr) : k(_rr.blockSize()) {}
 

trunk/paradiseo-mo/tutorial/Lesson1/CMakeLists.txt

@@ -14,6 +14,7 @@ ADD_EXECUTABLE(lesson1_fitContinuator lesson1_fitContinuator.cpp)
 ADD_EXECUTABLE(lesson1_fullEvalContinuator lesson1_fullEvalContinuator.cpp) 
 ADD_EXECUTABLE(lesson1_evalContinuator lesson1_evalContinuator.cpp) 
 ADD_EXECUTABLE(lesson1_combinedContinuator lesson1_combinedContinuator.cpp) 
+ADD_EXECUTABLE(firstImprHC_maxSAT firstImprHC_maxSAT.cpp) 
 
 TARGET_LINK_LIBRARIES(lesson1_simpleHC eoutils ga eo) 
 TARGET_LINK_LIBRARIES(lesson1_firstImprHC eoutils ga eo) 
@@ -24,3 +25,4 @@ TARGET_LINK_LIBRARIES(lesson1_fitContinuator eoutils ga eo)
 TARGET_LINK_LIBRARIES(lesson1_fullEvalContinuator eoutils ga eo) 
 TARGET_LINK_LIBRARIES(lesson1_evalContinuator eoutils ga eo) 
 TARGET_LINK_LIBRARIES(lesson1_combinedContinuator eoutils ga eo) 
+TARGET_LINK_LIBRARIES(firstImprHC_maxSAT eoutils ga eo) 

trunk/paradiseo-mo/tutorial/Lesson1/firstImprHC_maxSAT.cpp

@@ -0,0 +1,222 @@
+//-----------------------------------------------------------------------------
+/** firstImprHC_maxSAT.cpp
+ *
+ * SV - 05/05/10 
+ *
+ */
+//-----------------------------------------------------------------------------
+
+// standard includes
+#define HAVE_SSTREAM
+
+#include <stdexcept>  // runtime_error 
+#include <iostream>   // cout
+#include <sstream>    // ostrstream, istrstream
+#include <fstream>
+#include <string.h>
+
+// the general include for eo
+#include <eo>
+
+// declaration of the namespace
+using namespace std;
+
+//-----------------------------------------------------------------------------
+// representation of solutions, and neighbors
+#include <ga/eoBit.h>                         // bit string : see also EO tutorial lesson 1: FirstBitGA.cpp
+#include <problems/bitString/moBitNeighbor.h> // neighbor of bit string
+
+//-----------------------------------------------------------------------------
+// fitness function, and evaluation of neighbors
+#include <eval/maxSATeval.h>
+#include <problems/eval/moMaxSATincrEval.h>
+#include <eval/moFullEvalByModif.h>
+
+//-----------------------------------------------------------------------------
+// neighborhood description
+#include <neighborhood/moRndWithoutReplNeighborhood.h> // visit all neighbors in random order without repeating any neighbor
+
+//-----------------------------------------------------------------------------
+// the first improvement Hill-Climbing local search
+#include <algo/moFirstImprHC.h>
+
+// Declaration of types
+//-----------------------------------------------------------------------------
+// Indi is the typedef of the solution type like in paradisEO-eo
+typedef eoBit<unsigned int> Indi;                      // bit string with unsigned fitness type
+// Neighbor is the typedef of the neighbor type,
+// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)  
+// all classes from paradisEO-mo use this template type
+typedef moBitNeighbor<unsigned int> Neighbor ;         // bit string neighbor with unsigned fitness type
+
+
+// Main function
+//-----------------------------------------------------------------------------
+void main_function(int argc, char **argv)
+{
+  /* =========================================================
+   *
+   * Parameters from parser
+   *
+   * ========================================================= */
+  // more information on the input parameters: see EO tutorial lesson 3
+  // but don't care at first it just read the parameters of the bit string size and the random seed.
+
+  // First define a parser from the command-line arguments
+  eoParser parser(argc, argv);
+
+  // For each parameter, define Parameter, read it through the parser,
+  // and assign the value to the variable
+
+  // random seed parameter
+  eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
+  parser.processParam( seedParam );
+  unsigned seed = seedParam.value();
+
+  // length of the bit string
+  eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
+  parser.processParam( vecSizeParam, "Representation" );
+  unsigned vecSize = vecSizeParam.value();
+
+  // Number of clauses of the max SAT problem
+  eoValueParam<unsigned int> ncParam(10, "nbClauses", "Number of clauses", 'm');
+  parser.processParam( ncParam, "Representation" );
+  unsigned nbClause = ncParam.value();
+
+  // Number of litteral by clauses
+  eoValueParam<unsigned int> kParam(3, "nbLitt", "Number of litteral by clauses", 'k');
+  parser.processParam( kParam, "Representation" );
+  unsigned nbLitteral = kParam.value();
+
+  // the name of the instance file
+  string str_in = "" ; // default value
+  eoValueParam<string> inParam(str_in.c_str(), "in", "Input file of the file in ncf format", 'f');
+  parser.processParam(inParam, "Persistence" );
+  str_in = inParam.value();
+
+  // the name of the "status" file where all actual parameter values will be saved
+  string str_status = parser.ProgramName() + ".status"; // default value
+  eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
+  parser.processParam( statusParam, "Persistence" );
+  
+  // 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 (statusParam.value() != "") {
+    ofstream os(statusParam.value().c_str());
+    os << parser;// and you can use that file as parameter file
+  }
+
+  /* =========================================================
+   *
+   * Random seed
+   *
+   * ========================================================= */
+
+  // reproducible random seed: if you don't change SEED above,
+  // you'll aways get the same result, NOT a random run
+  // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
+  rng.reseed(seed);
+
+  /* =========================================================
+   *
+   * Eval fitness function (full evaluation)
+   *
+   * ========================================================= */
+
+  // the max SAT evaluation
+  MaxSATeval<Indi> * fullEval;
+
+  if (str_in.compare("") == 0)
+    fullEval = new MaxSATeval<Indi>(vecSize, nbClause, nbLitteral);
+  else {
+    fullEval = new MaxSATeval<Indi>(str_in);
+    vecSize = fullEval->nbVar ;
+  }
+
+  //  string out = "cnf.dat";
+  //  fullEval->save(out);
+
+  /* =========================================================
+   *
+   * evaluation of a neighbor solution
+   *
+   * ========================================================= */
+
+  // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
+  //  moFullEvalByModif<Neighbor> neighborEval(*fullEval);
+
+  // Incremental evaluation of the neighbor:
+  moMaxSATincrEval<Neighbor> neighborEval(*fullEval);
+
+  /* =========================================================
+   *
+   * Initialization of the solution
+   *
+   * ========================================================= */
+
+  // a Indi random initializer: each bit is random
+  // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
+  eoUniformGenerator<bool> uGen;
+  eoInitFixedLength<Indi> random(vecSize, uGen);
+
+  /* =========================================================
+   *
+   * the neighborhood of a solution
+   *
+   * ========================================================= */
+
+  // Exploration of the neighborhood in random order of the neigbor's index:
+  // each neighbor is visited only once
+  moRndWithoutReplNeighborhood<Neighbor> neighborhood(vecSize);
+
+  /* =========================================================
+   *
+   * the local search algorithm
+   *
+   * ========================================================= */
+
+  moFirstImprHC<Neighbor> hc(neighborhood, *fullEval, neighborEval);
+
+  /* =========================================================
+   *
+   * executes the local search from a random solution
+   *
+   * ========================================================= */
+
+  // The current solution
+  Indi solution;
+
+  // Apply random initialization
+  random(solution);
+
+  // Evaluation of the initial solution:
+  // can be evaluated here, or else it will be done at the beginning of the local search
+  (*fullEval)(solution);
+
+  // Output: the intial solution 
+  std::cout << "initial: " << solution << std::endl ;
+
+  // Apply the local search on the solution !
+  hc(solution);
+
+  // Output: the final solution 
+  std::cout << "final:   " << solution << std::endl ;
+
+}
+
+// A main that catches the exceptions
+
+int main(int argc, char **argv)
+{
+  try {
+    main_function(argc, argv);
+  }
+  catch (exception& e) {
+    cout << "Exception: " << e.what() << '\n';
+  }
+  return 1;
+}

trunk/problems/eval/maxSATeval.h

@@ -0,0 +1,275 @@
+/*
+<maxSATeval.h>
+Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2010
+
+Sebastien Verel, Arnaud Liefooghe, Jeremie Humeau
+
+This software is governed by the CeCILL license under French law and
+abiding by the rules of distribution of free software.  You can  ue,
+modify and/ or redistribute the software under the terms of the CeCILL
+license as circulated by CEA, CNRS and INRIA at the following URL
+"http://www.cecill.info".
+
+In this respect, the user's attention is drawn to the risks associated
+with loading,  using,  modifying and/or developing or reproducing the
+software by the user in light of its specific status of free software,
+that may mean  that it is complicated to manipulate,  and  that  also
+therefore means  that it is reserved for developers  and  experienced
+professionals having in-depth computer knowledge. Users are therefore
+encouraged to load and test the software's suitability as regards their
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and,  more generally, to use and operate it in the
+same conditions as regards security.
+The fact that you are presently reading this means that you have had
+knowledge of the CeCILL license and that you accept its terms.
+
+ParadisEO WebSite : http://paradiseo.gforge.inria.fr
+Contact: paradiseo-help@lists.gforge.inria.fr
+*/
+
+#ifndef _maxSATeval_h
+#define _maxSATeval_h
+
+#include <vector>
+#include <eoEvalFunc.h>
+
+/**
+ * Full evaluation Function for max-SAT problem
+ */
+template< class EOT >
+class MaxSATeval : public eoEvalFunc<EOT>
+{
+public:
+
+  /**
+   * Constructor
+   * generate a random instance of max k-SAT problem
+   *
+   * @param _n number of variables
+   * @param _m number of clauses
+   * @param _k of litteral by clause
+   */
+  MaxSATeval(unsigned _n, unsigned _m, unsigned _k) {
+    nbVar      = _n;
+    nbClauses  = _m;
+    nbLitteral = _k;
+
+    // creation of the clauses
+    clauses = new vector<int>[nbClauses];
+
+    // the variables are numbered from 1 to nbVar
+    variables = new vector<int>[nbVar + 1];
+
+    int var[nbVar];
+    unsigned i, j, ind;
+
+    // to selected nbLitteral different variables in the clauses
+    for(i = 0; i < nbVar; i++)
+      var[i] = i + 1;
+    
+    int number, tmp;
+
+    // generation of the clauses
+    for(i = 0; i < nbClauses; i++) {
+      for(j = 0 ; j < nbLitteral; j++) {
+	// selection of the variable
+	ind = rng.random(nbVar - j);
+	number = var[ind];
+
+	// permutation for forbidd identical variables
+	tmp = var[ind];
+	var[ind] = var[nbVar - j - 1];
+	var[nbVar - j - 1] = tmp;
+
+	// litteral = (variable) or (not variable) ?
+	// negative value means not variable
+	if (rng.flip())
+	  number = -number;
+	
+	// variable number belong to clause i
+	if (number < 0)
+	  variables[-number].push_back(-i);
+	else
+	  variables[number].push_back(i);
+
+	// clause i has got the litteral number 
+	clauses[i].push_back(number);
+      }
+    }
+
+  }
+
+  /**
+   * Constructor
+   * instance is given in the cnf format (see dimacs)
+   *
+   * @param _fileName file name of the instance in cnf format
+   */
+  MaxSATeval(string & _fileName) {
+    fstream file(_fileName.c_str(), ios::in);
+
+    if (!file) {
+      string str = "MaxSATeval: Could not open file [" + _fileName + "]." ;
+      throw runtime_error(str);
+    }
+    
+    string s;
+
+    // commentaries
+    string line;
+    file >> s;
+    while (s[0] == 'c') {
+      getline(file,line,'\n');
+      file >> s;
+    }
+
+    // parameters
+    if (s[0] != 'p') {
+      string str = "MaxSATeval: could not read the parameters of the instance from file [" + _fileName + "]." ;
+      throw runtime_error(str);
+    }
+    file >> s;
+    if (s != "cnf") {
+      string str = "MaxSATeval: " + _fileName + " is not a file in cnf format.";
+      throw runtime_error(str);
+    }
+
+    file >> nbVar >> nbClauses;
+    nbLitteral = 0; // could be different from one clause to antoher, so no value
+
+    // creation of the clauses
+    clauses = new vector<int>[nbClauses];
+
+    // the variables are numbered from 1 to nbVar
+    variables = new vector<int>[nbVar + 1];
+
+    // read the clauses
+    int number;
+    for(unsigned i = 0; i < nbClauses; i++) {
+      do {
+	file >> number;
+	if (number != 0) {
+	  clauses[i].push_back(number);
+	  if (number < 0)
+	    number = -number;
+
+	  if (number < 0)
+	    variables[-number].push_back(-i);
+	  else
+	    variables[number].push_back(i);
+	}
+      } while (number != 0);    
+    }
+    
+    file.close();
+  }
+
+  /**
+   * Destructor
+   */
+  ~MaxSATeval() {
+    // delete the clauses
+    delete[] clauses;
+
+    // delete the variables
+    delete[] variables;
+  }
+
+  /**
+   * export the instance to a file in cnf format
+   *
+   * @param _fileName file name to export the instance
+   */
+  void save(string & _fileName) {
+    fstream file(_fileName.c_str(), ios::out);
+
+    if (!file) {
+      string str = "MaxSATeval: Could not open " + _fileName;
+      throw runtime_error(str);
+    }
+    
+    // write some commentaries
+    file << "c random max k-SAT generated by maxSATeval from paradisEO framework on sourceForge" << endl;
+    file << "c  "<< endl;
+
+    // write the parameters
+    file << "p cnf " << nbVar << " " << nbClauses << endl;
+
+    // write the clauses
+    unsigned int i, j;
+
+    for(i = 0; i < nbClauses; i++) {
+      j = 0;
+      while (j < clauses[i].size()) {
+	file << clauses[i][j] << " ";
+	j++;
+      }    
+      file << "0" << std::endl;
+    }
+
+    file.close();
+  }
+
+  /**
+   * evaluation the clause
+   *
+   * @param _n number of the given clause
+   * @param _solution the solution to evaluation
+   * @return true when the clause is true
+   */
+  bool clauseEval(unsigned int _n, EOT & _solution) {
+    unsigned nLitteral = clauses[_n].size();
+    int litteral;
+
+    bool clause = false;
+
+    unsigned int j = 0;
+    while (j < nLitteral && !clause) {
+      litteral = clauses[_n][j];
+      clause = ((litteral > 0) && _solution[litteral - 1]) || ((litteral < 0) && !(_solution[-litteral - 1]));
+      
+      j++;
+    }
+
+    return clause;
+  }
+
+  /**
+   * fitness evaluation of the solution
+   *
+   * @param _solution the solution to evaluation
+   */
+  virtual void operator()(EOT & _solution) {
+    unsigned int fit = 0;
+
+    for(unsigned i = 0; i < nbClauses; i++)
+      if (clauseEval(i, _solution))
+	fit++;
+
+    _solution.fitness(fit);
+  }
+
+  /**
+   * Public variables (used in incremental evaluation)
+   */
+
+  // number of variables
+  unsigned int nbVar; 
+  // number of clauses
+  unsigned int nbClauses;
+  // number of litteral by clause (0 when the instance is read from file)
+  unsigned int nbLitteral;
+
+  // list of clauses: 
+  //   each clause has the number of the variable (from 1 to nbVar) 
+  //   when the value is negative, litteral = not(variable)
+  vector<int> * clauses;
+
+  // list of variables:
+  //   for each variable, the list of clauses
+  //   when the value is negative, litteral = not(variable) in this clause
+  vector<int> * variables;
+
+};
+
+#endif