gecoder-with-gecode 0.7.1

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

@@ -0,0 +1,74 @@
+/*
+ *  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.
+ *
+ */
+
+#ifndef __GECODE_TEST_STRESS_HH__
+#define __GECODE_TEST_STRESS_HH__
+
+#include "gecode/kernel.hh"
+#include "gecode/int.hh"
+#include "test.hh"
+
+using namespace Gecode;
+using namespace Int;
+
+class StressTestSpace : public Space {
+public:
+  IntVarArray x;
+private:
+  const Options opt;
+public:
+  StressTestSpace(int n, IntSet dom, const Options& o);
+  StressTestSpace(bool share, StressTestSpace& s);
+  virtual Space* copy(bool share);
+  bool is_failed(void);
+};
+
+enum CheckResult {
+  CR_OK,
+  CR_FOS,
+  CR_SOF,
+  CR_UNSPEC
+};
+
+class StressTest : public Test {
+protected:
+  IntSetValues param;
+public:
+  StressTest(const char* t, const IntSet& p)
+    : Test("Stress", t), param(p) {}
+  // Check for solution
+  virtual CheckResult check(const StressTestSpace *s) const = 0;
+  // Run test-space
+  virtual StressTestSpace *run(StressTestSpace *s) const;
+  // Create propagators
+  virtual void initialize(Space* home, IntVarArray& x, int param) = 0;
+  virtual int    vars(int param) = 0;
+  virtual IntSet dom(int param)  = 0;
+  // Perform test
+  virtual bool run(const Options& opt);
+};
+
+#endif
+
+// STATISTICS: test-stress
+

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

@@ -0,0 +1,70 @@
+/*
+ *  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"
+
+static int vals[] = {10, 100, 1000};
+static IntSet _p(vals, sizeof(vals)/sizeof(int));
+static int smallvals[] = {10, 100};
+static IntSet _smallp(smallvals, sizeof(smallvals)/sizeof(int));
+
+/*
+ * Stress distinct propagator
+ *
+ * Performs propagation on a pathological example. The example is taken
+ * from: Jean-François Puget, A fast algorithm for the bound consistency
+ * of alldiff constraints, AAAI-98, pages 359-366, July 1998,
+ * Madison, WI, USA.
+ */
+class StressDistinct : public StressTest {
+private:
+  IntConLevel icl;
+public:
+  StressDistinct(const char* t, IntConLevel icl0, IntSet& p)
+    : StressTest(t,p), icl(icl0) {}
+  virtual CheckResult check(const StressTestSpace *s) const {
+    for (int i=0; i<s->x.size(); i++) {
+      if (!s->x[i].assigned()) return CR_UNSPEC;
+      for (int j=i+1; j<s->x.size(); j++){
+	if (s->x[i].val() == s->x[j].val())
+	  return CR_FOS;
+      }
+    }
+    return CR_OK;
+  }
+  virtual void initialize(Space* home, IntVarArray& x, int param) {
+    distinct(home, x, icl);
+    branch(home, x, BVAR_NONE, BVAL_MIN);
+  }
+  virtual int    vars(int param) { return 2*param+1; }
+  virtual IntSet dom(int param)  { return IntSet(-param, param); }
+};
+
+namespace {
+  StressDistinct _dom("Distinct::Dom",ICL_DOM, _smallp);
+  StressDistinct _bnd("Distinct::Bnd",ICL_BND, _p);
+  StressDistinct _val("Distinct::Val",ICL_VAL, _p);
+}
+
+// STATISTICS: test-stress
+

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

@@ -0,0 +1,69 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *     Mikael Lagerkvist, 2005
+ *
+ *  Last modified:
+ *     $Date: 2005-11-10 11:33:57 +0100 (Thu, 10 Nov 2005) $ by $Author: zayenz $
+ *     $Revision: 2534 $
+ *
+ *  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"
+
+static int vals[] = {10, 100, 1000, 10000};
+static IntSet _p(vals, sizeof(vals)/sizeof(int));
+
+/*
+ * Stress the implementation of variable domains
+ *
+ * Chops first a large number of holes into some variable domains
+ * and then shrinks the domain.
+ */
+struct Domain : public StressTest {
+  Domain()
+    : StressTest("Domain", _p) {
+  }
+  virtual CheckResult check(const StressTestSpace *s) const {
+    if (!s) return CR_OK;
+    for (int i = 0; i < s->x.size(); ++i) {
+      if (!s->x[i].assigned()) return CR_SOF;
+    }
+    return CR_UNSPEC;
+  }
+  virtual void initialize(Space* home, IntVarArray& x, int param) {
+    // Cut holes: expand
+    for (int i = 5; i--; ) {
+      for (int j = 0; j <= 5*param; j++)
+	rel(home, x[i], IRT_NQ, 5*j);
+      for (int j = 0; j <= 5*param; j++)
+	rel(home, x[i], IRT_NQ, 5*j+2);
+      for (int j = 0; j <= 5*param; j++)
+	rel(home, x[i], IRT_NQ, 5*j+4);
+    }
+    // Contract
+    for (int j = 0; j <= 5*param/2; j++)
+      for (int i = 5; i--; ) {
+	rel(home, x[i], IRT_GQ, 5*j);
+	rel(home, x[i], IRT_LQ, 5*(j + (5*param/2)));
+      }
+  }
+  virtual int    vars(int param) { return 5; }
+  virtual IntSet dom(int param)  { return IntSet(0, 5*param); }
+};
+
+static Domain _domain;
+
+// STATISTICS: test-stress

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

@@ -0,0 +1,60 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2003
+ *     Mikael Lagerkvist, 2005
+ *
+ *  Last modified:
+ *     $Date: 2006-03-27 16:41:23 +0200 (Mon, 27 Mar 2006) $ by $Author: schulte $
+ *     $Revision: 3114 $
+ *
+ *  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"
+
+static int vals[] = {10, 100, 1000, 1000000, 1 << 24};
+static IntSet _p(vals, sizeof(vals)/sizeof(int));
+static bool gflag = false;
+
+/*
+ * Creates two propagates requiring a huge amount of propagation
+ * steps to detect failure. Stresses how fast a system can control
+ * propagation.
+ */
+struct Exec : public StressTest {
+  bool flag;
+  Exec()
+    : StressTest("Exec", _p), flag(gflag) {
+    gflag = !gflag;
+  }
+  virtual CheckResult check(const StressTestSpace *s) const {
+    return (s==NULL) ? CR_OK : CR_SOF;
+  }
+  virtual void initialize(Space* home, IntVarArray& x, int param) {
+    if (flag) {
+      rel(home, x[0], IRT_LE, x[1]);
+      rel(home, x[1], IRT_LE, x[0]);
+    } else {
+      rel(home, x[1], IRT_LE, x[0]);
+      rel(home, x[0], IRT_LE, x[1]);
+    }
+  }
+  virtual int    vars(int param) { return 2; }
+  virtual IntSet dom(int param)  { return IntSet(0, param); }
+};
+
+static Exec _exec;
+
+// STATISTICS: test-stress
+

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

@@ -0,0 +1,63 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Mikael Lagerkvist <lagerkvis@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *     Mikael Lagerkvist, 2005
+ *
+ *  Last modified:
+ *     $Date: 2005-11-10 11:33:57 +0100 (Thu, 10 Nov 2005) $ by $Author: zayenz $
+ *     $Revision: 2534 $
+ *
+ *  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"
+
+#undef min
+
+static int vals[] = {10, 100, 200};
+static IntSet _p(vals, sizeof(vals)/sizeof(int));
+
+/*
+ * Sorts param numbers using min and ordering-relations.
+ */
+struct MinSort : public StressTest {
+  MinSort()
+    : StressTest("MinSort", _p) {
+  }
+  virtual CheckResult check(const StressTestSpace *s) const {
+    if (!s) return CR_FOS;
+    for (int i = 0; i < s->x.size()-1; ++i) {
+      if (!s->x[i].assigned() || !s->x[i+1].assigned()) return CR_FOS;
+      if (s->x[i].val() < s->x[i+1].val()) return CR_FOS;
+    }
+    return CR_OK;
+  }
+  virtual void initialize(Space* home, IntVarArray& x, int param) {
+    for (int i=1; i<param; i++) {
+      IntVarArgs y(i);
+      for (int j=0; j<i; j++)
+	y[j] = x[j];
+      IntVar m(home,0,2*param);
+      min(home, y, m);
+      rel(home, m, IRT_GR, x[i]);
+    }
+    branch(home, x, BVAR_NONE, BVAL_SPLIT_MAX);
+  }
+  virtual int    vars(int param) { return param; }
+  virtual IntSet dom(int param)  { return IntSet(1, 2*param); }
+};
+
+static MinSort _minsort;
+
+// STATISTICS: test-stress

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

@@ -0,0 +1,112 @@
+/*
+ *  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 "gecode/support/dynamic-array.hh"
+
+static int vals[] = {3, 4, 5, 6, 7, 8};
+static IntSet _p(vals, sizeof(vals)/sizeof(int));
+
+typedef Support::DynamicArray<DFA::Transition> Transitions;
+
+// Create all states for permutation of symbols
+void
+permute(int i_state, int i, int n, int p,
+	Transitions& t, int& n_t, int& n_state) {
+  if (i<n-1) {
+    for (int j=n; j--; )
+      if (!(p & (1 << j))) {
+	t[n_t].i_state = i_state;
+	t[n_t].symbol  = j;
+	t[n_t].o_state = ++n_state;
+	n_t++;
+	permute(n_state,i+1,n,p | (1 << j),
+		t,n_t,n_state);
+      }
+  } else {
+    for (int j=n; j--; )
+      if (!(p & (1 << j))) {
+	t[n_t].i_state = i_state;
+	t[n_t].symbol  = j;
+	t[n_t].o_state = 1;
+	n_t++;
+      }
+  }
+}
+
+// Construct a distinct %DFA
+DFA
+construct(int n) {
+  Transitions t;
+  int n_t     = 0;
+  int n_state = 1;
+  permute(0,0,n,0,t,n_t,n_state);
+  t[n_t].i_state = -1;
+  int f[] = {1,-1};
+  DFA d(0,t,f);
+  return d;
+}
+
+/*
+ * Stress the regular constraint
+ *
+ * Creates a huge DFA specifying that all values are pairwise distinct
+ * and use the DFA for propagation.
+ */
+struct StressRegular : public StressTest {
+  int n;
+  StressRegular()
+    : StressTest("Regular",_p) {}
+  virtual CheckResult check(const StressTestSpace *s) const {
+    for (int i=0; i<s->x.size(); ++i)
+      if (!s->x[i].assigned()) return CR_UNSPEC;
+    for (int o = 0; o <= 3*n; ++o) {
+      for (int i = 0; i < n; ++i) {
+	for (int j = i+1; j < n; ++j) {
+	  if (s->x[o+i].val() == s->x[o+j].val())
+	    return CR_FOS;
+	}
+      }
+    }
+    return CR_OK;
+  }
+  virtual void initialize(Space* home, IntVarArray& x, int param) {
+    n = param;
+    DFA a = construct(param);
+    IntVarArgs y(param);
+    for (int i = 0; i <= 3*param; ++i) {
+      for (int j = param; j--; )
+	y[j] = x[i+j];
+      regular(home, y, a);
+    }
+    for (int j=param; j--; )
+      y[j] = x[j];
+    branch(home, y, BVAR_NONE, BVAL_MED);
+  }
+  virtual int    vars(int param) { return 4*param; }
+  virtual IntSet dom(int param)  { return IntSet(0, param); }
+};
+
+static StressRegular _reg;
+
+// STATISTICS: test-stress