gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/int/count/rel.icc

@@ -0,0 +1,100 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2003
+ *
+ *  Last modified:
+ *     $Date: 2006-08-25 17:05:19 +0200 (Fri, 25 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3572 $
+ *
+ *  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/rel.hh"
+
+namespace Gecode { namespace Int { namespace Count {
+
+  /*
+   * Counting domain-consistent equality
+   *
+   */
+
+  template <class VX>
+  forceinline RelTest
+  holds(VX x, ConstIntView y) {
+    return rtest_eq_dom(x,y.val());
+  }
+  template <class VX>
+  forceinline RelTest
+  holds(VX x, VX y) {
+    return rtest_eq_dom(x,y);
+  }
+  template <class VX>
+  forceinline ExecStatus
+  post_true(Space* home, VX x, ConstIntView y) {
+    GECODE_ME_CHECK(x.eq(home,y.val()));
+    return ES_SUBSUMED;
+  }
+  template <class VX>
+  forceinline ExecStatus
+  post_true(Space* home, ViewArray<VX>& x, ConstIntView y) {
+    for (int i = x.size(); i--; )
+      GECODE_ME_CHECK(x[i].eq(home,y.val()));
+    return ES_SUBSUMED;
+  }
+  template <class VX>
+  forceinline ExecStatus
+  post_false(Space* home, VX x, ConstIntView y) {
+    GECODE_ME_CHECK(x.nq(home,y.val()));
+    return ES_SUBSUMED;
+  }
+  template <class VX>
+  forceinline ExecStatus
+  post_false(Space* home, ViewArray<VX>& x, ConstIntView y) {
+    for (int i = x.size(); i--; )
+      GECODE_ME_CHECK(x[i].nq(home,y.val()));
+    return ES_SUBSUMED;
+  }
+  template <class VX>
+  forceinline ExecStatus
+  post_true(Space* home, ViewArray<VX>& x, VX y) {
+    ViewArray<VX> z(home,x.size()+1);
+    z[x.size()] = y;
+    for (int i = x.size(); i--; )
+      z[i] = x[i];
+    GECODE_ES_CHECK(Rel::NaryEqDom<VX>::post(home,z));
+    return ES_SUBSUMED;
+  }
+  template <class VX>
+  forceinline ExecStatus
+  post_true(Space* home, VX x, VX y) {
+    GECODE_ES_CHECK((Rel::EqDom<VX,VX>::post(home,x,y)));
+    return ES_SUBSUMED;
+  }
+  template <class VX>
+  forceinline ExecStatus
+  post_false(Space* home, ViewArray<VX>& x, VX y) {
+    for (int i = x.size(); i--; )
+      GECODE_ES_CHECK(Rel::Nq<VX>::post(home,x[i],y));
+    return ES_SUBSUMED;
+  }
+  template <class VX>
+  forceinline ExecStatus
+  post_false(Space* home, VX x, VX y) {
+    GECODE_ES_CHECK(Rel::Nq<VX>::post(home,x,y));
+    return ES_SUBSUMED;
+  }
+
+}}}
+
+// STATISTICS: int-prop
+

data/ext/gecode-1.3.1/gecode/int/count/view.icc

@@ -0,0 +1,332 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2003
+ *
+ *  Last modified:
+ *     $Date: 2006-09-07 11:57:31 +0200 (Thu, 07 Sep 2006) $ by $Author: schulte $
+ *     $Revision: 3612 $
+ *
+ *  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 Count {
+
+  /*
+   * General baseclass
+   *
+   */
+
+  template <class VX, class VY, class VZ, bool shr>
+  BaseView<VX,VY,VZ,shr>::BaseView(Space* home,
+				   ViewArray<VX>& x0, VY y0, VZ z0, int c0)
+    : Propagator(home), x(x0), y(y0), z(z0), c(c0) {
+    x.subscribe(home,this,PC_INT_DOM);
+    y.subscribe(home,this,PC_INT_DOM);
+    z.subscribe(home,this,PC_INT_BND);
+  }
+
+  template <class VX, class VY, class VZ, bool shr>
+  inline
+  BaseView<VX,VY,VZ,shr>::BaseView(Space* home, bool share,
+				   BaseView<VX,VY,VZ,shr>& p)
+    : Propagator(home,shr,p), c(p.c) {
+    x.update(home,share,p.x);
+    y.update(home,share,p.y);
+    z.update(home,share,p.z);
+  }
+
+  template <class VX, class VY, class VZ, bool shr>
+  PropCost
+  BaseView<VX,VY,VZ,shr>::cost(void) const {
+    return cost_lo(x.size()+1, PC_LINEAR_LO);
+  }
+
+  template <class VX, class VY, class VZ, bool shr>
+  size_t
+  BaseView<VX,VY,VZ,shr>::dispose(Space* home) {
+    assert(!home->failed());
+    x.cancel(home,this,PC_INT_DOM);
+    y.cancel(home,this,PC_INT_DOM);
+    z.cancel(home,this,PC_INT_BND);
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+  template <class VX, class VY, class VZ, bool shr>
+  forceinline void
+  BaseView<VX,VY,VZ,shr>::count(Space* home) {
+    int n = x.size();
+    for (int i=n; i--; )
+      switch (holds(x[i],y)) {
+      case RT_FALSE:
+	x[i].cancel(home,this,PC_INT_DOM); x[i]=x[--n];
+	break;
+      case RT_TRUE:
+	x[i].cancel(home,this,PC_INT_DOM); x[i]=x[--n];
+	c--;
+	break;
+      case RT_MAYBE:
+	break;
+      default: 
+	GECODE_NEVER;
+      }
+    x.size(n);
+  }
+
+  template <class VX, class VY, class VZ, bool shr>
+  forceinline int
+  BaseView<VX,VY,VZ,shr>::atleast(void) const {
+    return -c;
+  }
+
+  template <class VX, class VY, class VZ, bool shr>
+  forceinline int
+  BaseView<VX,VY,VZ,shr>::atmost(void) const {
+    return x.size()-c;
+  }
+
+  template <class VX, class VY, class VZ, bool shr>
+  inline bool
+  BaseView<VX,VY,VZ,shr>::sharing(const ViewArray<VX>& x,
+				  const VY& y, const VZ& z) {
+    if (shared(y,z))
+      return true;
+    for (int i = x.size(); i--; )
+      if (shared(x[i],z))
+	return true;
+    return false;
+  }
+
+  /*
+   * Equality
+   *
+   */
+
+  template <class VX, class VY, class VZ, bool shr>
+  forceinline
+  EqView<VX,VY,VZ,shr>::EqView(Space* home, 
+			       ViewArray<VX>& x, VY y, VZ z, int c)
+    : BaseView<VX,VY,VZ,shr>(home,x,y,z,c) {}
+
+  template <class VX, class VY, class VZ, bool shr>
+  ExecStatus
+  EqView<VX,VY,VZ,shr>::post(Space* home, 
+			     ViewArray<VX>& x, VY y, VZ z, int c) {
+    if (z.assigned())
+      return EqInt<VX,VY>::post(home,x,y,z.val()+c);
+    if (sharing(x,y,z))
+      (void) new (home) EqView<VX,VY,VZ,true>(home,x,y,z,c);
+    else
+      (void) new (home) EqView<VX,VY,VZ,false>(home,x,y,z,c);
+    return ES_OK;
+  }
+
+  template <class VX, class VY, class VZ, bool shr>
+  forceinline
+  EqView<VX,VY,VZ,shr>::EqView(Space* home, bool share, 
+			       EqView<VX,VY,VZ,shr>& p)
+    : BaseView<VX,VY,VZ,shr>(home,share,p) {}
+
+  template <class VX, class VY, class VZ, bool shr>
+  Actor*
+  EqView<VX,VY,VZ,shr>::copy(Space* home, bool share) {
+    return new (home) EqView<VX,VY,VZ,shr>(home,share,*this);
+  }
+
+  template <class VX, class VY, class VZ, bool shr>
+  ExecStatus
+  EqView<VX,VY,VZ,shr>::propagate(Space* home) {
+    count(home);
+
+    GECODE_ME_CHECK(z.gq(home,atleast()));
+    GECODE_ME_CHECK(z.lq(home,atmost()));
+
+    if (z.assigned()) {
+      if (z.val() == atleast())
+	return post_false(home,x,y);
+      if (z.val() == atmost())
+	return post_true(home,x,y);
+      GECODE_ES_CHECK((EqInt<VX,VY>::post(home,x,y,z.val()+c)));
+      return ES_SUBSUMED;
+    }
+    return shr ? ES_NOFIX : ES_FIX;
+  }
+
+
+
+
+  /*
+   * Disequality
+   *
+   */
+
+  template <class VX, class VY, class VZ, bool shr>
+  forceinline
+  NqView<VX,VY,VZ,shr>::NqView(Space* home, 
+			       ViewArray<VX>& x, VY y, VZ z, int c)
+    : BaseView<VX,VY,VZ,shr>(home,x,y,z,c) {}
+
+  template <class VX, class VY, class VZ, bool shr>
+  ExecStatus
+  NqView<VX,VY,VZ,shr>::post(Space* home, 
+			     ViewArray<VX>& x, VY y, VZ z, int c) {
+    if (z.assigned())
+      return NqInt<VX,VY>::post(home,x,y,z.val()+c);
+    (void) new (home) NqView<VX,VY,VZ,shr>(home,x,y,z,c);
+    return ES_OK;
+  }
+
+  template <class VX, class VY, class VZ, bool shr>
+  forceinline
+  NqView<VX,VY,VZ,shr>::NqView(Space* home, bool share, 
+			       NqView<VX,VY,VZ,shr>& p)
+    : BaseView<VX,VY,VZ,shr>(home,share,p) {}
+
+  template <class VX, class VY, class VZ, bool shr>
+  Actor*
+  NqView<VX,VY,VZ,shr>::copy(Space* home, bool share) {
+    return new (home) NqView<VX,VY,VZ,shr>(home,share,*this);
+  }
+
+  template <class VX, class VY, class VZ, bool shr>
+  ExecStatus
+  NqView<VX,VY,VZ,shr>::propagate(Space* home) {
+    count(home);
+    if (atleast() == atmost()) {
+      GECODE_ME_CHECK(z.nq(home,atleast()));
+      return ES_SUBSUMED;
+    }
+    if (z.max() < atleast())
+      return ES_SUBSUMED;
+    if (z.min() > atmost())
+      return ES_SUBSUMED;
+    if (z.assigned()) {
+      GECODE_ES_CHECK((NqInt<VX,VY>::post(home,x,y,z.val()+c)));
+      return ES_SUBSUMED;
+    }
+    return ES_FIX;
+  }
+
+
+
+  /*
+   * Less or equal
+   *
+   */
+
+  template <class VX, class VY, class VZ, bool shr>
+  forceinline
+  LqView<VX,VY,VZ,shr>::LqView(Space* home, ViewArray<VX>& x, 
+			       VY y, VZ z, int c)
+    : BaseView<VX,VY,VZ,shr>(home,x,y,z,c) {}
+
+  template <class VX, class VY, class VZ, bool shr>
+  ExecStatus
+  LqView<VX,VY,VZ,shr>::post(Space* home, ViewArray<VX>& x, 
+			     VY y, VZ z, int c) {
+    if (z.assigned())
+      return LqInt<VX,VY>::post(home,x,y,z.val()+c);
+    if (sharing(x,y,z))
+      (void) new (home) LqView<VX,VY,VZ,true>(home,x,y,z,c);
+    else
+      (void) new (home) LqView<VX,VY,VZ,false>(home,x,y,z,c);
+    return ES_OK;
+  }
+
+  template <class VX, class VY, class VZ, bool shr>
+  forceinline
+  LqView<VX,VY,VZ,shr>::LqView(Space* home, bool share, 
+			       LqView<VX,VY,VZ,shr>& p)
+    : BaseView<VX,VY,VZ,shr>(home,share,p) {}
+
+  template <class VX, class VY, class VZ, bool shr>
+  Actor*
+  LqView<VX,VY,VZ,shr>::copy(Space* home, bool share) {
+    return new (home) LqView<VX,VY,VZ,shr>(home,share,*this);
+  }
+
+  template <class VX, class VY, class VZ, bool shr>
+  ExecStatus
+  LqView<VX,VY,VZ,shr>::propagate(Space* home) {
+    count(home);
+    GECODE_ME_CHECK(z.gq(home,atleast()));
+    if (z.max() == atleast())
+      return post_false(home,x,y);
+    if (x.size() == 0)
+      return ES_SUBSUMED;
+    if (z.assigned()) {
+      GECODE_ES_CHECK((LqInt<VX,VY>::post(home,x,y,z.val()+c)));
+      return ES_SUBSUMED;
+    }
+    return shr ? ES_NOFIX : ES_FIX;
+  }
+
+
+
+  /*
+   * Greater or equal
+   *
+   */
+
+  template <class VX, class VY, class VZ, bool shr>
+  forceinline
+  GqView<VX,VY,VZ,shr>::GqView(Space* home, ViewArray<VX>& x, VY y, VZ z, int c)
+    : BaseView<VX,VY,VZ,shr>(home,x,y,z,c) {}
+
+  template <class VX, class VY, class VZ, bool shr>
+  ExecStatus
+  GqView<VX,VY,VZ,shr>::post(Space* home, 
+			     ViewArray<VX>& x, VY y, VZ z, int c) {
+    if (z.assigned())
+      return GqInt<VX,VY>::post(home,x,y,z.val()+c);
+    if (sharing(x,y,z))
+      (void) new (home) GqView<VX,VY,VZ,true>(home,x,y,z,c);
+    else
+      (void) new (home) GqView<VX,VY,VZ,false>(home,x,y,z,c);
+    return ES_OK;
+  }
+
+  template <class VX, class VY, class VZ, bool shr>
+  forceinline
+  GqView<VX,VY,VZ,shr>::GqView(Space* home, bool share, 
+			       GqView<VX,VY,VZ,shr>& p)
+    : BaseView<VX,VY,VZ,shr>(home,share,p) {}
+
+  template <class VX, class VY, class VZ, bool shr>
+  Actor*
+  GqView<VX,VY,VZ,shr>::copy(Space* home, bool share) {
+    return new (home) GqView<VX,VY,VZ,shr>(home,share,*this);
+  }
+
+  template <class VX, class VY, class VZ, bool shr>
+  ExecStatus
+  GqView<VX,VY,VZ,shr>::propagate(Space* home) {
+    count(home);
+
+    GECODE_ME_CHECK(z.lq(home,atmost()));
+
+    if (z.min() == atmost())
+      return post_true(home,x,y);
+    if (x.size() == 0)
+      return ES_SUBSUMED;
+    if (z.assigned()) {
+      GECODE_ES_CHECK((GqInt<VX,VY>::post(home,x,y,z.val()+c)));
+      return ES_SUBSUMED;
+    }
+    return shr ? ES_NOFIX : ES_FIX;
+  }
+
+}}}
+
+// STATISTICS: int-prop
+

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

@@ -0,0 +1,210 @@
+/*
+ *  Main authors:
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Mikael Lagerkvist, 2005
+ *
+ *  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/cumulatives.hh"
+
+#include "gecode/int/linear.hh"
+
+namespace Gecode {
+
+  using namespace Int;
+
+  namespace {
+    ViewArray<IntView>
+    make_view_array(Space *home, const IntVarArgs& in)
+    {
+      return ViewArray<IntView>(home, in);
+    }
+
+    ViewArray<ConstIntView>
+    make_view_array(Space *home, const IntArgs& in)
+    {
+      ViewArray<ConstIntView> res(home, in.size());
+      for (int i = in.size(); i--; ) {
+	if(in[i] < Limits::Int::int_min ||
+	   in[i] > Limits::Int::int_max)
+	  throw new NumericalOverflow("Int::cumulatives");
+	res[i] = ConstIntView(in[i]);
+      }
+
+      return res;
+    }
+
+    template<class In> class ViewType;
+
+    template<>
+    class ViewType<IntArgs> {
+    public:
+      typedef ConstIntView Result;
+    };
+
+    template<>
+    class ViewType<IntVarArgs> {
+    public:
+      typedef IntView Result;
+    };
+
+    void
+    sum(Space *home, const IntVar& s, const IntVar& d, const IntVar& e)
+    {
+      GECODE_AUTOARRAY(Linear::Term, t, 3);
+      t[0].a= 1; t[0].x=s;
+      t[1].a= 1; t[1].x=d;
+      t[2].a=-1; t[2].x=e;
+      Linear::post(home, t, 3, IRT_EQ, 0);
+    }
+
+    void
+    sum(Space *home, const IntVar& s, int d, const IntVar& e)
+    {
+      GECODE_AUTOARRAY(Linear::Term, t, 2);
+      t[0].a= 1; t[0].x=s;
+      t[1].a=-1; t[1].x=e;
+      Linear::post(home, t, 2, IRT_EQ, -d);
+    }
+
+    template <class Machine, class Duration, class Height>
+    void
+    post_cumulatives(Space* home, const Machine& machine,
+		     const IntVarArgs& start, const Duration& duration,
+		     const IntVarArgs& end, const Height& height,
+		     const IntArgs& limit, bool at_most,
+		     IntConLevel cl) {
+      if (home->failed()) return;
+
+      if(machine.size() != start.size()  ||
+	 start.size() != duration.size() ||
+	 duration.size() != end.size()   ||
+	 end.size() != height.size())
+	throw new ArgumentSizeMismatch("Int::cumulatives");
+
+      ViewArray<typename ViewType<Machine>::Result>
+	vmachine  = make_view_array(home,  machine);
+      ViewArray<typename ViewType<Duration>::Result>
+	vduration = make_view_array(home, duration);
+      ViewArray<typename ViewType<Height>::Result>
+	vheight   = make_view_array(home,   height);
+      ViewArray<IntView>
+	vstart    = make_view_array(home,    start),
+	vend      = make_view_array(home,      end);
+
+      // There is only the value-consistent propagator for this constraint
+      GECODE_ES_FAIL(home,(Cumulatives::Val<
+			   typename ViewType<Machine>::Result,
+			   typename ViewType<Duration>::Result,
+			   typename ViewType<Height>::Result,
+			   IntView>::post(home, vmachine,vstart, vduration,
+					  vend, vheight,limit, at_most)));
+
+      // By definition, s+d=e should hold.
+      // We enforce this using basic linear constraints, since the
+      // sweep-algorithm does not check for it.
+      for (int i = start.size(); i--; ) {
+	sum(home, start[i], duration[i], end[i]);
+      }
+    }
+  }
+
+
+  void
+  cumulatives(Space* home, const IntVarArgs& machine,
+	      const IntVarArgs& start, const IntVarArgs& duration,
+	      const IntVarArgs& end, const IntVarArgs& height,
+	      const IntArgs& limit, bool at_most,
+	      IntConLevel cl) {
+    post_cumulatives(home, machine, start, duration, end,
+		     height, limit, at_most, cl);
+  }
+
+  void
+  cumulatives(Space* home, const IntArgs& machine,
+	      const IntVarArgs& start, const IntVarArgs& duration,
+	      const IntVarArgs& end, const IntVarArgs& height,
+	      const IntArgs& limit, bool at_most,
+	      IntConLevel cl) {
+    post_cumulatives(home, machine, start, duration, end,
+		     height, limit, at_most, cl);
+  }
+
+  void
+  cumulatives(Space* home, const IntVarArgs& machine,
+	      const IntVarArgs& start, const IntArgs& duration,
+	      const IntVarArgs& end, const IntVarArgs& height,
+	      const IntArgs& limit, bool at_most,
+	      IntConLevel cl) {
+    post_cumulatives(home, machine, start, duration, end,
+		     height, limit, at_most, cl);
+  }
+
+  void
+  cumulatives(Space* home, const IntArgs& machine,
+	      const IntVarArgs& start, const IntArgs& duration,
+	      const IntVarArgs& end, const IntVarArgs& height,
+	      const IntArgs& limit, bool at_most,
+	      IntConLevel cl) {
+    post_cumulatives(home, machine, start, duration, end,
+		     height, limit, at_most, cl);
+  }
+
+  void
+  cumulatives(Space* home, const IntVarArgs& machine,
+	      const IntVarArgs& start, const IntVarArgs& duration,
+	      const IntVarArgs& end, const IntArgs& height,
+	      const IntArgs& limit, bool at_most,
+	      IntConLevel cl) {
+    post_cumulatives(home, machine, start, duration, end,
+		     height, limit, at_most, cl);
+  }
+
+  void
+  cumulatives(Space* home, const IntArgs& machine,
+	      const IntVarArgs& start, const IntVarArgs& duration,
+	      const IntVarArgs& end, const IntArgs& height,
+	      const IntArgs& limit, bool at_most,
+	      IntConLevel cl) {
+    post_cumulatives(home, machine, start, duration, end,
+		     height, limit, at_most, cl);
+  }
+
+  void
+  cumulatives(Space* home, const IntVarArgs& machine,
+	      const IntVarArgs& start, const IntArgs& duration,
+	      const IntVarArgs& end, const IntArgs& height,
+	      const IntArgs& limit, bool at_most,
+	      IntConLevel cl) {
+    post_cumulatives(home, machine, start, duration, end,
+		     height, limit, at_most, cl);
+  }
+
+  void
+  cumulatives(Space* home, const IntArgs& machine,
+	      const IntVarArgs& start, const IntArgs& duration,
+	      const IntVarArgs& end, const IntArgs& height,
+	      const IntArgs& limit, bool at_most,
+	      IntConLevel cl) {
+    post_cumulatives(home, machine, start, duration, end,
+		     height, limit, at_most, cl);
+  }
+
+}
+
+// STATISTICS: int-post
+