gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/contribs/map/shortdesc.ac

@@ -0,0 +1,2 @@
+map variable
+graph matching

data/ext/gecode-1.3.1/contribs/map/var.icc

@@ -0,0 +1,346 @@
+/*
+ *  Main authors:
+ *     Zampelli St�phane <sz@info.ucl.ac.be> 
+ *
+ *  Copyright:
+ *     Universit� catholique de Louvain, 2005
+ *
+ *  Last modified:
+ *     $Date$
+ *     $Revision$
+ *
+ *  This file is part of CP(Map)
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+#include "int/count.hh" //for the count constraint
+#include <iostream>
+#include <map>
+#include <vector>
+
+/**
+ * \namespace Gecode::Map
+ * \brief Contains the MapVar declarations with propagator classes
+ *
+ */
+//@{
+
+//#include "constraints.hh" //Declaration of FRIEND propagator functions in Gecode namespace 
+
+
+namespace Gecode { namespace Map {
+
+  /**
+   * \defgroup TaskActorMapMEPC Map modification events and propagation conditions
+   * \ingroup TaskActorMap
+   */
+
+  //@{
+
+  /// Domain operation has resulted in failure
+  const ModEvent ME_MAP_FAILED = ME_GEN_FAILED;
+  /// Domain operation has not changed domain
+  const ModEvent ME_MAP_NONE  = ME_GEN_NONE;
+  /// Domain operation has resulted in a value (assigned variable)
+  const ModEvent ME_MAP_VAL   = ME_GEN_ASSIGNED;
+
+
+  /*ModEvents declaration*/
+  
+  /**
+   * \brief Domain operation has changed the domain 
+   *
+   * Note that this implies that the domain has not resulted in a value.
+   */
+  const ModEvent ME_MAP_DOM   = ME_MAP_VAL + 1;
+  /**
+   * \brief Domain operation has changed the codomain 
+   *
+   * Note that this implies that the domain has not resulted in a value.
+   */
+  const ModEvent ME_MAP_CODOM   = ME_MAP_DOM + 1;
+  /**
+   * \brief Domain operation has changed both greatest domain and 
+   * codomain
+   *
+   * Note that this implies that the domain has not resulted in a value.
+   */
+  const ModEvent ME_MAP_ANY   = ME_MAP_CODOM + 1;
+
+  /*Propagation conditions declaration*/
+  
+  /**
+   * \brief Propagate when a view becomes assigned (single value)
+   *
+   * If a propagator \a p depends on a view \a x with propagation
+   * condition PC_MAP_VAL, then \a p is propagated when a domain
+   * update operation on \a x returns the modification event ME_MAP_VAL.
+   */
+  const PropCond PC_MAP_VAL  = PC_GEN_ASSIGNED;
+  /**
+   * \brief Propagate when the codomain changes
+   *
+   * If a propagator \a p depends on a view \a x with propagation
+   * condition PC_MAP_DOM, then \a p is propagated when a domain
+   * update operation on \a x returns the modification event ME_MAP_VAL,
+   * ME_MAP_DOM, ME_MAP_ANY
+   */
+  const PropCond PC_MAP_DOM = PC_MAP_VAL + 1;
+  /**
+   * \brief Propagate when the codom changes
+   *
+   * If a propagator \a p depends on a view \a x with propagation
+   * condition PC_MAP_CODOM, then \a p is propagated when a domain
+   * update operation on \a x returns the modification event ME_MAP_VAL,
+   * ME_MAP_CODOM, ME_MAP_ANY
+   */
+  const PropCond PC_MAP_CODOM = PC_MAP_DOM + 1;
+  /**
+   * \brief Propagate when the domain or/and the codomain changes
+   *
+   * If a propagator \a p depends on a view \a x with propagation
+   * condition PC_MAP_ANY, then \a p is propagated when a domain
+   * update operation on \a x returns any modification event but ME_MAP_FAILED
+   * and ME_MAP_NONE.
+   */
+  const PropCond PC_MAP_ANY  = PC_MAP_CODOM + 1;
+  //@}
+}}
+
+namespace Gecode { namespace Map {
+class MapVar;
+}}
+
+namespace Gecode {void injective(Space *home, Gecode::Map::MapVar M);}
+
+namespace Gecode { namespace Map {
+
+   /**
+    * \defgroup FIMV Finite Integer Map Variable 
+    *
+    * This implementation uses an Array of IntView to represent the matching, together 
+    * with one SetView for the domain and one SetView for the codomain. 
+    *
+    * Reified propagators are posted to ensure coherence between the array and the Set variables. 
+    * 
+    */  
+   //@{
+    /**
+    * \brief Implementation of Finite Integer Map Variable 
+    *
+    * This implementation uses an Array of IntView to represent the matching, together 
+    * with one SetView for the domain and one SetView for the codomain. 
+    *
+    * Reified propagators are posted to ensure coherence between the array and the Set variables. 
+    *
+    */  
+  
+   class MapVar 
+	   //: public Variable<VTI_MAP,PC_MAP_ANY> 
+	   {
+	 public:
+	 ///Repesents the domain
+	 Gecode::SetVar Domain;
+	 ///Represents the codomain
+	 Gecode::SetVar Codomain;
+	 ///Represents the map
+	 ViewArray<Gecode::Int::IntView> array;  
+	 ///Size of the initial domain
+	 int maxDomSize;     
+	 ///Size of the initial codomain
+	 int maxCodomSize;     
+	 ///Stores the empty symbol for each IntVar (alldiff)
+	 map < int, int > *e;     
+	 ///Maps real domain values to technical \f$\{0,\ldots,n-1\}\f$ indexes
+	 map < int,int > *index;
+	 ///Maps indexes to real domain values
+	 map < int,int > *indexInv; 
+
+
+//	 /// Map variable processor for modified variables
+//	 class Processor : public VarTypeProcessor<VTI_MAP,PC_MAP_ANY> {
+//	    public:
+//	       /// Initialize and register
+//	       Processor(void);
+//	 };
+//	 /// The processor
+//	 GECODE_MAP_EXPORT static Processor svp;
+
+      protected:
+	 /// Constructor for cloning \a x
+	 MapVar(Space* home, bool share, MapVar& x);
+	 /// Destructor 
+	 //~MapVar();
+      public:
+
+	 /// \name Constructors and initialization
+	 //@{
+	 MapVar(void);
+
+	 // Initialize with empty lower and full upper bound
+	 //    MapVar(Space* home);
+	 /// Initialize with a SetView Dom representing the domain and a SetView Codom representing the codomain. 
+	 MapVar(Space* home, SetVar Dom, SetVar Codom);
+	 //@}
+
+	 /// \name Value access
+	 //@{
+	 /// Return current domain cardinality minimum
+	 unsigned int cardDomainMin(void) const;
+	 /// Return current domain cardinality maximum
+	 unsigned int cardDomainMax(void) const;
+	 /// Return current codomain cardinality minimum
+	 unsigned int cardCodomainMin(void) const;
+	 /// Return current codomain cardinality maximum
+	 unsigned int cardCodomainMax(void) const;
+	 /// Return the \a n -th smallest element in the domain least upper bound
+	 int domLubMinN(int n) const;
+	 /// Return the \a n -th largest element in the domain least upper bound
+	 int domLubMaxN(int n) const;
+	 /// Return the smallest element in the domain greatest lower bound
+	 int domGlbMin() const;
+	 /// Return the largest element in the domain least upper bound
+	 int domGlbMax() const;
+	 /// Return the size of the domain least upper bound
+	 unsigned int domLubSize(void) const;
+	 /// Return the size of the domain greatest lower bound
+	 unsigned int domGlbSize(void) const;
+	 /// Return the \a n -th smallest element in the codomain least upper bound
+	 int codomLubMinN(int n) const;
+	 /// Return the \a n -th largest element in the codomain least upper bound
+	 int codomLubMaxN(int n) const;
+	 /// Return the smallest element in the codomain greatest lower bound
+	 int codomGlbMin() const;
+	 /// Return the largest element in the codomain greatest lower bound
+	 int codomGlbMax() const;
+	 /// Return the smallest element in the codomain least upper bound
+	 int codomLubMin() const;
+	 /// Return the largest element in the codomain least upper bound
+	 int codomLubMax() const;
+	 /// Return the size of the codomain least upper bound
+	 unsigned int codomLubSize(void) const;
+	 /// Return the size of the codomain greatest lower bound
+	 unsigned int codomGlbSize(void) const;
+	 /// Return the number of potential images of \f$f(i)\f$
+	 unsigned int size(int i);
+	 /// Return \f$f(i)\f$ (only if f(i) is mapped)
+	 int MapVar::imageAssigned(int i);
+	 /// Return the size of the initial upper bound of dom(f)
+	 unsigned int maxInitDomSize(void) const;
+	 //@}
+
+	 /// \name Domain tests
+	 //@{
+	 ///Test wether f(i) is mapped
+	 bool mapped(int i) ;
+	 /// Test whether variable is assigned
+	 bool assigned(void) ;
+	 /// Test whether \f$f(a)=b\f$
+	 bool map(int a, int b);
+	 ///Test wether \f$ b \in f(a)\g$
+	 bool imageIn(int a, int b);
+	 ///Test wether \f$b \notin f(a)\f$
+	 bool imageOut(int a, int b);
+	 ///Test wether \a a has no image i.e. \f$ a \notin Dom(f)\f$
+	 bool noImage(int a);
+	 //
+	 ///Test wether \a f is in least upper bound
+	 //bool knownOut(map<int,int> f);
+	 ///Test wether\a f is in grestest lower bound
+	 //bool knownIn(map<int,int> f);
+	 //@}
+
+
+      private:
+	 /// Test whether glb is a subset of lub
+	 //bool boundsConsistent(void) const;
+      public:
+
+	 /// \name Domain update by value
+	 //@{
+
+	 /// Include \a n in domain
+	 ModEvent includeDom(Space *home, int n);
+	 /// Exclude \a n from domain
+	 ModEvent excludeDom(Space *home, int n);
+	 /// Include \a n in codomain
+	 ModEvent includeCodom(Space *home, int n);
+	 /// Exclude \a n from codomain
+	 ModEvent excludeCodom(Space *home, int n);
+
+	 /// Restrict domain cardinality to be at least n 
+	 ModEvent cardDomMin(Space *home, unsigned int n);
+	 /// Restrict domain cardinality to be at most n
+	 ModEvent cardDomMax(Space *home, unsigned int n);
+	 /// Restrict codomain cardinality to be at least n
+	 ModEvent cardCodomMin(Space *home, unsigned int n);
+	 /// Restrict codomain cardinality to be at most n
+	 ModEvent cardCodomMax(Space *home, unsigned int n); 
+
+	 /// f(i)=j
+	 ModEvent map(Space *home, int i, int j);
+	 /// f(i)\=j
+	 ModEvent nomap(Space *home, int i, int j);
+	 ExecStatus nomapB(Space *home, int i, int j);
+	 //@}
+
+	 /// \name Domain update by range iterator
+	 //@{
+	 /// Include set described by \a i in the greatest lower bound
+	 //template <class I> ModEvent includeI(Space* home,I& i);
+	 /// Exclude set described by \a i from the least upper bound
+	 //template <class I> ModEvent excludeI(Space* home,I& i);
+	 /// Exclude everything but set described by \a i from the least upper bound
+	 //template <class I> ModEvent intersectI(Space* home,I& i);
+	 //@}
+
+	 typedef Iter::Ranges::ToValues<LubRanges<SetView> > CodomLubIterator ;
+	 CodomLubIterator iter_codom_lub();
+
+      public:
+	 /// \name Dependencies
+	 //@{
+	 /// Subscribe propagator \a p with propagation condition \a pc to variable
+	 GECODE_MAP_EXPORT void subscribe(Space* home,Propagator* p,PropCond pc);
+	 //@}
+
+      private:
+	 /// Return copy of not-yet copied variable
+	 GECODE_MAP_EXPORT MapVar* perform_copy(Space* home, bool share);
+
+      public:
+	 /// \name Cloning
+	 //@{
+	 /// Return copy of this variable
+	 MapVar* copy(Space* home, bool share);
+	 /// Update this variable to be a clone of variable \a x
+	 void update(Space* home, bool share, MapVar& x);
+	 //@}
+
+	 void print(void);
+	 void print(int i); 
+
+	 //friend void Gecode::branch(Space *home, MapVar M, BvarSel vars, BvalSel vals);
+	 //friend void Gecode::injective(Gecode::Space *, MapVar);
+   };
+   //a}
+}
+}
+
+#include "var/imp.icc"
+//@}
+
+/**
+ * \brief Print set variable \a x
+ * \relates Gecode::MapVar
+ */
+GECODE_MAP_EXPORT std::ostream&
+operator<<(std::ostream&, const Gecode::Map::MapVar& x);
+
+//
+// STATISTICS: set-var
+//

data/ext/gecode-1.3.1/contribs/map/var/imp.cc

@@ -0,0 +1,42 @@
+/*
+ *  Main authors:
+ *     Zampelli St�phane <sz@info.ucl.ac.be>
+ *
+ *  Copyright:
+ *     Universit� catholique de Louvain, 2005
+ *
+ *  Last modified:
+ *     $Date$
+ *     $Revision$
+ *
+ *  This file is part of CP(Map)
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+
+#include "map.hh"
+
+namespace Gecode { namespace Map {
+  
+  /// Return copy of not-yet copied variable
+  GECODE_MAP_EXPORT MapVar* MapVar::perform_copy(Space* home, bool share)
+  {
+    return new (home) MapVar(home,share,*this);
+  }
+}}
+
+GECODE_MAP_EXPORT std::ostream&
+operator<<(std::ostream& os, const Gecode::Map::MapVar& x)
+{
+  for (int i=0; i<x.array.size(); i++) {
+    os << (x.array[i]) << endl;
+  };
+
+  return os;
+}
+
+

data/ext/gecode-1.3.1/contribs/map/var/imp.icc

@@ -0,0 +1,436 @@
+/*
+ *  Main authors:
+ *     Zampelli St�phane <sz@info.ucl.ac.be> 
+ *
+ *  Copyright:
+ *     Universit� catholique de Louvain, 2005
+ *
+ *  Last modified:
+ *     $Date$
+ *     $Revision$
+ *
+ *  This file is part of CP(Map)
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+
+ #define CREATE(VY,VZ,C)                                                  \
+   if (C<IntView,VY,VZ,Count::RelEqDom<IntView>,true>::post(home,newarray,y,T,c) \
+       == ES_FAILED)                                                      \
+     home->fail();                                                        \
+
+namespace Gecode { namespace Map {
+
+ forceinline MapVar::MapVar(){};//: Variable<VTI_MAP,PC_MAP_ANY>(NULL) {};
+
+  forceinline MapVar::MapVar(Space* home, bool share, MapVar& x) : 
+    //Variable<VTI_MAP,PC_MAP_ANY>(home,share,x),
+    Domain(x.Domain), Codomain(x.Codomain),
+    array(x.array), maxDomSize(x.maxDomSize), maxCodomSize(x.maxCodomSize),
+    e(x.e), index(x.index), indexInv(x.indexInv)
+  {}; 
+
+  forceinline MapVar::MapVar(Space* home, SetVar Dom, SetVar Codom)
+    : //Variable<VTI_MAP,PC_MAP_ANY>(home), 
+    Domain(Dom), Codomain(Codom), 
+    //This call array(...) only allocates space, does not create Views. ViewArrays are containers.
+    array(home, Dom.cardMax()), 
+    maxDomSize(Dom.cardMax()), maxCodomSize(Codom.cardMax()), e(NULL),
+    index(NULL), indexInv(NULL)
+    {
+       //external pointers for private members 
+       //they never change during search
+       e=new std::map<int,int>;
+       index=new std::map<int,int>;
+       indexInv=new std::map<int,int>;
+
+       //Create index and indexInv maps
+       LubRanges<SetView> DomUB(Dom);
+       Iter::Ranges::ToValues<LubRanges<SetView> > DomV(DomUB);
+       int i=0;
+       while (DomV()) {
+	  (*index)[DomV.val()]=i;
+	  (*indexInv)[i]=DomV.val();
+	  ++i;
+	  ++DomV;
+       }
+
+       //Fill r structure with Codomain UB 
+       int *r=NULL;
+       r = new int[maxCodomSize+1]; //represent the domain of Codom plus empty symbol
+       LubRanges<SetView> CodomUB(Codom);
+       Iter::Ranges::ToValues<LubRanges<SetView> > CodomV(CodomUB);
+       i=0;
+       while (CodomV()) {
+	  r[i]=CodomV.val();
+	  ++i;
+	  ++CodomV;
+       }
+
+       //Create suitable Views and insert them into array
+       for (int i=0; i<maxDomSize; i++) 
+       {
+	  (*e)[i]=Codom.lubMax()+i+1;  //The empty symbol is stored
+	  r[maxCodomSize]=(*e)[i];
+	  IntSet is(r,maxCodomSize+1);
+	  IntVar myvar(home, is);
+	  IntView myview(myvar);
+	  array[i]=myview;
+       };
+
+	delete [] r;
+
+       /*Post coherence constraints between array, S and T*/
+       for (int i=0; i<maxDomSize; i++)
+       {
+	  BoolVar b1_; b1_.init(home,0,1);
+	  BoolVar b1;  b1.init(home,0,1);
+
+	  eq(home, array[i], (*e)[i], b1_);
+
+	  bool_not(home, b1, b1_);
+	  //Image_i == e <-> i \notin S
+	  dom(home, Dom, SRT_SUP, (*indexInv)[i], b1);
+
+	  //Image_i == e <-> Image_i \notin T
+	  rel(home, Codom, SRT_SUP, array[i], b1);
+       }
+
+       //Post 'Occurs' constraint to propagate upon UB(T)
+
+       //for all i in UB(Codom) : Occurs(array,i)=0 -> i \notin Codom 
+       LubRanges<SetView> CodomUB2(Codom);
+       Iter::Ranges::ToValues<LubRanges<SetView> > CodomV2(CodomUB2);
+       while (CodomV2()) {
+	  //IntVar T; T.init(home,0,maxDomSize);
+	  IntVar T;T.init(home,0,maxDomSize);
+	  BoolVar b1_; b1_.init(home,0,1);
+	  BoolVar b2_; b2_.init(home,0,1);
+
+	  ConstIntView y(CodomV2.val());
+	  int c=0;
+	  //Copy before posting, because Eq modify its own ViewArray 
+	  ViewArray<IntView> newarray(home,array);  
+	  //count(home, array, CodomV2.val(), IRT_EQ, T);
+	  CREATE(ConstIntView,IntView,Count::Eq);
+
+	  //b2_ <-> not(b1_) <-> T \= 0
+	  eq(home, T, 0, b1_);
+	  bool_not(home,b2_,b1_); 
+
+	  //T==0 <-> y \notin Codom
+	  IntVar tmp(home,CodomV2.val(), CodomV2.val());
+	  IntView tmp2(tmp);
+	  rel(home, Codom, SRT_SUP, tmp2, b2_ ); 
+
+	  ++CodomV2;
+       } 
+
+    };
+
+//  forceinline MapVar::Processor::Processor(void) {
+//
+//    // Combination of modification events
+//    mec(ME_MAP_DOM,  ME_MAP_CODOM,  ME_MAP_ANY);
+//
+//    // Mapping between modification events and propagation conditions
+//    mepc(ME_MAP_VAL, PC_MAP_VAL);
+//    mepc(ME_MAP_DOM, PC_MAP_DOM);
+//    mepc(ME_MAP_CODOM, PC_MAP_CODOM);
+//    mepc(ME_MAP_ANY, PC_MAP_ANY);
+//
+//    // Transfer to kernel
+//    enter();
+//  }
+
+  /// Return current domain cardinality minimum
+  forceinline unsigned int MapVar::cardDomainMin(void) const {return Domain.cardMin();}
+  /// Return current domain cardinality maximum
+  forceinline unsigned int MapVar::cardDomainMax(void) const {return Domain.cardMax();}
+  /// Return current codomain cardinality minimum
+  forceinline unsigned int MapVar::cardCodomainMin(void) const {return Codomain.cardMin();}
+  /// Return current codomain cardinality maximum
+  forceinline unsigned int MapVar::cardCodomainMax(void) const {return Codomain.cardMax();}
+  /// Return the \a n -th smallest element in the domain least upper bound
+  forceinline int MapVar::domLubMinN(int n) const {
+     SetView DomainView(Domain); //no cost thanks to compiler optimization
+     return DomainView.lubMinN(n);
+  }
+  /// Return the \a n -th largest element in the domain least upper bound
+  forceinline int MapVar::domLubMaxN(int n) const {
+     SetView DomainView(Domain); //no cost thanks to compiler optimization
+    return DomainView.lubMaxN(n);
+  }
+  /// Return the size of the domain least upper bound
+  forceinline unsigned int MapVar::domLubSize(void) const {return Domain.lubSize();}
+  /// Return the size of the domain greatest lower bound
+  forceinline unsigned int MapVar::domGlbSize(void) const {return Domain.glbSize();}
+
+  forceinline int MapVar::domGlbMin(void) const {return Domain.glbMin();}
+  forceinline int MapVar::domGlbMax(void) const {return Domain.glbMax();}
+
+
+  /// Return the \a n -th smallest element in the codomain least upper bound
+  forceinline int MapVar::codomLubMinN(int n) const {
+     SetView CodomainView(Codomain); //no cost thanks to compiler optimization
+     return CodomainView.lubMinN(n);
+  }
+
+  /// Return the \a n -th largest element in the codomain least upper bound
+  forceinline int MapVar::codomLubMaxN(int n) const {
+     SetView CodomainView(Codomain); //no cost thanks to compiler optimization
+     return CodomainView.lubMaxN(n);};
+
+  forceinline int MapVar::codomGlbMin(void) const {return Codomain.glbMin();}
+  forceinline int MapVar::codomGlbMax(void) const {return Codomain.glbMax();}
+  forceinline int MapVar::codomLubMin(void) const {return Codomain.lubMin();}
+  forceinline int MapVar::codomLubMax(void) const {return Codomain.lubMax();}
+
+  /// Return the size of the codomain least upper bound
+  forceinline unsigned int MapVar::codomLubSize(void) const {return Codomain.lubSize();}
+  /// Return the size of the codomain greatest lower bound
+  forceinline unsigned int MapVar::codomGlbSize(void) const {return Codomain.glbSize();}
+  ///Return the initial size of UB of dom(f)
+  forceinline unsigned int MapVar::maxInitDomSize(void) const {return array.size();}
+  ///Returns the size of f(i)
+  forceinline unsigned int MapVar::size(int i) {return array[(*index)[i]].size();}
+  /// Test whether variable is assigned
+  forceinline bool MapVar::assigned(void) 
+  { 
+    bool assigned=(Domain.assigned() && Codomain.assigned());
+    if (assigned) {
+      for (int i=array.size(); i--; ) {
+	if ((array[i].assigned()) && (array[i].in((*e)[i]))) { assigned=false; break;  }        
+      }
+    }
+    return assigned;
+  }
+
+  /// Test whether f(a)=b
+  forceinline bool MapVar::map(int a, int b) { 
+    if ( (!Domain.notContains(a)) && (!Codomain.notContains(b)) ) { 
+      return ( array[(*index)[a]].assigned() && array[(*index)[a]].in(b) ); };
+    return false;
+  }
+  ///Test wether b in f(a)
+  forceinline bool MapVar::imageIn(int a, int b) { 
+    if ( (!Domain.notContains(a)) && (!Codomain.notContains(b)) && (*e)[(*index)[a]]!=b) { 
+      return array[(*index)[a]].in(b); };
+    return false;
+  }
+  ///Test wether b not in f(a)
+  forceinline bool MapVar::imageOut(int a, int b) { 
+    if ( (!Domain.notContains(a)) && (!Codomain.notContains(b)) ) { 
+      return !array[(*index)[a]].in(b) && (*e)[(*index)[a]]!=b; };
+    return false;
+  }
+  ///Test wether \a a has no image i.e. \a a \notin Dom(f)
+  forceinline bool MapVar::noImage(int a) { 
+    return array[(*index)[a]].assigned() && array[(*index)[a]].in((*e)[(*index)[a]]);
+  }
+
+
+  /// Test whether \a f is contained in greatest lower bound
+  //forceinline bool MapVar::knownIn(map<int,int> f);
+  /// Test whether \a f is contained in least upper bound
+  //forceinline bool MapVar::knownOut(map<int,int> f);
+  //@}
+
+  /// Include \a n in domain
+  forceinline ModEvent MapVar::includeDom(Space *home, int n)
+  {
+    SetView DomainView(Domain); //no cost thanks to compiler optimization
+    ModEvent me = DomainView.include(home, n);
+    if (me == Gecode::Set::ME_SET_FAILED) {return ME_MAP_FAILED;};
+    if (me == Gecode::Set::ME_SET_NONE) {return ME_MAP_NONE;};
+    return ME_MAP_DOM;
+  }
+  /// Exclude \a n from domain
+  forceinline ModEvent MapVar::excludeDom(Space *home, int n)
+  {
+    SetView DomainView(Domain); //no cost thanks to compiler optimization
+    ModEvent me = DomainView.exclude(home, n);
+    if (me == Gecode::Set::ME_SET_FAILED) {return ME_MAP_FAILED;};
+    if (me == Gecode::Set::ME_SET_NONE) {return ME_MAP_NONE;};
+    return ME_MAP_DOM;
+  }
+  /// Include \a n in codomain
+  forceinline ModEvent MapVar::includeCodom(Space *home, int n)
+  {
+    SetView CodomainView(Codomain); //no cost thanks to compiler optimization
+    ModEvent me = CodomainView.include(home, n);
+    if (me == Gecode::Set::ME_SET_FAILED) {return ME_MAP_FAILED;};
+    if (me == Gecode::Set::ME_SET_NONE) {return ME_MAP_NONE;};
+    return ME_MAP_CODOM;
+  }
+
+  /// Exclude \a n from codomain
+  forceinline ModEvent MapVar::excludeCodom(Space *home, int n)
+  {
+    SetView CodomainView(Codomain); //no cost thanks to compiler optimization
+    ModEvent me = CodomainView.exclude(home, n);
+    if (me == Gecode::Set::ME_SET_FAILED) {return ME_MAP_FAILED;};
+    if (me == Gecode::Set::ME_SET_NONE) {return ME_MAP_NONE;};
+    return ME_MAP_CODOM;
+  }
+
+  /// Restrict domain cardinality to be at least n 
+  forceinline ModEvent MapVar::cardDomMin(Space *home, unsigned int n)
+  {
+    SetView DomainView(Domain); //no cost thanks to compiler optimization
+    ModEvent me = DomainView.cardMin(home, n);
+    if (me == Gecode::Set::ME_SET_FAILED) {return ME_MAP_FAILED;};
+    if (me == Gecode::Set::ME_SET_NONE) {return ME_MAP_NONE;};
+    return ME_MAP_DOM;
+  }
+  /// Restrict domain cardinality to be at most n
+  forceinline ModEvent MapVar::cardDomMax(Space *home, unsigned int n)
+  {
+    SetView DomainView(Domain); //no cost thanks to compiler optimization
+    ModEvent me = DomainView.cardMax(home, n);
+    if (me == Gecode::Set::ME_SET_FAILED) {return ME_MAP_FAILED;};
+    if (me == Gecode::Set::ME_SET_NONE) {return ME_MAP_NONE;};
+    return ME_MAP_DOM;
+  }
+  /// Restrict codomain cardinality to be at least n
+  forceinline ModEvent MapVar::cardCodomMin(Space *home, unsigned int n)
+  {
+    SetView CodomainView(Codomain); //no cost thanks to compiler optimization
+    ModEvent me = CodomainView.cardMin(home, n);
+    if (me == Gecode::Set::ME_SET_FAILED) {return ME_MAP_FAILED;};
+    if (me == Gecode::Set::ME_SET_NONE) {return ME_MAP_NONE;};
+    return ME_MAP_CODOM;
+  }
+
+  /// Restrict codomain cardinality to be at most n
+  forceinline ModEvent MapVar::cardCodomMax(Space *home, unsigned int n) 
+  {
+    SetView CodomainView(Codomain); //no cost thanks to compiler optimization
+    ModEvent me = CodomainView.cardMax(home, n);
+    if (me == Gecode::Set::ME_SET_FAILED) {return ME_MAP_FAILED;};
+    if (me == Gecode::Set::ME_SET_NONE) {return ME_MAP_NONE;};
+    return ME_MAP_CODOM;
+  }
+
+  /// f(i)=j
+  forceinline ModEvent MapVar::map(Space *home, int i, int j)
+  {
+    if ((!Domain.notContains(i)) && (!Codomain.notContains(j))) {
+      ModEvent me = array[(*index)[i]].eq(home, j);
+      if (me == Gecode::Int::ME_INT_FAILED) {return ME_MAP_FAILED;};
+      if (me == Gecode::Int::ME_INT_NONE) {return ME_MAP_NONE;};
+      return ME_MAP_ANY;
+    }
+    return ME_MAP_NONE;
+  }
+
+  /// f(i)\=j
+  forceinline ModEvent MapVar::nomap(Space *home, int i, int j)
+  {
+    if ((!Domain.notContains(i)) && (!Codomain.notContains(j))) {
+      ModEvent me = array[(*index)[i]].nq(home, j);
+      if (me == Gecode::Int::ME_INT_FAILED) {return ME_MAP_FAILED;};
+      if (me == Gecode::Int::ME_INT_NONE) {return ME_MAP_NONE;};
+      return ME_MAP_ANY;
+    }
+    return ME_MAP_NONE;
+
+  }
+
+  /// f(i)\=j
+  forceinline ExecStatus MapVar::nomapB(Space *home, int i, int j)
+  {
+    if ((!Domain.notContains(i)) && (!Codomain.notContains(j))) {
+      return me_failed(array[(*index)[i]].nq(home,j)) ? ES_FAILED : ES_OK;
+      //if (me == Gecode::Int::ME_INT_FAILED) {return ME_MAP_FAILED;};
+      //if (me == Gecode::Int::ME_INT_NONE) {return ME_MAP_NONE;};
+      //return ME_MAP_ANY;
+    }
+    return ES_OK;
+  }
+
+
+  /// Subscribe propagator \a p with propagation condition \a pc to variable
+  forceinline
+    GECODE_MAP_EXPORT void MapVar::subscribe(Space* home,Propagator* p,PropCond pc)
+    {
+      //translate pc to pc of SetView and IntViewArray
+      if (pc == PC_MAP_DOM) {
+	 SetView DomainView(Domain); //no cost thanks to compiler optimization
+	DomainView.subscribe(home, p, Gecode::Set::PC_SET_ANY);
+      }
+
+      if (pc == PC_MAP_CODOM) {
+	 SetView CodomainView(Codomain); //no cost thanks to compiler optimization
+	CodomainView.subscribe(home, p, Gecode::Set::PC_SET_ANY);
+      }
+
+      if (pc == PC_MAP_ANY) {
+
+	 SetView DomainView(Domain); //no cost thanks to compiler optimization
+	 DomainView.subscribe(home, p, Gecode::Set::PC_SET_ANY);
+	 SetView CodomainView(Codomain); //no cost thanks to compiler optimization
+	CodomainView.subscribe(home, p, Gecode::Set::PC_SET_ANY);
+	array.subscribe(home, p, Gecode::Int::PC_INT_DOM);
+      }
+
+    }
+
+//  forceinline
+//    MapVar* MapVar::copy(Space* home, bool share)
+//    {
+//      if (copied()) {
+//	return static_cast<MapVar*>(forward()); 
+//      }
+//      perform_copy(home,share);
+//    }
+
+  forceinline
+    void MapVar::update(Space* home, bool share, MapVar& x)
+    {
+      Domain.update(home, share, x.Domain);
+      Codomain.update(home, share, x.Codomain);
+      array.update(home, share, x.array);
+      e = x.e;
+      index = x.index;
+      indexInv = x.indexInv;
+      maxDomSize = x.maxDomSize;
+      maxCodomSize = x.maxCodomSize;
+   }
+
+  /// Returns f(i) (only if f(i) is mapped)
+  forceinline int MapVar::imageAssigned(int i) {return array[(*index)[i]].val();};
+
+  ///Test wether f(i) is mapped
+  forceinline bool MapVar::mapped(int i) {
+    return ((array[(*index)[i]].assigned()) && (array[(*index)[i]].in((*e)[(*index)[i]])==false));};
+
+  forceinline 
+    void MapVar::print() 
+    {
+       for (int s=0; s<array.size(); s++)
+       {
+	  cout << "array[" << s << "] = " << array[s] << endl;
+       }
+    }
+
+  forceinline void MapVar::print(int i)
+  {
+	 cout << "array[" << i << "] = " << array[i] << endl; 
+  }
+
+  forceinline MapVar::CodomLubIterator MapVar::iter_codom_lub(void) {
+    LubRanges<SetView> CodomUB(Codomain);
+    Iter::Ranges::ToValues<LubRanges<SetView> > CodomV(CodomUB);
+    return CodomV;
+  }
+  
+
+
+}
+}
+