gecoder-with-gecode 0.7.1 → 0.8.0

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

@@ -1,105 +0,0 @@
-/*
- *  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

@@ -1,283 +0,0 @@
-/*
- *  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

@@ -1,259 +0,0 @@
-/*
- *  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