main page modules namespaces classes files
Gecode home

search for 

nary.icc

Go to the documentation of this file.

/*
 *  Main authors:
 *     Christian Schulte <schulte@gecode.org>
 *
 *  Copyright:
 *     Christian Schulte, 2003
 *
 *  Last modified:
 *     $Date: 2006-08-04 16:03:26 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
 *     $Revision: 3512 $
 *
 *  This file is part of Gecode, the generic constraint
 *  development environment:
 *     http://www.gecode.org
 *
 *  See the file "LICENSE" for information on usage and
 *  redistribution of this file, and for a
 *     DISCLAIMER OF ALL WARRANTIES.
 *
 */

#include "gecode/int/linear/noview.icc"

namespace Gecode { namespace Int { namespace Linear {

  template <class P, class N>
  forceinline bool
  isunit(ViewArray<P>& x, ViewArray<N>& y) { return false; }
  template <>
  forceinline bool
  isunit(ViewArray<IntView>& x, ViewArray<IntView>& y) { return true; }
  template <>
  forceinline bool
  isunit(ViewArray<IntView>& x, ViewArray<NoView>& y) { return true; }
  template <>
  forceinline bool
  isunit(ViewArray<NoView>& x, ViewArray<IntView>& y) { return true; }

  /*
   * Linear propagators
   *
   */
  template <class Val, class P, class N, PropCond pc>
  forceinline
  Lin<Val,P,N,pc>::Lin(Space* home, ViewArray<P>& x0, ViewArray<N>& y0, Val c0)
    : Propagator(home), x(x0), y(y0), c(c0) {
    x.subscribe(home,this,pc);
    y.subscribe(home,this,pc);
  }

  template <class Val, class P, class N, PropCond pc>
  forceinline
  Lin<Val,P,N,pc>::Lin(Space* home, bool share, Lin<Val,P,N,pc>& p)
    : Propagator(home,share,p), c(p.c) {
    x.update(home,share,p.x);
    y.update(home,share,p.y);
  }

  template <class Val, class P, class N, PropCond pc>
  PropCost
  Lin<Val,P,N,pc>::cost(void) const {
    return cost_lo(x.size() + y.size(), PC_LINEAR_LO);
  }

  template <class Val, class P, class N, PropCond pc>
  forceinline size_t
  Lin<Val,P,N,pc>::dispose(Space* home) {
    assert(!home->failed());
    x.cancel(home,this,pc);
    y.cancel(home,this,pc);
    (void) Propagator::dispose(home);
    return sizeof(*this);
  }


  /*
   * Reified linear propagators
   *
   */
  template <class Val, class P, class N, PropCond pc, class Ctrl>
  forceinline
  ReLin<Val,P,N,pc,Ctrl>::ReLin
  (Space* home, ViewArray<P>& x, ViewArray<N>& y, Val c, Ctrl b0)
    : Lin<Val,P,N,pc>(home,x,y,c), b(b0) {
    b.subscribe(home,this,PC_INT_VAL);
  }

  template <class Val, class P, class N, PropCond pc, class Ctrl>
  forceinline
  ReLin<Val,P,N,pc,Ctrl>::ReLin
  (Space* home, bool share, ReLin<Val,P,N,pc,Ctrl>& p)
    : Lin<Val,P,N,pc>(home,share,p) {
    b.update(home,share,p.b);
  }

  template <class Val, class P, class N, PropCond pc, class Ctrl>
  size_t
  ReLin<Val,P,N,pc,Ctrl>::dispose(Space* home) {
    assert(!home->failed());
    b.cancel(home,this,PC_INT_VAL);
    (void) Lin<Val,P,N,pc>::dispose(home);
    return sizeof(*this);
  }


  /*
   * Computing bounds
   *
   */

  template <class Val, class View>
  void
  bounds_p(const Propagator* p, ViewArray<View>& x,
           Val& c, Val& sl, Val& su) {
    int n = x.size();
    if (IntView::pme(p) == ME_INT_VAL) {
      for (int i = n; i--; ) {
        Val m = x[i].min();
        if (x[i].assigned()) {
          c -= m; x[i] = x[--n];
        } else {
          sl -= m; su -= x[i].max();
        }
      }
      x.size(n);
    } else {
      for (int i = n; i--; ) {
        sl -= x[i].min(); su -= x[i].max();
      }
    }
  }

  template <class Val, class View>
  void
  bounds_n(const Propagator* p, ViewArray<View>& y,
           Val& c, Val& sl, Val& su) {
    int n = y.size();
    if (IntView::pme(p) == ME_INT_VAL) {
      for (int i = n; i--; ) {
        Val m = y[i].max();
        if (y[i].assigned()) {
          c += m; y[i] = y[--n];
        } else {
          sl += m; su += y[i].min();
        }
      }
      y.size(n);
    } else {
      for (int i = n; i--; ) {
        sl += y[i].max(); su += y[i].min();
      }
    }
  }


  template <class Val, class P, class N>
  ExecStatus
  prop_bnd(const Propagator* p, Space* home,
           ViewArray<P>& x, ViewArray<N>& y, Val& c) {
    // Eliminate singletons
    Val sl = 0;
    Val su = 0;

    bounds_p<Val,P>(p, x, c, sl, su);
    bounds_n<Val,N>(p, y, c, sl, su);

    if ((IntView::pme(p) == ME_INT_VAL) && ((x.size() + y.size()) <= 1)) {
      if (x.size() == 1) {
        GECODE_ME_CHECK(x[0].eq(home,c)); return ES_SUBSUMED;
      }
      if (y.size() == 1) {
        GECODE_ME_CHECK(y[0].eq(home,-c)); return ES_SUBSUMED;
      }
      return (c == static_cast<Val>(0)) ? ES_SUBSUMED : ES_FAILED;
    }

    sl += c; su += c;

    const int mod_sl = 1;
    const int mod_su = 2;

    int mod = mod_sl | mod_su;

    do {
      if (mod & mod_sl) {
        mod -= mod_sl;
        // Propagate upper bound for positive variables
        for (int i = x.size(); i--; ) {
          const Val xi_max = x[i].max();
          ModEvent me = x[i].lq(home,sl + x[i].min());
          if (me_failed(me))
            return ES_FAILED;
          if (me_modified(me)) {
            su += xi_max - x[i].max();
            mod |= mod_su;
          }
        }
        // Propagate lower bound for negative variables
        for (int i = y.size(); i--; ) {
          const Val yi_min = y[i].min();
          ModEvent me = y[i].gq(home,y[i].max() - sl);
          if (me_failed(me))
            return ES_FAILED;
          if (me_modified(me)) {
            su += y[i].min() - yi_min;
            mod |= mod_su;
          }
        }
      }
      if (mod & mod_su) {
        mod -= mod_su;
        // Propagate lower bound for positive variables
        for (int i = x.size(); i--; ) {
          const Val xi_min = x[i].min();
          ModEvent me = x[i].gq(home,su + x[i].max());
          if (me_failed(me))
            return ES_FAILED;
          if (me_modified(me)) {
            sl += xi_min - x[i].min();
            mod |= mod_sl;
          }
        }
        // Propagate upper bound for negative variables
        for (int i = y.size(); i--; ) {
          const Val yi_max = y[i].max();
          ModEvent me = y[i].lq(home,y[i].min() - su);
          if (me_failed(me))
            return ES_FAILED;
          if (me_modified(me)) {
            sl += y[i].max() - yi_max;
            mod |= mod_sl;
          }
        }
      }
    } while (mod);

    return (sl == su) ? ES_SUBSUMED : ES_FIX;
  }

  /*
   * Bound consistent linear equation
   *
   */

  template <class Val, class P, class N>
  forceinline
  Eq<Val,P,N>::Eq(Space* home, ViewArray<P>& x, ViewArray<N>& y, Val c)
    : Lin<Val,P,N,PC_INT_BND>(home,x,y,c) {}

  template <class Val, class P, class N>
  ExecStatus
  Eq<Val,P,N>::post(Space* home, ViewArray<P>& x, ViewArray<N>& y, Val c) {
    ViewArray<NoView> nva;
    if (y.size() == 0) {
      (void) new (home) Eq<Val,P,NoView>(home,x,nva,c);
    } else if (x.size() == 0) {
      (void) new (home) Eq<Val,N,NoView>(home,y,nva,-c);
    } else {
      (void) new (home) Eq<Val,P,N>(home,x,y,c);
    }
    return ES_OK;
  }


  template <class Val, class P, class N>
  forceinline
  Eq<Val,P,N>::Eq(Space* home, bool share, Eq<Val,P,N>& p)
    : Lin<Val,P,N,PC_INT_BND>(home,share,p) {}

  template <class Val, class P, class N>
  forceinline Actor*
  eqtobin(Space* home, bool share, Propagator& p,
          ViewArray<P>& x, ViewArray<N>& y, Val c) {
    return NULL;
  }
  template <class Val>
  forceinline Actor*
  eqtobin(Space* home, bool share, Propagator& p,
          ViewArray<IntView>& x, ViewArray<NoView>& y, Val c) {
    assert(x.size() == 2);
    return new (home) EqBin<Val,IntView,IntView>
      (home,share,p,x[0],x[1],c);
  }
  template <class Val>
  forceinline Actor*
  eqtobin(Space* home, bool share, Propagator& p,
          ViewArray<NoView>& x, ViewArray<IntView>& y, Val c) {
    assert(y.size() == 2);
    return new (home) EqBin<Val,IntView,IntView>
      (home,share,p,y[0],y[1],-c);
  }
  template <class Val>
  forceinline Actor*
  eqtobin(Space* home, bool share, Propagator& p,
          ViewArray<IntView>& x, ViewArray<IntView>& y, Val c) {
    if (x.size() == 2)
      return new (home) EqBin<Val,IntView,IntView>
        (home,share,p,x[0],x[1],c);
    if (x.size() == 1)
      return new (home) EqBin<Val,IntView,MinusView>
        (home,share,p,x[0],y[0],c);
    return new (home) EqBin<Val,IntView,IntView>
      (home,share,p,y[0],y[1],-c);
  }

  template <class Val, class P, class N>
  forceinline Actor*
  eqtoter(Space* home, bool share, Propagator& p,
          ViewArray<P>& x, ViewArray<N>& y, Val c) {
    return NULL;
  }
  template <class Val>
  forceinline Actor*
  eqtoter(Space* home, bool share, Propagator& p,
          ViewArray<IntView>& x, ViewArray<NoView>& y, Val c) {
    assert(x.size() == 3);
    return new (home) EqTer<Val,IntView,IntView,IntView>
      (home,share,p,x[0],x[1],x[2],c);
  }
  template <class Val>
  forceinline Actor*
  eqtoter(Space* home, bool share, Propagator& p,
          ViewArray<NoView>& x, ViewArray<IntView>& y, Val c) {
    assert(y.size() == 3);
    return new (home) EqTer<Val,IntView,IntView,IntView>
      (home,share,p,y[0],y[1],y[2],-c);
  }
  template <class Val>
  forceinline Actor*
  eqtoter(Space* home, bool share, Propagator& p,
          ViewArray<IntView>& x, ViewArray<IntView>& y, Val c) {
    if (x.size() == 3)
      return new (home) EqTer<Val,IntView,IntView,IntView>
        (home,share,p,x[0],x[1],x[2],c);
    if (x.size() == 2)
      return new (home) EqTer<Val,IntView,IntView,MinusView>
        (home,share,p,x[0],x[1],y[0],c);
    if (x.size() == 1)
      return new (home) EqTer<Val,IntView,IntView,MinusView>
        (home,share,p,y[0],y[1],x[0],-c);
    return new (home) EqTer<Val,IntView,IntView,IntView>
      (home,share,p,y[0],y[1],y[2],-c);
  }

  template <class Val, class P, class N>
  Actor*
  Eq<Val,P,N>::copy(Space* home, bool share) {
    if (isunit(x,y)) {
      // Check whether rewriting is possible
      if (x.size() + y.size() == 2)
        return eqtobin(home,share,*this,x,y,c);
      if (x.size() + y.size() == 3)
        return eqtoter(home,share,*this,x,y,c);
    }
    return new (home) Eq<Val,P,N>(home,share,*this);
  }


  template <class Val, class P, class N>
  ExecStatus
  Eq<Val,P,N>::propagate(Space* home) {
    return prop_bnd<Val,P,N>(this,home,x,y,c);
  }

  /*
   * Reified bound consistent linear equation
   *
   */

  template <class Val, class P, class N, class Ctrl>
  forceinline
  ReEq<Val,P,N,Ctrl>::ReEq(Space* home,
                           ViewArray<P>& x, ViewArray<N>& y, Val c, Ctrl b)
    : ReLin<Val,P,N,PC_INT_BND,Ctrl>(home,x,y,c,b) {}

  template <class Val, class P, class N, class Ctrl>
  ExecStatus
  ReEq<Val,P,N,Ctrl>::post(Space* home,
                           ViewArray<P>& x, ViewArray<N>& y, Val c, Ctrl b) {
    ViewArray<NoView> nva;
    if (y.size() == 0) {
      (void) new (home) ReEq<Val,P,NoView,Ctrl>(home,x,nva,c,b);
    } else if (x.size() == 0) {
      (void) new (home) ReEq<Val,N,NoView,Ctrl>(home,y,nva,-c,b);
    } else {
      (void) new (home) ReEq<Val,P,N,Ctrl>(home,x,y,c,b);
    }
    return ES_OK;
  }


  template <class Val, class P, class N, class Ctrl>
  forceinline
  ReEq<Val,P,N,Ctrl>::ReEq(Space* home, bool share, ReEq<Val,P,N,Ctrl>& p)
    : ReLin<Val,P,N,PC_INT_BND,Ctrl>(home,share,p) {}

  template <class Val, class P, class N, class Ctrl>
  Actor*
  ReEq<Val,P,N,Ctrl>::copy(Space* home, bool share) {
    return new (home) ReEq<Val,P,N,Ctrl>(home,share,*this);
  }

  template <class Val, class P, class N, class Ctrl>
  ExecStatus
  ReEq<Val,P,N,Ctrl>::propagate(Space* home) {
    if (b.zero())
      return (Nq<Val,P,N>::post(home,x,y,c) == ES_FAILED)
        ? ES_FAILED : ES_SUBSUMED;
    if (b.one())
      return (Eq<Val,P,N>::post(home,x,y,c) == ES_FAILED)
        ? ES_FAILED : ES_SUBSUMED;

    Val sl = 0;
    Val su = 0;

    bounds_p<Val,P>(this, x, c, sl, su);
    bounds_n<Val,N>(this, y, c, sl, su);

    if ((-sl == c) && (-su == c)) {
      b.t_one_none(home); return ES_SUBSUMED;
    }
    if ((-sl > c) || (-su < c)) {
      b.t_zero_none(home); return ES_SUBSUMED;
    }
    return ES_FIX;
  }


  /*
   * Domain consistent linear disequation
   *
   */

  template <class Val, class P, class N>
  forceinline
  Nq<Val,P,N>::Nq(Space* home, ViewArray<P>& x, ViewArray<N>& y, Val c)
    : Lin<Val,P,N,PC_INT_VAL>(home,x,y,c) {}

  template <class Val, class P, class N>
  ExecStatus
  Nq<Val,P,N>::post(Space* home, ViewArray<P>& x, ViewArray<N>& y, Val c) {
    ViewArray<NoView> nva;
    if (y.size() == 0) {
      (void) new (home) Nq<Val,P,NoView>(home,x,nva,c);
    } else if (x.size() == 0) {
      (void) new (home) Nq<Val,N,NoView>(home,y,nva,-c);
    } else {
      (void) new (home) Nq<Val,P,N>(home,x,y,c);
    }
    return ES_OK;
  }


  template <class Val, class P, class N>
  forceinline
  Nq<Val,P,N>::Nq(Space* home, bool share, Nq<Val,P,N>& p)
    : Lin<Val,P,N,PC_INT_VAL>(home,share,p) {}

  template <class Val, class P, class N>
  forceinline Actor*
  nqtobin(Space* home, bool share, Propagator& p,
          ViewArray<P>& x, ViewArray<N>& y, Val c) {
    return NULL;
  }
  template <class Val>
  forceinline Actor*
  nqtobin(Space* home, bool share, Propagator& p,
          ViewArray<IntView>& x, ViewArray<NoView>& y, Val c) {
    assert(x.size() == 2);
    return new (home) NqBin<Val,IntView,IntView>
      (home,share,p,x[0],x[1],c);
  }
  template <class Val>
  forceinline Actor*
  nqtobin(Space* home, bool share, Propagator& p,
          ViewArray<NoView>& x, ViewArray<IntView>& y, Val c) {
    assert(y.size() == 2);
    return new (home) NqBin<Val,IntView,IntView>
      (home,share,p,y[0],y[1],-c);
  }
  template <class Val>
  forceinline Actor*
  nqtobin(Space* home, bool share, Propagator& p,
          ViewArray<IntView>& x, ViewArray<IntView>& y, Val c) {
    if (x.size() == 2)
      return new (home) NqBin<Val,IntView,IntView>
        (home,share,p,x[0],x[1],c);
    if (x.size() == 1)
      return new (home) NqBin<Val,IntView,MinusView>
        (home,share,p,x[0],y[0],c);
    return new (home) NqBin<Val,IntView,IntView>
      (home,share,p,y[0],y[1],-c);
  }

  template <class Val, class P, class N>
  forceinline Actor*
  nqtoter(Space* home, bool share, Propagator& p,
          ViewArray<P>& x, ViewArray<N>& y, Val c) {
    return NULL;
  }
  template <class Val>
  forceinline Actor*
  nqtoter(Space* home, bool share, Propagator& p,
          ViewArray<IntView>& x, ViewArray<NoView>& y, Val c) {
    assert(x.size() == 3);
    return new (home) NqTer<Val,IntView,IntView,IntView>
      (home,share,p,x[0],x[1],x[2],c);
  }
  template <class Val>
  forceinline Actor*
  nqtoter(Space* home, bool share, Propagator& p,
          ViewArray<NoView>& x, ViewArray<IntView>& y, Val c) {
    assert(y.size() == 3);
    return new (home) NqTer<Val,IntView,IntView,IntView>
      (home,share,p,y[0],y[1],y[2],-c);
  }
  template <class Val>
  forceinline Actor*
  nqtoter(Space* home, bool share, Propagator& p,
          ViewArray<IntView>& x, ViewArray<IntView>& y, Val c) {
    if (x.size() == 3)
      return new (home) NqTer<Val,IntView,IntView,IntView>
        (home,share,p,x[0],x[1],x[2],c);
    if (x.size() == 2)
      return new (home) NqTer<Val,IntView,IntView,MinusView>
        (home,share,p,x[0],x[1],y[0],c);
    if (x.size() == 1)
      return new (home) NqTer<Val,IntView,IntView,MinusView>
        (home,share,p,y[0],y[1],x[0],-c);
    return new (home) NqTer<Val,IntView,IntView,IntView>
      (home,share,p,y[0],y[1],y[2],-c);
  }

  template <class Val, class P, class N>
  Actor*
  Nq<Val,P,N>::copy(Space* home, bool share) {
    if (isunit(x,y)) {
      // Check whether rewriting is possible
      if (x.size() + y.size() == 2)
        return nqtobin(home,share,*this,x,y,c);
      if (x.size() + y.size() == 3)
        return nqtoter(home,share,*this,x,y,c);
    }
    return new (home) Nq<Val,P,N>(home,share,*this);
  }

  template <class Val, class P, class N>
  ExecStatus
  Nq<Val,P,N>::propagate(Space* home) {
    for (int i = x.size(); i--; )
      if (x[i].assigned()) {
        c -= x[i].val();  x.move_lst(i);
      }
    for (int i = y.size(); i--; )
      if (y[i].assigned()) {
        c += y[i].val();  y.move_lst(i);
      }
    if (x.size() + y.size() <= 1) {
      if (x.size() == 1) {
        GECODE_ME_CHECK(x[0].nq(home,c)); return ES_SUBSUMED;
      }
      if (y.size() == 1) {
        GECODE_ME_CHECK(y[0].nq(home,-c)); return ES_SUBSUMED;
      }
      return (c == static_cast<Val>(0)) ? ES_FAILED : ES_SUBSUMED;
    }
    return ES_FIX;
  }


  /*
   * Bound consistent linear inequation
   *
   */

  template <class Val, class P, class N>
  forceinline
  Lq<Val,P,N>::Lq(Space* home, ViewArray<P>& x, ViewArray<N>& y, Val c)
    : Lin<Val,P,N,PC_INT_BND>(home,x,y,c) {}

  template <class Val, class P, class N>
  ExecStatus
  Lq<Val,P,N>::post(Space* home, ViewArray<P>& x, ViewArray<N>& y, Val c) {
    ViewArray<NoView> nva;
    if (y.size() == 0) {
      (void) new (home) Lq<Val,P,NoView>(home,x,nva,c);
    } else if (x.size() == 0) {
      (void) new (home) Lq<Val,NoView,N>(home,nva,y,c);
    } else {
      (void) new (home) Lq<Val,P,N>(home,x,y,c);
    }
    return ES_OK;
  }


  template <class Val, class P, class N>
  forceinline
  Lq<Val,P,N>::Lq(Space* home, bool share, Lq<Val,P,N>& p)
    : Lin<Val,P,N,PC_INT_BND>(home,share,p) {}

  template <class Val, class P, class N>
  forceinline Actor*
  lqtobin(Space* home, bool share, Propagator& p,
          ViewArray<P>& x, ViewArray<N>& y, Val c) {
    return NULL;
  }
  template <class Val>
  forceinline Actor*
  lqtobin(Space* home, bool share, Propagator& p,
          ViewArray<IntView>& x, ViewArray<NoView>& y, Val c) {
    assert(x.size() == 2);
    return new (home) LqBin<Val,IntView,IntView>
      (home,share,p,x[0],x[1],c);
  }
  template <class Val>
  forceinline Actor*
  lqtobin(Space* home, bool share, Propagator& p,
          ViewArray<NoView>& x, ViewArray<IntView>& y, Val c) {
    assert(y.size() == 2);
    return new (home) LqBin<Val,MinusView,MinusView>
      (home,share,p,y[0],y[1],c);
  }
  template <class Val>
  forceinline Actor*
  lqtobin(Space* home, bool share, Propagator& p,
          ViewArray<IntView>& x, ViewArray<IntView>& y, Val c) {
    if (x.size() == 2)
      return new (home) LqBin<Val,IntView,IntView>
        (home,share,p,x[0],x[1],c);
    if (x.size() == 1)
      return new (home) LqBin<Val,IntView,MinusView>
        (home,share,p,x[0],y[0],c);
    return new (home) LqBin<Val,MinusView,MinusView>
      (home,share,p,y[0],y[1],c);
  }

  template <class Val, class P, class N>
  forceinline Actor*
  lqtoter(Space* home, bool share, Propagator& p,
          ViewArray<P>& x, ViewArray<N>& y, Val c) {
    return NULL;
  }
  template <class Val>
  forceinline Actor*
  lqtoter(Space* home, bool share, Propagator& p,
          ViewArray<IntView>& x, ViewArray<NoView>& y, Val c) {
    assert(x.size() == 3);
    return new (home) LqTer<Val,IntView,IntView,IntView>
      (home,share,p,x[0],x[1],x[2],c);
  }
  template <class Val>
  forceinline Actor*
  lqtoter(Space* home, bool share, Propagator& p,
          ViewArray<NoView>& x, ViewArray<IntView>& y, Val c) {
    assert(y.size() == 3);
    return new (home) LqTer<Val,MinusView,MinusView,MinusView>
      (home,share,p,y[0],y[1],y[2],c);
  }
  template <class Val>
  forceinline Actor*
  lqtoter(Space* home, bool share, Propagator& p,
          ViewArray<IntView>& x, ViewArray<IntView>& y, Val c) {
    if (x.size() == 3)
      return new (home) LqTer<Val,IntView,IntView,IntView>
        (home,share,p,x[0],x[1],x[2],c);
    if (x.size() == 2)
      return new (home) LqTer<Val,IntView,IntView,MinusView>
        (home,share,p,x[0],x[1],y[0],c);
    if (x.size() == 1)
      return new (home) LqTer<Val,IntView,MinusView,MinusView>
        (home,share,p,x[0],y[0],y[1],c);
    return new (home) LqTer<Val,MinusView,MinusView,MinusView>
      (home,share,p,y[0],y[1],y[2],c);
  }

  template <class Val, class P, class N>
  Actor*
  Lq<Val,P,N>::copy(Space* home, bool share) {
    if (isunit(x,y)) {
      // Check whether rewriting is possible
      if (x.size() + y.size() == 2)
        return lqtobin(home,share,*this,x,y,c);
      if (x.size() + y.size() == 3)
        return lqtoter(home,share,*this,x,y,c);
    }
    return new (home) Lq<Val,P,N>(home,share,*this);
  }

  template <class Val, class P, class N>
  ExecStatus
  Lq<Val,P,N>::propagate(Space* home) {
    // Eliminate singletons
    Val sl = 0;

    if (IntView::pme(this) == ME_INT_VAL) {
      for (int i = x.size(); i--; ) {
        Val m = x[i].min();
        if (x[i].assigned()) {
          c  -= m;  x.move_lst(i);
        } else {
          sl -= m;
        }
      }
      for (int i = y.size(); i--; ) {
        Val m = y[i].max();
        if (y[i].assigned()) {
          c  += m;  y.move_lst(i);
        } else {
          sl += m;
        }
      }
      if ((x.size() + y.size()) <= 1) {
        if (x.size() == 1) {
          GECODE_ME_CHECK(x[0].lq(home,c));
          return ES_SUBSUMED;
        }
        if (y.size() == 1) {
          GECODE_ME_CHECK(y[0].gq(home,-c));
          return ES_SUBSUMED;
        }
        return (c >= static_cast<Val>(0)) ? ES_SUBSUMED : ES_FAILED;
      }
    } else {
      for (int i = x.size(); i--; )
        sl -= x[i].min();
      for (int i = y.size(); i--; )
        sl += y[i].max();
    }

    sl += c;

    ExecStatus es = ES_FIX;
    bool assigned = true;
    for (int i = x.size(); i--; ) {
      assert(!x[i].assigned());
      Val slx = sl + x[i].min();
      ModEvent me = x[i].lq(home,slx);
      if (me == ME_INT_FAILED)
        return ES_FAILED;
      if (me != ME_INT_VAL)
        assigned = false;
      if (me_modified(me) && (slx != x[i].max()))
        es = ES_NOFIX;
    }

    for (int i = y.size(); i--; ) {
      assert(!y[i].assigned());
      Val sly = y[i].max() - sl;
      ModEvent me = y[i].gq(home,sly);
      if (me == ME_INT_FAILED)
        return ES_FAILED;
      if (me != ME_INT_VAL)
        assigned = false;
      if (me_modified(me) && (sly != y[i].min()))
        es = ES_NOFIX;
    }
    return assigned ? ES_SUBSUMED : es;
  }

  /*
   * Reified bound consistent linear inequation
   *
   */

  template <class Val, class P, class N>
  forceinline
  ReLq<Val,P,N>::ReLq
  (Space* home, ViewArray<P>& x, ViewArray<N>& y, Val c, BoolView b)
    : ReLin<Val,P,N,PC_INT_BND,BoolView>(home,x,y,c,b) {}

  template <class Val, class P, class N>
  ExecStatus
  ReLq<Val,P,N>::post
  (Space* home, ViewArray<P>& x, ViewArray<N>& y, Val c, BoolView b) {
    ViewArray<NoView> nva;
    if (y.size() == 0) {
      (void) new (home) ReLq<Val,P,NoView>(home,x,nva,c,b);
    } else if (x.size() == 0) {
      (void) new (home) ReLq<Val,NoView,N>(home,nva,y,c,b);
    } else {
      (void) new (home) ReLq<Val,P,N>(home,x,y,c,b);
    }
    return ES_OK;
  }


  template <class Val, class P, class N>
  forceinline
  ReLq<Val,P,N>::ReLq(Space* home, bool share, ReLq<Val,P,N>& p)
    : ReLin<Val,P,N,PC_INT_BND,BoolView>(home,share,p) {}

  template <class Val, class P, class N>
  Actor*
  ReLq<Val,P,N>::copy(Space* home, bool share) {
    return new (home) ReLq<Val,P,N>(home,share,*this);
  }


  template <class Val, class P, class N>
  ExecStatus
  ReLq<Val,P,N>::propagate(Space* home) {
    if (b.zero())
      return (Lq<Val,N,P>::post(home,y,x,-c-1) == ES_FAILED)
        ? ES_FAILED : ES_SUBSUMED;
    if (b.one())
      return (Lq<Val,P,N>::post(home,x,y,c) == ES_FAILED)
        ? ES_FAILED : ES_SUBSUMED;

    // Eliminate singletons
    Val sl = 0;
    Val su = 0;

    bounds_p<Val,P>(this,x,c,sl,su);
    bounds_n<Val,N>(this,y,c,sl,su);

    if (-sl > c) {
      b.t_zero_none(home); return ES_SUBSUMED;
    }
    if (-su <= c) {
      b.t_one_none(home); return ES_SUBSUMED;
    }

    return ES_FIX;
  }

}}}

// STATISTICS: int-prop