gecoder-with-gecode 0.9.0 → 0.9.1

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

@@ -1,433 +0,0 @@
-/* -*- 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-03-06 10:39:58 +0100 (Thu, 06 Mar 2008) $ by $Author: tack $
- *     $Revision: 6446 $
- *
- *  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.1.1/gecode/int/linear/int-bin.icc

@@ -1,605 +0,0 @@
-/* -*- 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-02-13 18:45:15 +0100 (Wed, 13 Feb 2008) $ by $Author: nikopp $
- *     $Revision: 6155 $
- *
- *  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
-