gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.2.0/gecode/int/linear/bool-post.cc

@@ -0,0 +1,433 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2008-06-11 11:39:04 +0200 (Wed, 11 Jun 2008) $ by $Author: tack $
+ *     $Revision: 7094 $
+ *
+ *  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/int/linear.hh"
+
+namespace Gecode { namespace Int { namespace Linear {
+
+  void
+  post_pos_unit(Space* home, 
+                Term<BoolView>* t_p, int n_p,
+                IntRelType r, IntView y, int c,
+                PropKind) {
+    switch (r) {
+    case IRT_EQ:
+      {
+        ViewArray<BoolView> x(home,n_p);
+        for (int i=n_p; i--; )
+          x[i]=t_p[i].x;
+        GECODE_ES_FAIL(home,(EqBoolView<BoolView,IntView>
+                             ::post(home,x,y,c)));
+      }
+      break;
+    case IRT_NQ:
+      {
+        ViewArray<BoolView> x(home,n_p);
+        for (int i=n_p; i--; )
+          x[i]=t_p[i].x;
+        GECODE_ES_FAIL(home,(NqBoolView<BoolView,IntView>
+                             ::post(home,x,y,c)));
+      }
+      break;
+    case IRT_GQ:
+      {
+        ViewArray<BoolView> x(home,n_p);
+        for (int i=n_p; i--; )
+          x[i]=t_p[i].x;
+        GECODE_ES_FAIL(home,(GqBoolView<BoolView,IntView>
+                             ::post(home,x,y,c)));
+      }
+      break;
+    case IRT_LQ:
+      {
+        ViewArray<NegBoolView> x(home,n_p);
+        for (int i=n_p; i--; )
+          x[i]=t_p[i].x;
+        MinusView z(y);
+        GECODE_ES_FAIL(home,(GqBoolView<NegBoolView,MinusView>
+                             ::post(home,x,z,n_p-c)));
+      }
+      break;
+    default: GECODE_NEVER;
+    }
+  }
+  
+  void
+  post_pos_unit(Space* home, 
+                Term<BoolView>* t_p, int n_p,
+                IntRelType r, ZeroIntView, int c, 
+                PropKind pk) {
+    switch (r) {
+    case IRT_EQ:
+      {
+        ViewArray<BoolView> x(home,n_p);
+        for (int i=n_p; i--; )
+          x[i]=t_p[i].x;
+        GECODE_ES_FAIL(home,(EqBoolInt<BoolView>::post(home,x,c,pk)));
+      }
+      break;
+    case IRT_NQ:
+      {
+        ViewArray<BoolView> x(home,n_p);
+        for (int i=n_p; i--; )
+          x[i]=t_p[i].x;
+        GECODE_ES_FAIL(home,(NqBoolInt<BoolView>::post(home,x,c)));
+      }
+      break;
+    case IRT_GQ:
+      {
+        ViewArray<BoolView> x(home,n_p);
+        for (int i=n_p; i--; )
+          x[i]=t_p[i].x;
+        GECODE_ES_FAIL(home,(GqBoolInt<BoolView>::post(home,x,c,pk)));
+      }
+      break;
+    case IRT_LQ:
+      {
+        ViewArray<NegBoolView> x(home,n_p);
+        for (int i=n_p; i--; )
+          x[i]=t_p[i].x;
+        GECODE_ES_FAIL(home,(GqBoolInt<NegBoolView>::post(home,x,n_p-c,pk)));
+      }
+      break;
+    default: GECODE_NEVER;
+    }
+  }
+  
+  void
+  post_neg_unit(Space* home, 
+                Term<BoolView>* t_n, int n_n,
+                IntRelType r, IntView y, int c,
+                PropKind) {
+    switch (r) {
+    case IRT_EQ:
+      {
+        ViewArray<BoolView> x(home,n_n);
+        for (int i=n_n; i--; )
+          x[i]=t_n[i].x;
+        MinusView z(y);
+        GECODE_ES_FAIL(home,(EqBoolView<BoolView,MinusView>
+                             ::post(home,x,z,-c)));
+      }
+      break;
+    case IRT_NQ:
+      {
+        ViewArray<BoolView> x(home,n_n);
+        for (int i=n_n; i--; )
+          x[i]=t_n[i].x;
+        MinusView z(y);
+        GECODE_ES_FAIL(home,(NqBoolView<BoolView,MinusView>
+                             ::post(home,x,z,-c)));
+      }
+      break;
+    case IRT_GQ:
+      {
+        ViewArray<NegBoolView> x(home,n_n);
+        for (int i=n_n; i--; )
+          x[i]=t_n[i].x;
+        GECODE_ES_FAIL(home,(GqBoolView<NegBoolView,IntView>
+                             ::post(home,x,y,n_n+c)));
+      }
+      break;
+    case IRT_LQ:
+      {
+        ViewArray<BoolView> x(home,n_n);
+        for (int i=n_n; i--; )
+          x[i]=t_n[i].x;
+        MinusView z(y);
+        GECODE_ES_FAIL(home,(GqBoolView<BoolView,MinusView>
+                             ::post(home,x,z,-c)));
+      }
+      break;
+    default: GECODE_NEVER;
+    }
+  }
+  
+  void
+  post_neg_unit(Space* home, 
+                Term<BoolView>* t_n, int n_n,
+                IntRelType r, ZeroIntView, int c, 
+                PropKind pk) {
+    switch (r) {
+    case IRT_EQ:
+      {
+        ViewArray<BoolView> x(home,n_n);
+        for (int i=n_n; i--; )
+          x[i]=t_n[i].x;
+        GECODE_ES_FAIL(home,(EqBoolInt<BoolView>::post(home,x,-c,pk)));
+      }
+      break;
+    case IRT_NQ:
+      {
+        ViewArray<BoolView> x(home,n_n);
+        for (int i=n_n; i--; )
+          x[i]=t_n[i].x;
+        GECODE_ES_FAIL(home,(NqBoolInt<BoolView>::post(home,x,-c)));
+      }
+      break;
+    case IRT_GQ:
+      {
+        ViewArray<NegBoolView> x(home,n_n);
+        for (int i=n_n; i--; )
+          x[i]=t_n[i].x;
+        GECODE_ES_FAIL(home,(GqBoolInt<NegBoolView>::post(home,x,n_n+c,pk)));
+      }
+      break;
+    case IRT_LQ:
+      {
+        ViewArray<BoolView> x(home,n_n);
+        for (int i=n_n; i--; )
+          x[i]=t_n[i].x;
+        GECODE_ES_FAIL(home,(GqBoolInt<BoolView>::post(home,x,-c,pk)));
+      }
+      break;
+    default: GECODE_NEVER;
+    }
+  }
+
+
+  void
+  post_mixed(Space* home,
+             Term<BoolView>* t_p, int n_p,
+             Term<BoolView>* t_n, int n_n,
+             IntRelType r, IntView y, int c) {
+    ScaleBoolArray b_p(home,n_p);
+    {
+      ScaleBool* f=b_p.fst();
+      for (int i=n_p; i--; ) {
+        f[i].x=t_p[i].x; f[i].a=t_p[i].a;
+      }
+    }
+    ScaleBoolArray b_n(home,n_n);
+    {
+      ScaleBool* f=b_n.fst();
+      for (int i=n_n; i--; ) {
+        f[i].x=t_n[i].x; f[i].a=t_n[i].a;
+      }
+    }
+    switch (r) {
+    case IRT_EQ:
+      GECODE_ES_FAIL(home,
+                     (EqBoolScale<ScaleBoolArray,ScaleBoolArray,IntView>
+                      ::post(home,b_p,b_n,y,c)));
+      break;
+    case IRT_NQ:
+      GECODE_ES_FAIL(home,
+                     (NqBoolScale<ScaleBoolArray,ScaleBoolArray,IntView>
+                      ::post(home,b_p,b_n,y,c)));
+      break;
+    case IRT_LQ:
+      GECODE_ES_FAIL(home,
+                     (LqBoolScale<ScaleBoolArray,ScaleBoolArray,IntView>
+                      ::post(home,b_p,b_n,y,c)));
+      break;
+    case IRT_GQ:
+      {
+        MinusView m(y);
+        GECODE_ES_FAIL(home,
+                       (LqBoolScale<ScaleBoolArray,ScaleBoolArray,MinusView>
+                        ::post(home,b_n,b_p,m,-c)));
+      }
+      break;
+    default:
+      GECODE_NEVER;
+    }
+  }
+  
+
+  void
+  post_mixed(Space* home, 
+             Term<BoolView>* t_p, int n_p,
+             Term<BoolView>* t_n, int n_n,
+             IntRelType r, ZeroIntView y, int c) {
+    ScaleBoolArray b_p(home,n_p);
+    {
+      ScaleBool* f=b_p.fst();
+      for (int i=n_p; i--; ) {
+        f[i].x=t_p[i].x; f[i].a=t_p[i].a;
+      }
+    }
+    ScaleBoolArray b_n(home,n_n);
+    {
+      ScaleBool* f=b_n.fst();
+      for (int i=n_n; i--; ) {
+        f[i].x=t_n[i].x; f[i].a=t_n[i].a;
+      }
+    }
+    switch (r) {
+    case IRT_EQ:
+      GECODE_ES_FAIL(home,
+                     (EqBoolScale<ScaleBoolArray,ScaleBoolArray,ZeroIntView>
+                      ::post(home,b_p,b_n,y,c)));
+      break;
+    case IRT_NQ:
+      GECODE_ES_FAIL(home,
+                     (NqBoolScale<ScaleBoolArray,ScaleBoolArray,ZeroIntView>
+                      ::post(home,b_p,b_n,y,c)));
+      break;
+    case IRT_LQ:
+      GECODE_ES_FAIL(home,
+                     (LqBoolScale<ScaleBoolArray,ScaleBoolArray,ZeroIntView>
+                      ::post(home,b_p,b_n,y,c)));
+      break;
+    case IRT_GQ:
+      GECODE_ES_FAIL(home,
+                     (LqBoolScale<ScaleBoolArray,ScaleBoolArray,ZeroIntView>
+                      ::post(home,b_n,b_p,y,-c)));
+      break;
+    default:
+      GECODE_NEVER;
+    }
+  }
+  
+  template <class View>
+  forceinline void
+  post_all(Space* home, 
+           Term<BoolView>* t, int n,
+           IntRelType r, View x, int c, PropKind pk) {
+
+    Limits::check(c,"Int::linear");
+
+    {
+      double d = c;
+
+      // Eliminate non-strict relations
+      switch (r) {
+      case IRT_EQ: case IRT_NQ: case IRT_LQ: case IRT_GQ:
+        break;
+      case IRT_LE:
+        d--; r = IRT_LQ; break;
+      case IRT_GR:
+        d++; r = IRT_GQ; break;
+      default:
+        throw UnknownRelation("Int::linear");
+      }
+
+      // Eliminate assigned views
+      for (int i=n; i--; )
+        if (t[i].x.one()) {
+          d -= t[i].a; t[i]=t[--n];
+        } else if (t[i].x.zero()) {
+          t[i]=t[--n];
+        }
+
+      Limits::check(d,"Int::linear");
+      
+      c = static_cast<int>(d);
+    }
+    
+    Term<BoolView> *t_p, *t_n;
+    int n_p, n_n;
+    bool unit = normalize<BoolView>(t,n,t_p,n_p,t_n,n_n);
+
+    if (n == 0) {
+      switch (r) {
+      case IRT_EQ: GECODE_ME_FAIL(home,x.eq(home,-c)); break;
+      case IRT_NQ: GECODE_ME_FAIL(home,x.nq(home,-c)); break;
+      case IRT_GQ: GECODE_ME_FAIL(home,x.lq(home,-c)); break;
+      case IRT_LQ: GECODE_ME_FAIL(home,x.gq(home,-c)); break;
+      default: GECODE_NEVER;
+      }
+      return;
+    }
+    
+    // Check for overflow
+    {
+      double sl = x.max()+c;
+      double su = x.min()+c;
+      for (int i=n_p; i--; )
+        su -= t_p[i].a;
+      for (int i=n_n; i--; )
+        sl += t_n[i].a;
+      Limits::check(sl,"Int::linear");
+      Limits::check(su,"Int::linear");
+    }
+    
+    if (unit && (n_n == 0)) {
+      /// All coefficients are 1
+      post_pos_unit(home,t_p,n_p,r,x,c,pk);
+    } else if (unit && (n_p == 0)) {
+      // All coefficients are -1
+      post_neg_unit(home,t_n,n_n,r,x,c,pk);
+    } else {
+      // Mixed coefficients
+      post_mixed(home,t_p,n_p,t_n,n_n,r,x,c);
+    }
+  }
+  
+
+  void
+  post(Space* home, 
+       Term<BoolView>* t, int n, IntRelType r, IntView x, int c, 
+       IntConLevel, PropKind pk) {
+    post_all(home,t,n,r,x,c,pk);
+  }
+  
+  void
+  post(Space* home, 
+       Term<BoolView>* t, int n, IntRelType r, int c, 
+       IntConLevel, PropKind pk) {
+    ZeroIntView x;
+    post_all(home,t,n,r,x,c,pk);
+  }
+
+  void
+  post(Space* home, 
+       Term<BoolView>* t, int n, IntRelType r, IntView x, BoolView b,
+       IntConLevel icl, PropKind pk) {
+    int l, u;
+    estimate(t,n,0,l,u);
+    IntVar z(home,l,u); IntView zv(z);
+    post_all(home,t,n,IRT_EQ,zv,0,pk);
+    rel(home,z,r,x,b,icl,pk);    
+  }
+  
+  void
+  post(Space* home, 
+       Term<BoolView>* t, int n, IntRelType r, int c, BoolView b,
+       IntConLevel icl, PropKind pk) {
+    int l, u;
+    estimate(t,n,0,l,u);
+    IntVar z(home,l,u); IntView zv(z);
+    post_all(home,t,n,IRT_EQ,zv,0,pk);
+    rel(home,z,r,c,b,icl,pk);
+  }
+
+}}}
+
+// STATISTICS: int-post
+

data/ext/gecode-2.2.0/gecode/int/linear/int-bin.icc

@@ -0,0 +1,605 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2003
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 09:28:48 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7285 $
+ *
+ *  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 Linear {
+
+  /*
+   * Binary linear propagators
+   *
+   */
+  template <class Val, class A, class B, PropCond pc>
+  forceinline
+  LinBin<Val,A,B,pc>::LinBin(Space* home, A y0, B y1, Val c0)
+    : Propagator(home), x0(y0), x1(y1), c(c0) {
+    x0.subscribe(home,this,pc);
+    x1.subscribe(home,this,pc);
+  }
+
+  template <class Val, class A, class B, PropCond pc>
+  forceinline
+  LinBin<Val,A,B,pc>::LinBin(Space* home, bool share, LinBin<Val,A,B,pc>& p)
+    : Propagator(home,share,p), c(p.c) {
+    x0.update(home,share,p.x0);
+    x1.update(home,share,p.x1);
+  }
+
+  template <class Val, class A, class B, PropCond pc>
+  forceinline
+  LinBin<Val,A,B,pc>::LinBin(Space* home, bool share, Propagator& p,
+                             A y0, B y1, Val c0)
+    : Propagator(home,share,p), c(c0) {
+    x0.update(home,share,y0);
+    x1.update(home,share,y1);
+  }
+
+  template <class Val, class A, class B, PropCond pc>
+  PropCost
+  LinBin<Val,A,B,pc>::cost(ModEventDelta) const {
+    return PC_BINARY_LO;
+  }
+
+  template <class Val, class A, class B, PropCond pc>
+  Reflection::ActorSpec
+  LinBin<Val,A,B,pc>::spec(const Space* home, Reflection::VarMap& m,
+                           const Support::Symbol& ati) const {
+    Reflection::ActorSpec s(ati);
+    return s << x0.spec(home, m)
+             << x1.spec(home, m)
+             << c;
+  }
+
+
+  template <class Val, class A, class B, PropCond pc>
+  forceinline size_t
+  LinBin<Val,A,B,pc>::dispose(Space* home) {
+    assert(!home->failed());
+    x0.cancel(home,this,pc);
+    x1.cancel(home,this,pc);
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+
+  /*
+   * Binary reified linear propagators
+   *
+   */
+  template <class Val, class A, class B, PropCond pc, class Ctrl>
+  forceinline
+  ReLinBin<Val,A,B,pc,Ctrl>::ReLinBin(Space* home, A y0, B y1, Val c0, Ctrl b0)
+    : Propagator(home), x0(y0), x1(y1), c(c0), b(b0) {
+    x0.subscribe(home,this,pc);
+    x1.subscribe(home,this,pc);
+    b.subscribe(home,this,PC_INT_VAL);
+  }
+
+  template <class Val, class A, class B, PropCond pc, class Ctrl>
+  forceinline
+  ReLinBin<Val,A,B,pc,Ctrl>::ReLinBin(Space* home, bool share,
+                                      ReLinBin<Val,A,B,pc,Ctrl>& p)
+    : Propagator(home,share,p), c(p.c) {
+    x0.update(home,share,p.x0);
+    x1.update(home,share,p.x1);
+    b.update(home,share,p.b);
+  }
+
+  template <class Val, class A, class B, PropCond pc, class Ctrl>
+  PropCost
+  ReLinBin<Val,A,B,pc,Ctrl>::cost(ModEventDelta) const {
+    return PC_BINARY_LO;
+  }
+
+  template <class Val, class A, class B, PropCond pc, class Ctrl>
+  forceinline size_t
+  ReLinBin<Val,A,B,pc,Ctrl>::dispose(Space* home) {
+    assert(!home->failed());
+    x0.cancel(home,this,pc);
+    x1.cancel(home,this,pc);
+    b.cancel(home,this,PC_BOOL_VAL);
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+  template <class Val, class A, class B, PropCond pc, class Ctrl>
+  Reflection::ActorSpec
+  ReLinBin<Val,A,B,pc,Ctrl>::spec(const Space* home, Reflection::VarMap& m,
+                                  const Support::Symbol& ati) const {
+    Reflection::ActorSpec s(ati);
+    return s << x0.spec(home, m)
+             << x1.spec(home, m)
+             << c
+             << b.spec(home, m);
+  }
+
+  /*
+   * Binary bounds consistent linear equality
+   *
+   */
+
+  template <class Val, class A, class B>
+  forceinline
+  EqBin<Val,A,B>::EqBin(Space* home, A x0, B x1, Val c)
+    : LinBin<Val,A,B,PC_INT_BND>(home,x0,x1,c) {}
+
+  template <class Val, class A, class B>
+  ExecStatus
+  EqBin<Val,A,B>::post(Space* home, A x0, B x1, Val c) {
+    (void) new (home) EqBin<Val,A,B>(home,x0,x1,c);
+    return ES_OK;
+  }
+
+
+  template <class Val, class A, class B>
+  forceinline
+  EqBin<Val,A,B>::EqBin(Space* home, bool share, EqBin<Val,A,B>& p)
+    : LinBin<Val,A,B,PC_INT_BND>(home,share,p) {}
+
+  template <class Val, class A, class B>
+  forceinline
+  EqBin<Val,A,B>::EqBin(Space* home, bool share, Propagator& p,
+                        A x0, B x1, Val c)
+    : LinBin<Val,A,B,PC_INT_BND>(home,share,p,x0,x1,c) {}
+
+  template <class Val, class A, class B>
+  Actor*
+  EqBin<Val,A,B>::copy(Space* home, bool share) {
+    return new (home) EqBin<Val,A,B>(home,share,*this);
+  }
+
+  template <class Val, class A, class B>
+  inline Support::Symbol
+  EqBin<Val,A,B>::ati(void) {
+    return Reflection::mangle<Val,A,B>("Gecode::Int::Linear::EqBin");
+  }
+
+  template <class Val, class A, class B>
+  Reflection::ActorSpec
+  EqBin<Val,A,B>::spec(const Space* home, Reflection::VarMap& m) const {
+    return LinBin<Val,A,B,PC_INT_BND>::spec(home, m, ati());
+  }
+
+  template <class Val, class A, class B>
+  void
+  EqBin<Val,A,B>::post(Space* home, Reflection::VarMap& vars,
+                       const Reflection::ActorSpec& spec) {
+    spec.checkArity(3);
+    A x(home, vars, spec[0]);
+    B y(home, vars, spec[1]);
+    Val c = spec[2]->toInt();
+    (void) new (home) EqBin<Val,A,B>(home, x, y, c);
+  }
+
+  /// Describe which view has been modified how
+  enum BinMod {
+    BM_X0_MIN = 1<<0,
+    BM_X0_MAX = 1<<1,
+    BM_X1_MIN = 1<<2,
+    BM_X1_MAX = 1<<3,
+    BM_ALL    = BM_X0_MIN|BM_X0_MAX|BM_X1_MIN|BM_X1_MAX
+  };
+
+#define GECODE_INT_PV(CASE,TELL,UPDATE)         \
+  if (bm & (CASE)) {                            \
+    bm -= (CASE); ModEvent me = (TELL);         \
+    if (me_failed(me))   return ES_FAILED;      \
+    if (me_modified(me)) bm |= (UPDATE);        \
+  }
+
+  template <class Val, class A, class B>
+  ExecStatus
+  EqBin<Val,A,B>::propagate(Space* home, ModEventDelta) {
+    int bm = BM_ALL;
+    do {
+      GECODE_INT_PV(BM_X0_MIN, x0.gq(home,c-x1.max()), BM_X1_MAX);
+      GECODE_INT_PV(BM_X1_MIN, x1.gq(home,c-x0.max()), BM_X0_MAX);
+      GECODE_INT_PV(BM_X0_MAX, x0.lq(home,c-x1.min()), BM_X1_MIN);
+      GECODE_INT_PV(BM_X1_MAX, x1.lq(home,c-x0.min()), BM_X0_MIN);
+    } while (bm);
+    return x0.assigned() ? ES_SUBSUMED(this,sizeof(*this)) : ES_FIX;
+  }
+
+#undef GECODE_INT_PV
+
+
+
+
+
+  /*
+   * Reified binary bounds consistent linear equality
+   *
+   */
+
+  template <class Val, class A, class B, class Ctrl>
+  forceinline
+  ReEqBin<Val,A,B,Ctrl>::ReEqBin(Space* home, A x0, B x1, Val c, Ctrl b)
+    : ReLinBin<Val,A,B,PC_INT_BND,Ctrl>(home,x0,x1,c,b) {}
+
+  template <class Val, class A, class B, class Ctrl>
+  ExecStatus
+  ReEqBin<Val,A,B,Ctrl>::post(Space* home, A x0, B x1, Val c, Ctrl b) {
+    (void) new (home) ReEqBin<Val,A,B,Ctrl>(home,x0,x1,c,b);
+    return ES_OK;
+  }
+
+
+  template <class Val, class A, class B, class Ctrl>
+  forceinline
+  ReEqBin<Val,A,B,Ctrl>::ReEqBin(Space* home, bool share,
+                                 ReEqBin<Val,A,B,Ctrl>& p)
+    : ReLinBin<Val,A,B,PC_INT_BND,Ctrl>(home,share,p) {}
+
+  template <class Val, class A, class B, class Ctrl>
+  Actor*
+  ReEqBin<Val,A,B,Ctrl>::copy(Space* home, bool share) {
+    return new (home) ReEqBin<Val,A,B,Ctrl>(home,share,*this);
+  }
+
+  template <class Val, class A, class B, class Ctrl>
+  inline Support::Symbol
+  ReEqBin<Val,A,B,Ctrl>::ati(void) {
+    return Reflection::mangle<Val,A,B,Ctrl>("Gecode::Int::Linear::ReEqBin");
+  }
+
+  template <class Val, class A, class B, class Ctrl>
+  Reflection::ActorSpec
+  ReEqBin<Val,A,B,Ctrl>::spec(const Space* home,
+                              Reflection::VarMap& m) const {
+    return ReLinBin<Val,A,B,PC_INT_BND,Ctrl>::spec(home, m, ati());
+  }
+
+  template <class Val, class A, class B, class Ctrl>
+  void
+  ReEqBin<Val,A,B,Ctrl>::post(Space* home, Reflection::VarMap& vars,
+                              const Reflection::ActorSpec& spec) {
+    spec.checkArity(4);
+    A x(home, vars, spec[0]);
+    B y(home, vars, spec[1]);
+    Val c = spec[2]->toInt();
+    Ctrl b(home, vars, spec[3]);
+    (void) new (home) ReEqBin<Val,A,B,Ctrl>(home, x, y, c, b);
+  }
+
+  template <class Val, class A, class B, class Ctrl>
+  ExecStatus
+  ReEqBin<Val,A,B,Ctrl>::propagate(Space* home, ModEventDelta) {
+    if (b.zero())
+      GECODE_REWRITE(this,(NqBin<Val,A,B>::post(home,x0,x1,c)));
+    if (b.one())
+      GECODE_REWRITE(this,(EqBin<Val,A,B>::post(home,x0,x1,c)));
+    if ((x0.min() + x1.min() > c) || (x0.max() + x1.max() < c)) {
+      GECODE_ME_CHECK(b.zero_none(home)); return ES_SUBSUMED(this,home);
+    }
+    if (x0.assigned() && x1.assigned()) {
+      assert(x0.val() + x1.val() == c);
+      GECODE_ME_CHECK(b.one_none(home)); return ES_SUBSUMED(this,home);
+    }
+    return ES_FIX;
+  }
+
+
+
+
+  /*
+   * Binary domain consistent linear disequality
+   *
+   */
+  template <class Val, class A, class B>
+  forceinline
+  NqBin<Val,A,B>::NqBin(Space* home, A x0, B x1, Val c)
+    : LinBin<Val,A,B,PC_INT_VAL>(home,x0,x1,c) {}
+
+  template <class Val, class A, class B>
+  ExecStatus
+  NqBin<Val,A,B>::post(Space* home, A x0, B x1, Val c) {
+    (void) new (home) NqBin<Val,A,B>(home,x0,x1,c);
+    return ES_OK;
+  }
+
+
+  template <class Val, class A, class B>
+  forceinline
+  NqBin<Val,A,B>::NqBin(Space* home, bool share, NqBin<Val,A,B>& p)
+    : LinBin<Val,A,B,PC_INT_VAL>(home,share,p) {}
+
+  template <class Val, class A, class B>
+  Actor*
+  NqBin<Val,A,B>::copy(Space* home, bool share) {
+    return new (home) NqBin<Val,A,B>(home,share,*this);
+  }
+
+  template <class Val, class A, class B>
+  forceinline
+  NqBin<Val,A,B>::NqBin(Space* home, bool share, Propagator& p,
+                        A x0, B x1, Val c)
+    : LinBin<Val,A,B,PC_INT_VAL>(home,share,p,x0,x1,c) {}
+
+
+
+  template <class Val, class A, class B>
+  PropCost
+  NqBin<Val,A,B>::cost(ModEventDelta) const {
+    return PC_UNARY_LO;
+  }
+
+  template <class Val, class A, class B>
+  inline Support::Symbol
+  NqBin<Val,A,B>::ati(void) {
+    return Reflection::mangle<Val,A,B>("Gecode::Int::Linear::NqBin");
+  }
+
+  template <class Val, class A, class B>
+  Reflection::ActorSpec
+  NqBin<Val,A,B>::spec(const Space* home, Reflection::VarMap& m) const {
+    return LinBin<Val,A,B,PC_INT_VAL>::spec(home, m, ati());
+  }
+
+  template <class Val, class A, class B>
+  void
+  NqBin<Val,A,B>::post(Space* home, Reflection::VarMap& vars,
+                       const Reflection::ActorSpec& spec) {
+    spec.checkArity(3);
+    A x(home, vars, spec[0]);
+    B y(home, vars, spec[1]);
+    Val c = spec[2]->toInt();
+    (void) new (home) NqBin<Val,A,B>(home, x, y, c);
+  }
+
+  template <class Val, class A, class B>
+  ExecStatus
+  NqBin<Val,A,B>::propagate(Space* home, ModEventDelta) {
+    if (x0.assigned()) {
+      GECODE_ME_CHECK(x1.nq(home,c-x0.val()));
+    } else {
+      assert(x1.assigned());
+      GECODE_ME_CHECK(x0.nq(home,c-x1.val()));
+    }
+    return ES_SUBSUMED(this,home);
+  }
+
+
+  /*
+   * Binary domain consistent less equal
+   *
+   */
+
+  template <class Val, class A, class B>
+  forceinline
+  LqBin<Val,A,B>::LqBin(Space* home, A x0, B x1, Val c)
+    : LinBin<Val,A,B,PC_INT_BND>(home,x0,x1,c) {}
+
+  template <class Val, class A, class B>
+  ExecStatus
+  LqBin<Val,A,B>::post(Space* home, A x0, B x1, Val c) {
+    (void) new (home) LqBin<Val,A,B>(home,x0,x1,c);
+    return ES_OK;
+  }
+
+
+  template <class Val, class A, class B>
+  forceinline
+  LqBin<Val,A,B>::LqBin(Space* home, bool share, LqBin<Val,A,B>& p)
+    : LinBin<Val,A,B,PC_INT_BND>(home,share,p) {}
+
+  template <class Val, class A, class B>
+  Actor*
+  LqBin<Val,A,B>::copy(Space* home, bool share) {
+    return new (home) LqBin<Val,A,B>(home,share,*this);
+  }
+
+  template <class Val, class A, class B>
+  forceinline
+  LqBin<Val,A,B>::LqBin(Space* home, bool share, Propagator& p,
+                        A x0, B x1, Val c)
+    : LinBin<Val,A,B,PC_INT_BND>(home,share,p,x0,x1,c) {}
+
+  template <class Val, class A, class B>
+  inline Support::Symbol
+  LqBin<Val,A,B>::ati(void) {
+    return Reflection::mangle<Val,A,B>("Gecode::Int::Linear::LqBin");
+  }
+
+  template <class Val, class A, class B>
+  Reflection::ActorSpec
+  LqBin<Val,A,B>::spec(const Space* home, Reflection::VarMap& m) const {
+    return LinBin<Val,A,B,PC_INT_BND>::spec(home, m, ati());
+  }
+
+  template <class Val, class A, class B>
+  void
+  LqBin<Val,A,B>::post(Space* home, Reflection::VarMap& vars,
+                       const Reflection::ActorSpec& spec) {
+    spec.checkArity(3);
+    A x(home, vars, spec[0]);
+    B y(home, vars, spec[1]);
+    Val c = spec[2]->toInt();
+    (void) new (home) LqBin<Val,A,B>(home, x, y, c);
+  }
+
+  template <class Val, class A, class B>
+  ExecStatus
+  LqBin<Val,A,B>::propagate(Space* home, ModEventDelta) {
+    GECODE_ME_CHECK(x0.lq(home,c-x1.min()));
+    GECODE_ME_CHECK(x1.lq(home,c-x0.min()));
+    return (x0.max()+x1.max() <= c) ? ES_SUBSUMED(this,home) : ES_FIX;
+  }
+
+
+
+
+  /*
+   * Binary domain consistent greater equal
+   *
+   */
+
+  template <class Val, class A, class B>
+  forceinline
+  GqBin<Val,A,B>::GqBin(Space* home, A x0, B x1, Val c)
+    : LinBin<Val,A,B,PC_INT_BND>(home,x0,x1,c) {}
+
+  template <class Val, class A, class B>
+  ExecStatus
+  GqBin<Val,A,B>::post(Space* home, A x0, B x1, Val c) {
+    (void) new (home) GqBin<Val,A,B>(home,x0,x1,c);
+    return ES_OK;
+  }
+
+
+  template <class Val, class A, class B>
+  forceinline
+  GqBin<Val,A,B>::GqBin(Space* home, bool share, GqBin<Val,A,B>& p)
+    : LinBin<Val,A,B,PC_INT_BND>(home,share,p) {}
+
+  template <class Val, class A, class B>
+  Actor*
+  GqBin<Val,A,B>::copy(Space* home, bool share) {
+    return new (home) GqBin<Val,A,B>(home,share,*this);
+  }
+
+  template <class Val, class A, class B>
+  forceinline
+  GqBin<Val,A,B>::GqBin(Space* home, bool share, Propagator& p,
+                        A x0, B x1, Val c)
+    : LinBin<Val,A,B,PC_INT_BND>(home,share,p,x0,x1,c) {}
+
+  template <class Val, class A, class B>
+  inline Support::Symbol
+  GqBin<Val,A,B>::ati(void) {
+    return Reflection::mangle<Val,A,B>("Gecode::Int::Linear::GqBin");
+  }
+
+  template <class Val, class A, class B>
+  Reflection::ActorSpec
+  GqBin<Val,A,B>::spec(const Space* home, Reflection::VarMap& m) const {
+    return LinBin<Val,A,B,PC_INT_BND>::spec(home, m, ati());
+  }
+
+  template <class Val, class A, class B>
+  void
+  GqBin<Val,A,B>::post(Space* home, Reflection::VarMap& vars,
+                       const Reflection::ActorSpec& spec) {
+    spec.checkArity(3);
+    A x(home, vars, spec[0]);
+    B y(home, vars, spec[1]);
+    Val c = spec[2]->toInt();
+    (void) new (home) GqBin<Val,A,B>(home, x, y, c);
+  }
+
+  template <class Val, class A, class B>
+  ExecStatus
+  GqBin<Val,A,B>::propagate(Space* home, ModEventDelta) {
+    GECODE_ME_CHECK(x0.gq(home,c-x1.max()));
+    GECODE_ME_CHECK(x1.gq(home,c-x0.max()));
+    return (x0.min()+x1.min() >= c) ? ES_SUBSUMED(this,home) : ES_FIX;
+  }
+
+
+
+
+  /*
+   * Reified binary domain consistent less equal
+   *
+   */
+
+  template <class Val, class A, class B>
+  forceinline
+  ReLqBin<Val,A,B>::ReLqBin(Space* home, A x0, B x1, Val c, BoolView b)
+    : ReLinBin<Val,A,B,PC_INT_BND,BoolView>(home,x0,x1,c,b) {}
+
+  template <class Val, class A, class B>
+  ExecStatus
+  ReLqBin<Val,A,B>::post(Space* home, A x0, B x1, Val c, BoolView b) {
+    (void) new (home) ReLqBin<Val,A,B>(home,x0,x1,c,b);
+    return ES_OK;
+  }
+
+
+  template <class Val, class A, class B>
+  forceinline
+  ReLqBin<Val,A,B>::ReLqBin(Space* home, bool share, ReLqBin<Val,A,B>& p)
+    : ReLinBin<Val,A,B,PC_INT_BND,BoolView>(home,share,p) {}
+
+  template <class Val, class A, class B>
+  Actor*
+  ReLqBin<Val,A,B>::copy(Space* home, bool share) {
+    return new (home) ReLqBin<Val,A,B>(home,share,*this);
+  }
+
+  template <class Val, class A, class B>
+  Support::Symbol
+  ReLqBin<Val,A,B>::ati(void) {
+    return Reflection::mangle<Val,A,B>("Gecode::Int::Linear::ReLqBin");
+  }
+
+  template <class Val, class A, class B>
+  Reflection::ActorSpec
+  ReLqBin<Val,A,B>::spec(const Space* home, Reflection::VarMap& m) const {
+    return ReLinBin<Val,A,B,PC_INT_BND,BoolView>::spec(home, m, ati());
+  }
+
+  template <class Val, class A, class B>
+  void
+  ReLqBin<Val,A,B>::post(Space* home, Reflection::VarMap& vars,
+                         const Reflection::ActorSpec& spec) {
+    spec.checkArity(4);
+    A x(home, vars, spec[0]);
+    B y(home, vars, spec[1]);
+    Val c = spec[2]->toInt();
+    BoolView b(home, vars, spec[3]);
+    (void) new (home) ReLqBin<Val,A,B>(home, x, y, c, b);
+  }
+
+
+  template <class Val, class A, class B>
+  ExecStatus
+  ReLqBin<Val,A,B>::propagate(Space* home, ModEventDelta) {
+    if (b.one())
+      GECODE_REWRITE(this,(LqBin<Val,A,B>::post(home,x0,x1,c)));
+    if (b.zero())
+      GECODE_REWRITE(this,(GqBin<Val,A,B>::post(home,x0,x1,c+1)));
+    if (x0.max() + x1.max() <= c) {
+      GECODE_ME_CHECK(b.one_none(home)); return ES_SUBSUMED(this,home);
+    }
+    if (x0.min() + x1.min() > c) {
+      GECODE_ME_CHECK(b.zero_none(home)); return ES_SUBSUMED(this,home);
+    }
+    return ES_FIX;
+  }
+
+}}}
+
+// STATISTICS: int-prop
+