gecoder-with-gecode 0.7.1 → 0.8.0

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

@@ -0,0 +1,46 @@
+/*****************************************************[extensivecomparator.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_EXTENSIVECOMPARATOR__
+#define __QECODE_EXTENSIVECOMPARATOR__
+#include "qecode.hh"
+/** \brief A simple integer comparator.
+* This class compares two integer between them, according to the score they are given. Scores are stored in an array and can be modified every time.
+ */
+class QECODE_VTABLE_EXPORT ExtensiveComparator {
+  int size;  
+  int* scores; 
+
+public : 
+  /** Constructor for an extensive Comparator. 
+   *  @param the_size This comparator will compare integers from 0 to this parameter.
+   *  @param the_scores The array of scores.
+   */
+  QECODE_EXPORT ExtensiveComparator(int the_size, int* the_scores);
+
+  /** \brief The method to compare two integers.
+  *  This compares the scores of a and b. Returns true if the first argument has a smaller score than b.
+   */
+  QECODE_EXPORT bool operator() (int a, int b);
+};
+
+#endif

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

@@ -0,0 +1,151 @@
+/******************************************************************************************[Heap.h] 
+MiniSat -- Copyright (c) 2003-2005, Niklas Een, Niklas Sorensson 
+ 
+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 <vector> 
+#include <iostream> 
+//================================================================================================= 
+ 
+ 
+static inline int left  (int i) { return i+i; } 
+static inline int right (int i) { return i+i + 1; } 
+static inline int parent(int i) { return i >> 1; } 
+ 
+using namespace std; 
+ 
+template<class C> 
+class Heap { 
+  typedef vector<int> vectint; 
+private : 
+  C* comp; 
+public :  
+  vectint heap;     // heap of ints 
+  vectint indices;  // int -> index in heap 
+  Heap() { 
+    heap.push_back(-1); 
+  } 
+ 
+  Heap(C* co) { 
+    comp=co; 
+    heap.push_back(-1); 
+  } 
+ 
+  void initcomp(C* co) { 
+    comp=co; 
+  } 
+   
+  inline void percolateUp(int i) 
+  { 
+    int x = heap[i]; 
+    while (parent(i) != 0 && (*comp)(x,heap[parent(i)])) { 
+      heap[i]          = heap[parent(i)]; 
+      indices[heap[i]] = i; 
+      i                = parent(i); 
+    } 
+    heap   [i] = x; 
+    indices[x] = i; 
+  } 
+   
+  inline void percolateDown(int i) 
+  { 
+    int x = heap[i]; 
+    while (left(i) < heap.size()){ 
+      int child = right(i) < heap.size() && (*comp)(heap[right(i)],heap[left(i)]) ? right(i) : left(i); 
+      if (!(*comp)(heap[child],x)) break; 
+      heap[i]          = heap[child]; 
+      indices[heap[i]] = i; 
+      i                = child; 
+    } 
+    heap   [i] = x; 
+    indices[x] = i; 
+  } 
+   
+  bool ok(int n) {  
+    return n >= 0 && n < indices.size(); 
+  } 
+   
+public: 
+   
+  int size() { 
+    return heap.size()-1; 
+  } 
+ 
+  void setBounds (int size) { /*assert(size >= 0);*/  
+    for (int i=indices.size();i<=size;i++) { 
+      indices.push_back(0); 
+    } 
+  } 
+   
+  bool inHeap (int n)    { 
+      /*assert(ok(n));*/ 
+    return indices[n] != 0;  
+  } 
+   
+  void increase  (int n)    { 
+      /*assert(ok(n));*/ 
+      /*assert(inHeap(n));*/ 
+    percolateUp(indices[n]); 
+  } 
+ 
+  void decrease (int n) { 
+      /*assert(ok(n));*/ 
+      /*assert(inHeap(n));*/ 
+    percolateDown(indices[n]); 
+  } 
+   
+  bool empty () { 
+    return heap.size() == 1; 
+  } 
+   
+  void insert(int n) { 
+//    cout<<"Insertion de "<<n<<endl; 
+      /*assert(ok(n));*/ 
+      if (inHeap(n)) return;
+    indices[n] = heap.size(); 
+    heap.push_back(n); 
+    percolateUp(indices[n]); } 
+   
+  int getminwopop() {
+      return heap[1];
+  }
+  
+  int  getmin() { 
+    int r            = heap[1]; 
+    heap[1]          = heap.back(); 
+    indices[heap[1]] = 1; 
+    indices[r]       = 0; 
+    heap.pop_back(); 
+    if (heap.size() > 1) 
+      percolateDown(1); 
+    return r; } 
+   
+  bool heapProperty() { 
+    return heapProperty(1); } 
+   
+  bool heapProperty(int i) { 
+    return (size_t)i >= heap.size() 
+      || ((parent(i) == 0 || !(*comp)(heap[i],heap[parent(i)])) && heapProperty(left(i)) && heapProperty(right(i))); } 
+  
+  void print() {
+      cout<<"heap: ";
+      for (int i=0;i<heap.size();i++) cout<<"-"<<heap[i];
+      cout<<"-"<<endl;
+      cout<<"indices: ";
+      for (int i=0;i<indices.size();i++) cout<<"-"<<indices[i];
+      cout<<"-"<<endl;
+  }
+}; 

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

@@ -0,0 +1,595 @@
+/*************************************************************[implicative.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 "implicative.hh"
+#include "myDom.cc"
+
+Implicative::Implicative(int ns,bool firstQ,int* nv) : QSpace() {
+    n=0;
+    for (int i=0;i<ns;i++) {
+        n += nv[i];
+    }
+    nbSpaces=ns;
+    v=new void*[n];
+    type_of_v = new VarType[n];
+    q=new bool[n];
+    whichSpaceOwns=new int[n];
+    nbVarBySpace=new int[nbSpaces];
+    rules=new MySpace*[ns];
+    ruleDefined=new bool[n];
+    nbVarBySpace[0]=nv[0];
+    rules[0]=new MySpace(nbVarBySpace[0]);
+    ruleDefined[0] = true;
+    for (int i=1;i<nbSpaces;i++) {
+        nbVarBySpace[i]=nbVarBySpace[i-1]+nv[i];
+        rules[i]=new MySpace(nbVarBySpace[i]);
+        ruleDefined[i]=true;
+    }
+    goal=new MySpace(n);
+    goalDefined=true;
+    for(unsigned int i=0;i<n;i++) {
+        int lespace=0;
+        while (nbVarBySpace[lespace]<=i) lespace++;
+        whichSpaceOwns[i]=lespace;
+        q[i] = ((lespace%2 == 0) ? firstQ : !firstQ);
+    }
+    
+    varInitialised=new bool[n];
+    for (unsigned int i=0;i<n;i++) varInitialised[i]=false;
+    currentDeclareSpace=0;
+    prop_power=2;
+}
+
+
+Implicative::Implicative(Implicative& qc) : QSpace(qc) {
+    
+    unsigned long int rien;
+    q=qc.q;
+    nbSpaces=qc.nbSpaces;             // | Shared among every descendants of Implicatives
+    nbVarBySpace=qc.nbVarBySpace;     // |
+    whichSpaceOwns=qc.whichSpaceOwns; // |
+    varInitialised=qc.varInitialised; // |
+    rules = new MySpace*[n];
+    ruleDefined=new bool[n];
+    w=qc.w;
+    w->update(this);
+    prop_power=qc.prop_power;
+    
+    for (int i=0;i<nbSpaces;i++) {
+        if (!qc.ruleDefined[i]) {
+            ruleDefined[i]=false;
+        }
+        else if (qc.rules[i]->status(rien) == SS_FAILED) {
+            ruleDefined[i]=false;
+        }
+        else {
+            rules[i]=static_cast<MySpace*>(qc.rules[i]->clone());
+            ruleDefined[i]=true;
+        }
+    }
+    if (!qc.goalDefined) {
+        goalDefined=false;
+    }
+    else if (qc.goal->status(rien) == SS_FAILED) {
+        goalDefined=false;
+    }
+    else {
+        goal=static_cast<MySpace*>(qc.goal->clone());
+        goalDefined=true;
+    }
+    
+    for (unsigned int i=0;i<n;i++) {
+        if (ruleDefined[whichSpaceOwns[i]]) {
+            v[i] = (rules[whichSpaceOwns[i]]->v[i]);
+        }
+    }
+    
+    
+}
+
+
+Implicative::~Implicative() {
+    for (int i=0;i<nbSpaces;i++) {
+        if (ruleDefined[i])
+            delete rules[i];
+    }    
+    
+    if (goalDefined) 
+        delete goal;
+    delete [] rules;
+    delete [] ruleDefined;
+}
+
+
+int Implicative::spaces() {
+    return nbSpaces;
+}
+
+
+void Implicative::QIntVar(int var,int min,int max) {
+    if (varInitialised[var]) {
+        cout<<"Variable "<<var<<"  Already created !!"<<endl;
+        abort();
+    }
+    
+    for (int i=whichSpaceOwns[var];i<nbSpaces;i++) {
+        rules[i]->v[var] = new IntVar(rules[i],min,max);
+        rules[i]->type_of_v[var] = VTYPE_INT;
+    }
+    goal->v[var] = new IntVar(goal,min,max);
+    goal->type_of_v[var] = VTYPE_INT;
+    varInitialised[var]=true;
+    type_of_v[var]=VTYPE_INT;
+}
+
+
+void Implicative::QBoolVar(int var,int min,int max) {
+    if (varInitialised[var]) {
+        cout<<"Variable "<<var<<" Already created !!"<<endl;
+        abort();
+    }
+    
+    for (int i=whichSpaceOwns[var];i<nbSpaces;i++) {
+        rules[i]->v[var] = new BoolVar(rules[i],min,max);
+        rules[i]->type_of_v[var]=VTYPE_BOOL;
+    }
+    goal->v[var] = new BoolVar(goal,min,max);
+    goal->type_of_v[var]=VTYPE_BOOL;
+    varInitialised[var]=true;
+    type_of_v[var]=VTYPE_BOOL;
+}
+
+
+void Implicative::QIntVar(int var,IntSet dom) {
+    if (varInitialised[var]) {
+        cout<<"Variable "<<var<<" Already created !!"<<endl;
+        abort();
+    }
+    
+    for (int i=whichSpaceOwns[var];i<nbSpaces;i++) {
+        rules[i]->v[var] = new IntVar(rules[i],dom);
+        rules[i]->type_of_v[var] = VTYPE_INT;
+    }
+    goal->v[var] = new IntVar(goal,dom);
+    goal->type_of_v[var] = VTYPE_INT;
+    varInitialised[var]=true;
+    type_of_v[var]=VTYPE_INT;
+}
+
+
+MySpace* Implicative::space() {
+    if (currentDeclareSpace<nbSpaces)
+        return rules[currentDeclareSpace];
+    if (currentDeclareSpace==nbSpaces)
+        return goal;
+    return NULL;
+}
+
+
+IntVar Implicative::var(int n) {
+    return *(static_cast<IntVar*>(space()->v[n]));
+}
+
+
+BoolVar Implicative::bvar(int n) {
+    return *(static_cast<BoolVar*>(space()->v[n]));
+}
+
+
+int Implicative::nextScope() {
+    if (currentDeclareSpace == -1) return -1;
+    currentDeclareSpace++;
+    if (currentDeclareSpace>nbSpaces) return -1;
+    return currentDeclareSpace;
+}
+
+/*
+MySpace* Implicative::getRuleSpace(int sp) {
+    bool var=true;
+    for(int i=0;i<n;i++) {
+        var = var && varInitialised[i];
+    }
+    if (!var) return NULL;
+    if ( sp >= nbSpaces ) return NULL;
+    return rules[sp];
+}
+
+
+MySpace* Implicative::getGoalSpace() {
+    bool var=true;
+    for(int i=0;i<n;i++) {
+        var = var && varInitialised[i];
+    }
+    if (!var) return NULL;
+    return goal;
+}
+*/
+
+void Implicative::makeStructure() {
+//    bool varInit=true;
+    for (unsigned int i=0;i<n;i++) {
+        if (varInitialised[i] == false) {
+            cout<<"Can't make structure : variable "<<i<<" not initialised"<<endl;
+            abort();
+        }
+    }
+    
+    for (unsigned int i=0;i<n;i++) {
+        v[i] = rules[whichSpaceOwns[i]]->v[i];
+    }
+    w=new Warner(this);
+    for(unsigned int i=0;i<n;i++) {
+        switch (type_of_v[i]) {
+            case VTYPE_INT:
+                IntWarningProp::IntWarning(rules[whichSpaceOwns[i]],i,*(static_cast<IntVar*>(rules[whichSpaceOwns[i]]->v[i])),w);
+                break;
+            case VTYPE_BOOL:
+                BoolWarningProp::BoolWarning(rules[whichSpaceOwns[i]],i,*(static_cast<BoolVar*>(rules[whichSpaceOwns[i]]->v[i])),w);
+                break;
+            default:
+                abort();
+        }
+    } 
+}
+
+
+bool Implicative::quantification(int v) {
+    return q[v];
+}
+
+// Returns the number of the first failed space (number of rule space, nbSpaces if goal, nbSpaces+1 if there is no failed space)
+int Implicative::cascade(int firstSpace, unsigned long int& propsteps) {
+    int curSpace = firstSpace;
+    
+    while(curSpace < nbSpaces) {
+        MySpace* nextSpace = (curSpace==nbSpaces-1)?goal:rules[curSpace+1];
+        bool* nextDefined  = (curSpace==nbSpaces-1)?&goalDefined:&(ruleDefined[curSpace+1]);
+        
+        if (!ruleDefined[curSpace]) {
+            return curSpace;
+        }
+        if (rules[curSpace]->status(propsteps) == SS_FAILED) {
+            return curSpace;
+        }
+        if (*nextDefined) {
+            if (nextSpace->status(propsteps) != SS_FAILED) {
+                for (int i=0;i<nbVarBySpace[curSpace];i++) {
+                    switch (type_of_v[i]) {
+                        case VTYPE_INT :
+                        {
+                            IntView dest(*(static_cast<IntVar*>(nextSpace->v[i])));
+                            IntView src(*(static_cast<IntVar*>(rules[curSpace]->v[i])));
+                            ViewRanges<IntView> rg(src);
+                            if (dest.inter_r(nextSpace,rg) == ME_GEN_FAILED) {
+                                nextSpace->fail();
+                            };
+                        }
+                            break;
+                        case VTYPE_BOOL :
+                        {
+                            BoolView bdest(*(static_cast<BoolVar*>(nextSpace->v[i])));
+                            BoolView bsrc(*(static_cast<BoolVar*>(rules[curSpace]->v[i])));
+                            ViewRanges<BoolView> brg(bsrc);
+                            if (bdest.inter_r(nextSpace,brg) == ME_GEN_FAILED) {
+                                nextSpace->fail();
+                            };
+                        }
+                            break;
+                    }
+                }
+            }
+        }
+        curSpace++;
+    }
+    
+    if (!goalDefined) {
+        return nbSpaces;
+    }
+    if (goal->status(propsteps) == SS_FAILED) {
+        return nbSpaces;
+    }
+    
+    return nbSpaces+1;
+}
+
+
+int Implicative::status(int var, unsigned long int& propsteps) {
+    int currentSpace=whichSpaceOwns[var];
+    currentSpace--;
+    if (currentSpace<0) currentSpace=0;
+    
+    // First case : Strong propagation : ///////////////////////////////////////////
+    // First, call cascade propagation. ////////////////////////////////////////////
+    // We fail the spaces after the first failed one (so they are not //////////////
+    // copied anymore)//////////////////////////////////////////////////////////////
+    if (prop_power == 2) {                                                        //
+        int firstFailed=cascade(currentSpace,propsteps);                          //
+        for (int i=firstFailed;i<nbSpaces;i++) {                                  //
+            if (ruleDefined[i]) rules[i]->fail();                                 //
+        }                                                                         //
+        if (firstFailed <= nbSpaces) {                                            //
+            if (goalDefined)                                                      //
+                goal->fail();                                                     //
+        }                                                                         //
+                                                                                  //
+        if (firstFailed==currentSpace) {                                          //
+            return (quantification(var)?1:0);                                     //
+        }                                                                         //
+                                                                                  //
+        return -1;                                                                //
+    }                                                                             //
+    ////////////////////////////////////////////////////////////////////////////////
+    
+    else {
+        cout<<"Propagation "<<prop_power<<" is not supported in this version of Qecode."<<endl;
+        abort();
+    }
+}
+
+
+int Implicative::finalStatus(unsigned long int& propsteps) {
+    
+    // Step 1 : we check every rule space in the order. If one of them is failed, //
+    // we can answer. //////////////////////////////////////////////////////////////
+    for (int i=0;i<nbSpaces;i++) {                                                //
+        if (!ruleDefined[i])                                                      //
+            return q[ nbVarBySpace[i]-1 ] ? 1 : 0;                                //
+        if (rules[i]->status(propsteps) == SS_FAILED)                             //
+            return q[ nbVarBySpace[i]-1 ] ? 1 : 0;                                //
+    }                                                                             //
+    ////////////////////////////////////////////////////////////////////////////////
+    
+    // Step 2 : if we are here, then the rules were not violated. So, we check /////
+    // the goal. ///////////////////////////////////////////////////////////////////
+    if (!goalDefined)                                                             //
+        return 0;                                                                 //
+    if (goal->status(propsteps) == SS_FAILED)                                     //
+        return 0;                                                                 //
+    ////////////////////////////////////////////////////////////////////////////////
+    
+    // Step 3 : if we are here, then the rules were respected, and the goal ////////
+    // is also true. So, the whole problem is true. ////////////////////////////////
+    return 1;                                                                     //
+    ////////////////////////////////////////////////////////////////////////////////
+}
+
+bool Implicative::subsumed(int var) {
+    
+    int varSpace=whichSpaceOwns[var];
+    if (!ruleDefined[varSpace])
+        return true;
+    
+    switch (type_of_v[var]) {
+        case VTYPE_INT : 
+        {
+            IntVar* zeVar = static_cast<IntVar*>(rules[varSpace]->v[var]);
+            unsigned int varSize=zeVar->size();
+            
+            if (zeVar->size() < 2) {
+                return true;
+            }
+
+            if (zeVar->degree() > 1) {
+                return false;
+            }        
+                
+            for (int i=varSpace+1;i<nbSpaces;i++) {
+                if (!ruleDefined[i])
+                    return true;
+                if (static_cast<IntVar*>(rules[i]->v[var])->degree() > 0)
+                    return false;
+                if (static_cast<IntVar*>(rules[i]->v[var])->size() < varSize)
+                    return false;
+            }
+                
+            if (!goalDefined) {
+                return true;
+            }
+            if (static_cast<IntVar*>(goal->v[var])->degree() >0) {
+                return false;
+            }
+            if (static_cast<IntVar*>(goal->v[var])->size() < varSize) {
+                return false;
+            }
+            //else
+            return true;
+        }
+            break;
+        case VTYPE_BOOL :
+        {
+            BoolVar* zeBVar = static_cast<BoolVar*>(rules[varSpace]->v[var]);
+            unsigned int varBSize=zeBVar->size();
+            
+            if (zeBVar->size() < 2) {
+                return true;
+            }
+                
+            if (zeBVar->degree() > 1) {
+                return false;
+            }        
+            
+            for (int i=varSpace+1;i<nbSpaces;i++) {
+                if (!ruleDefined[i])
+                    return true;
+                if (static_cast<BoolVar*>(rules[i]->v[var])->degree() > 0)
+                    return false;
+                if (static_cast<BoolVar*>(rules[i]->v[var])->size() < varBSize)
+                    return false;
+            }
+                
+            if (!goalDefined) {
+                return true;
+            }
+            if (static_cast<BoolVar*>(goal->v[var])->degree() >0) {
+                return false;
+            }
+            if (static_cast<BoolVar*>(goal->v[var])->size() < varBSize) {
+                return false;
+            }
+            //else
+            return true;
+        }
+            break;
+        default :
+            return false;
+    }
+}
+
+
+Implicative* Implicative::clone() {
+    Implicative* resultat=new Implicative(*this);
+    return resultat;
+}
+
+
+void Implicative::assign_int(int var,int** vals,int nbVals) {
+    if (type_of_v[var] != VTYPE_INT) {
+        cout<<"Wrong variable type for assigning"<<endl;
+        abort();
+    }
+    int varspace = whichSpaceOwns[var];
+    for (int i=varspace;i<nbSpaces;i++) {
+        if (ruleDefined[i]) {
+            MySpace* s = rules[i];
+            post(s,*(static_cast<IntVar*>(s->v[var])) >= vals[0][0]);
+            for (int j=1;j<nbVals;j++) {
+                IntSet rg(vals[1][j-1]+1,vals[0][j]-1);
+                myAntidom_int(s,*(static_cast<IntVar*>(s->v[var])),rg,ICL_DOM);
+            }
+            post(s,*(static_cast<IntVar*>(s->v[var])) <= vals[1][nbVals-1]);
+        }
+    }
+}
+
+
+void Implicative::remove_int(int var,int** vals,int nbVals) {
+    if (type_of_v[var] != VTYPE_INT) {
+        cout<<"Wrong variable type for assigning"<<endl;
+        abort();
+    }
+    int varspace = whichSpaceOwns[var];
+    for (int i=varspace;i<nbSpaces;i++) {
+        if (ruleDefined[i]) {
+            MySpace* s = rules[i];
+            for (int j=0;j<nbVals;j++) {
+                IntSet rg(vals[0][j],vals[1][j]);
+                myAntidom_int(s,*(static_cast<IntVar*>(s->v[var])),rg,ICL_DOM);
+            }
+        }
+    }
+}
+
+void Implicative::assign_bool(int var,int** vals,int nbVals) {
+    if (type_of_v[var] != VTYPE_BOOL) {
+        cout<<"Wrong variable type for assigning"<<endl;
+        abort();
+    }
+    int varspace = whichSpaceOwns[var];
+    for (int i=varspace;i<nbSpaces;i++) {
+        if (ruleDefined[i]) {
+            MySpace* s = rules[i];
+            post(s,*(static_cast<BoolVar*>(s->v[var])) >= vals[0][0]);
+            for (int j=1;j<nbVals;j++) {
+                IntSet rg(vals[1][j-1]+1,vals[0][j]-1);
+                myAntidom_bool(s,*(static_cast<BoolVar*>(s->v[var])),rg,ICL_DOM);
+            }
+            post(s,*(static_cast<BoolVar*>(s->v[var])) <= vals[1][nbVals-1]);
+        }
+    }
+}
+
+
+void Implicative::remove_bool(int var,int** vals,int nbVals) {
+    if (type_of_v[var] != VTYPE_BOOL) {
+        cout<<"Wrong variable type for assigning"<<endl;
+        abort();
+    }
+    int varspace = whichSpaceOwns[var];
+    for (int i=varspace;i<nbSpaces;i++) {
+        if (ruleDefined[i]) {
+            MySpace* s = rules[i];
+            for (int j=0;j<nbVals;j++) {
+                IntSet rg(vals[0][j],vals[1][j]);
+                myAntidom_bool(s,*(static_cast<BoolVar*>(s->v[var])),rg,ICL_DOM);
+            }
+        }
+    }
+}
+
+void Implicative::assign_bool(int var,int b) {
+    if (type_of_v[var] != VTYPE_INT) {
+        cout<<"Wrong variable type for assigning"<<endl;
+        abort();
+    }
+    int varspace = whichSpaceOwns[var];
+    for (int i=varspace;i<nbSpaces;i++) {
+        if (ruleDefined[i]) {
+            MySpace* s = rules[i];
+            rel(s,*(static_cast<BoolVar*>(s->v[var])),IRT_EQ,b);
+        }
+    }
+}
+
+void Implicative::remove_bool(int var,int b) {
+    if (type_of_v[var] != VTYPE_INT) {
+        cout<<"Wrong variable type for assigning"<<endl;
+        abort();
+    }
+    int varspace = whichSpaceOwns[var];
+    for (int i=varspace;i<nbSpaces;i++) {
+        if (ruleDefined[i]) {
+            MySpace* s = rules[i];
+            rel(s,*(static_cast<BoolVar*>(s->v[var])),IRT_NQ,b);
+        }
+    }
+}
+
+
+void Implicative::backtrack() {
+    w->update(this);
+}
+
+
+void Implicative::indicateBranchingHeuristic(BranchingHeuristic* bh) {
+    w->setBH(bh);
+}
+
+void Implicative::print() {
+    for (int i=0;i<nv();i++)
+        cout<<(q[i]?"A":"E");
+    cout<<endl;
+    for (int i=0;i<nbSpaces;i++) {
+        if (ruleDefined[i]) {
+            for (int j=0;j<nbVarBySpace[i];j++)
+                cout<<rules[i]->v[j]<<" ";
+            cout<<endl;
+        }
+        else cout<<"Undefined"<<endl;
+    }
+    if (goalDefined) {
+        for (int j=0;j<nv();j++)
+            cout<<goal->v[j]<<" ";
+        cout<<endl;
+    }
+    else cout<<"Undefined"<<endl;
+    cout<<endl<<endl;
+}