gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/set/var-imp.vis

@@ -0,0 +1,205 @@
+#
+#  Main authors:
+#     Guido Tack <tack@gecode.org>
+#
+#  Contributing authors:
+#     Christian Schulte <schulte@gecode.org>
+#
+#  Copyright:
+#     Guido Tack, 2004
+#     Christian Schulte, 2006
+#
+#  Last modified:
+#     $Date: 2006-07-28 16:27:48 +0200 (Fri, 28 Jul 2006) $ by $Author: tack $
+#     $Revision: 3477 $
+#
+#  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.
+#
+
+#
+# Header of file to be generated
+#
+[Header]
+
+namespace Gecode { namespace Set {
+
+#
+# General settings
+#
+[General]
+Name:		Set
+VTI:		SET
+Export:		GECODE_SET_EXPORT
+Forceinline:	forceinline
+
+#
+# Definition of modification events
+#
+[ModEventHeader]
+  /**
+   * \defgroup TaskActorSetMEPC Set modification events and propagation conditions
+   * \ingroup TaskActorSet
+   */
+
+  //@{
+[ModEvent]
+Name:		FAILED=FAILED
+  /// Domain operation has resulted in failure
+[ModEvent]
+Name:		NONE=NONE
+  /// Domain operation has not changed domain
+[ModEvent]
+Name:		VAL=ASSIGNED
+Combine:	VAL=VAL,CARD=VAL,LUB=VAL,GLB=VAL,BB=VAL,CLUB=VAL,CGLB=VAL,CBB=VAL
+  /// Domain operation has resulted in a value (assigned variable)
+[ModEvent]
+Name:		CARD
+Combine:	VAL=VAL,CARD=CARD,LUB=CLUB,GLB=CGLB,BB=CBB,CLUB=CLUB,CGLB=CGLB,CBB=CBB
+  /**
+   * \brief Domain operation has changed the variable cardinality
+   *
+   * Note that this implies that the domain has not resulted in a value.
+   */
+[ModEvent]
+Name:		LUB
+Combine:	VAL=VAL,CARD=CLUB,LUB=LUB,GLB=BB,BB=BB,CLUB=CLUB,CGLB=CGLB,CBB=CBB
+  /**
+   * \brief Domain operation has changed the least upper bound
+   *
+   * Note that this implies that the domain has not resulted in a value
+   * and that also neither cardinality nor the greatest lower bound
+   * have changed.
+   */
+[ModEvent]
+Name:		GLB
+Combine:	VAL=VAL,CARD=CGLB,LUB=BB,GLB=GLB,BB=BB,CLUB=CBB,CGLB=CGLB,CBB=CBB
+  /**
+   * \brief Domain operation has changed the greatest lower bound
+   *
+   * Note that this implies that the domain has not resulted in a value
+   * and that also neither cardinality nor the least upper bound
+   * have changed.
+   */
+[ModEvent]
+Name:		BB
+Combine:	VAL=VAL,CARD=CBB,LUB=BB,GLB=BB,BB=BB,CLUB=CBB,CGLB=CBB,CBB=CBB
+  /**
+   * \brief Domain operation has changed both greatest lower and least
+   * upper bound
+   *
+   * Note that this implies that the domain has not resulted in a value
+   * and that also the cardinality has not changed.
+   */
+[ModEvent]
+Name:		CLUB
+Combine:	VAL=VAL,CARD=CLUB,LUB=CLUB,GLB=CBB,BB=CBB,CLUB=CLUB,CGLB=CBB,CBB=CBB
+  /**
+   * \brief Domain operation has changed the least upper bound and the cardinality
+   *
+   * Note that this implies that the domain has not resulted in a value
+   * and that also the greatest lower bound has not changed.
+   */
+[ModEvent]
+Name:		CGLB
+Combine:	VAL=VAL,CARD=CGLB,LUB=CBB,GLB=CGLB,BB=CBB,CLUB=CBB,CGLB=CGLB,CBB=CBB
+  /**
+   * \brief Domain operation has changed the greatest lower bound and the cardinality
+   *
+   * Note that this implies that the domain has not resulted in a value
+   * and that also the least upper bound has not changed.
+   */
+[ModEvent]
+Name:		CBB=SUBSCRIBE
+Combine:	VAL=VAL,CARD=CBB,LUB=CBB,GLB=CBB,BB=CBB,CLUB=CBB,CGLB=CBB,CBB=CBB
+  /**
+   * \brief Domain operation has changed both the greatest lower bound and
+   * the least upper bound, as well as the cardinality
+   *
+   * Note that this implies that the domain has not resulted in a value.
+   *
+   * If a propagator subscribes to this variable, it will be processed
+   * assuming a ME_SET_CBB modification event.
+   *
+   */
+
+# [ModEventFooter]: Nothing
+##
+## Definition of propagation conditions
+##
+# [PropCondHeader]: Nothing
+[PropCond]
+Name:		VAL=ASSIGNED
+ModEvents:	VAL
+  /**
+   * \brief Propagate when a view becomes assigned (single value)
+   *
+   * If a propagator \a p depends on a view \a x with propagation
+   * condition PC_SET_VAL, then \a p is propagated when a domain
+   * update operation on \a x returns the modification event ME_SET_VAL.
+   */
+[PropCond]
+Name:		CARD
+ModEvents:	VAL,CARD,CGLB,CLUB,CBB
+  /**
+   * \brief Propagate when the cardinality of a view changes
+   *
+   * If a propagator \a p depends on a view \a x with propagation
+   * condition PC_SET_CARD, then \a p is propagated when a domain
+   * update operation on \a x returns the modification event ME_SET_VAL,
+   * ME_SET_CARD, ME_SET_CGLB, ME_SET_CLUB, or ME_SET_CBB.
+   */
+[PropCond]
+Name:		CLUB
+ModEvents:	VAL,CARD,LUB,BB,CLUB,CGLB,CBB
+  /**
+   * \brief Propagate when the cardinality or the least upper bound
+   * of a view changes
+   *
+   * If a propagator \a p depends on a view \a x with propagation
+   * condition PC_SET_CLUB, then \a p is propagated when a domain
+   * update operation on \a x returns the modification event ME_SET_VAL,
+   * ME_SET_LUB, ME_SET_BB, ME_SET_CARD, ME_SET_CGLB, ME_SET_CLUB,
+   * or ME_SET_CBB.
+   */
+[PropCond]
+Name:		CGLB
+ModEvents:	VAL,CARD,GLB,BB,CLUB,CGLB,CBB
+  /**
+   * \brief Propagate when the cardinality or the greatest lower bound
+   * of a view changes
+   *
+   * If a propagator \a p depends on a view \a x with propagation
+   * condition PC_SET_CGLB, then \a p is propagated when a domain
+   * update operation on \a x returns the modification event ME_SET_VAL,
+   * ME_SET_GLB, ME_SET_BB, ME_SET_CARD, ME_SET_CGLB, ME_SET_CLUB,
+   * or ME_SET_CBB.
+   */
+[PropCond]
+Name:		ANY
+ModEvents:	VAL,CARD,LUB,GLB,BB,CLUB,CGLB,CBB
+  /**
+   * \brief Propagate when any bound or the cardinality
+   * of a view changes
+   *
+   * If a propagator \a p depends on a view \a x with propagation
+   * condition PC_SET_ANY, then \a p is propagated when a domain
+   * update operation on \a x returns any modification event but ME_SET_FAILED
+   * and ME_SET_NONE.
+   */
+[PropCondFooter]
+  //@}
+##
+## Footer of file to be generated
+##
+[Footer]
+
+}}
+
+// STATISTICS: set-var
+[End]

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

@@ -0,0 +1,1090 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Contributing authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *     Gabor Szokoli, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-08-25 10:43:21 +0200 (Fri, 25 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3568 $
+ *
+ *  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/support/shared-array.hh"
+
+#include <iostream>
+
+#include "gecode/set/var/imp-hdr.icc"
+#include "gecode/iter.hh"
+
+namespace Gecode { namespace Set {
+
+  /**
+   * \brief Lists of ranges (intervals)
+   *
+   */
+  class RangeList : public FreeList {
+  protected:
+    /// Minimum of range
+    int        _min;
+    /// Maximum of range
+    int        _max;
+  public:
+    /// \name Constructors
+    //@{
+    /// Default constructor (noop)
+    RangeList(void);
+    /// Initialize with minimum \a min and maximum \a max and predecessor \a p and successor \a n
+    RangeList(int min, int max, RangeList* p, RangeList* n);
+    //@}
+
+    /// \name Access
+    //@{
+    /// Return minimum
+    int min(void) const;
+    /// Return maximum
+    int max(void) const;
+    /// Return width (distance between maximum and minimum)
+    unsigned int width(void) const;
+
+    /// Return next element (from previous \a p)
+    RangeList* next(const RangeList* p) const;
+    /// Return previous element (from next \a n)
+    RangeList* prev(const RangeList* n) const;
+    //@}
+
+    /// \name Update
+    //@{
+    /// Set minimum to \a n
+    void min(int n);
+    /// Set maximum to \a n
+    void max(int n);
+
+    /// Set previous element to \a p and next element to \a n
+    void prevnext(RangeList* p, RangeList* n);
+    /// Set next element from \a o to \a n
+    void next(RangeList* o, RangeList* n);
+    /// Set previous element from \a o to \a n
+    void prev(RangeList* o, RangeList* n);
+    /// Restore simple link to next element (so that it becomes a true free list)
+    void fix(RangeList* n);
+    //@}
+
+    /// \name Memory management
+    //@{
+    /**
+     * \brief Free memory for all elements between this and \a l (inclusive)
+     *
+     * \a p must be the pointer to the previous element of \c this.
+     */
+    void dispose(Space* home, RangeList* p, RangeList* l);
+    
+    /// Allocate memory from space
+    static void* operator new(size_t s, Space* home);
+    /// No-op (for exceptions)
+    static void  operator delete(void*);
+    /// No-op (use dispose instead)
+    static void  operator delete(void*, Space* home);
+    //@}
+  };
+
+
+  /**
+   * \brief Sets of integers
+   */
+  class BndSet  {
+  private:
+    RangeList* first;
+    RangeList* last;
+  protected:
+    /// The size of this set
+    unsigned int _size;
+    /// Set first range to \a r
+    void fst(RangeList* r);
+    /// Set last range to \a r
+    void lst(RangeList* r);
+
+    /// Return first range
+    RangeList* fst(void) const;
+    /// Return last range
+    RangeList* lst(void) const;
+
+  public:
+    /// Returned by empty sets when asked for their maximum element
+    static const int MAX_OF_EMPTY = Limits::Set::int_min-1;
+    /// Returned by empty sets when asked for their minimum element
+    static const int MIN_OF_EMPTY = Limits::Set::int_max+1;
+
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor. Creates an empty set.
+    BndSet(void);
+    /// Initialize as the set \f$ \{i,\dots,j\}\f$
+    BndSet(Space* home, int i, int j);
+    /// Initialize as the set represented by \a s
+    BndSet(Space* home, const IntSet& s);
+    //@}
+
+    /// \name Memory management
+    //@{
+    /// Free memory used by this set
+    void dispose(Space* home);
+    //@}
+
+    /// \name Value access
+    //@{
+    /// Return smallest element
+    int min(void) const;
+    /// Return greatest element
+    int max(void) const;
+    /// Return \a n -th smallest element
+    int minN(unsigned int n) const;
+    /// Return \a n -th greatest element
+    int maxN(unsigned int n) const;
+    /// Return size
+    unsigned int size(void) const;
+    //@}
+
+    /// \name Tests
+    //@{
+    /// Test whether this set is empty
+    bool empty(void) const;
+    /// Test whether \a i is an element of this set
+    bool in(int i) const;
+    //@}
+
+    /// \name Update operations
+    //@{
+    /// Make this set equal to \a s
+    void linkTo(Space* home, const BndSet& s);
+    //@}
+    
+    /// \name Range list access for iteration
+    //@{
+    /// Return range list for iteration
+    RangeList* ranges(void) const;
+    //@}
+
+  protected:
+    /// Overwrite the ranges with those represented by \a i
+    template <class I> bool overwrite(Space* home,I& i);
+
+  public:
+    /// \name Cloning
+    //@{
+    /// Update this set to be a clone of set \a x
+    void update(Space* home, BndSet& x);
+    //@}
+
+    /// Check whether internal invariants hold
+    GECODE_SET_EXPORT bool isConsistent(void) const;
+  };
+
+  /**
+   * \brief Range iterator for integer sets
+   *
+   */
+  class BndSetRanges {
+  private:
+    /// Previous range
+    const RangeList* p;
+    /// Current range
+    const RangeList* c;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    BndSetRanges(void);
+    /// Initialize with BndSet \a s
+    BndSetRanges(const BndSet& s);
+    /// Initialize with BndSet \a s
+    void init(const BndSet& s);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Test whether iterator is still at a range or done
+    bool operator()(void) const;
+    /// Move iterator to next range (if possible)
+    void operator++(void);
+    //@}
+
+    /// \name Range access
+    //@{
+    /// Return smallest value of range
+    int min(void) const;
+    /// Return largest value of range
+    int max(void) const;
+    /// Return width of range (distance between minimum and maximum)
+    unsigned int width(void) const;
+    //@}
+  };
+
+  /**
+   * \brief Growing sets of integers
+   *
+   * These sets provide operations for monotonically growing the set.
+   * Growing sets are used for implementing the greatest lower bound of
+   * set variables.
+   */
+  class GLBndSet : public BndSet {
+  private:
+    /// Include the set \f$\{i,\dots,j\}\f$ in this set
+    GECODE_SET_EXPORT bool include_full(Space* home,int,int);
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor. Creates an empty set.
+    GLBndSet(Space* =NULL);
+    /// Initialize as the set \f$ \{i,\dots,j\}\f$
+    GLBndSet(Space* home, int i, int j);
+    /// Initialize as the set represented by \a s
+    GLBndSet(Space* home, const IntSet& s);
+    /// Initialize as the empty set
+    void init(Space* home);
+    //@}
+
+    /// \name Update operations
+    //@{
+    /// Include the set \f$\{i,\dots,j\}\f$ in this set
+    bool include(Space* home,int i,int j);
+    /// Include the set represented by \a i in this set
+    template <class I> bool includeI(Space* home,I& i);
+    //@}
+  private:
+    GLBndSet(const GLBndSet&);
+    const GLBndSet& operator=(const GLBndSet&);
+  };
+
+  /**
+   * \brief Shrinking sets of integers
+   *
+   * These sets provide operations for monotonically shrinking the set.
+   * Shrinking sets are used for implementing the least upper bound of
+   * set variables.
+   */
+  class LUBndSet: public BndSet{
+  private:
+    GECODE_SET_EXPORT bool exclude_full(Space* home, int, int);
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor. Creates an empty set.
+    LUBndSet(void);
+    /// Initialize as the full set including everything between Limits::Set::int_min and Limits::Set::int_max
+    LUBndSet(Space* home);
+    /// Initialize as the set \f$ \{i,\dots,j\}\f$
+    LUBndSet(Space* home, int i, int j);
+    /// Initialize as the set represented by \a s
+    LUBndSet(Space* home, const IntSet& s);
+    /// Initialize as the full set including everything between Limits::Set::int_min and Limits::Set::int_max
+    void init(Space* home);
+    //@}
+
+    /// \name Update operations
+    //@{
+    /// Exclude the set \f$\{i,\dots,j\}\f$ from this set
+    bool exclude(Space* home, int i, int j);
+    /// Exclude all elements not in the set represented by \a i from this set
+    template <class I> bool intersectI(Space* home, I& i);
+    /// Exclude all elements in the set represented by \a i from this set
+    template <class I> bool excludeI(Space* home, I& i);
+    //@}
+  private:
+    LUBndSet(const LUBndSet&);
+    const LUBndSet& operator=(const LUBndSet&);
+  };
+
+  /*
+   * Iterators
+   *
+   */
+
+
+  /**
+   * \brief A complement iterator spezialized for the BndSet limits
+   *
+   * \ingroup TaskActorSet
+   */
+  template <class I>
+  class RangesCompl :
+    public Iter::Ranges::Compl<Limits::Set::int_min, Limits::Set::int_max, I> {
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    RangesCompl(void);
+    /// Initialize with iterator \a i
+    RangesCompl(I& i);
+    /// Initialize with iterator \a i
+    void init(I& i);
+    //@}
+  };
+
+  /**
+   * \brief Range iterator for the least upper bound
+   *
+   * This class provides (by specialization) a range iterator 
+   * for the least upper bounds of all set views.
+   *
+   * Note that this template class serves only as a specification
+   * of the interface of the various specializations.
+   *
+   * \ingroup TaskActorSet
+   */
+  template <class T> class LubRanges {
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    LubRanges(void);
+    /// Initialize with least upper bound ranges for set variable \a x
+    LubRanges(const T& x);
+    /// Initialize with least upper bound ranges for set variable \a x
+    void init(const T& x);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Test whether iterator is still at a range or done
+    bool operator()(void) const;
+    /// Move iterator to next range (if possible)
+    void operator++(void);
+    //@}
+
+    /// \name Range access
+    //@{
+    /// Return smallest value of range
+    int min(void) const;
+    /// Return largest value of range
+    int max(void) const;
+    /// Return width of range (distance between minimum and maximum)
+    unsigned int width(void) const;
+    //@}
+  };
+  
+  /**
+   * \brief Range iterator for the greatest lower bound
+   *
+   * This class provides (by specialization) a range iterator 
+   * for the greatest lower bounds of all set views.
+   *
+   * Note that this template class serves only as a specification
+   * of the interface of the various specializations.
+   *
+   * \ingroup TaskActorSet
+   */
+  template <class T> class GlbRanges {
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    GlbRanges(void);
+    /// Initialize with greatest lower bound ranges for set variable \a x
+    GlbRanges(const T& x);
+    /// Initialize with greatest lower bound ranges for set variable \a x
+    void init(const T& x);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Test whether iterator is still at a range or done
+    bool operator()(void) const;
+    /// Move iterator to next range (if possible)
+    void operator++(void);
+    //@}
+
+    /// \name Range access
+    //@{
+    /// Return smallest value of range
+    int min(void) const;
+    /// Return largest value of range
+    int max(void) const;
+    /// Return width of range (distance between minimum and maximum)
+    unsigned int width(void) const;
+    //@}
+  };
+
+  /**
+   * \brief Range iterator for the unknown set
+   *
+   * This class provides a range iterator 
+   * for the unknown set of all set views. The unknown set is the
+   * difference between least upper and greatest lower bound, i.e.
+   * those elements which still may be in the set, but are not yet
+   * known to be in.
+   *
+   * \ingroup TaskActorSet
+   */
+  template <class T>
+  class UnknownRanges : public Iter::Ranges::Diff<LubRanges<T>, GlbRanges<T> >{
+  private:
+    LubRanges<T> i1;
+    GlbRanges<T> i2;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    UnknownRanges(void);
+    /// Initialize with unknown set ranges for set variable \a x
+    UnknownRanges(const T& x);
+    /// Initialize with unknown set ranges for set variable \a x
+    void init(const T& x);
+    //@}
+  };
+  
+}}
+
+#include "gecode/set/var/integerset.icc"
+#include "gecode/set/var/iter.icc"
+
+namespace Gecode { namespace Set {
+
+  /**
+   * \brief Finite integer set variable implementation
+   *
+   * \ingroup Other
+   */  
+  class SetVarImp : public SetVarImpBase {
+    friend class LubRanges<SetVarImp*>;
+    friend class GlbRanges<SetVarImp*>;
+  private:
+    /// The least upper bound of the domain
+    LUBndSet lub;
+    /// The greatest lower bound of the domain
+    GLBndSet glb;
+    /// The minimum cardinality
+    unsigned int _cardMin;
+    /// The maximum cardinality
+    unsigned int _cardMax;
+
+  protected:
+    /// Constructor for cloning \a x
+    SetVarImp(Space* home, bool share, SetVarImp& x);
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Initialize with empty lower and full upper bound
+    SetVarImp(Space* home);
+    /**
+     * \brief Initialize with given bounds and cardinality
+     *
+     * Creates a set variable \f$s\f$ with
+     * \f$\mathit{glb}(s)=\{\mathit{glbMin},\dots,\mathit{glbMax}\}\f$,
+     * \f$\mathit{lub}(s)=\{\mathit{lubMin},\dots,\mathit{lubMax}\}\f$, and
+     * \f$\mathit{cardMin}\leq |s|\leq\mathit{cardMax}\f$
+     */
+    SetVarImp(Space* home,int glbMin,int glbMax,int lubMin,int lubMax,
+	       unsigned int cardMin = 0,
+	       unsigned int cardMax = Limits::Set::card_max);
+    /**
+     * \brief Initialize with given bounds and cardinality
+     *
+     * Creates a set variable \f$s\f$ with
+     * \f$\mathit{glb}(s)=\mathit{glbD}\f$,
+     * \f$\mathit{lub}(s)=\{\mathit{lubMin},\dots,\mathit{lubMax}\}\f$, and
+     * \f$\mathit{cardMin}\leq |s|\leq\mathit{cardMax}\f$
+     */
+    SetVarImp(Space* home,const IntSet& glbD,int lubMin,int lubMax,
+	      unsigned int cardMin,unsigned int cardMax);
+    /**
+     * \brief Initialize with given bounds and cardinality
+     *
+     * Creates a set variable \f$s\f$ with
+     * \f$\mathit{glb}(s)=\{\mathit{glbMin},\dots,\mathit{glbMax}\}\f$,
+     * \f$\mathit{lub}(s)=\mathit{lubD}\f$, and
+     * \f$\mathit{cardMin}\leq |s|\leq\mathit{cardMax}\f$
+     */
+    SetVarImp(Space* home,int glbMin,int glbMax,const IntSet& lubD,
+	      unsigned int cardMin,unsigned int cardMax);
+    /**
+     * \brief Initialize with given bounds and cardinality
+     *
+     * Creates a set variable \f$s\f$ with
+     * \f$\mathit{glb}(s)=\mathit{glbD}\f$,
+     * \f$\mathit{lub}(s)=\mathit{lubD}\f$, and
+     * \f$\mathit{cardMin}\leq |s|\leq\mathit{cardMax}\f$
+     */
+    SetVarImp(Space* home,const IntSet& glbD,const IntSet& lubD,
+	      unsigned int cardMin,unsigned int cardMax);
+    //@}
+
+    /// \name Value access
+    //@{
+    /// Return current cardinality minimum
+    unsigned int cardMin(void) const;
+    /// Return current cardinality maximum
+    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 \a n -th smallest element in the least upper bound
+    int lubMinN(int n) const;
+    /// Return \a n -th largest element in 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 size of the greatest lower bound
+    unsigned int glbSize(void) const;
+    /// Return the size of the least upper bound
+    unsigned int lubSize(void) const;
+    //@}
+
+    /// \name Domain tests
+    //@{
+    /// Test whether variable is assigned
+    bool assigned(void) const;
+    /// Test whether \a n is contained in greatest lower bound
+    bool knownIn(int n) const;
+    /// Test whether \a n is not contained in least upper bound
+    bool knownOut(int) const;
+    //@}
+
+  private:
+    /// \name Common methods for the tell operations
+    //@{
+    /// Computes ModEvent that resulted from updating the least upper bound
+    GECODE_SET_EXPORT ModEvent processLubChange(Space* home);
+    /// Computes ModEvent that resulted from updating the greatest lower bound
+    GECODE_SET_EXPORT ModEvent processGlbChange(Space* home);
+    /** \brief Check whether least upper and minimum cardinality agree
+     * If the minimum cardinality is still smaller than the lub size, \a me
+     * is returned. If minimum cardinality and lub size are the same, the
+     * variable is assigned, and ME_SET_VAL is returned. Otherwise
+     * returns ME_SET_FAILED.
+     */
+    ModEvent checkLubCardAssigned(Space* home,ModEvent me);
+    /** \brief Check whether greatest lower bound and maximum cardinality agree
+     * If the maximum cardinality is still greater than the glb size, \a me
+     * is returned. If maximum cardinality and glb size are the same, the
+     * variable is assigned, and ME_SET_VAL is returned. Otherwise
+     * returns ME_SET_FAILED.
+     */
+    ModEvent checkGlbCardAssigned(Space* home,ModEvent me);
+    //@}
+
+    /// \name Cardinality update implementation
+    //@{
+    /// Restrict cardinality to be at least n
+    GECODE_SET_EXPORT ModEvent cardMin_full(Space* home,unsigned int n);
+    /// Restrict cardinality to be at most n
+    GECODE_SET_EXPORT ModEvent cardMax_full(Space* home,unsigned int n);
+    //@}
+
+    /// Test whether glb is a subset of lub
+    bool boundsConsistent(void) const;
+  public:
+
+    /// \name Domain update by value
+    //@{
+    /// Include \a n in the greatest lower bound
+    ModEvent include(Space* home,int n);
+    /// Include the range \f$\{i,\dots,j\}\f$ in the greatest lower bound
+    ModEvent include(Space* home,int i,int j);
+    /// Exclude \a n from the least upper bound
+    ModEvent exclude(Space* home,int n);
+    /// Exclude the range \f$\{i,\dots,j\}\f$ from the least upper bound
+    ModEvent exclude(Space* home,int i,int j);
+    /// Exclude everything but \a n from the least upper bound
+    ModEvent intersect(Space* home,int n);
+    /// Exclude everything but the range \f$\{i,\dots,j\}\f$ from the least upper bound
+    ModEvent intersect(Space* home,int i,int j);
+    /// Restrict cardinality to be at least n
+    ModEvent cardMin(Space* home,unsigned int n);
+    /// Restrict cardinality to be at most n
+    ModEvent cardMax(Space* home,unsigned int n);
+    //@}
+
+    /// \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);
+    //@}
+
+  public:
+    /// \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);
+    //@}
+
+  private:
+    /// Return copy of not-yet copied variable
+    GECODE_SET_EXPORT SetVarImp* perform_copy(Space* home, bool share);
+
+  public:
+    /// \name Cloning
+    //@{
+    /// Return copy of this variable
+    SetVarImp* copy(Space* home, bool share);
+    //@}
+
+  };
+
+}}
+
+#include "gecode/set/var/imp.icc"
+
+namespace Gecode {
+
+  /**
+   * \brief %Set variables
+   * 
+   * \ingroup TaskIntSetVars
+   */
+  class SetVar {
+  private:
+    /// Finite set variable implementation used
+    Set::SetVarImp* x;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    GECODE_SET_EXPORT SetVar(void);
+
+    /// Initialize variable with empty greatest lower and full least upper bound
+    GECODE_SET_EXPORT SetVar(Space* home);
+    /// Initialize variable with empty greatest lower and full least upper bound
+    void init(Space* home);
+
+    /**
+     * \brief Initialize variable with given bounds and cardinality
+     *
+     * The variable is created with
+     * greatest lower bound \f$\{\mathit{glbMin},\dots,\mathit{glbMax}\}\f$,
+     * least upper bound \f$\{\mathit{lubMin},\dots,\mathit{lubMax}\}\f$, and
+     * cardinality minimum \a cardMin and maximum \a cardMax.
+     * The following exceptions might be thrown:
+     *  - If the bounds are no legal set bounds (between Limits::Set::int_min
+     *    and Limits::Set::int_max), an exception of type
+     *    Gecode::Set::VariableOutOfRangeDomain is thrown.
+     *  - If the cardinality is greater than Limits::Set::max_set_size, an
+     *    exception of type Gecode::Set::VariableOutOfRangeCardinality is
+     *    thrown.
+     *  - If \a minCard > \a maxCard, an exception of type
+     *    Gecode::Set::VariableFailedDomain is thrown.
+     */
+    GECODE_SET_EXPORT 
+    SetVar(Space* home,int glbMin,int glbMax,int lubMin,int lubMax,
+	   unsigned int cardMin = 0,
+	   unsigned int cardMax = Limits::Set::card_max);
+    /**
+     * \brief Initialize variable with given bounds and cardinality
+     *
+     * The variable is created with
+     * greatest lower bound \f$\{\mathit{glbMin},\dots,\mathit{glbMax}\}\f$,
+     * least upper bound \f$\{\mathit{lubMin},\dots,\mathit{lubMax}\}\f$, and
+     * cardinality minimum \a cardMin and maximum \a cardMax.
+     * The following exceptions might be thrown:
+     *  - If the bounds are no legal set bounds (between Limits::Set::int_min
+     *    and Limits::Set::int_max), an exception of type
+     *    Gecode::Set::VariableOutOfRangeDomain is thrown.
+     *  - If the cardinality is greater than Limits::Set::max_set_size, an
+     *    exception of type Gecode::Set::VariableOutOfRangeCardinality is
+     *    thrown.
+     *  - If \a minCard > \a maxCard, an exception of type
+     *    Gecode::Set::VariableFailedDomain is thrown.
+     */
+    void init(Space* home,int glbMin,int glbMax,int lubMin,int lubMax,
+	      unsigned int cardMin = 0,
+	      unsigned int cardMax = Limits::Set::card_max);
+
+    /**
+     * \brief Initialize variable with given bounds and cardinality
+     *
+     * The variable is created with
+     * greatest lower bound \a glbD,
+     * least upper bound \f$\{\mathit{lubMin},\dots,\mathit{lubMax}\}\f$, and
+     * cardinality minimum \a cardMin and maximum \a cardMax.
+     * The following exceptions might be thrown:
+     *  - If the bounds are no legal set bounds (between Limits::Set::int_min
+     *    and Limits::Set::int_max), an exception of type
+     *    Gecode::Set::VariableOutOfRangeDomain is thrown.
+     *  - If the cardinality is greater than Limits::Set::max_set_size, an
+     *    exception of type Gecode::Set::VariableOutOfRangeCardinality is
+     *    thrown.
+     *  - If \a minCard > \a maxCard, an exception of type
+     *    Gecode::Set::VariableFailedDomain is thrown.
+     */
+    GECODE_SET_EXPORT 
+    SetVar(Space* home,const IntSet& glbD,int lubMin,int lubMax,
+	   unsigned int cardMin = 0,
+	   unsigned int cardMax = Limits::Set::card_max);
+    /**
+     * \brief Initialize variable with given bounds and cardinality
+     *
+     * The variable is created with
+     * greatest lower bound \a glbD,
+     * least upper bound \f$\{\mathit{lubMin},\dots,\mathit{lubMax}\}\f$, and
+     * cardinality minimum \a cardMin and maximum \a cardMax.
+     * The following exceptions might be thrown:
+     *  - If the bounds are no legal set bounds (between Limits::Set::int_min
+     *    and Limits::Set::int_max), an exception of type
+     *    Gecode::Set::VariableOutOfRangeDomain is thrown.
+     *  - If the cardinality is greater than Limits::Set::max_set_size, an
+     *    exception of type Gecode::Set::VariableOutOfRangeCardinality is
+     *    thrown.
+     *  - If \a minCard > \a maxCard, an exception of type
+     *    Gecode::Set::VariableFailedDomain is thrown.
+     */
+    void init(Space* home,const IntSet& glbD,int lubMin,int lubMax,
+	      unsigned int cardMin = 0,
+	      unsigned int cardMax = Limits::Set::card_max);
+
+    /**
+     * \brief Initialize variable with given bounds and cardinality
+     *
+     * The variable is created with
+     * greatest lower bound \f$\{\mathit{glbMin},\dots,\mathit{glbMax}\}\f$,
+     * least upper bound \a lubD, and
+     * cardinality minimum \a cardMin and maximum \a cardMax.
+     * The following exceptions might be thrown:
+     *  - If the bounds are no legal set bounds (between Limits::Set::int_min
+     *    and Limits::Set::int_max), an exception of type
+     *    Gecode::Set::VariableOutOfRangeDomain is thrown.
+     *  - If the cardinality is greater than Limits::Set::max_set_size, an
+     *    exception of type Gecode::Set::VariableOutOfRangeCardinality is
+     *    thrown.
+     *  - If \a minCard > \a maxCard, an exception of type
+     *    Gecode::Set::VariableFailedDomain is thrown.
+     */
+    GECODE_SET_EXPORT 
+    SetVar(Space* home,int glbMin,int glbMax,const IntSet& lubD,
+	   unsigned int cardMin = 0,
+	   unsigned int cardMax = Limits::Set::card_max);
+    /**
+     * \brief Initialize variable with given bounds and cardinality
+     *
+     * The variable is created with
+     * greatest lower bound \f$\{\mathit{glbMin},\dots,\mathit{glbMax}\}\f$,
+     * least upper bound \a lubD, and
+     * cardinality minimum \a cardMin and maximum \a cardMax.
+     * The following exceptions might be thrown:
+     *  - If the bounds are no legal set bounds (between Limits::Set::int_min
+     *    and Limits::Set::int_max), an exception of type
+     *    Gecode::Set::VariableOutOfRangeDomain is thrown.
+     *  - If the cardinality is greater than Limits::Set::max_set_size, an
+     *    exception of type Gecode::Set::VariableOutOfRangeCardinality is
+     *    thrown.
+     *  - If \a minCard > \a maxCard, an exception of type
+     *    Gecode::Set::VariableFailedDomain is thrown.
+     */
+    void init(Space* home,int glbMin,int glbMax,const IntSet& lubD,
+	      unsigned int cardMin = 0,
+	      unsigned int cardMax = Limits::Set::card_max);
+
+    /**
+     * \brief Initialize variable with given bounds and cardinality
+     *
+     * The variable is created with
+     * greatest lower bound \a glbD,
+     * least upper bound \a lubD, and
+     * cardinality minimum \a cardMin and maximum \a cardMax.
+     * The following exceptions might be thrown:
+     *  - If the bounds are no legal set bounds (between Limits::Set::int_min
+     *    and Limits::Set::int_max), an exception of type
+     *    Gecode::Set::VariableOutOfRangeDomain is thrown.
+     *  - If the cardinality is greater than Limits::Set::max_set_size, an
+     *    exception of type Gecode::Set::VariableOutOfRangeCardinality is
+     *    thrown.
+     *  - If \a minCard > \a maxCard, an exception of type
+     *    Gecode::Set::VariableFailedDomain is thrown.
+     */
+    GECODE_SET_EXPORT 
+    SetVar(Space* home,const IntSet& glbD,const IntSet& lubD,
+	   unsigned int cardMin = 0,
+	   unsigned int cardMax = Limits::Set::card_max);
+    /**
+     * \brief Initialize variable with given bounds and cardinality
+     *
+     * The variable is created with
+     * greatest lower bound \a glbD,
+     * least upper bound \a lubD, and
+     * cardinality minimum \a cardMin and maximum \a cardMax.
+     * The following exceptions might be thrown:
+     *  - If the bounds are no legal set bounds (between Limits::Set::int_min
+     *    and Limits::Set::int_max), an exception of type
+     *    Gecode::Set::VariableOutOfRangeDomain is thrown.
+     *  - If the cardinality is greater than Limits::Set::max_set_size, an
+     *    exception of type Gecode::Set::VariableOutOfRangeCardinality is
+     *    thrown.
+     *  - If \a minCard > \a maxCard, an exception of type
+     *    Gecode::Set::VariableFailedDomain is thrown.
+     */
+    void init(Space* home,const IntSet& glbD,const IntSet& lubD,
+	      unsigned int cardMin = 0,
+	      unsigned int cardMax = Limits::Set::card_max);
+    //@}
+
+    /// \name Variable implementation access
+    //@{
+    /// Return set variable implementation
+    Set::SetVarImp* variable(void) const;
+    ///@}
+    
+    /// \name Value access
+    //@{
+    /// Return number of elements in the greatest lower bound
+    unsigned int glbSize(void) const;
+    /// Return number of elements in the least upper bound
+    unsigned int lubSize(void) const;
+    /// Return number of unknown elements (elements in lub but not in glb)
+    unsigned int unknownSize(void) const;
+    /// Return cardinality minimum
+    unsigned int cardMin(void) const;
+    /// Return cardinality maximum
+    unsigned int cardMax(void) const;
+    /// Return minimum element of least upper bound
+    int lubMin(void) const;
+    /// Return maximum element of least upper bound
+    int lubMax(void) const;
+    /// Return minimum element of greatest lower bound
+    int glbMin(void) const;
+    /// Return maximum of greatest lower bound
+    int glbMax(void) const;
+    //@}
+
+    /// \name Domain tests
+    //@{
+    /// Test whether \a i is in greatest lower bound
+    bool contains(int i) const;
+    /// Test whether \a i is not in the least upper bound
+    bool notContains(int i) const;
+    /// Test whether this variable is assigned
+    bool assigned(void) const;
+
+    /// \name Cloning
+    //@{
+    /// Update this variable to be a clone of variable \a x
+    void update(Space* home, bool, SetVar& x);
+    //@}
+  };
+
+  /**
+   * \defgroup TaskIntSetIter Range and value iterators for set variables
+   * \ingroup TaskIntSet
+   */
+  //@{
+
+  /// Iterator for the greatest lower bound ranges of a set variable
+  class SetVarGlbRanges {
+  private:
+    Set::GlbRanges<Set::SetVarImp*> iter;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    SetVarGlbRanges(void);
+    /// Initialize to iterate ranges of variable \a x
+    SetVarGlbRanges(const SetVar& x);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Test whether iterator is still at a range or done
+    bool operator()(void) const;
+    /// Move iterator to next range (if possible)
+    void operator++(void);
+    //@}
+
+    /// \name Range access
+    //@{
+    /// Return smallest value of range
+    int min(void) const;
+    /// Return largest value of range
+    int max(void) const;
+    /// Return width of range (distance between minimum and maximum)
+    unsigned int width(void) const;
+    //@}
+  };
+
+  /// Iterator for the least upper bound ranges of a set variable
+  class SetVarLubRanges {
+  private:
+    Set::LubRanges<Set::SetVarImp*> iter;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    SetVarLubRanges(void);
+    /// Initialize to iterate ranges of variable \a x
+    SetVarLubRanges(const SetVar& x);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Test whether iterator is still at a range or done
+    bool operator()(void) const;
+    /// Move iterator to next range (if possible)
+    void operator++(void);
+    //@}
+
+    /// \name Range access
+    //@{
+    /// Return smallest value of range
+    int min(void) const;
+    /// Return largest value of range
+    int max(void) const;
+    /// Return width of range (distance between minimum and maximum)
+    unsigned int width(void) const;
+    //@}
+  };
+
+  /// Iterator for the unknown ranges of a set variable
+  class SetVarUnknownRanges {
+  private:
+    Set::UnknownRanges<Set::SetVarImp*> iter;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    SetVarUnknownRanges(void);
+    /// Initialize to iterate ranges of variable \a x
+    SetVarUnknownRanges(const SetVar& x);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Test whether iterator is still at a range or done
+    bool operator()(void) const;
+    /// Move iterator to next range (if possible)
+    void operator++(void);
+    //@}
+
+    /// \name Range access
+    //@{
+    /// Return smallest value of range
+    int min(void) const;
+    /// Return largest value of range
+    int max(void) const;
+    /// Return width of range (distance between minimum and maximum)
+    unsigned int width(void) const;
+    //@}
+  };
+  
+  /// Iterator for the values in the greatest lower bound of a set variable
+  class SetVarGlbValues {
+  private:
+    Iter::Ranges::ToValues<SetVarGlbRanges> iter;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    SetVarGlbValues(void);
+    /// Initialize to iterate values of variable \a x
+    SetVarGlbValues(const SetVar& x);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Test whether iterator is still at a value or done
+    bool operator()(void) const;
+    /// Move iterator to next value (if possible)
+    void operator++(void);
+    //@}
+
+    /// \name Value access
+    //@{
+    /// Return current value
+    int  val(void) const;
+    //@}
+  };
+
+  /// Iterator for the values in the least upper bound of a set variable
+  class SetVarLubValues {
+  private:
+    Iter::Ranges::ToValues<SetVarLubRanges> iter;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    SetVarLubValues(void);
+    /// Initialize to iterate values of variable \a x
+    SetVarLubValues(const SetVar& x);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Test whether iterator is still at a value or done
+    bool operator()(void) const;
+    /// Move iterator to next value (if possible)
+    void operator++(void);
+    //@}
+
+    /// \name Value access
+    //@{
+    /// Return current value
+    int  val(void) const;
+    //@}
+  };
+
+  /// Iterator for the values in the unknown set of a set variable
+  class SetVarUnknownValues {
+  private:
+    Iter::Ranges::ToValues<SetVarUnknownRanges> iter;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    SetVarUnknownValues(void);
+    /// Initialize to iterate values of variable \a x
+    SetVarUnknownValues(const SetVar& x);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Test whether iterator is still at a value or done
+    bool operator()(void) const;
+    /// Move iterator to next value (if possible)
+    void operator++(void);
+    //@}
+
+    /// \name Value access
+    //@{
+    /// Return current value
+    int  val(void) const;
+    //@}
+  };
+
+  //@}
+}
+
+#include "gecode/set/var/set.icc"
+
+/**
+ * \brief Print set variable \a x
+ * \relates Gecode::SetVar
+ */
+GECODE_SET_EXPORT std::ostream&
+operator<<(std::ostream&, const Gecode::SetVar& x);
+
+// STATISTICS: set-var
+