gecoder-with-gecode 0.7.1 → 0.8.0

data/ext/gecode-2.1.1/gecode/set/rel/re-subset.icc

@@ -0,0 +1,172 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2008-01-31 18:29:16 +0100 (Thu, 31 Jan 2008) $ by $Author: tack $
+ *     $Revision: 6017 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+namespace Gecode { namespace Set { namespace Rel {
+
+  template <class View0, class View1>
+  forceinline
+  ReSubset<View0,View1>::ReSubset(Space* home, View0 y0,
+                                  View1 y1, Gecode::Int::BoolView y2)
+    : Propagator(home), x0(y0), x1(y1), b(y2) {
+    b.subscribe(home,this, Gecode::Int::PC_INT_VAL);
+    x0.subscribe(home,this, PC_SET_ANY);
+    x1.subscribe(home,this, PC_SET_ANY);
+  }
+
+  template <class View0, class View1>
+  forceinline
+  ReSubset<View0,View1>::ReSubset(Space* home, bool share, ReSubset& p)
+    : Propagator(home,share,p) {
+    x0.update(home,share,p.x0);
+    x1.update(home,share,p.x1);
+    b.update(home,share,p.b);
+  }
+
+  template <class View0, class View1>
+  PropCost
+  ReSubset<View0,View1>::cost(ModEventDelta) const {
+    return PC_TERNARY_LO;
+  }
+
+  template <class View0, class View1>
+  Support::Symbol
+  ReSubset<View0,View1>::ati(void) {
+    return Reflection::mangle<View0,View1>("Gecode::Set::Rel::ReSubset");
+  }
+
+  template <class View0, class View1>
+  Reflection::ActorSpec
+  ReSubset<View0,View1>::spec(const Space* home,
+                              Reflection::VarMap& m) const {
+    Reflection::ActorSpec s(ati());
+    return s << x0.spec(home, m)
+             << x1.spec(home, m)
+             << b.spec(home, m);
+  }
+
+  template <class View0, class View1>
+  void
+  ReSubset<View0,View1>::post(Space* home, Reflection::VarMap& vars,
+                              const Reflection::ActorSpec& spec) {
+    spec.checkArity(3);
+    View0 x0(home, vars, spec[0]);
+    View1 x1(home, vars, spec[1]);
+    Gecode::Int::BoolView b(home, vars, spec[2]);
+    (void) new (home) ReSubset(home,x0,x1,b);
+  }
+
+  template <class View0, class View1>
+  size_t
+  ReSubset<View0,View1>::dispose(Space* home) {
+    assert(!home->failed());
+    b.cancel(home,this, Gecode::Int::PC_INT_VAL);
+    x0.cancel(home,this, PC_SET_ANY);
+    x1.cancel(home,this, PC_SET_ANY);
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+  template <class View0, class View1>
+  ExecStatus
+  ReSubset<View0,View1>::post(Space* home, View0 x0, View1 x1,
+                              Gecode::Int::BoolView b) {
+    (void) new (home) ReSubset<View0,View1>(home,x0,x1,b);
+    return ES_OK;
+  }
+
+  template <class View0, class View1>
+  Actor*
+  ReSubset<View0,View1>::copy(Space* home, bool share) {
+    return new (home) ReSubset<View0,View1>(home,share,*this);
+  }
+
+  template <class View0, class View1>
+  ExecStatus
+  ReSubset<View0,View1>::propagate(Space* home, ModEventDelta) {
+    if (b.one())
+      GECODE_REWRITE(this,(SubSet<View0,View1>::post(home,x0,x1)));
+    if (b.zero())
+      GECODE_REWRITE(this,(NoSubSet<View0,View1>::post(home,x0,x1)));
+
+    // check whether cardinalities still allow subset
+    if (x0.cardMin() > x1.cardMax()) {
+      GECODE_ME_CHECK(b.zero_none(home));
+      return ES_SUBSUMED(this,home);
+    }
+
+    // check lub(x0) subset glb(x1)
+    LubRanges<View0> x0ub(x0);
+    GlbRanges<View1> x1lb(x1);
+    Iter::Ranges::Diff<LubRanges<View0>,GlbRanges<View1> > diff1(x0ub, x1lb);
+    if ( !(diff1()) ) {
+      GECODE_ME_CHECK(b.one_none(home));
+      return ES_SUBSUMED(this,home);
+    }
+
+    // check glb(x0) subset lub(x1)
+    {
+      GlbRanges<View0> x0lb(x0);
+      LubRanges<View1> x1ub(x1);
+      Iter::Ranges::Diff<GlbRanges<View0>,LubRanges<View1> > diff2(x0lb, x1ub);
+      if ( diff2() ) {
+        GECODE_ME_CHECK(b.zero_none(home));
+        return ES_SUBSUMED(this,home);
+      } else if (x0.assigned() && x1.assigned()) {
+        GECODE_ME_CHECK(b.one_none(home));
+        return ES_SUBSUMED(this,home);
+      }
+    }
+    
+    if (x0.cardMin() > 0) {
+      LubRanges<View0> x0ub(x0);
+      LubRanges<View1> x1ub(x1);
+      Iter::Ranges::Inter<LubRanges<View0>,LubRanges<View1> >
+        inter(x0ub, x1ub);
+      if (!inter()) {
+        GECODE_ME_CHECK(b.zero_none(home));
+        return ES_SUBSUMED(this,home);
+      }
+    }
+    
+    return ES_FIX;
+  }
+
+}}}
+
+// STATISTICS: set-prop

data/ext/gecode-2.1.1/gecode/set/rel/subset.icc

@@ -0,0 +1,119 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Contributing authors:
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *     Gabor Szokoli, 2004
+ *
+ *  Last modified:
+ *     $Date: 2008-01-31 18:29:16 +0100 (Thu, 31 Jan 2008) $ by $Author: tack $
+ *     $Revision: 6017 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+namespace Gecode { namespace Set { namespace Rel {
+
+  template <class View0, class View1>
+  forceinline
+  SubSet<View0,View1>::SubSet(Space* home, View0 y0, View1 y1)
+    : MixBinaryPropagator<View0,PC_SET_CGLB,
+                            View1,PC_SET_CLUB>(home,y0,y1) {}
+
+  template <class View0, class View1>
+  forceinline
+  SubSet<View0,View1>::SubSet(Space* home, bool share, SubSet& p)
+    : MixBinaryPropagator<View0,PC_SET_CGLB,
+                            View1,PC_SET_CLUB>(home,share,p) {}
+
+  template <class View0, class View1>
+  ExecStatus SubSet<View0,View1>::post(Space* home, View0 x, View1 y) {
+    (void) new (home) SubSet(home,x,y);
+    return ES_OK;
+  }
+
+  template <class View0, class View1>
+  Actor*
+  SubSet<View0,View1>::copy(Space* home, bool share) {
+    return new (home) SubSet(home,share,*this);
+  }
+
+  template <class View0, class View1>
+  Support::Symbol
+  SubSet<View0,View1>::ati(void) {
+    return Reflection::mangle<View0,View1>("Gecode::Set::Rel::SubSet");
+  }
+
+  template <class View0, class View1>
+  Reflection::ActorSpec
+  SubSet<View0,View1>::spec(const Space* home, Reflection::VarMap& m) const {
+    return MixBinaryPropagator<View0,PC_SET_CGLB,View1,PC_SET_CLUB>
+      ::spec(home, m, ati());
+  }
+
+  template <class View0, class View1>
+  void
+  SubSet<View0,View1>::post(Space* home, Reflection::VarMap& vars,
+                            const Reflection::ActorSpec& spec) {
+    spec.checkArity(2);
+    View0 x0(home, vars, spec[0]);
+    View1 x1(home, vars, spec[1]);
+    (void) new (home) SubSet(home,x0,x1);
+  }
+
+  template <class View0, class View1>
+  ExecStatus
+  SubSet<View0,View1>::propagate(Space* home, ModEventDelta) {
+    bool oneassigned = x0.assigned() || x1.assigned();
+    unsigned int x0glbsize;
+    do {
+      GlbRanges<View0> x0lb(x0);
+      GECODE_ME_CHECK ( x1.includeI(home,x0lb) );
+      GECODE_ME_CHECK ( x1.cardMin(home,x0.cardMin()) );
+      LubRanges<View1> x1ub(x1);
+      x0glbsize = x0.glbSize();
+      GECODE_ME_CHECK ( x0.intersectI(home,x1ub) );
+      GECODE_ME_CHECK ( x0.cardMax(home,x1.cardMax()) );
+    } while (x0.glbSize() > x0glbsize);
+
+    if (x0.cardMin() == x1.cardMax())
+      GECODE_REWRITE(this,(Eq<View0,View1>::post(home,x0,x1)));
+
+    if (shared(x0,x1)) {
+      return oneassigned ? ES_SUBSUMED(this,home) : ES_NOFIX;
+    }
+    return (x0.assigned() || x1.assigned()) ? ES_SUBSUMED(this,home) : ES_FIX;
+  }
+
+}}}
+
+// STATISTICS: set-prop

data/ext/gecode-2.1.1/gecode/set/select.cc

@@ -0,0 +1,135 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2008-02-28 14:12:40 +0100 (Thu, 28 Feb 2008) $ by $Author: tack $
+ *     $Revision: 6344 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include "gecode/set/select.hh"
+
+namespace Gecode {
+
+  using namespace Gecode::Set;
+
+  void
+  selectUnion(Space* home, const SetVarArgs& x, SetVar y, SetVar z) {
+    if (home->failed()) return;
+    Set::Select::IdxViewArray<SetView> iv(home, x);
+    GECODE_ES_FAIL(home,
+                   (Select::SelectUnion<SetView,SetView>::
+                    post(home,z,iv,y)));
+  }
+
+  void
+  selectUnion(Space* home, const IntSetArgs& s, SetVar y, SetVar z) {
+    SharedArray<IntSet> x(s.size());
+    for (int i=s.size(); i--;)
+      new (&x[i]) IntSet(s[i]);
+    if (home->failed()) return;
+    GECODE_ES_FAIL(home,
+                   (Select::SelectUnionConst<SetView,SetView>::
+                    post(home,z,x,y)));
+  }
+
+  void
+  selectInter(Space* home, const SetVarArgs& x, SetVar y, SetVar z) {
+    if (home->failed()) return;
+    Set::Select::IdxViewArray<SetView> iv(home, x);
+    IntSet universe(Set::Limits::min,
+                    Set::Limits::max);
+    GECODE_ES_FAIL(home,
+                   (Select::SelectIntersection<SetView,SetView>::
+                    post(home,z,iv,y,universe)));
+  }
+
+  void
+  selectInterIn(Space* home, const SetVarArgs& x, SetVar y, SetVar z,
+                const IntSet& universe) {
+    if (home->failed()) return;
+    Set::Select::IdxViewArray<SetView> iv(home, x);
+    GECODE_ES_FAIL(home,
+                   (Select::SelectIntersection<SetView,SetView>::
+                    post(home,z,iv,y,universe)));
+  }
+
+  void
+  selectSet(Space* home, const SetVarArgs& x, IntVar y, SetVar z) {
+    if (home->failed()) return;
+    Set::Select::IdxViewArray<SetView > iv(home, x);
+    SetView zv(z);
+
+    Int::IntView yv(y);
+    SingletonView single(yv);
+    GECODE_ES_FAIL(home,(Select::SelectUnion<SetView,
+                         SingletonView>::post(home, z, iv, single)));
+  }
+
+  void
+  selectSet(Space* home, const IntSetArgs& s, IntVar y, SetVar z) {
+    for (int i=s.size(); i--;)
+      Set::Limits::check(s[i], "Set::selectSet");
+    if (home->failed()) return;
+    SetView zv(z);
+    SharedArray<IntSet> x(s.size());
+    for (int i=s.size(); i--;)
+      new (&x[i]) IntSet(s[i]);
+
+    Int::IntView yv(y);
+    SingletonView single(yv);
+    GECODE_ES_FAIL(home,(Select::SelectUnionConst<SetView,
+                         SingletonView>::post(home, z, x, single)));
+  }
+
+  void
+  selectDisjoint(Space* home, const SetVarArgs& x, SetVar y) {
+    if (home->failed()) return;
+    Set::Select::IdxViewArray<SetView> iv(home, x);
+    GECODE_ES_FAIL(home,Select::SelectDisjoint::post(home,iv,y));
+  }
+
+  namespace {
+    GECODE_REGISTER2(Select::SelectUnion<Gecode::Set::SetView, Gecode::Set::SingletonView>);
+    GECODE_REGISTER2(Select::SelectUnion<Gecode::Set::SetView, Gecode::Set::SetView>);
+    GECODE_REGISTER1(Select::SelectDisjoint);
+    GECODE_REGISTER2(Select::SelectUnionConst<Gecode::Set::SetView, Gecode::Set::SingletonView>);
+    GECODE_REGISTER2(Select::SelectUnionConst<Gecode::Set::SetView, Gecode::Set::SetView>);
+    GECODE_REGISTER2(Select::SelectIntersection<Gecode::Set::SetView, Gecode::Set::SetView>);
+    
+  }
+  
+}
+
+// STATISTICS: set-post
+

data/ext/gecode-2.1.1/gecode/set/select.hh

@@ -0,0 +1,233 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2008-01-29 13:37:51 +0100 (Tue, 29 Jan 2008) $ by $Author: tack $
+ *     $Revision: 5993 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#ifndef __GECODE_SET_SELECT_HH__
+#define __GECODE_SET_SELECT_HH__
+
+#include "gecode/set.hh"
+
+#include "gecode/set/select/idxarray.hh"
+#include "gecode/set/rel.hh"
+#include "gecode/set/rel-op.hh"
+
+namespace Gecode { namespace Set { namespace Select {
+
+  /**
+   * \namespace Gecode::Set::Select
+   * \brief %Set selection propagators
+   */
+
+  /**
+   * \brief %Propagator for selected intersection
+   *
+   * Requires \code #include "gecode/set/select.hh" \endcode
+   * \ingroup FuncSetProp
+   */
+  template <class SView, class RView>
+  class SelectIntersection :
+    public Propagator {
+  protected:
+    IntSet universe;
+    SView x0;
+    IdxViewArray<SView> iv;
+    RView x1;
+
+    /// Constructor for cloning \a p
+    SelectIntersection(Space* home, bool share,SelectIntersection& p);
+    /// Constructor for posting
+    SelectIntersection(Space* home,SView,IdxViewArray<SView>&,RView,
+                       const IntSet& universe);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor*      copy(Space* home,bool);
+    virtual PropCost    cost(ModEventDelta med) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+    /// Perform propagation
+    virtual ExecStatus  propagate(Space* home, ModEventDelta med);
+    /// Specification for this propagator
+    virtual Reflection::ActorSpec spec(const Space* home,
+                                        Reflection::VarMap& m) const;
+    /// Post using specification
+    static void post(Space* home, Reflection::VarMap& vars,
+                     const Reflection::ActorSpec& spec);
+    /// Name of this propagator
+    static Support::Symbol ati(void);
+    /** Post propagator for \f$ z=\bigcap\langle x_0,\dots,x_{n-1}\rangle[y] \f$ using \a u as universe
+     *
+     * If \a y is empty, \a z will be constrained to be the given universe
+     * \a u (as an empty intersection is the universe).
+     */
+    static  ExecStatus  post(Space* home,SView z,IdxViewArray<SView>& x,
+                             RView y, const IntSet& u);
+  };
+
+  /**
+   * \brief %Propagator for selected union
+   *
+   * Requires \code #include "gecode/set/select.hh" \endcode
+   * \ingroup FuncSetProp
+   */
+  template <class SView, class RView>
+  class SelectUnion :
+    public Propagator {
+  protected:
+    SView x0;
+    IdxViewArray<SView> iv;
+    RView x1;
+
+    /// Constructor for cloning \a p
+    SelectUnion(Space* home, bool share,SelectUnion& p);
+    /// Constructor for posting
+    SelectUnion(Space* home,SView,IdxViewArray<SView>&,RView);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor*      copy(Space* home,bool);
+    virtual PropCost    cost(ModEventDelta med) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+    /// Perform propagation
+    virtual ExecStatus  propagate(Space* home, ModEventDelta med);
+    /// Specification for this propagator
+    virtual Reflection::ActorSpec spec(const Space* home,
+                                        Reflection::VarMap& m) const;
+    /// Post using specification
+    static void post(Space* home, Reflection::VarMap& vars,
+                     const Reflection::ActorSpec& spec);
+    /// Name of this propagator
+    static Support::Symbol ati(void);
+    /** Post propagator for \f$ z=\bigcup\langle x_0,\dots,x_{n-1}\rangle[y] \f$
+     *
+     * If \a y is empty, \a z will be constrained to be empty
+     * (as an empty union is the empty set).
+     */
+    static  ExecStatus  post(Space* home,SView z,IdxViewArray<SView>& x,
+                             RView y);
+  };
+
+  /**
+   * \brief %Propagator for selected union with constant sets
+   *
+   * Requires \code #include "gecode/set/select.hh" \endcode
+   * \ingroup FuncSetProp
+   */
+  template <class SView, class RView>
+  class SelectUnionConst :
+    public Propagator {
+  protected:
+    SView x0;
+    SharedArray<IntSet> iv;
+    RView x1;
+
+    /// Constructor for cloning \a p
+    SelectUnionConst(Space* home, bool share,SelectUnionConst& p);
+    /// Constructor for posting
+    SelectUnionConst(Space* home,SView,SharedArray<IntSet>&,RView);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor*      copy(Space* home,bool);
+    virtual PropCost    cost(ModEventDelta med) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+    /// Perform propagation
+    virtual ExecStatus  propagate(Space* home, ModEventDelta med);
+    /// Specification for this propagator
+    virtual Reflection::ActorSpec spec(const Space* home,
+                                        Reflection::VarMap& m) const;
+    /// Post using specification
+    static void post(Space* home, Reflection::VarMap& vars,
+                     const Reflection::ActorSpec& spec);
+    /// Name of this propagator
+    static Support::Symbol ati(void);
+    /** Post propagator for \f$ z=\bigcup\langle s_0,\dots,s_{n-1}\rangle[y] \f$
+     *
+     * If \a y is empty, \a z will be constrained to be empty
+     * (as an empty union is the empty set).
+     */
+    static  ExecStatus  post(Space* home,SView z,SharedArray<IntSet>& x,
+                             RView y);
+  };
+
+  /**
+   * \brief %Propagator for selected disjointness
+   *
+   * Requires \code #include "gecode/set/select.hh" \endcode
+   * \ingroup FuncSetProp
+   */
+  class SelectDisjoint :
+    public Propagator {
+  protected:
+    IdxViewArray<SetView> iv;
+    SetView x1;
+
+    /// Constructor for cloning \a p
+    SelectDisjoint(Space* home, bool share,SelectDisjoint& p);
+    /// Constructor for posting
+    SelectDisjoint(Space* home,IdxViewArray<SetView>&,SetView);
+  public:
+    /// Copy propagator during cloning
+    GECODE_SET_EXPORT virtual Actor*      copy(Space* home,bool);
+    GECODE_SET_EXPORT virtual PropCost    cost(ModEventDelta med) const;
+    /// Delete propagator and return its size
+    GECODE_SET_EXPORT virtual size_t dispose(Space* home);
+    /// Perform propagation
+    GECODE_SET_EXPORT virtual ExecStatus  propagate(Space* home, ModEventDelta med);
+    /// Specification for this propagator
+    virtual Reflection::ActorSpec spec(const Space* home,
+                                        Reflection::VarMap& m) const;
+    /// Post using specification
+    static void post(Space* home, Reflection::VarMap& vars,
+                     const Reflection::ActorSpec& spec);
+    /// Name of this propagator
+    static Support::Symbol ati(void);
+    /// Post propagator for \f$ \parallel\langle x_0,\dots,x_{n-1}\rangle[y] \f$ 
+    static  ExecStatus  post(Space* home,IdxViewArray<SetView>& x,SetView y);
+  };
+
+}}}
+
+#include "gecode/set/select/inter.icc"
+#include "gecode/set/select/union.icc"
+#include "gecode/set/select/unionConst.icc"
+#include "gecode/set/select/disjoint.icc"
+
+#endif
+
+// STATISTICS: set-prop
+