gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/set/var/iter.icc

@@ -0,0 +1,47 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Gabor Szokoli, 2004
+ *
+ *  Last modified:
+ *     $Date: 2005-08-10 15:18:45 +0200 (Wed, 10 Aug 2005) $ by $Author: tack $
+ *     $Revision: 2199 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+namespace Gecode { namespace Set {
+
+  template <class T>
+  forceinline
+  UnknownRanges<T>::UnknownRanges(void) {}
+
+  template <class T>
+  forceinline
+  UnknownRanges<T>::UnknownRanges(const T& v) : i1(v), i2(v) {
+    Iter::Ranges::Diff<LubRanges<T>, GlbRanges<T> >::init(i1,i2);
+  }
+
+  template <class T>
+  forceinline void
+  UnknownRanges<T>::init(const T& v) {
+    i1.init(v);
+    i2.init(v);
+    Iter::Ranges::Diff<LubRanges<T>, GlbRanges<T> >::init(i1,i2);
+  }
+
+}}
+
+// STATISTICS: set-var
+

data/ext/gecode-1.3.1/gecode/set/var/set.cc

@@ -0,0 +1,99 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *     Gabor Szokoli, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-04-11 15:58:37 +0200 (Tue, 11 Apr 2006) $ by $Author: tack $
+ *     $Revision: 3188 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+
+#include "gecode/set.hh"
+
+namespace Gecode {
+
+  SetVar::SetVar(Space* home)
+    : x(new (home) Set::SetVarImp(home)) {}
+
+  SetVar::SetVar(Space* home,int lbMin,int lbMax,int ubMin,int ubMax,
+		 unsigned int minCard, unsigned int maxCard)
+    : x(new (home) Set::SetVarImp(home,lbMin,lbMax,ubMin,ubMax,
+				  minCard,maxCard)) {
+    if ((lbMin < Limits::Set::int_min) || 
+	(lbMax > Limits::Set::int_max) ||
+	(ubMin < Limits::Set::int_min) || 
+	(ubMax > Limits::Set::int_max))
+      throw Set::VariableOutOfRangeDomain("SetVar");
+    if (maxCard > Limits::Set::card_max)
+      throw Set::VariableOutOfRangeCardinality("SetVar");
+    if (minCard > maxCard)
+      throw Set::VariableFailedDomain("SetVar");
+  }
+
+  SetVar::SetVar(Space* home, const IntSet& glb,int ubMin,int ubMax,
+		 unsigned int minCard, unsigned int maxCard)
+    : x(new (home) Set::SetVarImp(home,glb,ubMin,ubMax,minCard,maxCard)) {
+    if ( ((glb.size() > 0) &&
+	  ((glb.min() < Limits::Set::int_min) ||
+	   (glb.max() > Limits::Set::int_max))) ||
+	 (ubMin < Limits::Set::int_min) || 
+	 (ubMax > Limits::Set::int_max))
+      throw Set::VariableOutOfRangeDomain("SetVar");
+    if (maxCard > Limits::Set::card_max)
+      throw Set::VariableOutOfRangeCardinality("SetVar");
+    if (minCard > maxCard)
+      throw Set::VariableFailedDomain("SetVar");
+  }
+
+  SetVar::SetVar(Space* home,int lbMin,int lbMax,const IntSet& lub,
+		 unsigned int minCard, unsigned int maxCard)
+    : x(new (home) Set::SetVarImp(home,lbMin,lbMax,lub,minCard,maxCard)) {
+    if ( ((lub.size() > 0) &&
+	  ((lub.min() < Limits::Set::int_min) ||
+	   (lub.max() > Limits::Set::int_max))) ||
+	 (lbMin < Limits::Set::int_min) || 
+	 (lbMax > Limits::Set::int_max))
+      throw Set::VariableOutOfRangeDomain("SetVarArray");
+    if (maxCard > Limits::Set::card_max)
+      throw Set::VariableOutOfRangeCardinality("SetVar");
+    if (minCard > maxCard)
+      throw Set::VariableFailedDomain("SetVar");
+  }
+
+  SetVar::SetVar(Space* home,
+		 const IntSet& glb, const IntSet& lub,
+		 unsigned int minCard, unsigned int maxCard)
+    : x(new (home) Set::SetVarImp(home,glb,lub,minCard,maxCard)) {
+    if (((glb.size() > 0) &&
+	 ((glb.min() < Limits::Set::int_min) ||
+	  (glb.max() > Limits::Set::int_max)))  ||
+	((glb.size() > 0) &&
+	 ((lub.min() < Limits::Set::int_min) ||
+	  (lub.max() > Limits::Set::int_max))))
+      throw Set::VariableOutOfRangeDomain("SetVar");
+    if (maxCard > Limits::Set::card_max)
+      throw Set::VariableOutOfRangeCardinality("SetVar");
+    if (minCard > maxCard)
+      throw Set::VariableFailedDomain("SetVar");
+  }
+
+}
+
+// STATISTICS: set-var
+

data/ext/gecode-1.3.1/gecode/set/var/set.icc

@@ -0,0 +1,282 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *     Gabor Szokoli, 2004
+ *
+ *  Last modified:
+ *     $Date: 2005-10-11 17:57:38 +0200 (Tue, 11 Oct 2005) $ by $Author: tack $
+ *     $Revision: 2334 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+namespace Gecode {
+
+  /*
+   * Constructors and access
+   *
+   */
+
+  forceinline
+  SetVar::SetVar(void) {
+    //Beware! Constructor bypassed when instance created via VarArray!
+    //Use init() instead!
+  }
+
+  forceinline void
+  SetVar::init(Space* home) {
+    x = new (home) Set::SetVarImp(home);
+  }
+
+  forceinline void
+  SetVar::init(Space* home,int lbMin,int lbMax,int ubMin,int ubMax,
+	       unsigned int cardMin, unsigned int cardMax) {
+    x = new (home) Set::SetVarImp(home, lbMin,lbMax,ubMin,ubMax,
+				  cardMin, cardMax);
+  }
+
+  forceinline void
+  SetVar::init(Space* home, const IntSet& glb,int ubMin,int ubMax,
+	       unsigned int cardMin, unsigned int cardMax) {
+    x = new (home) Set::SetVarImp(home, glb, ubMin, ubMax, cardMin, cardMax);
+  }
+
+  forceinline void
+  SetVar::init(Space* home, int lbMin,int lbMax,const IntSet& lub,
+	       unsigned int cardMin, unsigned int cardMax) {
+    x = new (home) Set::SetVarImp(home, lbMin, lbMax, lub, cardMin, cardMax);
+  }
+
+  forceinline void
+  SetVar::init(Space* home, const IntSet& glb, const IntSet& lub,
+	       unsigned int cardMin, unsigned int cardMax) {
+    x = new (home) Set::SetVarImp(home, glb, lub, cardMin, cardMax);
+  }
+
+  forceinline Set::SetVarImp*
+  SetVar::variable(void) const {
+    return x;
+  }
+
+
+
+  /*
+   * Variable information
+   *
+   */
+
+  forceinline unsigned int
+  SetVar::glbSize(void) const { return x->glbSize(); }
+
+  forceinline unsigned int
+  SetVar::lubSize(void) const { return x->lubSize(); }
+
+  forceinline unsigned int
+  SetVar::unknownSize(void) const { return x->lubSize() - x->glbSize(); }
+
+  forceinline bool
+  SetVar::assigned(void)  const { return x->assigned(); }
+
+  forceinline bool
+  SetVar::contains(int i) const { return (x->knownIn(i)); }
+
+  forceinline bool
+  SetVar::notContains(int i) const { return (x->knownOut(i)); }
+
+  forceinline unsigned int
+  SetVar::cardMin(void) const { return x->cardMin(); }
+
+  forceinline unsigned int
+  SetVar::cardMax(void) const { return x->cardMax(); }
+
+  forceinline int
+  SetVar::lubMin(void) const { return x->lubMin(); }
+
+  forceinline int
+  SetVar::lubMax(void) const { return x->lubMax(); }
+
+  forceinline int
+  SetVar::glbMin(void) const { return x->glbMin(); }
+
+  forceinline int
+  SetVar::glbMax(void) const { return x->glbMax(); }
+
+  /*
+   * Cloning
+   *
+   */
+
+  forceinline void
+  SetVar::update(Space* home, bool share, SetVar& y) {
+    x = y.x->copy(home,share);
+  }
+
+
+  /*
+   * Range and value iterators for set variables
+   *
+   */
+
+  forceinline
+  SetVarGlbRanges::SetVarGlbRanges(void) {}
+
+  forceinline
+  SetVarGlbRanges::SetVarGlbRanges(const SetVar& s)
+    : iter(s.variable()) {}
+
+  forceinline
+  bool
+  SetVarGlbRanges::operator()(void) const { return iter(); }
+
+  forceinline
+  void
+  SetVarGlbRanges::operator++(void) { ++iter; }
+
+  forceinline
+  int
+  SetVarGlbRanges::min(void) const { return iter.min(); }
+
+  forceinline
+  int
+  SetVarGlbRanges::max(void) const { return iter.max(); }
+
+  forceinline
+  unsigned int
+  SetVarGlbRanges::width(void) const { return iter.width(); }  
+
+  forceinline
+  SetVarLubRanges::SetVarLubRanges(void) {}
+
+  forceinline
+  SetVarLubRanges::SetVarLubRanges(const SetVar& s)
+    : iter(s.variable()) {}
+
+  forceinline
+  bool
+  SetVarLubRanges::operator()(void) const { return iter(); }
+
+  forceinline
+  void
+  SetVarLubRanges::operator++(void) { ++iter; }
+
+  forceinline
+  int
+  SetVarLubRanges::min(void) const { return iter.min(); }
+
+  forceinline
+  int
+  SetVarLubRanges::max(void) const { return iter.max(); }
+
+  forceinline
+  unsigned int
+  SetVarLubRanges::width(void) const { return iter.width(); }  
+
+  forceinline
+  SetVarUnknownRanges::SetVarUnknownRanges(void) {}
+
+  forceinline
+  SetVarUnknownRanges::SetVarUnknownRanges(const SetVar& s) {
+    Set::SetVarImp *si = s.variable();
+    iter.init(si);
+  }
+
+  forceinline
+  bool
+  SetVarUnknownRanges::operator()(void) const { return iter(); }
+
+  forceinline
+  void
+  SetVarUnknownRanges::operator++(void) { ++iter; }
+
+  forceinline
+  int
+  SetVarUnknownRanges::min(void) const { return iter.min(); }
+
+  forceinline
+  int
+  SetVarUnknownRanges::max(void) const { return iter.max(); }
+
+  forceinline
+  unsigned int
+  SetVarUnknownRanges::width(void) const { return iter.width(); }  
+
+  forceinline
+  SetVarGlbValues::SetVarGlbValues(const SetVar& x) {
+    SetVarGlbRanges ivr(x);
+    iter.init(ivr);
+  }
+
+  forceinline bool
+  SetVarGlbValues::operator()(void) const {
+    return iter();
+  }
+
+  forceinline void
+  SetVarGlbValues::operator++(void) {
+    ++iter;
+  }
+
+  forceinline int
+  SetVarGlbValues::val(void) const {
+    return iter.val();
+  }
+
+  forceinline
+  SetVarLubValues::SetVarLubValues(const SetVar& x) {
+    SetVarLubRanges ivr(x);
+    iter.init(ivr);
+  }
+
+  forceinline bool
+  SetVarLubValues::operator()(void) const {
+    return iter();
+  }
+
+  forceinline void
+  SetVarLubValues::operator++(void) {
+    ++iter;
+  }
+
+  forceinline int
+  SetVarLubValues::val(void) const {
+    return iter.val();
+  }
+
+  forceinline
+  SetVarUnknownValues::SetVarUnknownValues(const SetVar& x) {
+    SetVarUnknownRanges ivr(x);
+    iter.init(ivr);
+  }
+
+  forceinline bool
+  SetVarUnknownValues::operator()(void) const {
+    return iter();
+  }
+
+  forceinline void
+  SetVarUnknownValues::operator++(void) {
+    ++iter;
+  }
+
+  forceinline int
+  SetVarUnknownValues::val(void) const {
+    return iter.val();
+  }
+
+}
+
+// STATISTICS: set-var
+

data/ext/gecode-1.3.1/gecode/set/view.icc

@@ -0,0 +1,1075 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Contributing authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-08-24 11:25:05 +0200 (Thu, 24 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3559 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+#include <iostream>
+#include "gecode/iter.hh"
+
+namespace Gecode { 
+
+  namespace Set {
+
+    /**
+     * \defgroup TaskActorSetView Set views
+     *
+     * Set propagators and branchings compute with set views.
+     * Set views provide views on set variable implementations,
+     * set constants, and integer variable implementations.
+     * \ingroup TaskActorSet
+     */
+
+    /**
+     * \brief %Set view for set variables
+     * \ingroup TaskActorSetView
+     */
+
+    class SetView : public VariableViewBase<SetVarImp> {
+    protected:
+      using VariableViewBase<SetVarImp>::var;
+    public:
+      /// \name Constructors and initialization
+      //@{
+      /// Default constructor
+      SetView(void);
+      /// Initialize from set variable \a x
+      SetView(const SetVar& x);
+      //@}
+
+      /// \name Value access
+      //@{
+
+      /// Return minimum cardinality
+      unsigned int cardMin(void) const;
+      /// Return maximum cardinality
+      unsigned int cardMax(void) const;
+      /// Return minimum of the least upper bound
+      int lubMin(void) const;
+      /// Return maximum of the least upper bound
+      int lubMax(void) const;
+      /// Return n-th smallest element of the least upper bound
+      int lubMinN(int n) const;
+      /// Return the n-th largest element of the least upper bound
+      int lubMaxN(int n) const;
+      /// Return minimum of the greatest lower bound
+      int glbMin(void) const;
+      /// Return maximum of the greatest lower bound
+      int glbMax(void) const;
+
+      /// Return the number of elements in the greatest lower bound
+      unsigned int glbSize(void) const;
+      /// Return the number of elements in the least upper bound
+      unsigned int lubSize(void) const;
+      /// Return the number of unknown elements
+      unsigned int unknownSize(void) const;
+      //@}
+
+      /// \name Domain tests
+      //@{
+      /// Test whether view is assigned
+      bool assigned(void) const;
+      /// Test whether \a i is in the greatest lower bound
+      bool contains(int i) const;
+      /// Test whether \a i is not in the least upper bound
+      bool notContains(int i) const;
+      //@}
+
+
+      /// \name Domain update by value
+      //@{
+      /// Restrict cardinality to be greater than or equal to \a m
+      ModEvent cardMin(Space* home, unsigned int m);
+      /// Restrict cardinality to be less than or equal to \a m
+      ModEvent cardMax(Space* home, unsigned int m);
+      /**
+       * \brief Update greatest lower bound to include all elements
+       * between and including \a i and \a j
+       */
+      ModEvent include(Space* home,int i,int j);
+      /**
+       * \brief Restrict least upper bound to not contain all elements
+       * between and including \a i and \a j
+       */
+      ModEvent exclude(Space* home,int i,int j);
+      /// Update greatest lower bound to contain \a i
+      ModEvent include(Space* home,int i);
+      /// Restrict least upper bound to not contain \a i
+      ModEvent exclude(Space* home,int i);
+      /**
+       * \brief Update least upper bound to contain at most all elements
+       * between and including \a i and \a j
+       */
+      ModEvent intersect(Space* home,int i,int j);
+      /// Update least upper bound to contain at most the element \a i
+      ModEvent intersect(Space* home,int i);
+      //@}
+
+      /// \name Domain update by range iterator
+      //@{
+
+      /// Remove range sequence described by \a i from least upper bound
+      template <class I> ModEvent excludeI(Space* home, I& i);
+      /// Include range sequence described by \a i in greatest lower bound
+      template <class I> ModEvent includeI(Space* home, I& i);
+      /// Intersect least upper bound with range sequence described by \a i
+      template <class I> ModEvent intersectI(Space* home, I& iter);
+      //@}
+
+      /// \name Cloning
+      //@{
+      /// Update this view to be a clone of view \a x
+      void update(Space* home, bool share, SetView& x);
+      //@}
+    };
+
+  }
+
+  /**
+   * \brief Traits class for views and variable implementations
+   *
+   * This class specializes the ViewVarTraits for SetView.
+   * \ingroup TaskActorSetView
+   */
+  template<>
+  class ViewVarTraits<Set::SetView> {
+  public:
+    /// The variable type of a SetView
+    typedef Set::SetVarImp Var;
+  };
+
+  // Forward declarations for friends
+  namespace Set { class ConstantView;  }
+  bool same(const Set::ConstantView&, const Set::ConstantView&);
+  bool before(const Set::ConstantView&, const Set::ConstantView&);
+
+  namespace Set {
+    
+    /**
+     * \brief Constant view
+     *
+     * A constant set view \f$x\f$ for a set \f$s\f$ provides operations such
+     * that \f$x\f$ behaves like \f$s\f$.
+     * \ingroup TaskActorSetView
+     */
+    class ConstantView : public ConstantViewBase {
+      friend class LubRanges<ConstantView>;
+      friend class GlbRanges<ConstantView>;
+      friend bool Gecode::same(const Gecode::Set::ConstantView&, 
+			       const Gecode::Set::ConstantView&);
+      friend bool Gecode::before(const Gecode::Set::ConstantView&, 
+				 const Gecode::Set::ConstantView&);
+    private:
+      int *ranges;
+      unsigned int size;
+      unsigned int domSize;
+    public:
+      /// \name Constructors and initialization
+      //@{
+      /// Default constructor
+      ConstantView(void);
+      /// Construct with \a s as the domain
+      ConstantView(Space* home, const IntSet& s);
+      //@}
+
+      /// \name Value access
+      //@{
+      /// Return minimum cardinality
+      unsigned int cardMin(void) const;
+      /// Return maximum cardinality
+      unsigned int cardMax(void) const;
+      /// Return minimum of the least upper bound
+      int lubMin(void) const;
+      /// Return maximum of the least upper bound
+      int lubMax(void) const;
+      /// Return n-th smallest element of the least upper bound
+      int lubMinN(int n) const;
+      /// Return the n-th largest element of the least upper bound
+      int lubMaxN(int n) const;
+      /// Return minimum of the greatest lower bound
+      int glbMin(void) const;
+      /// Return maximum of the greatest lower bound
+      int glbMax(void) const;
+
+      /// Return the number of elements in the greatest lower bound
+      unsigned int glbSize(void) const;
+      /// Return the number of elements in the least upper bound
+      unsigned int lubSize(void) const;
+      /// Return the number of unknown elements
+      unsigned int unknownSize(void) const;
+      //@}
+
+      /// \name Domain tests
+      //@{
+      /// Test whether view is assigned
+      bool assigned(void) const;
+      /// Test whether \a i is in the greatest lower bound
+      bool contains(int i) const;
+      /// Test whether \a i is not in the least upper bound
+      bool notContains(int i) const;
+      //@}
+
+
+      /// \name Domain update by value
+      //@{
+      /// Restrict cardinality to be greater than or equal to \a m
+      ModEvent cardMin(Space* home, unsigned int m);
+      /// Restrict cardinality to be less than or equal to \a m
+      ModEvent cardMax(Space* home, unsigned int m);
+      /**
+       * \brief Update greatest lower bound to include all elements
+       * between and including \a i and \a j
+       */
+      ModEvent include(Space* home,int i,int j);
+      /**
+       * \brief Restrict least upper bound to not contain all elements
+       * between and including \a i and \a j
+       */
+      ModEvent exclude(Space* home,int i,int j);
+      /// Update greatest lower bound to contain \a i
+      ModEvent include(Space* home,int i);
+      /// Restrict least upper bound to not contain \a i
+      ModEvent exclude(Space* home,int i);
+      /**
+       * \brief Update least upper bound to contain at most all elements
+       * between and including \a i and \a j
+       */
+      ModEvent intersect(Space* home,int i,int j);
+      /// Update least upper bound to contain at most the element \a i
+      ModEvent intersect(Space* home,int i);
+      //@}
+
+      /// \name Domain update by range iterator
+      //@{
+
+      /// Remove range sequence described by \a i from least upper bound
+      template <class I> ModEvent excludeI(Space* home, I& i);
+      /// Include range sequence described by \a i in greatest lower bound
+      template <class I> ModEvent includeI(Space* home, I& i);
+      /// Intersect least upper bound with range sequence described by \a i
+      template <class I> ModEvent intersectI(Space* home, I& iter);
+      //@}
+
+      /// \name Propagator modification events
+      //@{
+      /// Return modification event of propagator \a p for view
+      static ModEvent     pme(const Propagator* p);
+      /// Translate modification event \a me to propagator modification event for view
+      static PropModEvent pme(ModEvent);
+      //@}
+
+      /// \name Dependencies
+      //@{
+      /**
+       * \brief Subscribe propagator \a p with propagation condition \a pc to variable
+       *
+       * In case \a process is false, the propagator is just subscribed but
+       * not processed for execution (this must be used when creating
+       * subscriptions during propagation).
+       */
+      void subscribe(Space* home, Propagator* p, PropCond pc, bool process=true);
+      /// Cancel subscription of propagator \a p with propagation condition \a pc to view
+      void cancel(Space* home, Propagator* p, PropCond pc);
+      //@}
+
+      /// \name Cloning
+      //@{
+      /// Update this view to be a clone of view \a x
+      void update(Space* home, bool share, ConstantView& x);
+      //@}
+    };
+
+  }
+
+  /** \name View comparison
+   *  \relates Gecode::Set::ConstantView
+   */
+  //@{
+  /// Test whether views \a x and \a y are the same
+  bool same(const Set::ConstantView& x, const Set::ConstantView& y);
+  /// Test whether view \a x comes before \a y (arbitrary order)
+  bool before(const Set::ConstantView& x, const Set::ConstantView& y);
+  //@}
+
+  /**
+   * \brief Traits class for views and variable implementations
+   *
+   * This class specializes the ViewVarTraits for ConstantView.
+   * \ingroup TaskActorSetView
+   */
+  template<>
+  class ViewVarTraits<Set::ConstantView> {
+  public:
+    /// The variable type of a ConstantView
+    typedef VarBase Var;
+  };
+
+  namespace Set {
+
+    /**
+     * \brief Constant view for the empty set
+     *
+     * A constant set view \f$x\f$ for the empty set provides operations such
+     * that \f$x\f$ behaves like the empty set.
+     * \ingroup TaskActorSetView
+     */
+
+    class EmptyView : public ConstantViewBase {
+    public:
+      /// \name Constructors and initialization
+      //@{
+      /// Default constructor
+      EmptyView(void);
+      //@}
+
+      /// \name Value access
+      //@{
+
+      /// Return minimum cardinality
+      unsigned int cardMin(void) const;
+      /// Return maximum cardinality
+      unsigned int cardMax(void) const;
+      /// Return minimum of the least upper bound
+      int lubMin(void) const;
+      /// Return maximum of the least upper bound
+      int lubMax(void) const;
+      /// Return n-th smallest element of the least upper bound
+      int lubMinN(int n) const;
+      /// Return the n-th largest element of the least upper bound
+      int lubMaxN(int n) const;
+      /// Return minimum of the greatest lower bound
+      int glbMin(void) const;
+      /// Return maximum of the greatest lower bound
+      int glbMax(void) const;
+
+      /// Return the number of elements in the greatest lower bound
+      unsigned int glbSize(void) const;
+      /// Return the number of elements in the least upper bound
+      unsigned int lubSize(void) const;
+      /// Return the number of unknown elements
+      unsigned int unknownSize(void) const;
+      //@}
+
+      /// \name Domain tests
+      //@{
+      /// Test whether view is assigned
+      bool assigned(void) const;
+      /// Test whether \a i is in the greatest lower bound
+      bool contains(int i) const;
+      /// Test whether \a i is not in the least upper bound
+      bool notContains(int i) const;
+      //@}
+
+
+      /// \name Domain update by value
+      //@{
+      /// Restrict cardinality to be greater than or equal to \a m
+      ModEvent cardMin(Space* home, unsigned int m);
+      /// Restrict cardinality to be less than or equal to \a m
+      ModEvent cardMax(Space* home, unsigned int m);
+      /**
+       * \brief Update greatest lower bound to include all elements
+       * between and including \a i and \a j
+       */
+      ModEvent include(Space* home,int i,int j);
+      /**
+       * \brief Restrict least upper bound to not contain all elements
+       * between and including \a i and \a j
+       */
+      ModEvent exclude(Space* home,int i,int j);
+      /// Update greatest lower bound to contain \a i
+      ModEvent include(Space* home,int i);
+      /// Restrict least upper bound to not contain \a i
+      ModEvent exclude(Space* home,int i);
+      /**
+       * \brief Update least upper bound to contain at most all elements
+       * between and including \a i and \a j
+       */
+      ModEvent intersect(Space* home,int i,int j);
+      /// Update least upper bound to contain at most the element \a i
+      ModEvent intersect(Space* home,int i);
+      //@}
+
+      /// \name Domain update by range iterator
+      //@{
+
+      /// Remove range sequence described by \a i from least upper bound
+      template <class I> ModEvent excludeI(Space* home, I& i);
+      /// Include range sequence described by \a i in greatest lower bound
+      template <class I> ModEvent includeI(Space* home, I& i);
+      /// Intersect least upper bound with range sequence described by \a i
+      template <class I> ModEvent intersectI(Space* home, I& iter);
+      //@}
+
+      /// \name Propagator modification events
+      //@{
+      /// Return modification event of propagator \a p for view
+      static ModEvent     pme(const Propagator* p);
+      /// Translate modification event \a me to propagator modification event for view
+      static PropModEvent pme(ModEvent);
+      //@}
+
+      /// \name Dependencies
+      //@{
+      /**
+       * \brief Subscribe propagator \a p with propagation condition \a pc to variable
+       *
+       * In case \a process is false, the propagator is just subscribed but
+       * not processed for execution (this must be used when creating
+       * subscriptions during propagation).
+       */
+      void subscribe(Space* home, Propagator* p, PropCond pc, bool process=true);
+      /// Cancel subscription of propagator \a p with propagation condition \a pc to view
+      void cancel(Space* home, Propagator* p, PropCond pc);
+      //@}
+
+      /// \name Cloning
+      //@{
+      /// Update this view to be a clone of view \a x
+      void update(Space* home, bool share, EmptyView& x);
+      //@}
+    };
+
+  }
+
+  /** \name View comparison
+   *  \relates Gecode::Set::EmptyView
+   */
+  //@{
+  /// Test whether views \a x and \a y are the same
+  bool same(const Set::EmptyView& x, const Set::EmptyView& y);
+  /// Test whether view \a x comes before \a y (arbitrary order)
+  bool before(const Set::EmptyView& x, const Set::EmptyView& y);
+  //@}
+
+  /**
+   * \brief Traits class for views and variable implementations
+   *
+   * This class specializes the ViewVarTraits for EmptyView.
+   * \ingroup TaskActorSetView
+   */
+  template<>
+  class ViewVarTraits<Set::EmptyView> {
+  public:
+    /// The variable type of an EmptyView
+    typedef VarBase Var;
+  };
+
+  namespace Set {
+
+
+    /**
+     * \brief Constant view for the universe
+     *
+     * A constant set view \f$x\f$ for the universe provides operations such
+     * that \f$x\f$ behaves like the universe.
+     * \ingroup TaskActorSetView
+     */
+
+    class UniverseView : public ConstantViewBase {
+    public:
+      /// \name Constructors and initialization
+      //@{
+      /// Default constructor
+      UniverseView(void);
+      //@}
+
+      /// \name Value access
+      //@{
+
+      /// Return minimum cardinality
+      unsigned int cardMin(void) const;
+      /// Return maximum cardinality
+      unsigned int cardMax(void) const;
+      /// Return minimum of the least upper bound
+      int lubMin(void) const;
+      /// Return maximum of the least upper bound
+      int lubMax(void) const;
+      /// Return n-th smallest element of the least upper bound
+      int lubMinN(int n) const;
+      /// Return the n-th largest element of the least upper bound
+      int lubMaxN(int n) const;
+      /// Return minimum of the greatest lower bound
+      int glbMin(void) const;
+      /// Return maximum of the greatest lower bound
+      int glbMax(void) const;
+
+      /// Return the number of elements in the greatest lower bound
+      unsigned int glbSize(void) const;
+      /// Return the number of elements in the least upper bound
+      unsigned int lubSize(void) const;
+      /// Return the number of unknown elements
+      unsigned int unknownSize(void) const;
+      //@}
+
+      /// \name Domain tests
+      //@{
+      /// Test whether view is assigned
+      bool assigned(void) const;
+      /// Test whether \a i is in the greatest lower bound
+      bool contains(int i) const;
+      /// Test whether \a i is not in the least upper bound
+      bool notContains(int i) const;
+      //@}
+
+
+      /// \name Domain update by value
+      //@{
+      /// Restrict cardinality to be greater than or equal to \a m
+      ModEvent cardMin(Space* home, unsigned int m);
+      /// Restrict cardinality to be less than or equal to \a m
+      ModEvent cardMax(Space* home, unsigned int m);
+      /**
+       * \brief Update greatest lower bound to include all elements
+       * between and including \a i and \a j
+       */
+      ModEvent include(Space* home,int i,int j);
+      /**
+       * \brief Restrict least upper bound to not contain all elements
+       * between and including \a i and \a j
+       */
+      ModEvent exclude(Space* home,int i,int j);
+      /// Update greatest lower bound to contain \a i
+      ModEvent include(Space* home,int i);
+      /// Restrict least upper bound to not contain \a i
+      ModEvent exclude(Space* home,int i);
+      /**
+       * \brief Update least upper bound to contain at most all elements
+       * between and including \a i and \a j
+       */
+      ModEvent intersect(Space* home,int i,int j);
+      /// Update least upper bound to contain at most the element \a i
+      ModEvent intersect(Space* home,int i);
+      //@}
+
+      /// \name Domain update by range iterator
+      //@{
+
+      /// Remove range sequence described by \a i from least upper bound
+      template <class I> ModEvent excludeI(Space* home, I& i);
+      /// Include range sequence described by \a i in greatest lower bound
+      template <class I> ModEvent includeI(Space* home, I& i);
+      /// Intersect least upper bound with range sequence described by \a i
+      template <class I> ModEvent intersectI(Space* home, I& iter);
+      //@}
+
+      /// \name Propagator modification events
+      //@{
+      /// Return modification event of propagator \a p for view
+      static ModEvent     pme(const Propagator* p);
+      /// Translate modification event \a me to propagator modification event for view
+      static PropModEvent pme(ModEvent);
+      //@}
+
+      /// \name Dependencies
+      //@{
+      /**
+       * \brief Subscribe propagator \a p with propagation condition \a pc to variable
+       *
+       * In case \a process is false, the propagator is just subscribed but
+       * not processed for execution (this must be used when creating
+       * subscriptions during propagation).
+       */
+      void subscribe(Space* home, Propagator* p, PropCond pc, bool process=true);
+      /// Cancel subscription of propagator \a p with propagation condition \a pc to view
+      void cancel(Space* home, Propagator* p, PropCond pc);
+      //@}
+
+      /// \name Cloning
+      //@{
+      /// Update this view to be a clone of view \a x
+      void update(Space* home, bool share, UniverseView& x);
+      //@}
+    };
+
+  }
+
+  /** \name View comparison
+   *  \relates Gecode::Set::UniverseView
+   */
+  //@{
+  /// Test whether views \a x and \a y are the same
+  bool same(const Set::UniverseView& x, const Set::UniverseView& y);
+  /// Test whether view \a x comes before \a y (arbitrary order)
+  bool before(const Set::UniverseView& x, const Set::UniverseView& y);
+  //@}
+
+  /**
+   * \brief Traits class for views and variable implementations
+   *
+   * This class specializes the ViewVarTraits for UniverseView.
+   * \ingroup TaskActorSetView
+   */
+  template<>
+  class ViewVarTraits<Set::UniverseView> {
+  public:
+    /// The variable type of a UniverseView
+    typedef VarBase Var;
+  };
+
+  namespace Set {
+
+
+
+    /**
+     * \brief Singleton set view
+     *
+     * A singleton set view \f$s\f$ for an integer view \f$x\f$ provides
+     * operations such that \f$s\f$ behaves like the singleton set \f$\{x\}\f$.
+     * \ingroup TaskActorSetView
+     */
+
+    class SingletonView :
+      public DerivedViewBase<Gecode::Int::IntView> {
+    protected:
+      using DerivedViewBase<Gecode::Int::IntView>::view;;
+
+      /// Convert set variable PropCond \a pc to a PropCond for integer variables
+      static PropCond pc_settoint(PropCond pc);
+      /// Convert integer variable ModEvent \a me to a ModEvent for set variables
+      static ModEvent me_inttoset(ModEvent me);
+
+    public:
+      /// \name Constructors and initialization
+      //@{
+      /// Default constructor
+      SingletonView(void);
+      /// Initialize with integer view \a x
+      SingletonView(Gecode::Int::IntView& x);
+      //@}
+
+      /// \name Value access
+      //@{
+
+      /// Return minimum cardinality
+      unsigned int cardMin(void) const;
+      /// Return maximum cardinality
+      unsigned int cardMax(void) const;
+      /// Return minimum of the least upper bound
+      int lubMin(void) const;
+      /// Return maximum of the least upper bound
+      int lubMax(void) const;
+      /// Return n-th smallest element of the least upper bound
+      int lubMinN(int n) const;
+      /// Return the n-th largest element of the least upper bound
+      int lubMaxN(int n) const;
+      /// Return minimum of the greatest lower bound
+      int glbMin(void) const;
+      /// Return maximum of the greatest lower bound
+      int glbMax(void) const;
+
+      /// Return the number of elements in the greatest lower bound
+      unsigned int glbSize(void) const;
+      /// Return the number of elements in the least upper bound
+      unsigned int lubSize(void) const;
+      /// Return the number of unknown elements
+      unsigned int unknownSize(void) const;
+      //@}
+
+      /// \name Domain tests
+      //@{
+      /// Test whether view is assigned
+      bool assigned(void) const;
+      /// Test whether \a i is in the greatest lower bound
+      bool contains(int i) const;
+      /// Test whether \a i is not in the least upper bound
+      bool notContains(int i) const;
+      //@}
+
+
+      /// \name Domain update by value
+      //@{
+      /// Restrict cardinality to be greater than or equal to \a m
+      ModEvent cardMin(Space* home, unsigned int m);
+      /// Restrict cardinality to be less than or equal to \a m
+      ModEvent cardMax(Space* home, unsigned int m);
+      /**
+       * \brief Update greatest lower bound to include all elements
+       * between and including \a i and \a j
+       */
+      ModEvent include(Space* home,int i,int j);
+      /**
+       * \brief Restrict least upper bound to not contain all elements
+       * between and including \a i and \a j
+       */
+      ModEvent exclude(Space* home,int i,int j);
+      /// Update greatest lower bound to contain \a i
+      ModEvent include(Space* home,int i);
+      /// Restrict least upper bound to not contain \a i
+      ModEvent exclude(Space* home,int i);
+      /**
+       * \brief Update least upper bound to contain at most all elements
+       * between and including \a i and \a j
+       */
+      ModEvent intersect(Space* home,int i,int j);
+      /// Update least upper bound to contain at most the element \a i
+      ModEvent intersect(Space* home,int i);
+      //@}
+
+      /// \name Domain update by range iterator
+      //@{
+
+      /// Remove range sequence described by \a i from least upper bound
+      template <class I> ModEvent excludeI(Space* home, I& i);
+      /// Include range sequence described by \a i in greatest lower bound
+      template <class I> ModEvent includeI(Space* home, I& i);
+      /// Intersect least upper bound with range sequence described by \a i
+      template <class I> ModEvent intersectI(Space* home, I& iter);
+      //@}
+
+      /// \name Propagator modification events
+      //@{
+      /// Return modification event of propagator \a p for view
+      static ModEvent     pme(const Propagator* p);
+      /// Translate modification event \a me to propagator modification event for view
+      static PropModEvent pme(ModEvent);
+      //@}
+
+      /// \name Dependencies
+      //@{
+      /**
+       * \brief Subscribe propagator \a p with propagation condition \a pc to variable
+       *
+       * In case \a process is false, the propagator is just subscribed but
+       * not processed for execution (this must be used when creating
+       * subscriptions during propagation).
+       */
+      void subscribe(Space* home, Propagator* p, PropCond pc, bool process=true);
+      /// Cancel subscription of propagator \a p with propagation condition \a pc to view
+      void cancel(Space* home, Propagator* p, PropCond pc);
+      //@}
+
+
+      /// \name Cloning
+      //@{
+      /// Update this view to be a clone of view \a x
+      void update(Space* home, bool share, SingletonView& x);
+      //@}
+    };
+
+  }
+
+  /** \name View comparison
+   *  \relates Gecode::Set::SingletonView
+   */
+  //@{
+  /// Test whether views \a x and \a y are the same
+  bool same(const Set::SingletonView& x, const Set::SingletonView& y);
+  /// Test whether view \a x comes before \a y (arbitrary order)
+  bool before(const Set::SingletonView& x, const Set::SingletonView& y);
+  //@}
+
+  /**
+   * \brief Traits class for views and variable implementations
+   *
+   * This class specializes the ViewVarTraits for SingletonView.
+   * \ingroup TaskActorSetView
+   */
+  template<>
+  class ViewVarTraits<Set::SingletonView> {
+  public:
+    /// The variable type of a SingletonView
+    typedef Int::IntVarImp Var;
+  };
+
+  namespace Set {
+
+
+    /**
+     * \brief Complement set view
+     *
+     * A complement set view \f$s\f$ for a set view \f$t\f$ provides
+     * operations such that \f$s\f$ behaves like the complement of \f$\{t\}\f$.
+     * The complement is defined in terms of the set universe.
+     * \ingroup TaskActorSetView
+     */
+
+    template <class View>
+    class ComplementView 
+      : public DerivedViewBase<View> {
+    protected:
+      using DerivedViewBase<View>::view;
+
+    public:
+      /// Negate the propagation condition \a pc
+      static PropCond pc_negateset(PropCond pc);
+      /// Negate the modification event \a me
+      static ModEvent me_negateset(ModEvent me);
+
+      /// \name Constructors and initialization
+      //@{
+      /// Default constructor
+      ComplementView(void);
+      /// Initialize with set view x
+      ComplementView(View& x);
+      //@}
+
+      /// \name Value access
+      //@{
+
+      /// Return minimum cardinality
+      unsigned int cardMin(void) const;
+      /// Return maximum cardinality
+      unsigned int cardMax(void) const;
+      /// Return minimum of the least upper bound
+      int lubMin(void) const;
+      /// Return maximum of the least upper bound
+      int lubMax(void) const;
+      /// Return n-th smallest element of the least upper bound
+      int lubMinN(int n) const;
+      /// Return the n-th largest element of the least upper bound
+      int lubMaxN(int n) const;
+      /// Return minimum of the greatest lower bound
+      int glbMin(void) const;
+      /// Return maximum of the greatest lower bound
+      int glbMax(void) const;
+
+      /// Return the number of elements in the greatest lower bound
+      unsigned int glbSize(void) const;
+      /// Return the number of elements in the least upper bound
+      unsigned int lubSize(void) const;
+      /// Return the number of unknown elements
+      unsigned int unknownSize(void) const;
+      //@}
+
+      /// \name Domain tests
+      //@{
+      /// Test whether view is assigned
+      bool assigned(void) const;
+      /// Test whether \a i is in the greatest lower bound
+      bool contains(int i) const;
+      /// Test whether \a i is not in the least upper bound
+      bool notContains(int i) const;
+      //@}
+
+
+      /// \name Domain update by value
+      //@{
+      /// Restrict cardinality to be greater than or equal to \a m
+      ModEvent cardMin(Space* home, unsigned int m);
+      /// Restrict cardinality to be less than or equal to \a m
+      ModEvent cardMax(Space* home, unsigned int m);
+      /**
+       * \brief Update greatest lower bound to include all elements
+       * between and including \a i and \a j
+       */
+      ModEvent include(Space* home,int i,int j);
+      /**
+       * \brief Restrict least upper bound to not contain all elements
+       * between and including \a i and \a j
+       */
+      ModEvent exclude(Space* home,int i,int j);
+      /// Update greatest lower bound to contain \a i
+      ModEvent include(Space* home,int i);
+      /// Restrict least upper bound to not contain \a i
+      ModEvent exclude(Space* home,int i);
+      /**
+       * \brief Update least upper bound to contain at most all elements
+       * between and including \a i and \a j
+       */
+      ModEvent intersect(Space* home,int i,int j);
+      /// Update least upper bound to contain at most the element \a i
+      ModEvent intersect(Space* home,int i);
+      //@}
+
+      /// \name Domain update by range iterator
+      //@{
+
+      /// Remove range sequence described by \a i from least upper bound
+      template <class I> ModEvent excludeI(Space* home, I& i);
+      /// Include range sequence described by \a i in greatest lower bound
+      template <class I> ModEvent includeI(Space* home, I& i);
+      /// Intersect least upper bound with range sequence described by \a i
+      template <class I> ModEvent intersectI(Space* home, I& iter);
+      //@}
+
+      /// \name Propagator modification events
+      //@{
+      /// Return modification event of propagator \a p for view
+      static ModEvent     pme(const Propagator* p);
+      /// Translate modification event \a me to propagator modification event for view
+      static PropModEvent pme(ModEvent);
+      //@}
+
+      /// \name Dependencies
+      //@{
+      /**
+       * \brief Subscribe propagator \a p with propagation condition \a pc to variable
+       *
+       * In case \a process is false, the propagator is just subscribed but
+       * not processed for execution (this must be used when creating
+       * subscriptions during propagation).
+       */
+      void subscribe(Space* home, Propagator* p, PropCond pc, bool process=true);
+      /// Cancel subscription of propagator \a p with propagation condition \a pc to view
+      void cancel(Space* home, Propagator* p, PropCond pc);
+      //@}
+
+
+      /// \name Cloning
+      //@{
+      /// Update this view to be a clone of view \a x
+      void update(Space* home, bool share, ComplementView& x);
+      //@}
+    };
+
+  }
+
+  /** \name View comparison
+   *  \relates Gecode::Set::ComplementView
+   */
+  //@{
+  /// Test whether views \a x and \a y are the same
+  template <class View>
+  bool same(const Set::ComplementView<View>& x, 
+	    const Set::ComplementView<View>& y);
+  /// Test whether view \a x comes before \a y (arbitrary order)
+  template <class View>
+  bool before(const Set::ComplementView<View>& x, 
+	      const Set::ComplementView<View>& y);
+  //@}
+
+
+  /**
+   * \brief Traits class for views and variable implementations
+   *
+   * This class specializes the ViewVarTraits for ComplementView.
+   * \ingroup TaskActorSetView
+   */
+  template <class View>
+  class ViewVarTraits<Set::ComplementView<View> > {
+  public:
+    /// The variable type of a ComplementView
+    typedef typename ViewVarTraits<View>::Var Var;
+  };
+
+  namespace Set {
+
+    /**
+     * \brief Complement set view specialized for complement set views
+     *
+     * A complement set view \f$s\f$ for a complement set view for a set
+     * view \f$t\f$ provides operations such that \f$s\f$ behaves like
+     * \f$\{t\}\f$. This eliminates double negation.
+     * \ingroup TaskActorSetView
+     */
+    template <class View>
+    class ComplementView<ComplementView<View> > : public View {
+    public:
+      /// \name Constructors and initialization
+      //@{
+      /// Default constructor
+      ComplementView(void);
+      /// Initialize with set view x
+      ComplementView(ComplementView<View>& x);
+      //@}
+    };
+
+  }
+
+  /** \name View comparison
+   *  \relates Gecode::Set::ComplementView
+   */
+  //@{
+  /// Test whether views \a x and \a y are the same
+  template <class View>
+  bool same(const Set::ComplementView<Set::ComplementView<View> >& x, 
+	    const Set::ComplementView<Set::ComplementView<View> >& y);
+  /// Test whether view \a x comes before \a y (arbitrary order)
+  template <class View>
+  bool before(const Set::ComplementView<Set::ComplementView<View> >& x, 
+	      const Set::ComplementView<Set::ComplementView<View> >& y);
+  //@}
+
+
+  /**
+   * \brief Traits class for views and variable implementations
+   *
+   * This class specializes the ViewVarTraits for double-negated
+   * ComplementView.
+   * \ingroup TaskActorSetView
+   */
+  template <class View>
+  class ViewVarTraits<Set::ComplementView<Set::ComplementView<View> > > {
+  public:
+    /// The variable type of a ComplementView
+    typedef typename ViewVarTraits<View>::Var Var;
+  };
+
+}
+
+#include "gecode/set/view/set.icc"
+#include "gecode/set/view/const.icc"
+#include "gecode/set/view/singleton.icc"
+#include "gecode/set/view/complement.icc"
+
+/**
+ * \brief Print set variable view
+ * \relates Gecode::Set::SetView
+ */
+GECODE_SET_EXPORT std::ostream&
+operator<<(std::ostream&, const Gecode::Set::SetView&);
+
+
+/**
+ * \brief Print empty set view
+ * \relates Gecode::Set::EmptyView
+ */
+GECODE_SET_EXPORT std::ostream&
+operator<<(std::ostream&, const Gecode::Set::EmptyView&);
+
+/**
+ * \brief Print universe set view
+ * \relates Gecode::Set::UniverseView
+ */
+GECODE_SET_EXPORT std::ostream&
+operator<<(std::ostream&, const Gecode::Set::UniverseView&);
+
+/**
+ * \brief Print set constant view
+ * \relates Gecode::Set::ConstantView
+ */
+GECODE_SET_EXPORT std::ostream&
+operator<<(std::ostream&, const Gecode::Set::ConstantView&);
+
+/**
+ * \brief Print singelton set view
+ * \relates Gecode::Set::SingletonView
+ */
+GECODE_SET_EXPORT std::ostream&
+operator<<(std::ostream&, const Gecode::Set::SingletonView&);
+
+/**
+ * \brief Print set complement view
+ * \relates Gecode::Set::ComplementView
+ */
+template <class View>
+std::ostream&
+operator<<(std::ostream&, const Gecode::Set::ComplementView<View>&);
+
+inline std::ostream&
+operator<<(std::ostream& os, const Gecode::SetVar& x) {
+  Gecode::Set::SetView vx(x);
+  return os << vx;
+}
+
+// STATISTICS: set-var