gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.2.0/gecode/int/rel/eq.icc

@@ -0,0 +1,885 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 10:49:55 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7348 $
+ *
+ *  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 Int { namespace Rel {
+
+  /*
+   * Binary bounds consistent equality
+   *
+   */
+
+  template <class View0, class View1>
+  forceinline
+  EqBnd<View0,View1>::EqBnd(Space* home, View0 x0, View1 x1)
+    : MixBinaryPropagator<View0,PC_INT_BND,View1,PC_INT_BND>(home,x0,x1) {}
+
+  template <class View0, class View1>
+  ExecStatus
+  EqBnd<View0,View1>::post(Space* home, View0 x0, View1 x1){
+    if (x0.assigned()) {
+      GECODE_ME_CHECK(x1.eq(home,x0.val()));
+    } else if (x1.assigned()) {
+      GECODE_ME_CHECK(x0.eq(home,x1.val()));
+    } else if (!same(x0,x1)) {
+      GECODE_ME_CHECK(x0.lq(home,x1.max()));
+      GECODE_ME_CHECK(x1.lq(home,x0.max()));
+      GECODE_ME_CHECK(x0.gq(home,x1.min()));
+      GECODE_ME_CHECK(x1.gq(home,x0.min()));
+      (void) new (home) EqBnd<View0,View1>(home,x0,x1);
+    }
+    return ES_OK;
+  }
+
+  template <class View0, class View1>
+  forceinline
+  EqBnd<View0,View1>::EqBnd(Space* home, bool share, EqBnd<View0,View1>& p)
+    : MixBinaryPropagator<View0,PC_INT_BND,View1,PC_INT_BND>(home,share,p) {}
+
+  template <class View0, class View1>
+  forceinline
+  EqBnd<View0,View1>::EqBnd(Space* home, bool share, Propagator& p,
+                            View0 x0, View1 x1)
+    : MixBinaryPropagator<View0,PC_INT_BND,View1,PC_INT_BND>(home,share,p,
+                                                             x0,x1) {}
+
+  template <class View0, class View1>
+  Actor*
+  EqBnd<View0,View1>::copy(Space* home, bool share) {
+    return new (home) EqBnd<View0,View1>(home,share,*this);
+  }
+
+  template <class View0, class View1>
+  inline Support::Symbol
+  EqBnd<View0,View1>::ati(void) {
+    return Reflection::mangle<View0,View1>("Gecode::Int::Rel::EqBnd");
+  }
+
+  template <class View0, class View1>
+  Reflection::ActorSpec
+  EqBnd<View0,View1>::spec(const Space* home, Reflection::VarMap& m) const {
+    return MixBinaryPropagator<View0,PC_INT_BND,View1,PC_INT_BND>
+      ::spec(home, m, ati());
+  }
+
+  template <class View0, class View1>
+  void
+  EqBnd<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) EqBnd<View0,View1>(home, x0, x1);
+  } 
+
+  template <class View0, class View1>
+  ExecStatus
+  EqBnd<View0,View1>::propagate(Space* home, ModEventDelta) {
+    if (x0.assigned()) {
+      GECODE_ME_CHECK(x1.eq(home,x0.val()));
+    } else if (x1.assigned()) {
+      GECODE_ME_CHECK(x0.eq(home,x1.val()));
+    } else {
+      do {
+        GECODE_ME_CHECK(x0.gq(home,x1.min()));
+        GECODE_ME_CHECK(x1.gq(home,x0.min()));
+      } while (x0.min() != x1.min());
+      do {
+        GECODE_ME_CHECK(x0.lq(home,x1.max()));
+        GECODE_ME_CHECK(x1.lq(home,x0.max()));
+      } while (x0.max() != x1.max());
+      if (!x0.assigned())
+        return ES_FIX;
+    }
+    assert(x0.assigned() && x1.assigned());
+    return ES_SUBSUMED(this,sizeof(*this));
+  }
+
+  /*
+   * Binary domain consistent equality
+   *
+   */
+
+  template <class View0, class View1>
+  forceinline
+  EqDom<View0,View1>::EqDom(Space* home, View0 x0, View1 x1)
+    : MixBinaryPropagator<View0,PC_INT_DOM,View1,PC_INT_DOM>(home,x0,x1) {}
+
+  template <class View0, class View1>
+  ExecStatus
+  EqDom<View0,View1>::post(Space* home, View0 x0, View1 x1){
+    if (x0.assigned()) {
+      GECODE_ME_CHECK(x1.eq(home,x0.val()));
+    } else if (x1.assigned()) {
+      GECODE_ME_CHECK(x0.eq(home,x1.val()));
+    } else if (!same(x0,x1)) {
+      GECODE_ME_CHECK(x0.lq(home,x1.max()));
+      GECODE_ME_CHECK(x1.lq(home,x0.max()));
+      GECODE_ME_CHECK(x0.gq(home,x1.min()));
+      GECODE_ME_CHECK(x1.gq(home,x0.min()));
+      (void) new (home) EqDom<View0,View1>(home,x0,x1);
+    }
+    return ES_OK;
+  }
+
+
+  template <class View0, class View1>
+  forceinline
+  EqDom<View0,View1>::EqDom(Space* home, bool share, EqDom<View0,View1>& p)
+    : MixBinaryPropagator<View0,PC_INT_DOM,View1,PC_INT_DOM>(home,share,p) {}
+
+  template <class View0, class View1>
+  forceinline
+  EqDom<View0,View1>::EqDom(Space* home, bool share, Propagator& p,
+                            View0 x0, View1 x1)
+    : MixBinaryPropagator<View0,PC_INT_DOM,View1,PC_INT_DOM>(home,share,p,
+                                                             x0,x1) {}
+
+  template <class View0, class View1>
+  Actor*
+  EqDom<View0,View1>::copy(Space* home, bool share) {
+    return new (home) EqDom<View0,View1>(home,share,*this);
+  }
+
+  template <class View0, class View1>
+  inline Support::Symbol
+  EqDom<View0,View1>::ati(void) {
+    return Reflection::mangle<View0,View1>("Gecode::Int::Rel::EqDom");
+  }
+
+  template <class View0, class View1>
+  Reflection::ActorSpec
+  EqDom<View0,View1>::spec(const Space* home, Reflection::VarMap& m) const {
+    return MixBinaryPropagator<View0,PC_INT_DOM,View1,PC_INT_DOM>
+      ::spec(home, m, ati());
+  }
+
+  template <class View0, class View1>
+  void
+  EqDom<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) EqDom<View0,View1>(home, x0, x1);
+  } 
+
+  template <class View0, class View1>
+  PropCost
+  EqDom<View0,View1>::cost(ModEventDelta med) const {
+    if ((View0::me(med) == ME_INT_VAL) || (View1::me(med) == ME_INT_VAL))
+      return PC_UNARY_LO;
+    if ((View0::me(med) == ME_INT_DOM) || (View1::me(med) == ME_INT_DOM))
+      return PC_BINARY_HI;
+    return PC_BINARY_LO;
+  }
+
+  template <class View0, class View1>
+  ExecStatus
+  EqDom<View0,View1>::propagate(Space* home, ModEventDelta med) {
+    if (x0.assigned()) {
+      GECODE_ME_CHECK(x1.eq(home,x0.val()));
+      return ES_SUBSUMED(this,sizeof(*this));
+    }
+    if (x1.assigned()) {
+      GECODE_ME_CHECK(x0.eq(home,x1.val()));
+      return ES_SUBSUMED(this,sizeof(*this));
+    }
+    if ((View0::me(med) != ME_INT_DOM) && (View1::me(med) != ME_INT_DOM)) {
+      do {
+        GECODE_ME_CHECK(x0.gq(home,x1.min()));
+        GECODE_ME_CHECK(x1.gq(home,x0.min()));
+      } while (x0.min() != x1.min());
+      do {
+        GECODE_ME_CHECK(x0.lq(home,x1.max()));
+        GECODE_ME_CHECK(x1.lq(home,x0.max()));
+      } while (x0.max() != x1.max());
+      if (x0.assigned())
+        return ES_SUBSUMED(this,sizeof(*this));
+      if (x0.range() && x1.range())
+        return ES_FIX;
+      return ES_FIX_PARTIAL(this,View0::med(ME_INT_DOM));
+    }
+    ViewRanges<View0> r0(x0);
+    GECODE_ME_CHECK(x1.inter_r(home,r0,false));
+    ViewRanges<View1> r1(x1);
+    GECODE_ME_CHECK(x0.narrow_r(home,r1,false));
+    if (x0.assigned())
+      return ES_SUBSUMED(this,sizeof(*this));
+    return ES_FIX;
+  }
+
+
+
+  /*
+   * Nary domain consistent equality
+   *
+   */
+
+  template <class View>
+  forceinline
+  NaryEqDom<View>::NaryEqDom(Space* home, ViewArray<View>& x)
+    : NaryPropagator<View,PC_INT_DOM>(home,x) {}
+
+  template <class View>
+  ExecStatus
+  NaryEqDom<View>::post(Space* home, ViewArray<View>& x) {
+    x.unique();
+    if (x.size() == 2) {
+      return EqDom<View,View>::post(home,x[0],x[1]);
+    } else if (x.size() > 2) {
+      int l = x[0].min();
+      int u = x[0].max();
+      for (int i=x.size(); i-- > 1; ) {
+        l = std::max(l,x[i].min());
+        u = std::min(u,x[i].max());
+      }
+      for (int i=x.size(); i--; ) {
+        GECODE_ME_CHECK(x[i].gq(home,l));
+        GECODE_ME_CHECK(x[i].lq(home,u));
+      }
+      (void) new (home) NaryEqDom<View>(home,x);
+    }
+    return ES_OK;
+  }
+
+  template <class View>
+  forceinline
+  NaryEqDom<View>::NaryEqDom(Space* home, bool share, NaryEqDom<View>& p)
+    : NaryPropagator<View,PC_INT_DOM>(home,share,p) {}
+
+  template <class View>
+  Actor*
+  NaryEqDom<View>::copy(Space* home, bool share) {
+    return new (home) NaryEqDom<View>(home,share,*this);
+  }
+
+  template <class View>
+  inline Support::Symbol
+  NaryEqDom<View>::ati(void) {
+    return Reflection::mangle<View>("Gecode::Int::Rel::NaryEqDom");
+  }
+
+  template <class View>
+  Reflection::ActorSpec
+  NaryEqDom<View>::spec(const Space* home, Reflection::VarMap& m) const {
+    return NaryPropagator<View,PC_INT_DOM>
+      ::spec(home, m, ati());
+  }
+
+  template <class View>
+  void
+  NaryEqDom<View>::post(Space* home, Reflection::VarMap& vars,
+                        const Reflection::ActorSpec& spec) {
+    spec.checkArity(1);
+    ViewArray<View> x(home, vars, spec[0]);
+    (void) new (home) NaryEqDom<View>(home, x);
+  }
+
+  template <class View>
+  PropCost
+  NaryEqDom<View>::cost(ModEventDelta med) const {
+    if (View::me(med) == ME_INT_VAL)
+      return PC_UNARY_LO;
+    if (View::me(med) == ME_INT_DOM)
+      return cost_hi(x.size(),PC_LINEAR_HI);
+    return cost_lo(x.size(),PC_LINEAR_LO);
+  }
+
+  template <class View>
+  ExecStatus
+  NaryEqDom<View>::propagate(Space* home, ModEventDelta med) {
+    assert(x.size() > 2);
+
+    ModEvent me = View::me(med);
+    if (me == ME_INT_VAL) {
+      // One of the variables is assigned
+      for (int i = 0; ; i++)
+        if (x[i].assigned()) {
+          int n = x[i].val();
+          x.move_lst(i);
+          for (int j = x.size(); j--; )
+            GECODE_ME_CHECK(x[j].eq(home,n));
+          return ES_SUBSUMED(this,sizeof(*this));
+        }
+      GECODE_NEVER;
+      return ES_SUBSUMED(this,sizeof(*this));
+    }
+
+    if (me == ME_INT_BND) {
+      {
+        // One of the mins has changed
+        int mn = x[0].min();
+      restart_min:
+        for (int i = x.size(); i--; ) {
+          GECODE_ME_CHECK(x[i].gq(home,mn));
+          if (mn < x[i].min()) {
+            mn = x[i].min();
+            goto restart_min;
+          }
+        }
+      }
+      {
+        // One of the maxs has changed
+        int mx = x[0].max();
+      restart_max:
+        for (int i = x.size(); i--; ) {
+          GECODE_ME_CHECK(x[i].lq(home,mx));
+          if (mx > x[i].max()) {
+            mx = x[i].max();
+            goto restart_max;
+          }
+        }
+      }
+      if (x[0].assigned())
+        return ES_SUBSUMED(this,sizeof(*this));
+      return ES_FIX_PARTIAL(this,View::med(ME_INT_DOM));
+    }
+
+    int n = x.size();
+
+    GECODE_AUTOARRAY(ViewRanges<View>, i_x, n);
+    for (int i = n; i--; ) {
+      ViewRanges<View> i_xi(x[i]);
+      i_x[i] = i_xi;
+    }
+    Iter::Ranges::NaryInter<ViewRanges<View> > r(i_x,n);
+    Iter::Ranges::Cache<Iter::Ranges::NaryInter<ViewRanges<View> > > rc(r);
+
+    if (!rc())
+      return ES_FAILED;
+    ++rc;
+    if (!rc()) {
+      rc.reset();
+      for (int i = n; i--; ) {
+        GECODE_ME_CHECK(x[i].gq(home,rc.min()));
+        GECODE_ME_CHECK(x[i].lq(home,rc.max()));
+      }
+    } else {
+      for (int i = n; i--; ) {
+        rc.reset();
+        GECODE_ME_CHECK(x[i].narrow_r(home,rc,false));
+      }
+    }
+    return ES_FIX;
+  }
+
+
+
+  /*
+   * Nary bound consistent equality
+   *
+   */
+
+  template <class View>
+  forceinline
+  NaryEqBnd<View>::NaryEqBnd(Space* home, ViewArray<View>& x)
+    : NaryPropagator<View,PC_INT_BND>(home,x) {}
+
+  template <class View>
+  ExecStatus
+  NaryEqBnd<View>::post(Space* home, ViewArray<View>& x) {
+    if (x.size() == 2) {
+      return EqBnd<View,View>::post(home,x[0],x[1]);
+    } else if (x.size() > 2) {
+      int l = x[0].min();
+      int u = x[0].max();
+      for (int i=x.size(); i-- > 1; ) {
+        l = std::max(l,x[i].min());
+        u = std::min(u,x[i].max());
+      }
+      for (int i=x.size(); i--; ) {
+        GECODE_ME_CHECK(x[i].gq(home,l));
+        GECODE_ME_CHECK(x[i].lq(home,u));
+      }
+      (void) new (home) NaryEqBnd<View>(home,x);
+    }
+    return ES_OK;
+  }
+
+  template <class View>
+  forceinline
+  NaryEqBnd<View>::NaryEqBnd(Space* home, bool share, NaryEqBnd<View>& p)
+    : NaryPropagator<View,PC_INT_BND>(home,share,p) {}
+
+  template <class View>
+  Actor*
+  NaryEqBnd<View>::copy(Space* home, bool share) {
+    return new (home) NaryEqBnd<View>(home,share,*this);
+  }
+
+  template <class View>
+  PropCost
+  NaryEqBnd<View>::cost(ModEventDelta med) const {
+    if (View::me(med) == ME_INT_VAL)
+      return PC_UNARY_LO;
+    return cost_lo(x.size(),PC_LINEAR_LO);
+  }
+
+  template <class View>
+  inline Support::Symbol
+  NaryEqBnd<View>::ati(void) {
+    return Reflection::mangle<View>("Gecode::Int::Rel::NaryEqBnd");
+  }
+
+  template <class View>
+  Reflection::ActorSpec
+  NaryEqBnd<View>::spec(const Space* home, Reflection::VarMap& m) const {
+    return NaryPropagator<View,PC_INT_BND>
+      ::spec(home, m, ati());
+  }
+
+  template <class View>
+  void
+  NaryEqBnd<View>::post(Space* home, Reflection::VarMap& vars,
+                        const Reflection::ActorSpec& spec) {
+    spec.checkArity(1);
+    ViewArray<View> x(home, vars, spec[0]);
+    (void) new (home) NaryEqBnd<View>(home, x);
+  }
+
+  template <class View>
+  ExecStatus
+  NaryEqBnd<View>::propagate(Space* home, ModEventDelta med) {
+    assert(x.size() > 2);
+    if (View::me(med) == ME_INT_VAL) {
+      // One of the variables is assigned
+      for (int i = 0; ; i++)
+        if (x[i].assigned()) {
+          int n = x[i].val();
+          x.move_lst(i);
+          for (int j = x.size(); j--; )
+            GECODE_ME_CHECK(x[j].eq(home,n));
+          return ES_SUBSUMED(this,sizeof(*this));
+        }
+      GECODE_NEVER;
+      return ES_SUBSUMED(this,sizeof(*this));
+    }
+
+    int mn = x[0].min();
+  restart_min:
+    for (int i = x.size(); i--; ) {
+      GECODE_ME_CHECK(x[i].gq(home,mn));
+      if (mn < x[i].min()) {
+        mn = x[i].min();
+        goto restart_min;
+      }
+    }
+    int mx = x[0].max();
+  restart_max:
+    for (int i = x.size(); i--; ) {
+      GECODE_ME_CHECK(x[i].lq(home,mx));
+      if (mx > x[i].max()) {
+        mx = x[i].max();
+        goto restart_max;
+      }
+    }
+    return x[0].assigned() ? ES_SUBSUMED(this,sizeof(*this)) : ES_FIX;
+  }
+
+
+
+  /*
+   * Reified domain consistent equality
+   *
+   */
+
+  template <class View, class CtrlView>
+  forceinline
+  ReEqDom<View,CtrlView>::ReEqDom(Space* home, View x0, View x1, CtrlView b)
+    : ReBinaryPropagator<View,PC_INT_DOM,CtrlView>(home,x0,x1,b) {}
+
+  template <class View, class CtrlView>
+  ExecStatus
+  ReEqDom<View,CtrlView>::post(Space* home, View x0, View x1, CtrlView b) {
+    if (b.one())
+      return EqDom<View,View>::post(home,x0,x1);
+    if (b.zero())
+      return Nq<View>::post(home,x0,x1);
+    if (!same(x0,x1)) {
+      (void) new (home) ReEqDom(home,x0,x1,b);
+    } else {
+      GECODE_ME_CHECK(b.one(home));
+    }
+    return ES_OK;
+  }
+
+
+  template <class View, class CtrlView>
+  forceinline
+  ReEqDom<View,CtrlView>::ReEqDom(Space* home, bool share, ReEqDom& p)
+    : ReBinaryPropagator<View,PC_INT_DOM,CtrlView>(home,share,p) {}
+
+  template <class View, class CtrlView>
+  Actor*
+  ReEqDom<View,CtrlView>::copy(Space* home, bool share) {
+    return new (home) ReEqDom<View,CtrlView>(home,share,*this);
+  }
+
+  template <class View, class CtrlView>
+  inline Support::Symbol
+  ReEqDom<View,CtrlView>::ati(void) {
+    return Reflection::mangle<View,CtrlView>("Gecode::Int::Rel::ReEqDom");
+  }
+
+  template <class View, class CtrlView>
+  Reflection::ActorSpec
+  ReEqDom<View,CtrlView>::spec(const Space* home,
+                               Reflection::VarMap& m) const {
+    return ReBinaryPropagator<View,PC_INT_DOM,CtrlView>
+      ::spec(home, m, ati());
+  }
+
+  template <class View, class CtrlView>
+  void
+  ReEqDom<View,CtrlView>::post(Space* home, Reflection::VarMap& vars,
+                               const Reflection::ActorSpec& spec) {
+    spec.checkArity(3);
+    View x0(home, vars, spec[0]);
+    View x1(home, vars, spec[1]);
+    CtrlView b(home, vars, spec[2]);
+    (void) new (home) ReEqDom<View,CtrlView>(home, x0, x1, b);
+  }
+
+  template <class View, class CtrlView>
+  ExecStatus
+  ReEqDom<View,CtrlView>::propagate(Space* home, ModEventDelta) {
+    if (b.one())
+      GECODE_REWRITE(this,(EqDom<View,View>::post(home,x0,x1)));
+    if (b.zero())
+      GECODE_REWRITE(this,Nq<View>::post(home,x0,x1));
+    switch (rtest_eq_dom(x0,x1)) {
+    case RT_TRUE:
+      GECODE_ME_CHECK(b.one_none(home)); return ES_SUBSUMED(this,home);
+    case RT_FALSE:
+      GECODE_ME_CHECK(b.zero_none(home)); return ES_SUBSUMED(this,home);
+    case RT_MAYBE:
+      break;
+    default: GECODE_NEVER;
+    }
+    return ES_FIX;
+  }
+
+
+
+  /*
+   * Reified bounds consistent equality
+   *
+   */
+
+  template <class View, class CtrlView>
+  forceinline
+  ReEqBnd<View,CtrlView>::ReEqBnd(Space* home, View x0, View x1, CtrlView b)
+    : ReBinaryPropagator<View,PC_INT_BND,CtrlView>(home,x0,x1,b) {}
+
+  template <class View, class CtrlView>
+  ExecStatus
+  ReEqBnd<View,CtrlView>::post(Space* home, View x0, View x1, CtrlView b){
+    if (b.one())
+      return EqBnd<View,View>::post(home,x0,x1);
+    if (b.zero())
+      return Nq<View>::post(home,x0,x1);
+    if (!same(x0,x1)) {
+      (void) new (home) ReEqBnd(home,x0,x1,b);
+    } else {
+      GECODE_ME_CHECK(b.one(home));
+    }
+    return ES_OK;
+  }
+
+
+  template <class View, class CtrlView>
+  forceinline
+  ReEqBnd<View,CtrlView>::ReEqBnd(Space* home, bool share, ReEqBnd& p)
+    : ReBinaryPropagator<View,PC_INT_BND,CtrlView>(home,share,p) {}
+
+  template <class View, class CtrlView>
+  Actor*
+  ReEqBnd<View,CtrlView>::copy(Space* home, bool share) {
+    return new (home) ReEqBnd<View,CtrlView>(home,share,*this);
+  }
+
+  template <class View, class CtrlView>
+  inline Support::Symbol
+  ReEqBnd<View,CtrlView>::ati(void) {
+    return Reflection::mangle<View,CtrlView>("Gecode::Int::Rel::ReEqBnd");
+  }
+
+  template <class View, class CtrlView>
+  Reflection::ActorSpec
+  ReEqBnd<View,CtrlView>::spec(const Space* home,
+                               Reflection::VarMap& m) const {
+    return ReBinaryPropagator<View,PC_INT_BND,CtrlView>
+      ::spec(home, m, ati());
+  }
+
+  template <class View, class CtrlView>
+  void
+  ReEqBnd<View,CtrlView>::post(Space* home, Reflection::VarMap& vars,
+                               const Reflection::ActorSpec& spec) {
+    spec.checkArity(3);
+    View x0(home, vars, spec[0]);
+    View x1(home, vars, spec[1]);
+    CtrlView b(home, vars, spec[2]);
+    (void) new (home) ReEqBnd<View,CtrlView>(home, x0, x1, b);
+  }
+
+  template <class View, class CtrlView>
+  ExecStatus
+  ReEqBnd<View,CtrlView>::propagate(Space* home, ModEventDelta) {
+    if (b.one())
+      GECODE_REWRITE(this,(EqBnd<View,View>::post(home,x0,x1)));
+    if (b.zero())
+      GECODE_REWRITE(this,Nq<View>::post(home,x0,x1));
+    switch (rtest_eq_bnd(x0,x1)) {
+    case RT_TRUE:
+      GECODE_ME_CHECK(b.one_none(home));  return ES_SUBSUMED(this,home);
+    case RT_FALSE:
+      GECODE_ME_CHECK(b.zero_none(home)); return ES_SUBSUMED(this,home);
+    case RT_MAYBE:
+      break;
+    default: GECODE_NEVER;
+    }
+    return ES_FIX;
+  }
+
+
+
+
+  /*
+   * Reified domain consistent equality (one variable)
+   *
+   */
+
+  template <class View, class CtrlView>
+  forceinline
+  ReEqDomInt<View,CtrlView>::ReEqDomInt
+  (Space* home, View x, int c0, CtrlView b)
+    : ReUnaryPropagator<View,PC_INT_DOM,CtrlView>(home,x,b), c(c0) {}
+
+  template <class View, class CtrlView>
+  ExecStatus
+  ReEqDomInt<View,CtrlView>::post(Space* home, View x, int c, CtrlView b) {
+    if (b.one()) {
+      GECODE_ME_CHECK(x.eq(home,c));
+    } else if (b.zero()) {
+      GECODE_ME_CHECK(x.nq(home,c));
+    } else if (x.assigned()) {
+      assert(b.none());
+      if (x.val() == c) {
+        GECODE_ME_CHECK(b.one_none(home));
+      } else {
+        GECODE_ME_CHECK(b.zero_none(home));
+      }
+    } else {
+      (void) new (home) ReEqDomInt(home,x,c,b);        
+    }
+    return ES_OK;
+  }
+
+
+  template <class View, class CtrlView>
+  forceinline
+  ReEqDomInt<View,CtrlView>::ReEqDomInt(Space* home, bool share, ReEqDomInt& p)
+    : ReUnaryPropagator<View,PC_INT_DOM,CtrlView>(home,share,p), c(p.c) {}
+
+  template <class View, class CtrlView>
+  Actor*
+  ReEqDomInt<View,CtrlView>::copy(Space* home, bool share) {
+    return new (home) ReEqDomInt<View,CtrlView>(home,share,*this);
+  }
+
+  template <class View, class CtrlView>
+  inline Support::Symbol
+  ReEqDomInt<View,CtrlView>::ati(void) {
+    return Reflection::mangle<View,CtrlView>("Gecode::Int::Rel::ReEqDomInt");
+  }
+
+  template <class View, class CtrlView>
+  Reflection::ActorSpec
+  ReEqDomInt<View,CtrlView>::spec(const Space* home,
+                                  Reflection::VarMap& m) const {
+    return ReUnaryPropagator<View,PC_INT_DOM,CtrlView>
+      ::spec(home, m, ati()) << c;
+  }
+
+  template <class View, class CtrlView>
+  void
+  ReEqDomInt<View,CtrlView>::post(Space* home, Reflection::VarMap& vars,
+                                  const Reflection::ActorSpec& spec) {
+    spec.checkArity(3);
+    View x0(home, vars, spec[0]);
+    CtrlView b(home, vars, spec[1]);
+    int c = spec[2]->toInt();
+    (void) new (home) ReEqDomInt<View,CtrlView>(home, x0, c, b);
+  }
+
+  template <class View, class CtrlView>
+  ExecStatus
+  ReEqDomInt<View,CtrlView>::propagate(Space* home, ModEventDelta) {
+    if (b.one()) {
+      GECODE_ME_CHECK(x0.eq(home,c)); 
+      assert(x0.assigned());
+      goto subsumed;
+    }
+    if (b.zero()) {
+      GECODE_ME_CHECK(x0.nq(home,c)); 
+      x0.cancel(home,this,PC_INT_DOM);
+      goto subsumed;
+    }
+    switch (rtest_eq_dom(x0,c)) {
+    case RT_TRUE:
+      GECODE_ME_CHECK(b.one_none(home)); 
+      assert(x0.assigned());
+      goto subsumed;
+    case RT_FALSE:
+      GECODE_ME_CHECK(b.zero_none(home)); 
+      x0.cancel(home,this,PC_INT_DOM);
+      goto subsumed;
+    case RT_MAYBE:
+      break;
+    default: GECODE_NEVER;
+    }
+    return ES_FIX;
+  subsumed:
+    return ES_SUBSUMED(this,sizeof(*this));    
+  }
+
+
+
+
+  /*
+   * Reified bounds consistent equality (one variable)
+   *
+   */
+
+  template <class View, class CtrlView>
+  forceinline
+  ReEqBndInt<View,CtrlView>::ReEqBndInt
+  (Space* home, View x, int c0, CtrlView b)
+    : ReUnaryPropagator<View,PC_INT_BND,CtrlView>(home,x,b), c(c0) {}
+
+  template <class View, class CtrlView>
+  ExecStatus
+  ReEqBndInt<View,CtrlView>::post(Space* home, View x, int c, CtrlView b) {
+    if (b.one()) {
+      GECODE_ME_CHECK(x.eq(home,c));
+    } else if (b.zero()) {
+      GECODE_ME_CHECK(x.nq(home,c));
+    } else if (x.assigned()) {
+      assert(b.none());
+      if (x.val() == c) {
+        GECODE_ME_CHECK(b.one_none(home));
+      } else {
+        GECODE_ME_CHECK(b.zero_none(home));
+      }
+    } else {
+      (void) new (home) ReEqBndInt(home,x,c,b);        
+    }
+    return ES_OK;
+  }
+
+
+  template <class View, class CtrlView>
+  forceinline
+  ReEqBndInt<View,CtrlView>::ReEqBndInt(Space* home, bool share, ReEqBndInt& p)
+    : ReUnaryPropagator<View,PC_INT_BND,CtrlView>(home,share,p), c(p.c) {}
+
+  template <class View, class CtrlView>
+  Actor*
+  ReEqBndInt<View,CtrlView>::copy(Space* home, bool share) {
+    return new (home) ReEqBndInt<View,CtrlView>(home,share,*this);
+  }
+
+  template <class View, class CtrlView>
+  inline Support::Symbol
+  ReEqBndInt<View,CtrlView>::ati(void) {
+    return Reflection::mangle<View,CtrlView>("Gecode::Int::Rel::ReEqBndInt");
+  }
+
+  template <class View, class CtrlView>
+  Reflection::ActorSpec
+  ReEqBndInt<View,CtrlView>::spec(const Space* home,
+                                  Reflection::VarMap& m) const {
+    return ReUnaryPropagator<View,PC_INT_BND,CtrlView>
+      ::spec(home, m, ati()) << c;
+  }
+
+  template <class View, class CtrlView>
+  void
+  ReEqBndInt<View,CtrlView>::post(Space* home, Reflection::VarMap& vars,
+                                  const Reflection::ActorSpec& spec) {
+    spec.checkArity(3);
+    View x0(home, vars, spec[0]);
+    CtrlView b(home, vars, spec[1]);
+    int c = spec[2]->toInt();
+    (void) new (home) ReEqBndInt<View,CtrlView>(home, x0, c, b);
+  }
+
+  template <class View, class CtrlView>
+  ExecStatus
+  ReEqBndInt<View,CtrlView>::propagate(Space* home, ModEventDelta) {
+    if (b.one()) {
+      GECODE_ME_CHECK(x0.eq(home,c)); 
+      assert(x0.assigned());
+      goto subsumed;
+    }
+    if (b.zero()) {
+      GECODE_ME_CHECK(x0.nq(home,c)); 
+      x0.cancel(home,this,PC_INT_BND);
+      goto subsumed;
+    }
+    switch (rtest_eq_bnd(x0,c)) {
+    case RT_TRUE:
+      GECODE_ME_CHECK(b.one_none(home)); 
+      assert(x0.assigned());
+      goto subsumed;
+    case RT_FALSE:
+      GECODE_ME_CHECK(b.zero_none(home)); 
+      x0.cancel(home,this,PC_INT_BND);
+      goto subsumed;
+    case RT_MAYBE:
+      break;
+    default: GECODE_NEVER;
+    }
+    return ES_FIX;
+  subsumed:
+    return ES_SUBSUMED(this,sizeof(*this));
+  }
+
+}}}
+
+// STATISTICS: int-prop