gecoder-with-gecode 0.7.1

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

@@ -0,0 +1,105 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     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.
+ *
+ */
+
+#include "test/int.hh"
+#include "test/log.hh"
+
+static IntSet ds_22(-2,2);
+
+class RegularA : public IntTest {
+public:
+  RegularA(const char* t)
+    : IntTest(t,4,ds_22,false,ICL_DOM) {}
+  virtual bool solution(const Assignment& x) const {
+    return (((x[0] == 0) || (x[0] == 2)) &&
+	    ((x[1] == -1) || (x[1] == 1)) &&
+	    ((x[2] == 0) || (x[2] == 1)) &&
+	    ((x[3] == 0) || (x[3] == 1)));
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    REG r =
+      (REG(0) | REG(2)) +
+      (REG(-1) | REG(1)) +
+      (REG(7) | REG(0) | REG(1)) +
+      (REG(0) | REG(1));
+    DFA d(r);
+    regular(home, x, d);
+  }
+};
+
+class RegularB : public IntTest {
+public:
+  RegularB(const char* t)
+    : IntTest(t,4,ds_22,false,ICL_DOM) {}
+  virtual bool solution(const Assignment& x) const {
+    return (x[0]<x[1]) && (x[1]<x[2]) && (x[2]<x[3]);
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    REG r =
+      (REG(-2) + REG(-1) + REG(0) + REG(1)) |
+      (REG(-2) + REG(-1) + REG(0) + REG(2)) |
+      (REG(-2) + REG(-1) + REG(1) + REG(2)) |
+      (REG(-2) + REG(0) + REG(1) + REG(2)) |
+      (REG(-1) + REG(0) + REG(1) + REG(2));
+    DFA d(r);
+    regular(home, x, d);
+  }
+};
+
+class RegularShared : public IntTest {
+public:
+  RegularShared(const char* t)
+    : IntTest(t,2,ds_22,false,ICL_DOM) {}
+  virtual bool solution(const Assignment& x) const {
+    return (((x[0] == 0) || (x[0] == 2)) &&
+	    ((x[1] == -1) || (x[1] == 1)) &&
+	    ((x[0] == 0) || (x[0] == 1)) &&
+	    ((x[1] == 0) || (x[1] == 1)));
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    Log::log("post regular: x[0]x[1]x[0]x[1] in (0|2)(-1|1)(7|0|1)(0|1)",
+	     "\tREG r = \n"
+	     "\t  (REG(0) | REG(2)) +\n"
+	     "\t  (REG(-1) | REG(1)) +\n"
+	     "\t  (REG(7) | REG(0) | REG(1)) +\n"
+	     "\t  (REG(0) | REG(1));\n"
+	     "\tDFA d(r);\n"
+	     "\tIntVarArgs y(4);\n"
+	     "\ty[0]=x[0]; y[1]=x[1]; y[2]=x[0]; y[3]=x[1];\n"
+	     "\tregular(home, y, d);\n");
+    REG r =
+      (REG(0) | REG(2)) +
+      (REG(-1) | REG(1)) +
+      (REG(7) | REG(0) | REG(1)) +
+      (REG(0) | REG(1));
+    DFA d(r);
+    IntVarArgs y(4);
+    y[0]=x[0]; y[1]=x[1]; y[2]=x[0]; y[3]=x[1];
+    regular(home, y, d);
+  }
+};
+
+RegularA _rega("Regular::A");
+RegularB _regb("Regular::B");
+RegularShared _regsa("Regular::Shared");
+
+// STATISTICS: test-int
+

data/ext/gecode-1.3.1/test/int/rel.cc

@@ -0,0 +1,283 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2005
+ *
+ *  Last modified:
+ *     $Date: 2006-08-31 17:36:38 +0200 (Thu, 31 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3579 $
+ *
+ *  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/int.hh"
+
+static IntSet ds_22(-2,2);
+
+class RelEqBin : public IntTest {
+private:
+  IntConLevel icl;
+public:
+  RelEqBin(const char* t, IntConLevel icl0)
+    : IntTest(t,2,ds_22,true), icl(icl0) {}
+  virtual bool solution(const Assignment& x) const {
+    return x[0]==x[1];
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    rel(home, x[0], IRT_EQ, x[1], icl);
+  }
+  virtual void post(Space* home, IntVarArray& x, BoolVar b) {
+    rel(home, x[0], IRT_EQ, x[1], b, icl);
+  }
+};
+RelEqBin _releqbinbnd("Rel::EqBinBnd",ICL_BND);
+RelEqBin _releqbindom("Rel::EqBinDom",ICL_DOM);
+
+class RelEqBinInt : public IntTest {
+private:
+  IntConLevel icl;
+public:
+  RelEqBinInt(const char* t, IntConLevel icl0)
+    : IntTest(t,1,ds_22,true), icl(icl0) {}
+  virtual bool solution(const Assignment& x) const {
+    return x[0]==0;
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    rel(home, x[0], IRT_EQ, 0, icl);
+  }
+  virtual void post(Space* home, IntVarArray& x, BoolVar b) {
+    rel(home, x[0], IRT_EQ, 0, b, icl);
+  }
+};
+RelEqBinInt _releqbinbndint("Rel::EqBinBndInt",ICL_BND);
+RelEqBinInt _releqbindomint("Rel::EqBinDomInt",ICL_DOM);
+
+
+class RelEqNary : public IntTest {
+private:
+  IntConLevel icl;
+public:
+  RelEqNary(const char* t, IntConLevel icl0)
+    : IntTest(t,4,ds_22,false), icl(icl0) {}
+  virtual bool solution(const Assignment& x) const {
+    return (x[0]==x[1]) && (x[1]==x[2]) && (x[2]==x[3]);
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    eq(home, x, icl);
+  }
+};
+RelEqNary _releqnarybnd("Rel::EqNaryBnd", ICL_BND);
+RelEqNary _releqnarydom("Rel::EqNaryDom", ICL_DOM);
+
+
+class RelNq : public IntTest {
+private:
+  IntConLevel icl;
+public:
+  RelNq(const char* t, IntConLevel icl0)
+    : IntTest(t,2,ds_22,true), icl(icl0) {}
+  virtual bool solution(const Assignment& x) const {
+    return x[0]!=x[1];
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    rel(home, x[0], IRT_NQ, x[1], icl);
+  }
+  virtual void post(Space* home, IntVarArray& x, BoolVar b) {
+    rel(home, x[0], IRT_NQ, x[1], b, icl);
+  }
+};
+RelNq _relnqbnd("Rel::NqBnd",ICL_BND);
+RelNq _relnqdom("Rel::NqDom",ICL_DOM);
+
+
+class RelLq : public IntTest {
+public:
+  RelLq(void)
+    : IntTest("Rel::Lq",2,ds_22,true) {}
+  virtual bool solution(const Assignment& x) const {
+    return x[0] <= x[1];
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    rel(home, x[0], IRT_LQ, x[1]);
+  }
+  virtual void post(Space* home, IntVarArray& x, BoolVar b) {
+    rel(home, x[0], IRT_LQ, x[1], b);
+  }
+};
+RelLq _rellq;
+
+class RelLqInt : public IntTest {
+public:
+  RelLqInt(void)
+    : IntTest("Rel::LqInt",1,ds_22,true) {}
+  virtual bool solution(const Assignment& x) const {
+    return x[0] <= 0;
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    rel(home, x[0], IRT_LQ, 0);
+  }
+  virtual void post(Space* home, IntVarArray& x, BoolVar b) {
+    rel(home, x[0], IRT_LQ, 0, b);
+  }
+};
+RelLqInt _rellqint;
+
+
+class RelLe : public IntTest {
+public:
+  RelLe(void)
+    : IntTest("Rel::Le",2,ds_22,true) {}
+  virtual bool solution(const Assignment& x) const {
+    return x[0] < x[1];
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    rel(home, x[0], IRT_LE, x[1]);
+  }
+  virtual void post(Space* home, IntVarArray& x, BoolVar b) {
+    rel(home, x[0], IRT_LE, x[1], b);
+  }
+};
+RelLe _relle;
+
+class RelLeInt : public IntTest {
+public:
+  RelLeInt(void)
+    : IntTest("Rel::LeInt",1,ds_22,true) {}
+  virtual bool solution(const Assignment& x) const {
+    return x[0] < 0;
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    rel(home, x[0], IRT_LE, 0);
+  }
+  virtual void post(Space* home, IntVarArray& x, BoolVar b) {
+    rel(home, x[0], IRT_LE, 0, b);
+  }
+};
+RelLeInt _relleint;
+
+class RelGq : public IntTest {
+public:
+  RelGq(void)
+    : IntTest("Rel::Gq",2,ds_22,true) {}
+  virtual bool solution(const Assignment& x) const {
+    return x[0] >= x[1];
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    rel(home, x[0], IRT_GQ, x[1]);
+  }
+  virtual void post(Space* home, IntVarArray& x, BoolVar b) {
+    rel(home, x[0], IRT_GQ, x[1], b);
+  }
+};
+RelGq _relgq;
+
+class RelGqInt : public IntTest {
+public:
+  RelGqInt(void)
+    : IntTest("Rel::GqInt",1,ds_22,true) {}
+  virtual bool solution(const Assignment& x) const {
+    return x[0] >= 0;
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    rel(home, x[0], IRT_GQ, 0);
+  }
+  virtual void post(Space* home, IntVarArray& x, BoolVar b) {
+    rel(home, x[0], IRT_GQ, 0, b);
+  }
+};
+RelGqInt _relgqint;
+
+
+class RelGr : public IntTest {
+public:
+  RelGr(void)
+    : IntTest("Rel::Gr",2,ds_22,true) {}
+  virtual bool solution(const Assignment& x) const {
+    return x[0] > x[1];
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    rel(home, x[0], IRT_GR, x[1]);
+  }
+  virtual void post(Space* home, IntVarArray& x, BoolVar b) {
+    rel(home, x[0], IRT_GR, x[1], b);
+  }
+};
+RelGr _relgr;
+
+class RelGrInt : public IntTest {
+public:
+  RelGrInt(void)
+    : IntTest("Rel::GrInt",1,ds_22,true) {}
+  virtual bool solution(const Assignment& x) const {
+    return x[0] > 0;
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    rel(home, x[0], IRT_GR, 0);
+  }
+  virtual void post(Space* home, IntVarArray& x, BoolVar b) {
+    rel(home, x[0], IRT_GR, 0, b);
+  }
+};
+RelGrInt _relgrint;
+
+class Lex : public IntTest {
+private:
+  int  n;
+  bool strict;
+public:
+  Lex(const char* t, int m, bool _strict)
+    : IntTest(t,m*2,ds_22), n(m), strict(_strict) {}
+  virtual bool solution(const Assignment& x) const {
+    for (int i=0; i<n; i++)
+      if (x[i]<x[n+i]) {
+	return true;
+      } else if (x[i]>x[n+i]) {
+	return false;
+      }
+    return !strict;
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    IntVarArgs y(n); IntVarArgs z(n);
+    for (int i=0; i<n; i++) {
+      y[i]=x[i]; z[i]=x[n+i];
+    }
+    rel(home, y, strict ? IRT_LE : IRT_LQ, z);
+  }
+};
+Lex _lexlq("Lex::Lq",3,false);
+Lex _lexle("Lex::Le",3,true);
+
+
+class NaryNq : public IntTest {
+private:
+  int  n;
+public:
+  NaryNq(const char* t, int m)
+    : IntTest(t,m*2,ds_22), n(m) {}
+  virtual bool solution(const Assignment& x) const {
+    for (int i=0; i<n; i++)
+      if (x[i] != x[n+i])
+	return true;
+    return false;
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    IntVarArgs y(n); IntVarArgs z(n);
+    for (int i=0; i<n; i++) {
+      y[i]=x[i]; z[i]=x[n+i];
+    }
+    rel(home, y, IRT_NQ, z);
+  }
+};
+NaryNq _nnq("NaryNq",3);
+
+// STATISTICS: test-int
+

data/ext/gecode-1.3.1/test/int/scheduling.cc

@@ -0,0 +1,259 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2005
+ *     Mikael Lagerkvist, 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/int.hh"
+#include "test/log.hh"
+#include "gecode/minimodel.hh"
+#include "gecode/search.hh"
+
+#include <vector>
+#include <algorithm>
+#include <string>
+#include <sstream>
+
+static IntSet ds_12(-1,2);
+
+namespace {
+  using namespace Gecode::Iter::Ranges;
+
+  /* We are only interested in assignments that represent tasks (s_i,
+   * d_i, e_i, h_i) such that the following hold:
+   *   - The task starts at a positive time and has some extension.
+   *   - The equation s_i + d_i = e_i holds.
+   *   - The tasks are ordered to remove some symmetries, i.e.,
+   *     s_i <= s_{i+1}
+   */
+  struct Ass : public Space {
+    IntVarArray x;
+    Ass(int n, const IntSet& d) : x(this, n, d) {
+      for (int i = 0; i < n; i += 4) {
+	post(this, x[i+0] >= 0);
+	post(this, x[i+1] >= 0);
+	post(this, x[i+2] >= 0);
+	post(this, x[i] + x[i+1] == x[i+2]);
+	// Doesn't work with search-based tests
+	//if (i+4 < n) {
+	//   post(this, x[i] <= x[i+4]);
+	//}
+	branch(this, x, BVAR_NONE, BVAL_MIN);
+      }
+    }
+    Ass(bool share, Ass& s) : Space(share,s) {
+      x.update(this, share, s.x);
+    }
+    virtual Space* copy(bool share) {
+      return new Ass(share,*this);
+    }
+  };
+
+  // Class for generating reasonable assignements (i.e. s+d=e)
+  class CumulativeAssignment : public Assignment {
+    Ass *cur, *nxt;
+    DFS<Ass> *e;
+  public:
+    CumulativeAssignment(int, const IntSet&);
+    virtual void reset(void);
+    virtual void operator++(void);
+    virtual int  operator[](int i) const;
+    virtual bool operator()(void)  const;
+    virtual ~CumulativeAssignment() {
+      if (cur) delete cur;
+      if (nxt) delete nxt;
+      if (e  ) delete e;
+    }
+  };
+
+  CumulativeAssignment::CumulativeAssignment(int n0, const IntSet& d0)
+    : Assignment(n0, d0), cur(NULL), nxt(NULL), e(NULL)
+  {
+    reset();
+  }
+  void
+  CumulativeAssignment::reset(void) {
+    Ass *a = new Ass(n, d);
+    delete e;
+    e = new DFS<Ass>(a);
+    delete a;
+    nxt = cur = e->next();
+    if (cur != NULL) nxt = e->next();
+  }
+  int
+  CumulativeAssignment::operator[](int i) const {
+    assert((i>=0) && (i<n) && cur != NULL);
+    return cur->x[i].val();
+  }
+  void
+  CumulativeAssignment::operator++(void) {
+    if(cur) delete cur;
+    cur = nxt;
+    if (nxt != NULL) nxt = e->next();
+  }
+  bool
+  CumulativeAssignment::operator()(void) const {
+    return nxt != NULL;
+  }
+
+  // Classes and functions for checking an assignment
+  struct Event {
+    int p, h;
+    bool start;
+    Event(int pos, int height, bool s) : p(pos), h(height), start(s) {}
+    bool operator<(const Event& e) const { return p<e.p; }
+  };
+
+  struct Below {
+    int limit;
+    Below(int l) : limit(l) {}
+    bool operator()(int val) { return val <= limit; }
+  };
+  struct Above {
+    int limit;
+    Above(int l) : limit(l) {}
+    bool operator()(int val) { return val >= limit; }
+  };
+
+  typedef std::vector<Event> eventv;
+
+  template <class C>
+  bool valid(eventv e, C comp) {
+    std::sort(e.begin(), e.end());
+    unsigned int i = 0;
+    int p = 0;
+    int h = 0;
+    int n = 0;
+    while (i < e.size()) {
+      p = e[i].p;
+      while (i < e.size() && e[i].p == p) {
+	h += e[i].h;
+	n += (e[i].start ? +1 : -1);
+	++i;
+      }
+      if (n && !comp(h)) {
+	return false;
+      }
+    }
+    return true;
+  }
+}
+
+class Cumulatives : public IntTest {
+protected:
+  int ntasks;
+  bool at_most;
+  int limit;
+
+  virtual Assignment* make_assignment() {
+    assert(arity == 4*ntasks);
+    return new CumulativeAssignment(arity, dom);
+  }
+public:
+  Cumulatives(const char* t, int nt, bool am, int l)
+    : IntTest(t,nt*4,ds_12), ntasks(nt), at_most(am), limit(l) {}
+
+  virtual bool solution(const Assignment& x) const {
+    eventv e;
+    for (int i = 0; i < ntasks; ++i) {
+      int p = i*4;
+      // Positive start, duration and end
+      if (x[p+0] < 0 || x[p+1] < 1 || x[p+2] < 1) return false;
+      // Start + Duration == End
+      if (x[p+0] + x[p+1] != x[p+2]) {
+	return false;
+      }
+    }
+    for (int i = 0; i < ntasks; ++i) {
+      int p = i*4;
+      // Up at start, down at end.
+      e.push_back(Event(x[p+0], +x[p+3],  true));
+      e.push_back(Event(x[p+2], -x[p+3], false));
+    }
+    if (at_most) {
+      return valid(e, Below(limit));
+    } else {
+      return valid(e, Above(limit));
+    }
+  }
+
+  virtual void post(Space* home, IntVarArray& x) {
+    if (Log::logging()) {
+      std::ostringstream buf;
+      buf << "\tint ntastks = " << ntasks << ", limit = " << limit
+	  << ";\n\tbool at_most = " << at_most << ";";
+      Log::log("", buf.str().c_str());
+      Log::log("post cumulatives",
+	       "\tIntArgs m(ntasks), l(1, limit);\n"
+	       "\tIntVarArgs s(ntasks), d(ntasks), e(ntasks), h(ntasks);\n"
+	       "\tfor (int i = 0; i < ntasks; ++i) {\n"
+	       "\t\tint p = i*4;\n"
+	       "\t\tm[i] = 0;\n"
+	       "\t\ts[i] = x[p+0]; rel(this, x[p+0], IRT_GQ, 0);\n"
+	       "\t\td[i] = x[p+1]; rel(this, x[p+1], IRT_GQ, 1);\n"
+	       "\t\te[i] = x[p+2]; rel(this, x[p+2], IRT_GQ, 1);\n"
+	       "\t\th[i] = x[p+3];\n"
+	       "\t}\n"
+	       "\tcumulatives(this, m, s, d, e, h, l, at_most);\n"
+	     );
+    }
+    IntArgs m(ntasks), l(1, limit);
+    IntVarArgs s(ntasks), d(ntasks), e(ntasks), h(ntasks);
+    for (int i = 0; i < ntasks; ++i) {
+      int p = i*4;
+      m[i] = 0;
+      s[i] = x[p+0]; rel(home, x[p+0], IRT_GQ, 0);
+      d[i] = x[p+1]; rel(home, x[p+1], IRT_GQ, 1);
+      e[i] = x[p+2]; rel(home, x[p+2], IRT_GQ, 1);
+      h[i] = x[p+3];
+    }
+    cumulatives(home, m, s, d, e, h, l, at_most);
+  }
+};
+
+namespace {
+  Cumulatives _cumu1t1("Cumulatives::1t1", 1,  true, 1);
+  Cumulatives _cumu1f1("Cumulatives::1f1", 1, false, 1);
+  Cumulatives _cumu1t2("Cumulatives::1t2", 1,  true, 2);
+  Cumulatives _cumu1f2("Cumulatives::1f2", 1, false, 2);
+  Cumulatives _cumu1t3("Cumulatives::1t3", 1,  true, 3);
+  Cumulatives _cumu1f3("Cumulatives::1f3", 1, false, 3);
+  Cumulatives _cumu2t1("Cumulatives::2t1", 2,  true, 1);
+  Cumulatives _cumu2f1("Cumulatives::2f1", 2, false, 1);
+  Cumulatives _cumu2t2("Cumulatives::2t2", 2,  true, 2);
+  Cumulatives _cumu2f2("Cumulatives::2f2", 2, false, 2);
+  Cumulatives _cumu2t3("Cumulatives::2t3", 2,  true, 3);
+  Cumulatives _cumu2f3("Cumulatives::2f3", 2, false, 3);
+  Cumulatives _cumu3t1("Cumulatives::3t1", 3,  true, 1);
+  Cumulatives _cumu3f1("Cumulatives::3f1", 3, false, 1);
+  Cumulatives _cumu3t2("Cumulatives::3t2", 3,  true, 2);
+  Cumulatives _cumu3f2("Cumulatives::3f2", 3, false, 2);
+  Cumulatives _cumu3t3("Cumulatives::3t3", 3,  true, 3);
+  Cumulatives _cumu3f3("Cumulatives::3f3", 3, false, 3);
+  /* These tests take quite some time to run.
+  Cumulatives _cumu4t1("Cumulatives::4t1", 4,  true, 1);
+  Cumulatives _cumu4f1("Cumulatives::4f1", 4, false, 1);
+  Cumulatives _cumu4t2("Cumulatives::4t2", 4,  true, 2);
+  Cumulatives _cumu4f2("Cumulatives::4f2", 4, false, 2);
+  Cumulatives _cumu4t3("Cumulatives::4t3", 4,  true, 3);
+  Cumulatives _cumu4f3("Cumulatives::4f3", 4, false, 3);
+  */
+}
+// STATISTICS: test-int