gecoder-with-gecode 0.7.1

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

@@ -0,0 +1,152 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2005
+ *     Christian Schulte, 2005
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:07:12 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3518 $
+ *
+ *  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_TEST_SET_HH__
+#define __GECODE_TEST_SET_HH__
+
+#include "gecode/set.hh"
+#include "test.hh"
+#include "int.hh"
+
+using namespace Gecode;
+using namespace Set;
+
+class CountableSetValues {
+private:
+  IntSetValues dv;
+  int cur;
+  int i;
+public:
+  CountableSetValues(void) {}
+  CountableSetValues(const IntSet& d0, int cur0) : dv(d0), cur(cur0), i(1) {
+    if (! (i & cur))
+      operator++();
+  }
+  void init(const IntSet& d0, int cur0) {
+    dv = d0;
+    cur = cur0;
+    i = 1;
+    if (! (i & cur))
+      operator++();
+  }
+  bool operator()(void) const {
+    return i<=cur;
+  }
+  void operator++(void) {
+    do {
+      ++dv;
+      i = i<<1;
+    } while (! (i & cur) && i<cur);
+  }
+  int val(void) const { return dv.val(); }
+};
+
+class CountableSetRanges : public Iter::Values::ToRanges<CountableSetValues> {
+private:
+  CountableSetValues v;
+public:
+  CountableSetRanges(void) {}
+  CountableSetRanges(const IntSet& d, int cur) : v(d, cur) {
+    Iter::Values::ToRanges<CountableSetValues>::init(v);
+  }
+  void init(const IntSet& d, int cur) {
+    v.init(d, cur);
+    Iter::Values::ToRanges<CountableSetValues>::init(v);
+  }
+};
+
+class CountableSet {
+private:
+  IntSet d;
+  //  IntSet curd;
+  unsigned int cur;
+  unsigned int lubmax;
+public:
+  CountableSet(const IntSet&);
+  CountableSet(void) {}
+  void init(const IntSet&);
+  void reset(void) { cur = 0; }
+  bool operator()(void) const { return cur<lubmax; }
+  void operator++(void);
+  int val(void) const;
+};
+
+class SetAssignment {
+private:
+  int n;
+  CountableSet* dsv;
+  Assignment ir;
+  bool done;
+public:
+  IntSet lub;
+  int withInt;
+  SetAssignment(int, const IntSet&, int withInt = 0);
+  void reset(void);
+  bool operator()(void) const {
+    return !done;
+  }
+  void operator++(void);
+  int operator[](int i) const {
+    assert((i>=0) && (i<n));
+    return dsv[i].val();
+  }
+  int intval(void) const { return ir[0]; }
+  const Assignment& ints(void) const { return ir; }
+  int size(void) const {
+    return n;
+  }
+  ~SetAssignment(void) {
+    delete [] dsv;
+  }
+};
+
+std::ostream&
+operator<<(std::ostream&, const SetAssignment&);
+
+class SetTest : public Test {
+private:
+  int     arity;
+  IntSet  lub;
+  bool    reified;
+  int    withInt;
+
+  void removeFromLub(int, SetVar&, int, const IntSet&);
+  void addToGlb(int, SetVar&, int, const IntSet&);
+  SetAssignment* make_assignment(void);
+public:
+  SetTest(const char* t,
+	  int a, const IntSet& d, bool r=false, int w=0)
+    : Test("Set",t), arity(a), lub(d), reified(r), withInt(w)  {}
+  /// Check for solution
+  virtual bool solution(const SetAssignment&) const = 0;
+  /// Post propagator
+  virtual void post(Space* home, SetVarArray& x, IntVarArray& y) = 0;
+  /// Post reified propagator
+  virtual void post(Space* home, SetVarArray& x, IntVarArray& y, BoolVar b) {}
+  /// Perform test
+  virtual bool run(const Options& opt);
+};
+
+#endif
+
+// STATISTICS: test-set

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

@@ -0,0 +1,94 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2005
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:07:12 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3518 $
+ *
+ *  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 "test/set.hh"
+
+static IntSet ds_33(-4,4);
+
+class Convex : public SetTest {
+public:
+  Convex(const char* t)
+    : SetTest(t,1,ds_33,false) {}
+  virtual bool solution(const SetAssignment& x) const {
+    CountableSetRanges xr0(x.lub, x[0]);
+    if (!xr0())
+      return true;
+    ++xr0;
+    if (!xr0())
+      return true;
+    return false;
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+    Gecode::convex(home, x[0]);
+  }
+};
+Convex _convex("Convex::Convex");
+
+class ConvexHull : public SetTest {
+public:
+  ConvexHull(const char* t)
+    : SetTest(t,2,ds_33,false) {}
+  virtual bool solution(const SetAssignment& x) const {
+    CountableSetRanges xr0(x.lub, x[0]);
+    CountableSetRanges xr1(x.lub, x[1]);
+
+    if (!xr0())
+      return !xr1();
+
+    int x0min = xr0.min();
+    int x0max = xr0.max();
+    ++xr0;
+    if (!xr0()) {
+      if (!xr1()) return false;
+      if (x0min != xr1.min()) return false;
+      int x1max = Limits::Set::int_min;
+      while (xr1()) { x1max = xr1.max(); ++xr1;}
+      if (x0max != x1max) return false;
+      return true;
+    }
+    return false;
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+    Gecode::convexHull(home, x[1], x[0]);
+  }
+};
+ConvexHull _convexhull("Convex::ConvexHull");
+
+class ConvexHullS : public SetTest {
+public:
+  ConvexHullS(const char* t)
+    : SetTest(t,1,ds_33,false) {}
+  virtual bool solution(const SetAssignment& x) const {
+    CountableSetRanges xr0(x.lub, x[0]);
+    if (!xr0())
+      return true;
+    ++xr0;
+    if (!xr0())
+      return true;
+    return false;
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+    Gecode::convexHull(home, x[0], x[0]);
+  }
+};
+ConvexHullS _convexhulls("Convex::Sharing::ConvexHullS");
+
+// STATISTICS: test-set

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

@@ -0,0 +1,148 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2005
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:07:12 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3518 $
+ *
+ *  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 "test/set.hh"
+
+static IntSet ds_33(-2,2);
+static IntSet ds_44(-4,4);
+
+class AtmostOne : public SetTest {
+public:
+  AtmostOne(const char* t)
+    : SetTest(t,3,ds_33,false) {}
+  virtual bool solution(const SetAssignment& x) const {
+    {
+      CountableSetRanges xr0(x.lub, x[0]);
+      CountableSetRanges xr1(x.lub, x[1]);
+      Iter::Ranges::Inter<CountableSetRanges,CountableSetRanges> i(xr0,xr1);
+      if (Iter::Ranges::size(i)>1)
+	return false;
+    }
+    {
+      CountableSetRanges xr0(x.lub, x[0]);
+      CountableSetRanges xr2(x.lub, x[2]);
+      Iter::Ranges::Inter<CountableSetRanges,CountableSetRanges> i(xr0,xr2);
+      if (Iter::Ranges::size(i)>1)
+	return false;
+    }
+    {
+      CountableSetRanges xr1(x.lub, x[1]);
+      CountableSetRanges xr2(x.lub, x[2]);
+      Iter::Ranges::Inter<CountableSetRanges,CountableSetRanges> i(xr1,xr2);
+      if (Iter::Ranges::size(i)>1)
+	return false;
+    }
+    {
+      CountableSetRanges xr0(x.lub, x[0]);
+      CountableSetRanges xr1(x.lub, x[1]);
+      CountableSetRanges xr2(x.lub, x[2]);
+      if (Iter::Ranges::size(xr0)!=3 ||
+	  Iter::Ranges::size(xr1)!=3 ||
+	  Iter::Ranges::size(xr2)!=3)
+	return false;
+    }
+    return true;
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+    SetVar s1(home, IntSet::empty, -2, 2, 0,1);
+    Gecode::rel(home, x[0], SOT_INTER, x[1], SRT_EQ, s1);
+    SetVar s2(home, IntSet::empty, -2, 2, 0,1);
+    Gecode::rel(home, x[0], SOT_INTER, x[2], SRT_EQ, s2);
+    SetVar s3(home, IntSet::empty, -2, 2, 0,1);
+    Gecode::rel(home, x[1], SOT_INTER, x[2], SRT_EQ, s3);
+    Gecode::atmostOne(home, x, 3);
+  }
+};
+AtmostOne _atmostone("Distinct::AtmostOne");
+
+class Distinct : public SetTest {
+public:
+  Distinct(const char* t)
+    : SetTest(t,4,ds_44,false) {}
+  virtual bool solution(const SetAssignment& x) const {
+    {
+      CountableSetRanges xr0(x.lub, x[0]);
+      CountableSetRanges xr1(x.lub, x[1]);
+      Iter::Ranges::Inter<CountableSetRanges,CountableSetRanges> i(xr0,xr1);
+      if (!i())
+	return false;
+    }
+    {
+      CountableSetRanges xr0(x.lub, x[0]);
+      CountableSetRanges xr2(x.lub, x[2]);
+      Iter::Ranges::Inter<CountableSetRanges,CountableSetRanges> i(xr0,xr2);
+      if (!i())
+	return false;
+    }
+    {
+      CountableSetRanges xr0(x.lub, x[0]);
+      CountableSetRanges xr3(x.lub, x[3]);
+      Iter::Ranges::Inter<CountableSetRanges,CountableSetRanges> i(xr0,xr3);
+      if (!i())
+	return false;
+    }
+    {
+      CountableSetRanges xr1(x.lub, x[1]);
+      CountableSetRanges xr2(x.lub, x[2]);
+      Iter::Ranges::Inter<CountableSetRanges,CountableSetRanges> i(xr1,xr2);
+      if (!i())
+	return false;
+    }
+    {
+      CountableSetRanges xr1(x.lub, x[1]);
+      CountableSetRanges xr3(x.lub, x[3]);
+      Iter::Ranges::Inter<CountableSetRanges,CountableSetRanges> i(xr1,xr3);
+      if (!i())
+	return false;
+    }
+    {
+      CountableSetRanges xr2(x.lub, x[2]);
+      CountableSetRanges xr3(x.lub, x[3]);
+      Iter::Ranges::Inter<CountableSetRanges,CountableSetRanges> i(xr2,xr3);
+      if (!i())
+	return false;
+    }
+    {
+      CountableSetRanges xr0(x.lub, x[0]);
+      CountableSetRanges xr1(x.lub, x[1]);
+      CountableSetRanges xr2(x.lub, x[2]);
+      CountableSetRanges xr3(x.lub, x[3]);
+      if (Iter::Ranges::size(xr0)!=3 ||
+	  Iter::Ranges::size(xr1)!=3 ||
+	  Iter::Ranges::size(xr2)!=3 ||
+	  Iter::Ranges::size(xr3)!=3)
+	return false;
+    }
+    return true;
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+    Gecode::rel(home, x[0], SRT_NQ, x[1]);
+    Gecode::rel(home, x[0], SRT_NQ, x[2]);
+    Gecode::rel(home, x[0], SRT_NQ, x[3]);
+    Gecode::rel(home, x[1], SRT_NQ, x[2]);
+    Gecode::rel(home, x[1], SRT_NQ, x[3]);
+    Gecode::rel(home, x[2], SRT_NQ, x[3]);
+    Gecode::atmostOne(home, x, 3);
+  }
+};
+Distinct _distinct("Distinct::Distinct");
+
+// STATISTICS: test-set

data/ext/gecode-1.3.1/test/set/dom.cc

@@ -0,0 +1,67 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2005
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:07:12 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3518 $
+ *
+ *  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 "test/set.hh"
+
+static const int d1r[4][2] = {
+  {-4,-3},{-1,-1},{1,1},{3,5}
+};
+static IntSet d1(d1r,4);
+
+static IntSet ds_33(-3,3);
+
+class DomEqRange : public SetTest {
+public:
+  DomEqRange(const char* t)
+    : SetTest(t,1,ds_33,true) {}
+  virtual bool solution(const SetAssignment& x) const {
+    CountableSetRanges xr(x.lub, x[0]);
+    IntSetRanges dr(ds_33);
+    return Iter::Ranges::equal(xr, dr);
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+    Gecode::dom(home, x[0], SRT_EQ, ds_33);
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&, BoolVar b) {
+    Gecode::dom(home, x[0], SRT_EQ, ds_33, b);
+  }
+};
+DomEqRange _domeqrange("Dom::EqRange");
+
+class DomEqDom : public SetTest {
+public:
+  DomEqDom(const char* t)
+    : SetTest(t,1,d1,true) {}
+  virtual bool solution(const SetAssignment& x) const {
+    CountableSetRanges xr(x.lub, x[0]);
+    IntSetRanges dr(d1);
+    return Iter::Ranges::equal(xr, dr);
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+    Gecode::dom(home, x[0], SRT_EQ, d1);
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&, BoolVar b) {
+    Gecode::dom(home, x[0], SRT_EQ, d1, b);
+  }
+};
+DomEqDom _domeq("Dom::EqDom");
+
+// STATISTICS: test-set