gecoder-with-gecode 0.7.1 → 0.8.0

data/ext/gecode-2.1.1/contribs/qecode/implicative.hh

@@ -0,0 +1,184 @@
+/*****************************************************************[implicative.hh]
+Copyright (c) 2007, Universite d'Orleans - Jeremie Vautard, Marco Benedetti,
+Arnaud Lallouet.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*****************************************************************************/
+#ifndef __QECODE_IMPLICATIVE__
+#define __QECODE_IMPLICATIVE__
+#include "qecode.hh"
+#include <iostream>
+#include <cstdlib>
+#include "gecode/minimodel.hh"
+#include "warner.hh"
+#include "qecore.hh"
+#include "myspace.hh"
+
+using namespace Gecode;
+using namespace std;
+using namespace Gecode::Int;
+
+
+class QECODE_VTABLE_EXPORT Implicative : public QSpace {
+    friend class valueHeuristic;
+
+protected : 
+  bool* q;                ///< Quantification of the variables (true for universal, false for existential)
+  int nbSpaces;           ///< Number of rule spaces
+  int currentDeclareSpace;///< The rule space in which we are currently declaring constraints (for declaration part only)
+  int* nbVarBySpace;      ///< Number of variables by rule space.
+  int* whichSpaceOwns;    ///< Indicates in which space a given variable first appears.
+  MySpace** rules;        ///< The rule spaces
+  MySpace* goal;          ///< The goal space
+  bool* varInitialised;   ///< Indicates wether a variable has been initialised or not (for declaration part only)
+  bool* ruleDefined;      ///< Indicates wether a rule space is defind or not. If not, it has a failed or solved value.
+  int* ruleStatus;        ///< Indicates wether a rule space is failed (0), solved (1), or not yet decided (-1).
+  bool goalDefined;       ///< Indicates wether the goal space is defined or not.
+  int goalStatus;         ///< Indicates wether the goal is failed, solved, or not yet decided.
+  Warner* w;
+  int prop_power;         ///< Propagation power applied.
+  /// Cascade propagation 
+  int cascade(int firstSpace, unsigned long int& propsteps);
+
+public : 
+
+  /** \brief  Default constructor for a restricted-quantified space.
+   *  This is the first step for building a restricted-quantified space. The prefix is defined here.
+   *  @param ns The number of scope i.e. the number of quantifier alternations in the prefix.
+   *  @param firstQ Must be set to true if the first quantifier is universal, false otherwise.
+   *  @param nv Array of integer which contains the number of variables by scope.
+   */
+  QECODE_EXPORT Implicative(int ns,bool firstQ,int* nv); 
+
+  /** Copy constructor for a restricted-quantified space.
+   *  @param im The space we want to copy.
+   */
+  QECODE_EXPORT Implicative(Implicative& im);
+
+  /** Destructor for a restricted-quantified space.
+   *  This doesn't destruct the shared datastructures between a quantified space and its copy. 
+   */
+  QECODE_EXPORT virtual ~Implicative();
+
+  /** \brief Number of "rules" the quantified space contains.
+   *  Returns the number of rules the quantified space contains. This is equal to the number of quantifier alternations in the prefix. 
+   */
+  QECODE_EXPORT int spaces();
+
+  /** \brief Defines an integer variable in a quantified space.
+   *  Defines an integer variable in the quantified space with an interval domain. 
+   *  @param var number of the variable to be defined.
+   *  @param min The min element of the domain
+   *  @param max the max element of the domain
+   */
+  QECODE_EXPORT void QIntVar(int var,int min,int max);
+
+  /** \brief Defines an integer variable in the quantified space.
+   *  Defines an integer variable in the quantifies space using a fully declared domain.
+   *  @param var Number of the variable to be  defined.
+   *  @param dom The initial domain of the variable.
+   */
+  QECODE_EXPORT void QIntVar(int var,IntSet dom);
+
+  /** \brief Defines a boolean variable in the quantified space.
+   * Defines a boolean variable in the quantified space, uning a min and a max domain value (with false < true).
+   *  @param var Number of the variable to be defined.
+   *  @param min The min element of the domain (0 or 1, respectively for false or true)
+   *  @param min The max element of the domain (0 or 1, respectively for false or true)
+   */
+  QECODE_EXPORT void QBoolVar(int var,int min, int max);
+
+  /** \brief Defines a boolean variable in the quantified space.
+   *  Defines a boolean variable with a full initial domain in the quantified space.
+   *  @param var Number of the variable to be defined.
+   */
+  QECODE_EXPORT void QBoolVar(int var) {QBoolVar(var,0,1);}
+
+
+//  /** \brief Returns one of the restrictor space.
+//   * Returns one of the restrictor space. Deprecated : use space() and nextScope instead for constraint posting.
+//   *  @param sp the number of the restrictor to get (first restrictor is 0).
+//   */
+//  MySpace* getRuleSpace(int sp);
+//
+//
+//  /** \brief Returns the goal space.
+//   *  Returns the goal space. Deprecated : use space() and nextScope instead for constraint posting.
+//   */
+//  MySpace* getGoalSpace();
+
+  
+  /** \brief Returns the current declarating space. 
+   *  Return the space we are currently declarating constraints in. nextScope() is used to set the nextspace as the current one.
+   */
+  QECODE_EXPORT MySpace* space();
+
+
+  /** \brief Returns an integer variable from the space we are currently declaring.
+   *  Returns an integer variable from the cpace we are currently declaring. Will abort if the variable is not integer.
+   *  @param n The number of the variable to return.
+   */
+  QECODE_EXPORT IntVar var(int n); 
+
+
+  /** \brief Returns a boolean variable from the space we are currently declaring.
+   * Returns a boolean variable from the space we are currently declaring. Will abort if the variable is not boolean.
+   *  @param n The number of the variable to return.
+   */
+  QECODE_EXPORT BoolVar bvar(int n); 
+
+
+
+  /** \brief Switch to the next space for constraint declaration.
+   *   Switches to the next space for constraint declaration. var, bvar and space methods will now refer to the next rule space (or to the goal space if the current space was the last rule one).
+   *  Returns the new space number, or -1 if it was called while there was no next space to declare constraints in.
+   */
+  QECODE_EXPORT int nextScope();
+
+
+  /** \brief Finalizes the restricted-quantified space construction. 
+   * Finalizes the restricted-quantified space construction. Must be invoked once all the variable and all the constraints have been declared, and before the search is performed on this space.
+   */
+  QECODE_EXPORT void makeStructure();
+
+  /** \brief Prints the current state of an implicative object.
+   * Prints the variable domains of all the spaces (if defined). Does not perform an ounce of propagation
+  */
+  QECODE_EXPORT virtual void print();
+      
+      
+  QECODE_EXPORT virtual bool quantification(int v);
+  QECODE_EXPORT virtual int status(int var,unsigned long int& propsteps);
+  QECODE_EXPORT virtual int finalStatus(unsigned long int& propsteps);
+  QECODE_EXPORT virtual bool subsumed(int var);
+  QECODE_EXPORT virtual Implicative* clone(); 
+  QECODE_EXPORT virtual void assign_int(int var,int** vals,int nbVals);
+  QECODE_EXPORT virtual void remove_int(int var,int** vals,int nbVals);
+  QECODE_EXPORT virtual void assign_bool(int var,int** vals,int nbVals);
+  QECODE_EXPORT virtual void remove_bool(int var,int** vals,int nbVals);
+  QECODE_EXPORT virtual void assign_bool(int var,int b);
+  QECODE_EXPORT virtual void remove_bool(int var,int b);
+//  virtual void infEqual(int var,int val);
+//  virtual void sup(int var,int val);
+  QECODE_EXPORT virtual void backtrack();
+  QECODE_EXPORT virtual void indicateBranchingHeuristic(BranchingHeuristic* bh);
+};
+
+
+#endif

data/ext/gecode-2.1.1/contribs/qecode/myDom.cc

@@ -0,0 +1,39 @@
+
+#ifndef QECODE_MYDOM
+#define QECODE_MYDOM
+#include "gecode/minimodel.hh"
+using namespace Gecode;
+using namespace Gecode::Int;
+using namespace std;
+
+void myAntidom_int(Space* home, IntVar x, const IntSet& is, IntConLevel) {
+    if (home->failed()) return;
+    IntView xv(x);
+    IntSetRanges ris(is);
+    GECODE_ME_FAIL(home,xv.minus_r(home,ris));
+}
+
+void myAntidom_bool(Space* home, BoolVar x, const IntSet& is, IntConLevel) {
+    if (home->failed()) return;
+    BoolView xv(x);
+    IntSetRanges ris(is);
+    GECODE_ME_FAIL(home,xv.minus_r(home,ris));
+}
+
+/*
+void myDom_int(Space* home, IntVar x, const IntSet& is, IntConLevel) {
+    if (home->failed()) return;
+    IntView xv(x);
+    IntSetRanges ris(is);
+    GECODE_ME_FAIL(home,xv.inter_r(home,ris));
+}
+
+void myDom_bool(Space* home, BoolVar x, const IntSet& is, IntConLevel) {
+    if (home->failed()) return;
+    BoolView xv(x);
+    IntSetRanges ris(is);
+    GECODE_ME_FAIL(home,xv.inter_r(home,ris));
+}
+*/
+
+#endif

data/ext/gecode-2.1.1/contribs/qecode/myspace.cc

@@ -0,0 +1,69 @@
+/*****************************************************************[myspace.cc]
+Copyright (c) 2007, Universite d'Orleans - Jeremie Vautard, Marco Benedetti,
+Arnaud Lallouet.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*****************************************************************************/
+#include "./myspace.hh"
+#include <iostream>
+
+
+using namespace std;
+
+MySpace::MySpace(unsigned int nv) {
+    n=nv;
+    v=new void*[n];
+    type_of_v=new VarType[n];
+}
+
+
+MySpace::~MySpace() {
+    for (int i=0;i<n;i++)
+        delete v[i];
+    
+    delete[] v;
+    delete[] type_of_v;
+}
+
+MySpace::MySpace(bool share,MySpace& ms) : Space(share,ms) {
+  n=ms.n;
+    v=new void*[n];
+    type_of_v=new VarType[n];
+    for (int i=0;i<n;i++) {
+        type_of_v[i] = ms.type_of_v[i];
+        switch (type_of_v[i]) {
+            case VTYPE_INT :
+                v[i] = new IntVar(*(static_cast<IntVar*>(ms.v[i])));
+                (static_cast<IntVar*>(v[i]))->update(this,true,*(static_cast<IntVar*>(ms.v[i])));
+                break;
+            case VTYPE_BOOL :
+                v[i] = new BoolVar(*(static_cast<BoolVar*>(ms.v[i])));
+                (static_cast<BoolVar*>(v[i]))->update(this,true,*(static_cast<BoolVar*>(ms.v[i])));
+                break;
+            default:
+                cout<<"Unsupported variable type"<<endl;
+                abort();
+        }
+    }
+}
+
+
+MySpace* MySpace::copy(bool share) {return new MySpace(share,*this);}
+
+

data/ext/gecode-2.1.1/contribs/qecode/myspace.hh

@@ -0,0 +1,69 @@
+/*****************************************************************[myspace.hh]
+Copyright (c) 2007, Universite d'Orleans - Jeremie Vautard, Marco Benedetti,
+Arnaud Lallouet.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*****************************************************************************/
+#ifndef __QECODE_MYSPACE__
+#define __QECODE_MYSPACE__
+
+#include "qecode.hh"
+#include <vector>
+#include "gecode/minimodel.hh"
+#include "vartype.hh"
+
+using namespace Gecode;
+using namespace Gecode::Int;
+
+/** \brief A simple extension of Gecode::Space class.
+*  A simple extension of the Space class from Gecode, in order to have access to the variables it contains.
+*/
+
+/** Types of variables.
+*/
+
+class QECODE_VTABLE_EXPORT MySpace : public Space {
+    
+protected :
+    unsigned int n;
+    
+public:
+    /** This array contains all the variables this space contains.
+    */
+    void** v;
+    
+    
+    /** This array indicates the type of each variable.
+    */
+    VarType* type_of_v;
+    
+    /** \brief Constructor of a space with a fixed number of variables.
+        * Builds a space which will contain  nv variables (the variables themselves are however not declared).
+        *  @param nv the number of variable the space must contain.
+        */
+    QECODE_EXPORT MySpace(unsigned int nv);
+    
+    QECODE_EXPORT MySpace(bool share,MySpace& ms);
+    QECODE_EXPORT virtual MySpace* copy(bool share);
+    QECODE_EXPORT virtual ~MySpace();
+};
+
+
+
+#endif

data/ext/gecode-2.1.1/contribs/qecode/qecode.hh

@@ -0,0 +1,56 @@
+/****   , [ qecode.hh ], 
+Copyright (c) 2007 Universite d'Orleans - Jeremie Vautard 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+ *************************************************************************/
+
+#ifndef __QECODE_HH__
+#define __QECODE_HH__
+
+#include "gecode/kernel.hh"
+
+#if !defined(GECODE_STATIC_LIBS) && \
+(defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER))
+
+#define QECODE_VTABLE_EXPORT
+
+#ifdef GECODE_BUILD_QECODE
+#define QECODE_EXPORT __declspec( dllexport )
+#else
+#define QECODE_EXPORT __declspec( dllimport )
+#endif
+
+#else
+
+#ifdef GECODE_GCC_HAS_CLASS_VISIBILITY
+
+#define QECODE_VTABLE_EXPORT __attribute__ ((visibility("default")))
+#define QECODE_EXPORT __attribute__ ((visibility("default")))
+
+#else
+#define QECODE_VTABLE_EXPORT
+#define QECODE_EXPORT
+
+#endif
+#endif
+
+#define QECODE_EXISTENTIAL false
+#define QECODE_UNIVERSAL true
+
+#endif

data/ext/gecode-2.1.1/contribs/qecode/qecore.cc

@@ -0,0 +1,145 @@
+/*****************************************************************[qecore.cc]
+Copyright (c) 2007, Universite d'Orleans - Jeremie Vautard, Marco Benedetti,
+Arnaud Lallouet.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*****************************************************************************/
+#include "qecore.hh"
+
+#include <iostream>
+
+
+QSpace::QSpace() {}
+
+QSpace::QSpace(QSpace& qs) {
+  n=qs.n;
+  ps=qs.ps;
+  v = new void*[n];
+  type_of_v = qs.type_of_v;
+}
+
+
+#define MARKER size
+
+BranchingHeuristic::BranchingHeuristic(QSpace* qs,VariableHeuristic* ev) {
+  
+  eval=ev;
+  size=qs->nv();
+  score=new int[size];
+  touched.push(MARKER);
+  bloc=new int[size];
+  
+  blocks=1; bool q=qs->quantification(0);
+  for (int i=0;i<size;i++) {
+    if ((qs->quantification(i)) != q) {
+      q=qs->quantification(i);
+      blocks++;
+    }
+    bloc[i]=(blocks-1);
+  }
+
+  treated.push(MARKER);
+
+  for (int i=0;i<size;i++) {
+    score[i]=eval->score(qs,i);
+  }
+
+  ExtensiveComparator* c = new ExtensiveComparator(size,score);
+
+  heaps=new cheap[blocks];
+  for (int i=0;i<blocks;i++) {
+    heaps[i]=cheap(c);
+    heaps[i].setBounds(size);
+  }
+
+  
+  int whichblock=0; bool qf=(qs->quantification(0));
+  for (int i=0;i<size;i++) {
+    if (qf != (qs->quantification(i)) ) {
+      whichblock++; 
+      qf=(qs->quantification(i));
+    }
+    heaps[whichblock].insert(i);
+  }
+  
+  curHeap=0;
+}
+
+int BranchingHeuristic::nextVar(QSpace* qs) {
+  int ret;
+  touched.push(MARKER);
+  while (! (heaps[blocks-1]).empty() ) {
+    if (heaps[curHeap].empty()) {
+      curHeap++;
+    }
+    if (curHeap >= blocks ) break;
+    ret=heaps[curHeap].getminwopop();
+    treated.push(ret);
+
+    if( !(qs->subsumed(ret)) ) {      // If the variable is a good one to branch on.../!\ A INSTANCIATED VARIABLE MUST BE SUBSUMED
+      treated.push(MARKER);
+      return ret;
+    }
+    else {    // If the variable is subsumed, we delete it fron the heap...
+        int rien=heaps[curHeap].getmin();
+    }
+  }
+  treated.push(MARKER);
+  return MARKER;
+}
+
+void BranchingHeuristic::updateVar(int pos, QSpace* qs) {
+
+  if (!(heaps[bloc[pos]].inHeap(pos)) ) return;         // If the variable is not in the heap (so, it is already assigned or ignored), do nothing
+  if ( eval->score(qs,pos) == score[pos] ) return;      // if no update is necessary, do nothing
+
+  if ( eval->score(qs,pos) < score[pos] ) {
+    score[pos]=eval->score(qs,pos);
+    heaps[bloc[pos]].increase(pos);
+  }
+  else {
+    score[pos]=eval->score(qs,pos);
+    heaps[bloc[pos]].decrease(pos);
+  }
+}
+
+void BranchingHeuristic::vartouched(int pos,QSpace* qs) {
+  touched.push(pos);
+  updateVar(pos,qs);
+}
+
+void BranchingHeuristic::backtrack(QSpace* qs) {
+  if (treated.top() != MARKER ) {
+    cout<<"Branching Heuristic : Probleme de pile... "<<endl;
+    abort();
+  }
+  else {
+    treated.pop();
+  }
+  while (treated.top() != MARKER ) {
+    heaps[bloc[treated.top()]].insert(treated.top() );
+    curHeap=bloc[treated.top()];
+    treated.pop();
+  }
+  
+  while (touched.top() != MARKER ) {
+    updateVar(touched.top(),qs);
+    touched.pop();
+  }
+}