gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.2.0/gecode/set/element.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-07-11 10:35:42 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7339 $
+ *
+ *  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/element.hh"
+
+namespace Gecode {
+
+  using namespace Gecode::Set;
+
+  void
+  elementsUnion(Space* home, const SetVarArgs& x, SetVar y, SetVar z) {
+    if (home->failed()) return;
+    Set::Element::IdxViewArray<SetView> iv(home, x);
+    GECODE_ES_FAIL(home,
+                   (Element::ElementUnion<SetView,SetView>::
+                    post(home,z,iv,y)));
+  }
+
+  void
+  elementsUnion(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,
+                   (Element::ElementUnionConst<SetView,SetView>::
+                    post(home,z,x,y)));
+  }
+
+  void
+  elementsInter(Space* home, const SetVarArgs& x, SetVar y, SetVar z) {
+    if (home->failed()) return;
+    Set::Element::IdxViewArray<SetView> iv(home, x);
+    IntSet universe(Set::Limits::min,
+                    Set::Limits::max);
+    GECODE_ES_FAIL(home,
+                   (Element::ElementIntersection<SetView,SetView>::
+                    post(home,z,iv,y,universe)));
+  }
+
+  void
+  elementsInter(Space* home, const SetVarArgs& x, SetVar y, SetVar z,
+                const IntSet& universe) {
+    if (home->failed()) return;
+    Set::Element::IdxViewArray<SetView> iv(home, x);
+    GECODE_ES_FAIL(home,
+                   (Element::ElementIntersection<SetView,SetView>::
+                    post(home,z,iv,y,universe)));
+  }
+
+  void
+  elementsDisjoint(Space* home, const SetVarArgs& x, SetVar y) {
+    if (home->failed()) return;
+    Set::Element::IdxViewArray<SetView> iv(home, x);
+    GECODE_ES_FAIL(home,Element::ElementDisjoint::post(home,iv,y));
+  }
+
+  void
+  element(Space* home, const SetVarArgs& x, IntVar y, SetVar z) {
+    if (home->failed()) return;
+    Set::Element::IdxViewArray<SetView > iv(home, x);
+    SetView zv(z);
+
+    Int::IntView yv(y);
+    SingletonView single(yv);
+    GECODE_ES_FAIL(home,(Element::ElementUnion<SetView,
+                         SingletonView>::post(home, z, iv, single)));
+  }
+
+  void
+  element(Space* home, const IntSetArgs& s, IntVar y, SetVar z) {
+    for (int i=s.size(); i--;)
+      Set::Limits::check(s[i], "Set::element");
+    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,(Element::ElementUnionConst<SetView,
+                         SingletonView>::post(home, z, x, single)));
+  }
+
+  namespace {
+    GECODE_REGISTER2(Element::ElementUnion<Gecode::Set::SetView, Gecode::Set::SingletonView>);
+    GECODE_REGISTER2(Element::ElementUnion<Gecode::Set::SetView, Gecode::Set::SetView>);
+    GECODE_REGISTER1(Element::ElementDisjoint);
+    GECODE_REGISTER2(Element::ElementUnionConst<Gecode::Set::SetView, Gecode::Set::SingletonView>);
+    GECODE_REGISTER2(Element::ElementUnionConst<Gecode::Set::SetView, Gecode::Set::SetView>);
+    GECODE_REGISTER2(Element::ElementIntersection<Gecode::Set::SetView, Gecode::Set::SetView>);
+    
+  }
+  
+}
+
+// STATISTICS: set-post
+

data/ext/gecode-2.2.0/gecode/set/element.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-07-11 10:35:42 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7339 $
+ *
+ *  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/element/idxarray.hh"
+#include "gecode/set/rel.hh"
+#include "gecode/set/rel-op.hh"
+
+namespace Gecode { namespace Set { namespace Element {
+
+  /**
+   * \namespace Gecode::Set::Element
+   * \brief %Set element propagators
+   */
+
+  /**
+   * \brief %Propagator for element with intersection
+   *
+   * Requires \code #include "gecode/set/element.hh" \endcode
+   * \ingroup FuncSetProp
+   */
+  template <class SView, class RView>
+  class ElementIntersection :
+    public Propagator {
+  protected:
+    IntSet universe;
+    SView x0;
+    IdxViewArray<SView> iv;
+    RView x1;
+
+    /// Constructor for cloning \a p
+    ElementIntersection(Space* home, bool share,ElementIntersection& p);
+    /// Constructor for posting
+    ElementIntersection(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 element with union
+   *
+   * Requires \code #include "gecode/set/element.hh" \endcode
+   * \ingroup FuncSetProp
+   */
+  template <class SView, class RView>
+  class ElementUnion :
+    public Propagator {
+  protected:
+    SView x0;
+    IdxViewArray<SView> iv;
+    RView x1;
+
+    /// Constructor for cloning \a p
+    ElementUnion(Space* home, bool share,ElementUnion& p);
+    /// Constructor for posting
+    ElementUnion(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 element with union of constant sets
+   *
+   * Requires \code #include "gecode/set/element.hh" \endcode
+   * \ingroup FuncSetProp
+   */
+  template <class SView, class RView>
+  class ElementUnionConst :
+    public Propagator {
+  protected:
+    SView x0;
+    SharedArray<IntSet> iv;
+    RView x1;
+
+    /// Constructor for cloning \a p
+    ElementUnionConst(Space* home, bool share,ElementUnionConst& p);
+    /// Constructor for posting
+    ElementUnionConst(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 element with disjointness
+   *
+   * Requires \code #include "gecode/set/element.hh" \endcode
+   * \ingroup FuncSetProp
+   */
+  class ElementDisjoint :
+    public Propagator {
+  protected:
+    IdxViewArray<SetView> iv;
+    SetView x1;
+
+    /// Constructor for cloning \a p
+    ElementDisjoint(Space* home, bool share,ElementDisjoint& p);
+    /// Constructor for posting
+    ElementDisjoint(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/element/inter.icc"
+#include "gecode/set/element/union.icc"
+#include "gecode/set/element/unionConst.icc"
+#include "gecode/set/element/disjoint.icc"
+
+#endif
+
+// STATISTICS: set-prop
+

data/ext/gecode-2.2.0/gecode/set/element/disjoint.cc

@@ -0,0 +1,308 @@
+/* -*- 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-05-27 19:24:07 +0200 (Tue, 27 May 2008) $ by $Author: tack $
+ *     $Revision: 6982 $
+ *
+ *  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/element.hh"
+#include "gecode/set/rel.hh"
+#include "gecode/set/rel-op.hh"
+
+namespace Gecode { namespace Set { namespace Element {
+
+  PropCost
+  ElementDisjoint::cost(ModEventDelta) const {
+    return PC_QUADRATIC_LO;
+  }
+
+  Support::Symbol
+  ElementDisjoint::ati(void) {
+    return Support::Symbol("Gecode::Set::Element::Disjoint");
+  }
+
+  Reflection::ActorSpec
+  ElementDisjoint::spec(const Space* home, Reflection::VarMap& m) const {
+    Reflection::ActorSpec s(ati());
+    return s << iv.spec(home, m) << x1.spec(home, m);
+  }
+
+  void
+  ElementDisjoint::post(Space* home, Reflection::VarMap& vars,
+                       const Reflection::ActorSpec& spec) {
+    spec.checkArity(2);
+    IdxViewArray<SetView> iv(home, vars, spec[0]);
+    SetView x1(home, vars, spec[1]);
+    (void) new (home) ElementDisjoint(home, iv, x1);
+  }
+
+  size_t
+  ElementDisjoint::dispose(Space* home) {
+    assert(!home->failed());
+    x1.cancel(home,this, PC_SET_ANY);
+    iv.cancel(home,this,PC_SET_ANY);
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+  Actor*
+  ElementDisjoint::copy(Space* home, bool share) {
+    return new (home) ElementDisjoint(home,share,*this);
+  }
+
+  ExecStatus
+  ElementDisjoint::propagate(Space* home, ModEventDelta) {
+    int n = iv.size();
+
+    bool fix_flag = false;
+    do {
+      fix_flag = false;
+      // Compute union of all selected elements' lower bounds
+      GlbRanges<SetView> x1lb(x1);
+      Iter::Ranges::ToValues<GlbRanges<SetView> > vx1lb(x1lb);
+      GLBndSet unionOfSelected(home);
+      for(int i=0; vx1lb(); ++vx1lb) {
+        while (iv[i].idx < vx1lb.val()) i++;
+        GlbRanges<SetView> clb(iv[i].var);
+        unionOfSelected.includeI(home,clb);
+      }
+
+      {
+        LubRanges<SetView> x1ub(x1);
+        Iter::Ranges::ToValues<LubRanges<SetView> > vx1ub(x1ub);
+        int i=0;
+        int j=0;
+        // Cancel all elements that are no longer in the upper bound
+        while (vx1ub()) {
+          if (iv[i].idx < vx1ub.val()) {
+            iv[i].var.cancel(home,this, PC_SET_ANY);
+            i++;
+            continue;
+          }
+          iv[j] = iv[i];
+          ++vx1ub;
+          ++i; ++j;
+        }
+
+        // cancel the variables with index greater than
+        // max of lub(x1)
+        for (int k=i; k<n; k++) {
+          iv[k].var.cancel(home,this, PC_SET_ANY);
+        }
+        n = j;
+        iv.size(n);
+      }
+
+      {
+      UnknownRanges<SetView> x1u(x1);
+      Iter::Ranges::Cache<UnknownRanges<SetView> > x1uc(x1u);
+      Iter::Ranges::ToValues<Iter::Ranges::Cache<UnknownRanges<SetView> > >
+        vx1u(x1uc);
+      int i=0;
+      int j=0;
+      while (vx1u()) {
+        while (iv[i].idx < vx1u.val()) {
+          iv[j] = iv[i];
+          i++; j++;
+        }
+        assert(iv[i].idx == vx1u.val());
+
+        SetView candidate = iv[i].var;
+        int candidateInd = iv[i].idx;
+
+        GlbRanges<SetView> clb(candidate);
+        BndSetRanges uos(unionOfSelected);
+        Iter::Ranges::Inter<GlbRanges<SetView>, BndSetRanges>
+          inter(clb, uos);
+        if (inter()) {
+          ModEvent me = x1.exclude(home,candidateInd);
+          fix_flag |= me_modified(me);
+          GECODE_ME_CHECK(me);
+
+          candidate.cancel(home,this, PC_SET_ANY);
+          ++i;
+          ++vx1u;
+          continue;
+        }
+        iv[j] = iv[i];
+        ++vx1u;
+        ++i; ++j;
+      }
+
+      unionOfSelected.dispose(home);
+
+      // copy remaining variables
+      for (int k=i; k<n; k++) {
+        iv[j] = iv[k];
+        j++;
+      }
+      n = j;
+      iv.size(n);
+      }
+
+      if (x1.cardMax()==0) {
+        // Selector is empty, we're done
+        return ES_SUBSUMED(this,home);
+      }
+
+      {
+        // remove all elements in a selected variable from
+        // all other selected variables
+        GlbRanges<SetView> x1lb(x1);
+        Iter::Ranges::ToValues<GlbRanges<SetView> > vx1lb(x1lb);
+        int i=0;
+        for (; vx1lb(); ++vx1lb) {
+          while (iv[i].idx < vx1lb.val()) i++;
+          assert(iv[i].idx==vx1lb.val());
+          GlbRanges<SetView> x1lb2(x1);
+          Iter::Ranges::ToValues<GlbRanges<SetView> > vx1lb2(x1lb2);
+          for (int j=0; vx1lb2(); ++vx1lb2) {
+            while (iv[j].idx < vx1lb2.val()) j++;
+            assert(iv[j].idx==vx1lb2.val());
+            if (iv[i].idx!=iv[j].idx) {
+              GlbRanges<SetView> xilb(iv[i].var);
+              ModEvent me = iv[j].var.excludeI(home,xilb);
+              fix_flag |= me_modified(me);
+              GECODE_ME_CHECK(me);
+            }
+          }
+        }
+      }
+
+      // remove all elements from the selector that overlap
+      // with all other possibly selected elements, if
+      // at least two more elements need to be selected
+      if (x1.cardMin()-x1.glbSize() > 1) {
+        UnknownRanges<SetView> x1u(x1);
+        Iter::Ranges::Cache<UnknownRanges<SetView> > x1uc(x1u);
+        Iter::Ranges::ToValues<Iter::Ranges::Cache<UnknownRanges<SetView> > >
+          vx1u(x1uc);
+
+        for (; vx1u() && x1.cardMin()-x1.glbSize() > 1; ++vx1u) {
+          int i = 0;
+          while (iv[i].idx < vx1u.val()) i++;
+          assert(iv[i].idx == vx1u.val());
+          bool flag=true;
+
+          UnknownRanges<SetView> x1u2(x1);
+          Iter::Ranges::ToValues<UnknownRanges<SetView> > vx1u2(x1u2);
+          for (; vx1u2(); ++vx1u2) {
+            int j = 0;
+            while (iv[j].idx < vx1u2.val()) j++;
+            assert(iv[j].idx == vx1u2.val());
+            if (iv[i].idx!=iv[j].idx) {
+              GlbRanges<SetView> xjlb(iv[j].var);
+              GlbRanges<SetView> xilb(iv[i].var);
+              Iter::Ranges::Inter<GlbRanges<SetView>, GlbRanges<SetView> >
+                inter(xjlb, xilb);
+              if (!inter()) {
+                flag = false;
+                goto here;
+              }
+            }
+          }
+        here:
+          if (flag) {
+            ModEvent me = x1.exclude(home,iv[i].idx);
+            fix_flag |= me_modified(me);
+            GECODE_ME_CHECK(me);
+          }
+        }
+      }
+
+      // if exactly two more elements need to be selected
+      // and there is a possible element i such that all other pairs of
+      // elements overlap, select i
+      UnknownRanges<SetView> x1u(x1);
+      Iter::Ranges::Cache<UnknownRanges<SetView> > x1uc(x1u);
+      Iter::Ranges::ToValues<Iter::Ranges::Cache<UnknownRanges<SetView> > >
+        vx1u(x1uc);
+
+      for (; x1.cardMin()-x1.glbSize() == 2 && vx1u(); ++vx1u) {
+        int i = 0;
+        while (iv[i].idx < vx1u.val()) i++;
+        assert (iv[i].idx == vx1u.val());
+        bool flag=true;
+
+        UnknownRanges<SetView> x1u2(x1);
+        Iter::Ranges::ToValues<UnknownRanges<SetView> > vx1u2(x1u2);
+        for (; vx1u2(); ++vx1u2) {
+          int j = 0;
+          while (iv[j].idx < vx1u2.val()) j++;
+          assert (iv[j].idx == vx1u2.val());
+          if (iv[i].idx!=iv[j].idx) {
+            UnknownRanges<SetView> x1u3(x1);
+            Iter::Ranges::ToValues<UnknownRanges<SetView> > vx1u3(x1u3);
+            for (; vx1u3(); ++vx1u3) {
+              int k = 0;
+              while (iv[k].idx < vx1u3.val()) k++;
+              assert (iv[k].idx == vx1u3.val());
+              if (iv[j].idx!=iv[k].idx && iv[i].idx!=iv[k].idx) {
+                GlbRanges<SetView> xjlb(iv[j].var);
+                GlbRanges<SetView> xilb(iv[k].var);
+                Iter::Ranges::Inter<GlbRanges<SetView>, GlbRanges<SetView> >
+                  inter(xjlb, xilb);
+                if (!inter()) {
+                  flag = false;
+                  goto here2;
+                }
+              }
+            }
+          }
+        }
+      here2:
+        if (flag) {
+          ModEvent me = x1.include(home,iv[i].idx);
+          fix_flag |= me_modified(me);
+          GECODE_ME_CHECK(me);
+        }
+      }
+    } while (fix_flag);
+
+    bool allAssigned = true;
+    for (int i=iv.size(); i--;)
+      if (!iv[i].var.assigned()) {
+        allAssigned = false;
+        break;
+      }
+    if (!x1.assigned())
+      allAssigned = false;
+
+    return allAssigned ? ES_SUBSUMED(this,home) : ES_FIX;
+  }
+
+}}}
+
+// STATISTICS: set-prop