gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/int/linear/ternary.icc

@@ -0,0 +1,255 @@
+/*
+ *  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.
+ *
+ */
+
+namespace Gecode { namespace Int { namespace Linear {
+
+  /*
+   * Ternary linear propagators
+   *
+   */
+  template <class Val, class A, class B, class C, PropCond pc>
+  forceinline
+  LinTer<Val,A,B,C,pc>::LinTer(Space* home, A y0, B y1, C y2, Val c0)
+    : Propagator(home), x0(y0), x1(y1), x2(y2), c(c0) {
+    x0.subscribe(home,this,pc);
+    x1.subscribe(home,this,pc);
+    x2.subscribe(home,this,pc);
+  }
+
+  template <class Val, class A, class B, class C, PropCond pc>
+  forceinline
+  LinTer<Val,A,B,C,pc>::LinTer(Space* home, bool share,
+			       LinTer<Val,A,B,C,pc>& p)
+    : Propagator(home,share,p), c(p.c) {
+    x0.update(home,share,p.x0);
+    x1.update(home,share,p.x1);
+    x2.update(home,share,p.x2);
+  }
+
+  template <class Val, class A, class B, class C, PropCond pc>
+  forceinline
+  LinTer<Val,A,B,C,pc>::LinTer(Space* home, bool share, Propagator& p,
+			       A y0, B y1, C y2, Val c0)
+    : Propagator(home,share,p), c(c0) {
+    x0.update(home,share,y0);
+    x1.update(home,share,y1);
+    x2.update(home,share,y2);
+  }
+
+  template <class Val, class A, class B, class C, PropCond pc>
+  PropCost
+  LinTer<Val,A,B,C,pc>::cost(void) const {
+    return PC_TERNARY_LO;
+  }
+
+  template <class Val, class A, class B, class C, PropCond pc>
+  size_t
+  LinTer<Val,A,B,C,pc>::dispose(Space* home) {
+    assert(!home->failed());
+    x0.cancel(home,this,pc);
+    x1.cancel(home,this,pc);
+    x2.cancel(home,this,pc);
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+  /*
+   * Equality propagator
+   *
+   */
+
+  template <class Val, class A, class B, class C>
+  forceinline
+  EqTer<Val,A,B,C>::EqTer(Space* home, A x0, B x1, C x2, Val c)
+    : LinTer<Val,A,B,C,PC_INT_BND>(home,x0,x1,x2,c) {}
+
+  template <class Val, class A, class B, class C>
+  ExecStatus
+  EqTer<Val,A,B,C>::post(Space* home, A x0, B x1, C x2, Val c) {
+    (void) new (home) EqTer<Val,A,B,C>(home,x0,x1,x2,c);
+    return ES_OK;
+  }
+
+
+  template <class Val, class A, class B, class C>
+  forceinline
+  EqTer<Val,A,B,C>::EqTer(Space* home, bool share, EqTer<Val,A,B,C>& p)
+    : LinTer<Val,A,B,C,PC_INT_BND>(home,share,p) {}
+
+  template <class Val, class A, class B, class C>
+  forceinline
+  EqTer<Val,A,B,C>::EqTer(Space* home, bool share, Propagator& p,
+			  A x0, B x1, C x2, Val c)
+    : LinTer<Val,A,B,C,PC_INT_BND>(home,share,p,x0,x1,x2,c) {}
+
+  template <class Val, class A, class B, class C>
+  Actor*
+  EqTer<Val,A,B,C>::copy(Space* home, bool share) {
+    return new (home) EqTer<Val,A,B,C>(home,share,*this);
+  }
+
+  /// Describe which view has been modified how
+  enum TerMod {
+    TM_X0_MIN = 1<<0,
+    TM_X0_MAX = 1<<1,
+    TM_X1_MIN = 1<<2,
+    TM_X1_MAX = 1<<3,
+    TM_X2_MIN = 1<<4,
+    TM_X2_MAX = 1<<5,
+    TM_ALL    = TM_X0_MIN|TM_X0_MAX|TM_X1_MIN|TM_X1_MAX|TM_X2_MIN|TM_X2_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, class C>
+  ExecStatus
+  EqTer<Val,A,B,C>::propagate(Space* home) {
+    int bm = TM_ALL;
+    do {
+      GECODE_INT_PV(TM_X0_MIN, x0.gq(home,c-x1.max()-x2.max()),
+		    TM_X1_MAX | TM_X2_MAX);
+      GECODE_INT_PV(TM_X1_MIN, x1.gq(home,c-x0.max()-x2.max()),
+		    TM_X0_MAX | TM_X2_MAX);
+      GECODE_INT_PV(TM_X2_MIN, x2.gq(home,c-x0.max()-x1.max()),
+		    TM_X0_MAX | TM_X1_MAX);
+      GECODE_INT_PV(TM_X0_MAX, x0.lq(home,c-x1.min()-x2.min()),
+		    TM_X1_MIN | TM_X2_MIN);
+      GECODE_INT_PV(TM_X1_MAX, x1.lq(home,c-x0.min()-x2.min()),
+		    TM_X0_MIN | TM_X2_MIN);
+      GECODE_INT_PV(TM_X2_MAX, x2.lq(home,c-x0.min()-x1.min()),
+		    TM_X0_MIN | TM_X1_MIN);
+    } while (bm);
+    return (x0.assigned() && x1.assigned()) ? ES_SUBSUMED : ES_FIX;
+  }
+
+#undef GECODE_INT_PV
+
+
+
+  /*
+   * Disequality propagator
+   *
+   */
+
+  template <class Val, class A, class B, class C>
+  forceinline
+  NqTer<Val,A,B,C>::NqTer(Space* home, A x0, B x1, C x2, Val c)
+    : LinTer<Val,A,B,C,PC_INT_VAL>(home,x0,x1,x2,c) {}
+
+  template <class Val, class A, class B, class C>
+  ExecStatus
+  NqTer<Val,A,B,C>::post(Space* home, A x0, B x1, C x2, Val c) {
+    (void) new (home) NqTer<Val,A,B,C>(home,x0,x1,x2,c);
+    return ES_OK;
+  }
+
+
+  template <class Val, class A, class B, class C>
+  forceinline
+  NqTer<Val,A,B,C>::NqTer(Space* home, bool share, NqTer<Val,A,B,C>& p)
+    : LinTer<Val,A,B,C,PC_INT_VAL>(home,share,p) {}
+
+  template <class Val, class A, class B, class C>
+  Actor*
+  NqTer<Val,A,B,C>::copy(Space* home, bool share) {
+    return new (home) NqTer<Val,A,B,C>(home,share,*this);
+  }
+
+  template <class Val, class A, class B, class C>
+  forceinline
+  NqTer<Val,A,B,C>::NqTer(Space* home, bool share, Propagator& p,
+			  A x0, B x1, C x2, Val c)
+    : LinTer<Val,A,B,C,PC_INT_VAL>(home,share,p,x0,x1,x2,c) {}
+
+
+  template <class Val, class A, class B, class C>
+  ExecStatus
+  NqTer<Val,A,B,C>::propagate(Space* home) {
+    if (x0.assigned() && x1.assigned()) {
+      GECODE_ME_CHECK(x2.nq(home,c-x0.val()-x1.val()));
+      return ES_SUBSUMED;
+    }
+    if (x0.assigned() && x2.assigned()) {
+      GECODE_ME_CHECK(x1.nq(home,c-x0.val()-x2.val()));
+      return ES_SUBSUMED;
+    }
+    if (x1.assigned() && x2.assigned()) {
+      GECODE_ME_CHECK(x0.nq(home,c-x1.val()-x2.val()));
+      return ES_SUBSUMED;
+    }
+    return ES_FIX;
+  }
+
+
+
+  /*
+   * Inequality propagator
+   *
+   */
+
+  template <class Val, class A, class B, class C>
+  forceinline
+  LqTer<Val,A,B,C>::LqTer(Space* home, A x0, B x1, C x2, Val c)
+    : LinTer<Val,A,B,C,PC_INT_BND>(home,x0,x1,x2,c) {}
+
+  template <class Val, class A, class B, class C>
+  ExecStatus
+  LqTer<Val,A,B,C>::post(Space* home, A x0, B x1, C x2, Val c) {
+    (void) new (home) LqTer<Val,A,B,C>(home,x0,x1,x2,c);
+    return ES_OK;
+  }
+
+
+  template <class Val, class A, class B, class C>
+  forceinline
+  LqTer<Val,A,B,C>::LqTer(Space* home, bool share, LqTer<Val,A,B,C>& p)
+    : LinTer<Val,A,B,C,PC_INT_BND>(home,share,p) {}
+
+  template <class Val, class A, class B, class C>
+  Actor*
+  LqTer<Val,A,B,C>::copy(Space* home, bool share) {
+    return new (home) LqTer<Val,A,B,C>(home,share,*this);
+  }
+
+  template <class Val, class A, class B, class C>
+  forceinline
+  LqTer<Val,A,B,C>::LqTer(Space* home, bool share, Propagator& p,
+			  A x0, B x1, C x2, Val c)
+    : LinTer<Val,A,B,C,PC_INT_BND>(home,share,p,x0,x1,x2,c) {}
+
+  template <class Val, class A, class B, class C>
+  ExecStatus
+  LqTer<Val,A,B,C>::propagate(Space* home) {
+    GECODE_ME_CHECK(x0.lq(home,c-x1.min()-x2.min()));
+    GECODE_ME_CHECK(x1.lq(home,c-x0.min()-x2.min()));
+    GECODE_ME_CHECK(x2.lq(home,c-x0.min()-x1.min()));
+    return (x0.max()+x1.max()+x2.max() <= c) ? ES_SUBSUMED : ES_FIX;
+  }
+
+}}}
+
+// STATISTICS: int-prop
+

data/ext/gecode-1.3.1/gecode/int/propagator.icc

@@ -0,0 +1,194 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2006-05-29 09:42:21 +0200 (Mon, 29 May 2006) $ by $Author: schulte $
+ *     $Revision: 3246 $
+ *
+ *  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.
+ *
+ */
+
+namespace Gecode {
+
+  /**
+   * \defgroup TaskPropRePat Reified propagator patterns
+   *
+   * The optional last Boolean argument (\a fd) to the constructor for creation
+   * defines whether deletion must be forced.
+   * \ingroup TaskActor
+   */
+
+  //@{
+  /**
+   * \brief Reified unary propagator
+   *
+   * Stores single view of type \a View with propagation condition \a pc
+   * and a Boolean control view of type \a CtrlView.
+   */
+  template <class View, PropCond pc, class CtrlView>
+  class ReUnaryPropagator : public Propagator {
+  protected:
+    /// Single view
+    View x0;
+    /// Boolean control view
+    CtrlView b;
+    /// Constructor for cloning \a p
+    ReUnaryPropagator(Space* home, bool share, ReUnaryPropagator& p);
+    /// Constructor for rewriting \a p during cloning
+    ReUnaryPropagator(Space* home, bool share, Propagator& p,
+		      View x0, CtrlView b);
+    /// Constructor for creation
+    ReUnaryPropagator(Space* home, View x0, CtrlView b, bool fd=false);
+  public:
+    /// Cost function (defined as PC_UNARY_LO)
+    virtual PropCost cost(void) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+  };
+
+  /**
+   * \brief Reified binary propagator
+   *
+   * Stores two views of type \a View with propagation condition \a pc
+   * and a Boolean control view of type \a CtrlView.
+   */
+  template <class View, PropCond pc, class CtrlView>
+  class ReBinaryPropagator : public Propagator {
+  protected:
+    /// Two views
+    View x0, x1;
+    /// Boolean control view
+    CtrlView b;
+    /// Constructor for cloning \a p
+    ReBinaryPropagator(Space* home, bool share, ReBinaryPropagator& p);
+    /// Constructor for rewriting \a p during cloning
+    ReBinaryPropagator(Space* home, bool share, Propagator& p,
+		       View x0, View x1, CtrlView b);
+    /// Constructor for creation
+    ReBinaryPropagator(Space* home, View x0, View x1,
+		       CtrlView b, bool fd=false);
+  public:
+    /// Cost function (defined as PC_BINARY_LO)
+    virtual PropCost cost(void) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+  };
+  //@}
+
+
+
+  /*
+   * Reified unary propagators
+   *
+   */
+  template <class View, PropCond pc, class CtrlView>
+  ReUnaryPropagator<View,pc,CtrlView>::ReUnaryPropagator
+  (Space* home, View y0, CtrlView b0, bool fd)
+    : Propagator(home,fd), x0(y0), b(b0) {
+    x0.subscribe(home,this,pc);
+    b.subscribe(home,this,Int::PC_INT_VAL);
+  }
+
+  template <class View, PropCond pc, class CtrlView>
+  forceinline
+  ReUnaryPropagator<View,pc,CtrlView>::ReUnaryPropagator
+  (Space* home, bool share, ReUnaryPropagator<View,pc,CtrlView>& p)
+    : Propagator(home,share,p) {
+    x0.update(home,share,p.x0);
+    b.update(home,share,p.b);
+  }
+
+  template <class View, PropCond pc, class CtrlView>
+  forceinline
+  ReUnaryPropagator<View,pc,CtrlView>::ReUnaryPropagator
+  (Space* home, bool share, Propagator& p, View y0, CtrlView b0)
+    : Propagator(home,share,p) {
+    x0.update(home,share,y0);
+    b.update(home,share,b0);
+  }
+
+  template <class View, PropCond pc, class CtrlView>
+  PropCost
+  ReUnaryPropagator<View,pc,CtrlView>::cost(void) const {
+    return PC_UNARY_LO;
+  }
+
+  template <class View, PropCond pc, class CtrlView>
+  size_t
+  ReUnaryPropagator<View,pc,CtrlView>::dispose(Space* home) {
+    if (!home->failed()) {
+      x0.cancel(home,this,pc);
+      b.cancel(home,this,Int::PC_INT_VAL);
+    }
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+
+
+  /*
+   * Reified binary propagators
+   *
+   */
+  template <class View, PropCond pc, class CtrlView>
+  ReBinaryPropagator<View,pc,CtrlView>::ReBinaryPropagator
+  (Space* home, View y0, View y1, CtrlView b1, bool fd)
+    : Propagator(home,fd), x0(y0), x1(y1), b(b1) {
+    x0.subscribe(home,this,pc);
+    x1.subscribe(home,this,pc);
+    b.subscribe(home,this,Int::PC_INT_VAL);
+  }
+
+  template <class View, PropCond pc, class CtrlView>
+  forceinline
+  ReBinaryPropagator<View,pc,CtrlView>::ReBinaryPropagator
+  (Space* home, bool share, ReBinaryPropagator<View,pc,CtrlView>& p)
+    : Propagator(home,share,p) {
+    x0.update(home,share,p.x0);
+    x1.update(home,share,p.x1);
+    b.update(home,share,p.b);
+  }
+
+  template <class View, PropCond pc, class CtrlView>
+  forceinline
+  ReBinaryPropagator<View,pc,CtrlView>::ReBinaryPropagator
+  (Space* home, bool share, Propagator& p, View y0, View y1, CtrlView b0)
+    : Propagator(home,share,p) {
+    x0.update(home,share,y0);
+    x1.update(home,share,y1);
+    b.update(home,share,b0);
+  }
+
+  template <class View, PropCond pc, class CtrlView>
+  PropCost
+  ReBinaryPropagator<View,pc,CtrlView>::cost(void) const {
+    return PC_BINARY_LO;
+  }
+
+  template <class View, PropCond pc, class CtrlView>
+  size_t
+  ReBinaryPropagator<View,pc,CtrlView>::dispose(Space* home) {
+    if (!home->failed()) {
+      x0.cancel(home,this,pc);
+      x1.cancel(home,this,pc);
+      b.cancel(home,this,Int::PC_INT_VAL);
+    }
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+}
+
+// STATISTICS: int-prop
+

data/ext/gecode-1.3.1/gecode/int/regular.cc

@@ -0,0 +1,40 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-04-11 15:58:37 +0200 (Tue, 11 Apr 2006) $ by $Author: tack $
+ *     $Revision: 3188 $
+ *
+ *  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/regular.hh"
+
+namespace Gecode {
+
+  using namespace Int;
+
+  void
+  regular(Space* home, const IntVarArgs& x, DFA& dfa, IntConLevel) {
+    if (home->failed()) return;
+    ViewArray<IntView> xv(home,x);
+    GECODE_ES_FAIL(home,Regular::Dom<IntView>::post(home,xv,dfa));
+  }
+
+}
+
+
+
+// STATISTICS: int-post
+