gecoder-with-gecode 0.7.1

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

@@ -0,0 +1,198 @@
+/*
+ *  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(-3,3);
+
+class RelBinNEq : public SetTest {
+public:
+  RelBinNEq(const char* t)
+    : SetTest(t,2,ds_33,true) {}
+  virtual bool solution(const SetAssignment& x) const {
+    CountableSetRanges xr0(x.lub, x[0]);
+    CountableSetRanges xr1(x.lub, x[1]);
+    return !Iter::Ranges::equal(xr0, xr1);
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+    Gecode::rel(home, x[0], SRT_NQ, x[1]);
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&, BoolVar b) {
+    Gecode::rel(home, x[0], SRT_NQ, x[1], b);
+  }
+};
+RelBinNEq _relneq("Rel::BinNEq");
+
+class RelBinNEqS : public SetTest {
+public:
+  RelBinNEqS(const char* t)
+    : SetTest(t,1,ds_33,true) {}
+  virtual bool solution(const SetAssignment& x) const {
+    return false;
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+    Gecode::rel(home, x[0], SRT_NQ, x[0]);
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&, BoolVar b) {
+    Gecode::rel(home, x[0], SRT_NQ, x[0], b);
+  }
+};
+RelBinNEqS _relneqs("Rel::Sharing::BinNEqS");
+
+class RelBinEq : public SetTest {
+public:
+  RelBinEq(const char* t)
+    : SetTest(t,2,ds_33,true) {}
+  virtual bool solution(const SetAssignment& x) const {
+    CountableSetRanges xr0(x.lub, x[0]);
+    CountableSetRanges xr1(x.lub, x[1]);
+    return Iter::Ranges::equal(xr0, xr1);
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+    Gecode::rel(home, x[0], SRT_EQ, x[1]);
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&, BoolVar b) {
+    Gecode::rel(home, x[0], SRT_EQ, x[1], b);
+  }
+};
+RelBinEq _releq("Rel::BinEq");
+
+class RelBinEqS : public SetTest {
+public:
+  RelBinEqS(const char* t)
+    : SetTest(t,1,ds_33,true) {}
+  virtual bool solution(const SetAssignment& x) const {
+    return true;
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+    Gecode::rel(home, x[0], SRT_EQ, x[0]);
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&, BoolVar b) {
+    Gecode::rel(home, x[0], SRT_EQ, x[0], b);
+  }
+};
+RelBinEqS _releqs("Rel::Sharing::BinEqS");
+
+class RelBinSub : public SetTest {
+public:
+  RelBinSub(const char* t)
+    : SetTest(t,2,ds_33,true) {}
+  virtual bool solution(const SetAssignment& x) const {
+    CountableSetRanges xr0(x.lub, x[0]);
+    CountableSetRanges xr1(x.lub, x[1]);
+    return Iter::Ranges::subset(xr0, xr1);
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+    Gecode::rel(home, x[0], SRT_SUB, x[1]);
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&, BoolVar b) {
+    Gecode::rel(home, x[0], SRT_SUB, x[1], b);
+  }
+};
+RelBinSub _relsub("Rel::BinSub");
+
+class RelBinSubS : public SetTest {
+public:
+  RelBinSubS(const char* t)
+    : SetTest(t,1,ds_33,true) {}
+  virtual bool solution(const SetAssignment& x) const {
+    return true;
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+    Gecode::rel(home, x[0], SRT_SUB, x[0]);
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&, BoolVar b) {
+    Gecode::rel(home, x[0], SRT_SUB, x[0], b);
+  }
+};
+RelBinSubS _relsubs("Rel::Sharing::BinSubS");
+
+class RelBinDisj : public SetTest {
+public:
+  RelBinDisj(const char* t)
+    : SetTest(t,2,ds_33,true) {}
+  virtual bool solution(const SetAssignment& x) const {
+    CountableSetRanges xr0(x.lub, x[0]);
+    CountableSetRanges xr1(x.lub, x[1]);
+    return Iter::Ranges::disjoint(xr0, xr1);
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+    Gecode::rel(home, x[0], SRT_DISJ, x[1]);
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&, BoolVar b) {
+    Gecode::rel(home, x[0], SRT_DISJ, x[1], b);
+  }
+};
+RelBinDisj _reldisj("Rel::BinDisj");
+
+class RelBinDisjS : public SetTest {
+public:
+  RelBinDisjS(const char* t)
+    : SetTest(t,1,ds_33,true) {}
+  virtual bool solution(const SetAssignment& x) const {
+    CountableSetRanges xr0(x.lub, x[0]);
+    return !xr0();
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+    Gecode::rel(home, x[0], SRT_DISJ, x[0]);
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&, BoolVar b) {
+    Gecode::rel(home, x[0], SRT_DISJ, x[0], b);
+  }
+};
+RelBinDisjS _reldisjs("Rel::Sharing::BinDisjS");
+
+class RelBinCompl : public SetTest {
+public:
+  RelBinCompl(const char* t)
+    : SetTest(t,2,ds_33,true) {}
+  virtual bool solution(const SetAssignment& x) const {
+    CountableSetRanges xr0(x.lub, x[0]);
+    CountableSetRanges xr1(x.lub, x[1]);
+    Set::RangesCompl<CountableSetRanges> xr1c(xr1);
+    return Iter::Ranges::equal(xr0, xr1c);
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+    Gecode::rel(home, x[0], SRT_CMPL, x[1]);
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&, BoolVar b) {
+    Gecode::rel(home, x[0], SRT_CMPL, x[1], b);
+  }
+};
+RelBinCompl _relcompl("Rel::BinCompl");
+
+class RelBinComplS : public SetTest {
+public:
+  RelBinComplS(const char* t)
+    : SetTest(t,1,ds_33,true) {}
+  virtual bool solution(const SetAssignment& x) const {
+    return false;
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+    Gecode::rel(home, x[0], SRT_CMPL, x[0]);
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&, BoolVar b) {
+    Gecode::rel(home, x[0], SRT_CMPL, x[0], b);
+  }
+};
+RelBinComplS _relcompls("Rel::Sharing::BinComplS");
+
+// STATISTICS: test-set

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

@@ -0,0 +1,108 @@
+/*
+ *  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_012(-1,2);
+
+class SelectUnion : public SetTest {
+public:
+  SelectUnion(const char* t)
+    : SetTest(t,5,ds_012,false) {}
+  virtual bool solution(const SetAssignment& x) const {
+    int selected = 0;
+    for (CountableSetValues sel2(x.lub, x[3]); sel2(); ++sel2, selected++);
+    CountableSetValues x4v(x.lub, x[4]);
+    if (selected==0)
+      return !x4v();
+    GECODE_AUTOARRAY(CountableSetRanges, sel, selected);
+    CountableSetValues selector(x.lub, x[3]);
+    for (int i=selected; i--;++selector) {
+      if (selector.val()>=3 || selector.val()<0)
+	return false;
+      sel[i].init(x.lub, x[selector.val()]);
+    }
+    Iter::Ranges::NaryUnion<CountableSetRanges> u(sel, selected);
+
+    CountableSetRanges z(x.lub, x[4]);
+    return Iter::Ranges::equal(u, z);
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+    SetVarArgs xs(x.size()-2);
+    for (int i=x.size()-2; i--;)
+      xs[i]=x[i];
+    Gecode::selectUnion(home, xs, x[x.size()-2], x[x.size()-1]);
+  }
+};
+SelectUnion _selectunion("Select::Union");
+
+class SelectInter : public SetTest {
+public:
+  SelectInter(const char* t)
+    : SetTest(t,5,ds_012,false) {}
+  virtual bool solution(const SetAssignment& x) const {
+    int selected = 0;
+    for (CountableSetValues sel2(x.lub, x[3]); sel2(); ++sel2, selected++);
+    CountableSetRanges x4r(x.lub, x[4]);
+    if (selected==0)
+      return Iter::Ranges::size(x4r)==Limits::Set::card_max;
+    GECODE_AUTOARRAY(CountableSetRanges, sel, selected);
+    CountableSetValues selector(x.lub, x[3]);
+    for (int i=selected; i--;++selector) {
+      if (selector.val()>=3 || selector.val()<0)
+	return false;
+      sel[i].init(x.lub, x[selector.val()]);
+    }
+    Iter::Ranges::NaryInter<CountableSetRanges> u(sel, selected);
+
+    CountableSetRanges z(x.lub, x[4]);
+    return Iter::Ranges::equal(u, z);
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+    SetVarArgs xs(x.size()-2);
+    for (int i=x.size()-2; i--;)
+      xs[i]=x[i];
+    Gecode::selectInter(home, xs, x[x.size()-2], x[x.size()-1]);
+  }
+};
+SelectInter _selectinter("Select::Inter");
+
+class SelectSet : public SetTest {
+public:
+  SelectSet(const char* t)
+    : SetTest(t,4,ds_012,false,true) {}
+  virtual bool solution(const SetAssignment& x) const {
+    if (x.intval() < 0 || x.intval() > 2)
+      return false;
+    CountableSetRanges z(x.lub, x[3]);
+    CountableSetRanges y(x.lub, x[x.intval()]);
+    return Iter::Ranges::equal(y, z);
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray& y) {
+    SetVarArgs xs(x.size()-1);
+    for (int i=x.size()-1; i--;)
+      xs[i]=x[i];
+    Gecode::selectSet(home, xs, y[0], x[x.size()-1]);
+  }
+};
+SelectSet _selectset("Select::Set");
+
+// STATISTICS: test-set

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

@@ -0,0 +1,83 @@
+/*
+ *  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(-1,2);
+
+class Sequence : public SetTest {
+public:
+  Sequence(const char* t)
+    : SetTest(t,4,ds_33,false) {}
+  virtual bool solution(const SetAssignment& x) const {
+    int max = Limits::Set::int_min - 1;
+    for (int i=0; i<4; i++) {
+      CountableSetRanges xir(x.lub, x[i]);
+      IntSet xi(xir);
+      if (xi.size() > 0) {
+	int oldMax = max;
+	max = xi.max();
+	if (xi.min() <= oldMax)
+	  return false;
+      }
+    }
+    return true;
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+    Gecode::sequence(home, x);
+  }
+};
+Sequence _sequence("Sequence::Sequence");
+
+class SeqU : public SetTest {
+public:
+  SeqU(const char* t)
+    : SetTest(t,4,ds_33,false) {}
+  virtual bool solution(const SetAssignment& x) const {
+    int max = Limits::Set::int_min - 1;
+    for (int i=0; i<3; i++) {
+      CountableSetRanges xir(x.lub, x[i]);
+      IntSet xi(xir);
+      if (xi.size() > 0) {
+	int oldMax = max;
+	max = xi.max();
+	if (xi.min() <= oldMax)
+	  return false;
+      }
+    }
+    GECODE_AUTOARRAY(CountableSetRanges, isrs, 3);
+    isrs[0].init(x.lub, x[0]);
+    isrs[1].init(x.lub, x[1]);
+    isrs[2].init(x.lub, x[2]);
+    Iter::Ranges::NaryUnion<CountableSetRanges> u(isrs, 3);
+    CountableSetRanges x3r(x.lub, x[3]);
+    return Iter::Ranges::equal(u, x3r);
+  }
+  virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+    SetVarArgs xs(x.size()-1);
+    for (int i=x.size()-1; i--;)
+      xs[i]=x[i];
+    Gecode::sequentialUnion(home, xs, x[x.size()-1]);
+  }
+};
+SeqU _sequ("Sequence::SeqU");
+
+// STATISTICS: test-set

data/ext/gecode-1.3.1/test/stress.cc

@@ -0,0 +1,93 @@
+/*
+ *  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/stress.hh"
+#include "test/int.hh"
+#include "test/log.hh"
+
+#include "gecode/search.hh"
+
+StressTestSpace::StressTestSpace(int n, IntSet dom, const Options& o)
+  : x(this, n, dom), opt(o) {
+  Log::initial(x, "x");
+}
+StressTestSpace::StressTestSpace(bool share, StressTestSpace& s)
+  : Space(share,s), opt(s.opt) {
+  x.update(this, share, s.x);
+}
+Space* StressTestSpace::copy(bool share) {
+  return new StressTestSpace(share,*this);
+}
+bool StressTestSpace::is_failed(void) {
+  Log::fixpoint();
+  return status() == SS_FAILED;
+}
+
+StressTestSpace *
+StressTest::run(StressTestSpace *s) const {
+  return dfs(s);
+}
+
+#define REPORT(M) \
+problem = (M);    \
+delete e;         \
+goto failed;
+
+bool
+StressTest::run(const Options& opt) {
+  const char* problem = "NONE";
+  while (param()) {
+    Log::reset();
+    int p = param.val();
+    StressTestSpace *s = new StressTestSpace(vars(p),dom(p),opt);
+    initialize(s,s->x,p);
+    StressTestSpace *e = run(s);
+    delete s;
+    switch (check(e)) {
+    case CR_OK:
+      break;
+    case CR_FOS:
+      REPORT("Failed on solution");
+      break;
+    case CR_SOF:
+      REPORT("Solved on failure");
+      break;
+    case CR_UNSPEC:
+      REPORT("Unspecified error");
+      break;
+    }
+    delete e;
+    ++param;
+  }
+  return true;
+ failed:
+  std::cout << "FAILURE" << std::endl
+	    << "\t" << "Problem:    " << problem << std::endl
+	    << "\t" << "Parameter: " << param.val() << std::endl;
+  return false;
+}
+
+#undef CHECK
+
+// STATISTICS: test-stress
+