gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/set/convex/conv.icc

@@ -0,0 +1,51 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Contributing authors:
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *     Gabor Szokoli, 2004
+ *
+ *  Last modified:
+ *     $Date: 2005-11-24 18:03:01 +0100 (Thu, 24 Nov 2005) $ by $Author: tack $
+ *     $Revision: 2639 $
+ *
+ *  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 Set { namespace Convex {
+
+  /*
+   * "Convex" propagator
+   *
+   */
+
+  forceinline
+  Convex::Convex(Space* home, SetView x)
+    : UnaryPropagator<SetView, PC_SET_ANY>(home,x) {}
+
+  forceinline
+  Convex::Convex(Space* home, bool share, Convex& p)
+    : UnaryPropagator<SetView, PC_SET_ANY>(home,share,p) {}
+
+  forceinline ExecStatus
+  Convex::post(Space* home, SetView x) {
+    (void) new (home) Convex(home,x);
+    return ES_OK;
+  }
+
+}}}
+
+// STATISTICS: set-prop

data/ext/gecode-1.3.1/gecode/set/convex/hull.cc

@@ -0,0 +1,100 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Contributing authors:
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *     Gabor Szokoli, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-05-23 15:09:53 +0200 (Tue, 23 May 2006) $ by $Author: tack $
+ *     $Revision: 3232 $
+ *
+ *  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/set.hh"
+#include "gecode/set/convex.hh"
+
+namespace Gecode { namespace Set { namespace Convex {
+
+  Actor*
+  ConvexHull::copy(Space* home, bool share) {
+    return new (home) ConvexHull(home,share,*this);
+  }
+
+  ExecStatus
+  ConvexHull::propagate(Space* home) {
+    //x1 is the convex hull of x0
+
+    GECODE_ME_CHECK( x1.cardMin(home,x0.cardMin()) );
+    GECODE_ME_CHECK( x0.cardMax(home,x1.cardMax()) );
+
+    do {
+
+      //intersect x1 with (x0.lubMin(),x0.lubMax())
+      //This empties x1 if x0.ub is empty. twice.
+      GECODE_ME_CHECK( x1.exclude(home,Limits::Set::int_min,
+                                  x0.lubMin()-1) );
+      GECODE_ME_CHECK( x1.exclude(home,x0.lubMax()+1,
+                                  Limits::Set::int_max) );
+
+      int minElement = std::min(x1.glbMin(),x0.glbMin());
+      int maxElement = std::max(x1.glbMax(),x0.glbMax());
+
+      if (minElement<maxElement) {
+        GECODE_ME_CHECK( x1.include(home, minElement, maxElement));
+      }
+
+      unsigned int cardMin = x1.cardMin();
+
+      LubRanges<SetView> ubRangeIt(x1);
+      Iter::Ranges::Cache< LubRanges<SetView> > ubRangeItC(ubRangeIt);
+      for (;ubRangeItC();++ubRangeItC){
+        if (ubRangeItC.width() < cardMin
+            || ubRangeItC.min() > minElement //No need to test for empty lb.
+            || ubRangeItC.max() < maxElement
+            ) {
+          GECODE_ME_CHECK( x1.exclude(home,
+                                      ubRangeItC.min(), ubRangeItC.max()) );
+        }
+      }
+
+      LubRanges<SetView> ubRangeIt2(x1);
+      GECODE_ME_CHECK(x0.intersectI(home,ubRangeIt2) );
+
+      if (x1.lubMin()!=BndSet::MIN_OF_EMPTY) {
+        if(x1.lubMin()==x1.glbMin()) {
+              GECODE_ME_CHECK(x0.include(home,x1.lubMin()));
+        }
+        if(x1.lubMax()==x1.glbMax()) {
+              GECODE_ME_CHECK(x0.include(home,x1.lubMax()));
+        }
+      }
+    } while(x0.assigned()&&!x1.assigned());
+    
+    //If x0 is assigned, x1 should be too.
+    assert(x1.assigned() || !x0.assigned());
+
+    if (x1.assigned()) {
+      return ES_SUBSUMED;
+    }
+
+    return ES_NOFIX;
+  }
+
+}}}
+
+// STATISTICS: set-prop

data/ext/gecode-1.3.1/gecode/set/convex/hull.icc

@@ -0,0 +1,52 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Contributing authors:
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *     Gabor Szokoli, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-05-23 15:09:53 +0200 (Tue, 23 May 2006) $ by $Author: tack $
+ *     $Revision: 3232 $
+ *
+ *  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 Set { namespace Convex {
+
+  /*
+   * "Convex hull" propagator
+   *
+   */
+
+  forceinline
+  ConvexHull::ConvexHull(Space* home, SetView x, SetView y)
+    : BinaryPropagator<SetView, PC_SET_ANY>(home, x, y) {}
+
+  forceinline
+  ConvexHull::ConvexHull(Space* home, bool share, ConvexHull& p)
+    : BinaryPropagator<SetView, PC_SET_ANY>(home, share, p) {}
+
+  forceinline ExecStatus
+  ConvexHull::post(Space* home, SetView x, SetView y) {
+    (void) new (home) ConvexHull(home,x,y);
+    return ES_OK;
+  }
+
+
+}}}
+
+// STATISTICS: set-prop

data/ext/gecode-1.3.1/gecode/set/distinct.cc

@@ -0,0 +1,48 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 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/set/distinct.hh"
+
+using namespace Gecode::Set;
+
+namespace Gecode {
+
+  void
+  atmostOne(Space* home, const SetVarArgs& xa, unsigned int c) {
+    if (home->failed()) return;
+    if (xa.size() < 2)
+      return;
+    ViewArray<SetView> x(home,xa);
+    GECODE_ES_FAIL(home,Distinct::AtmostOne::post(home, x, c));
+  }
+
+  void
+  distinct(Space* home, const SetVarArgs& xa, unsigned int c) {
+    if (home->failed()) return;
+    if (xa.size() < 2)
+      return;
+    ViewArray<SetView> x(home,xa);
+    GECODE_ES_FAIL(home,Distinct::Distinct::post(home, x, c));
+  }
+
+}
+
+// STATISTICS: set-post

data/ext/gecode-1.3.1/gecode/set/distinct.hh

@@ -0,0 +1,97 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-06-19 11:03:38 +0200 (Mon, 19 Jun 2006) $ by $Author: tack $
+ *     $Revision: 3304 $
+ *
+ *  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.
+ *
+ */
+
+#ifndef __GECODE_SET_ATMOSTONE_HH__
+#define __GECODE_SET_ATMOSTONE_HH__
+
+#include "gecode/set.hh"
+#include "gecode/set/distinct/binomial.icc"
+
+namespace Gecode { namespace Set { namespace Distinct {
+
+  /**
+   * \namespace Gecode::Set::Distinct
+   * \brief Propagators for global distinctness constraints
+   */
+
+  /**
+   * \brief %Propagator for the AtMostOneIntersection constraint
+   *
+   * Requires \code #include "gecode/set/distinct.hh" \endcode
+   * \ingroup FuncSetProp   
+   */
+
+  class AtmostOne :
+    public NaryPropagator<SetView, PC_SET_ANY> {
+  protected:
+    /// Cardinality of the sets
+    unsigned int c;
+    /// Constructor for cloning \a p
+    AtmostOne(Space* home, bool share,AtmostOne& p);
+    /// Constructor for posting
+    AtmostOne(Space* home,ViewArray<SetView>&,unsigned int);
+  public:
+    /// Copy propagator during cloning
+    GECODE_SET_EXPORT virtual Actor*      copy(Space* home, bool);
+    /// Perform propagation
+    GECODE_SET_EXPORT virtual ExecStatus propagate(Space* home);
+    /// Post propagator for \f$\forall 0\leq i\leq |x| : |x_i|=c\f$ and \f$\forall 0\leq i<j\leq |x| : |x_i\cap x_j|\leq 1\f$
+    static ExecStatus post(Space* home,ViewArray<SetView> x,unsigned int c);
+  };
+
+  /**
+   * \brief %Propagator for the n-ary distinct constraint with fixed cardinalities
+   *
+   * Requires \code #include "gecode/set/distinct.hh" \endcode
+   * \ingroup FuncSetProp   
+   */
+
+  class Distinct :
+    public NaryPropagator<SetView, PC_SET_ANY> {
+  protected:
+    /// Binomial coefficients table
+    Binomial bin;
+    /// Cardinality of the sets
+    unsigned int c;
+    /// Constructor for cloning \a p
+    Distinct(Space* home, bool share,Distinct& p);
+    /// Constructor for posting
+    Distinct(Space* home,ViewArray<SetView>&,unsigned int);
+  public:
+    /// Copy propagator during cloning
+    GECODE_SET_EXPORT virtual Actor*      copy(Space* home, bool);
+    /// Perform propagation
+    GECODE_SET_EXPORT virtual ExecStatus propagate(Space* home);
+    /// Post propagator for \f$\forall 0\leq i\leq |x| : |x_i|=c\f$ and \f$\forall 0\leq i<j\leq |x| : |x_i\cap x_j|\leq 1\f$
+    static ExecStatus post(Space* home,ViewArray<SetView> x,unsigned int c);
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+  };
+
+
+}}}
+
+#include "gecode/set/distinct/atmostOne.icc"
+#include "gecode/set/distinct/distinct.icc"
+
+#endif
+
+// STATISTICS: set-prop

data/ext/gecode-1.3.1/gecode/set/distinct/atmostOne.cc

@@ -0,0 +1,151 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 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/set.hh"
+#include "gecode/set/distinct.hh"
+
+/*
+ * These propagators implement the scheme discussed in
+ *
+ * Andrew Sadler and Carment Gervet: Global Reasoning on Sets.
+ * FORMUL'01 workshop in conjunction with CP 2001.
+ *
+ * Todo: make the propagators incremental.
+ */
+
+namespace Gecode { namespace Set { namespace Distinct {
+
+  /*
+   * "AtMostOneIntersection" propagator
+   *
+   */
+
+  Actor*
+  AtmostOne::copy(Space* home, bool share) {
+    return new (home) AtmostOne(home,share,*this);
+  }
+
+  ExecStatus
+  AtmostOne::propagate(Space* home) {
+
+    GECODE_AUTOARRAY(LubRanges<SetView>, lubs, x.size());
+    for (int i = x.size(); i--; ) {
+      lubs[i].init(x[i]);
+    }
+    Iter::Ranges::NaryUnion<LubRanges<SetView> > bigT(lubs, x.size());
+    Iter::Ranges::Cache<Iter::Ranges::NaryUnion<LubRanges<SetView> > >
+      bigTC(bigT);
+
+    Iter::Ranges::ToValues<Iter::Ranges::Cache<Iter::Ranges::NaryUnion<LubRanges<SetView> > > >
+      as(bigTC);
+
+    while (as()) {
+      int a = as.val(); ++as;
+
+      // cardSa is the number of sets that contain a in the glb
+      int cardSa = 0;
+      for (int i=x.size(); i--;)
+	if (x[i].contains(a))
+	  cardSa++;
+
+      // bigTa is the union of all lubs that contain a
+      GLBndSet bigTa(home);
+      for (int i=x.size(); i--;) {
+	if (!x[i].notContains(a)) {
+	  LubRanges<SetView> xilub(x[i]);
+	  bigTa.includeI(home, xilub);
+	}
+      }
+
+      // maxa is the maximum number of sets that can contain a
+      int maxa = (bigTa.size() - 1) / (c - 1);
+      bigTa.dispose(home);
+
+      // Conditional Rule A:
+      // If more sets already contain a than allowed, fail.
+      if (maxa < cardSa)
+	return ES_FAILED;
+
+      if (maxa == cardSa) {
+	// Conditional Rule B:
+	// All a used up. All other sets (those that don't have a in their
+	// glb already) cannot contain a.
+	for (int i=x.size(); i--;) {
+	  if (!x[i].contains(a)) {
+	    GECODE_ME_CHECK(x[i].exclude(home, a));
+	  }
+	}
+      } else {
+	GECODE_AUTOARRAY(LubRanges<SetView>, lubs2, x.size());
+	for (int i = x.size(); i--; ) {
+	  lubs2[i].init(x[i]);
+	}
+	Iter::Ranges::NaryUnion<LubRanges<SetView> > bigT2(lubs2, x.size());
+	
+	GECODE_AUTOARRAY(GlbRanges<SetView>, glbs, cardSa);
+	int count = 0;
+	for (int i=x.size(); i--; ) {
+	  if (x[i].contains(a)) {
+	    glbs[count].init(x[i]);
+	    count++;
+	  }
+	}
+	Iter::Ranges::NaryUnion<GlbRanges<SetView> > glbsa(glbs, cardSa);
+	Iter::Ranges::Diff<Iter::Ranges::NaryUnion<LubRanges<SetView> >,
+	  Iter::Ranges::NaryUnion<GlbRanges<SetView> > > deltaA(bigT2, glbsa);
+	Iter::Ranges::Cache<
+	Iter::Ranges::Diff<Iter::Ranges::NaryUnion<LubRanges<SetView> >,
+	  Iter::Ranges::NaryUnion<GlbRanges<SetView> > > > deltaAC(deltaA);
+	// deltaAC contains all elements that are not yet known to be
+	// in a set together with a.
+	// Formally: \cup_i lub(x_i) - \cup_i {glb(s_i) | a\in glb(s_i)}
+
+
+	if (Iter::Ranges::size(deltaAC) == c - 1) {
+	  // Conditional Rule C:
+	  // If deltaA has exactly c-1 elements, all sets that are not yet
+	  // known to contain a cannot contain a if it is impossible that
+	  // they contain all of deltaA. Or the other way around:
+	  // If a is added to the glb of a set s, deltaA must be a subset of
+	  // s, because otherwise s would share at least one more element
+	  // with another set that has a in its lower bound.
+	  // Weird, eh?
+	  for (int i=x.size(); i--; ) {
+	    if (!x[i].contains(a) && !x[i].notContains(a)) {
+	      deltaAC.reset();
+	      LubRanges<SetView> xilub(x[i]);
+	      if (!Iter::Ranges::subset(deltaAC, xilub)) {
+		GECODE_ME_CHECK(x[i].exclude(home, a));
+	      }
+	    }
+	  }
+	}
+
+      }
+
+    }
+
+    return ES_NOFIX;
+  }
+
+}}}
+
+// STATISTICS: set-prop