gecoder-with-gecode 0.7.1

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

@@ -0,0 +1,79 @@
+/*
+ *  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"
+
+static IntSet ds_03(0,3);
+static IntSet ds_05(0,5);
+
+class ChannelFull : public IntTest {
+public:
+  ChannelFull(const char* t, IntConLevel icl)
+    : IntTest(t,8,ds_03,false,icl) {}
+  virtual bool solution(const Assignment& x) const {
+    for (int i=0; i<4; i++)
+      if (x[4+x[i]] != i)
+	return false;
+    return true;
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    IntVarArgs xa(4);
+    IntVarArgs ya(4);
+    for (int i=4; i--; ) {
+      xa[i] = x[i];
+      ya[i] = x[4+i];
+    }
+    channel(home, xa, ya, icl);
+  }
+};
+
+ChannelFull _channel_full_dom("Channel::Full::Dom",ICL_DOM);
+ChannelFull _channel_full_val("Channel::Full::Val",ICL_VAL);
+
+class ChannelHalf : public IntTest {
+public:
+  ChannelHalf(const char* t, IntConLevel icl)
+    : IntTest(t,6,ds_05,false,icl) {}
+  virtual bool solution(const Assignment& x) const {
+    for (int i=0; i<6; i++)
+      for (int j=i+1; j<6; j++)
+	if (x[i] == x[j])
+	  return false;
+    return true;
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    IntVarArray y(home,6,dom);
+    for (int i=0; i<6; i++) {
+      for (int j=0; j<6; j++) {
+	BoolVar b(home,0,1);
+	rel(home, x[i], IRT_EQ, j, b);
+	rel(home, y[j], IRT_EQ, i, b);
+      }
+    }
+    channel(home, x, y, icl);
+  }
+};
+
+ChannelHalf _channel_half_dom("Channel::Half::Dom",ICL_DOM);
+ChannelHalf _channel_half_val("Channel::Half::Val",ICL_VAL);
+
+// STATISTICS: test-int
+

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

@@ -0,0 +1,264 @@
+/*
+ *  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);
+
+static inline int
+compare(int x, IntRelType r, int y) {
+  switch (r) {
+  case IRT_EQ: return x == y;
+  case IRT_NQ: return x != y;
+  case IRT_LQ: return x <= y;
+  case IRT_LE: return x < y;
+  case IRT_GR: return x > y;
+  case IRT_GQ: return x >= y;
+  default: ;
+  }
+  return false;
+}
+
+class CountIntInt : public IntTest {
+private:
+  IntRelType irt;
+public:
+  CountIntInt(const char* t, IntRelType irt0)
+    : IntTest(t,4,ds_22), irt(irt0) {}
+  virtual bool solution(const Assignment& x) const {
+    int m = 0;
+    for (int i=0; i<4; i++)
+      if (x[i] == 0)
+	m++;
+    return compare(m,irt,2);
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    count(home, x, 0, irt, 2);
+  }
+};
+
+CountIntInt _ceqii("Count::Eq::IntInt",IRT_EQ);
+CountIntInt _cnqii("Count::Nq::IntInt",IRT_NQ);
+CountIntInt _clqii("Count::Lq::IntInt",IRT_LQ);
+CountIntInt _cleii("Count::Le::IntInt",IRT_LE);
+CountIntInt _cgrii("Count::Gr::IntInt",IRT_GR);
+CountIntInt _cgqii("Count::Gq::IntInt",IRT_GQ);
+
+class CountIntIntDup : public IntTest {
+private:
+  IntRelType irt;
+public:
+  CountIntIntDup(const char* t, IntRelType irt0)
+    : IntTest(t,4,ds_22), irt(irt0) {}
+  virtual bool solution(const Assignment& x) const {
+    int m = 0;
+    for (int i=0; i<4; i++)
+      if (x[i] == 0)
+	m += 2;
+    return compare(m,irt,4);
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    IntVarArgs y(8);
+    for (int i=0; i<4; i++) {
+      y[i]=x[i]; y[4+i]=x[i];
+    }
+    count(home, y, 0, irt, 4);
+  }
+};
+
+CountIntIntDup _ceqiid("Count::Eq::IntInt::Dup",IRT_EQ);
+CountIntIntDup _cnqiid("Count::Nq::IntInt::Dup",IRT_NQ);
+CountIntIntDup _clqiid("Count::Lq::IntInt::Dup",IRT_LQ);
+CountIntIntDup _cleiid("Count::Le::IntInt::Dup",IRT_LE);
+CountIntIntDup _cgriid("Count::Gr::IntInt::Dup",IRT_GR);
+CountIntIntDup _cgqiid("Count::Gq::IntInt::Dup",IRT_GQ);
+
+class CountIntVar : public IntTest {
+private:
+  IntRelType irt;
+public:
+  CountIntVar(const char* t, IntRelType irt0)
+    : IntTest(t,5,ds_22), irt(irt0) {}
+  virtual bool solution(const Assignment& x) const {
+    int m = 0;
+    for (int i=0; i<4; i++)
+      if (x[i] == 0)
+	m++;
+    return compare(m,irt,x[4]);
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    IntVarArgs y(4);
+    for (int i=0; i<4; i++)
+      y[i]=x[i];
+    count(home, y, 0, irt, x[4]);
+  }
+};
+
+CountIntVar _ceqiv("Count::Eq::IntVar",IRT_EQ);
+CountIntVar _cnqiv("Count::Nq::IntVar",IRT_NQ);
+CountIntVar _clqiv("Count::Lq::IntVar",IRT_LQ);
+CountIntVar _cleiv("Count::Le::IntVar",IRT_LE);
+CountIntVar _cgriv("Count::Gr::IntVar",IRT_GR);
+CountIntVar _cgqiv("Count::Gq::IntVar",IRT_GQ);
+
+
+class CountIntVarShared : public IntTest {
+private:
+  IntRelType irt;
+public:
+  CountIntVarShared(const char* t, IntRelType irt0)
+    : IntTest(t,4,ds_22), irt(irt0) {}
+  virtual bool solution(const Assignment& x) const {
+    int m = 0;
+    for (int i=0; i<4; i++)
+      if (x[i] == 0)
+	m++;
+    return compare(m,irt,x[2]);
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    if(irt == IRT_LQ)
+      Log::log("count(home, x, 0)<=x[2]","\tcount(home, x, 0, IRT_LQ, x[2]);");
+    else if(irt == IRT_GQ)
+      Log::log("count(home, x, 0)>=x[2]","\tcount(home, x, 0, IRT_GQ, x[2]);");
+    count(home, x, 0, irt, x[2]);
+  }
+};
+
+CountIntVarShared _ceqivs("Count::Eq::IntVarShared",IRT_EQ);
+CountIntVarShared _cnqivs("Count::Nq::IntVarShared",IRT_NQ);
+CountIntVarShared _clqivs("Count::Lq::IntVarShared",IRT_LQ);
+CountIntVarShared _cleivs("Count::Le::IntVarShared",IRT_LE);
+CountIntVarShared _cgrivs("Count::Gr::IntVarShared",IRT_GR);
+CountIntVarShared _cgqivs("Count::Gq::IntVarShared",IRT_GQ);
+
+class CountVarVar : public IntTest {
+private:
+  IntRelType irt;
+public:
+  CountVarVar(const char* t, IntRelType irt0)
+    : IntTest(t,5,ds_22), irt(irt0) {}
+  virtual bool solution(const Assignment& x) const {
+    int m = 0;
+    for (int i=0; i<3; i++)
+      if (x[i] == x[3])
+	m++;
+    return compare(m,irt,x[4]);
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    IntVarArgs y(3);
+    for (int i=0; i<3; i++)
+      y[i]=x[i];
+    count(home, y, x[3], irt, x[4]);
+  }
+};
+
+CountVarVar _ceqvv("Count::Eq::VarVar",IRT_EQ);
+CountVarVar _cnqvv("Count::Nq::VarVar",IRT_NQ);
+CountVarVar _clqvv("Count::Lq::VarVar",IRT_LQ);
+CountVarVar _clevv("Count::Le::VarVar",IRT_LE);
+CountVarVar _cgrvv("Count::Gr::VarVar",IRT_GR);
+CountVarVar _cgqvv("Count::Gq::VarVar",IRT_GQ);
+
+class CountVarVarSharedA : public IntTest {
+private:
+  IntRelType irt;
+public:
+  CountVarVarSharedA(const char* t, IntRelType irt0)
+    : IntTest(t,5,ds_22), irt(irt0) {}
+  virtual bool solution(const Assignment& x) const {
+    int m = 0;
+    for (int i=0; i<4; i++)
+      if (x[i] == x[1])
+	m++;
+    return compare(m,irt,x[4]);
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    IntVarArgs y(4);
+    for (int i=0; i<4; i++)
+      y[i]=x[i];
+    count(home, y, x[1], irt, x[4]);
+  }
+};
+
+CountVarVarSharedA _ceqvvsa("Count::Eq::VarVarShared::A",IRT_EQ);
+CountVarVarSharedA _cnqvvsa("Count::Nq::VarVarShared::A",IRT_NQ);
+CountVarVarSharedA _clqvvsa("Count::Lq::VarVarShared::A",IRT_LQ);
+CountVarVarSharedA _clevvsa("Count::Le::VarVarShared::A",IRT_LE);
+CountVarVarSharedA _cgrvvsa("Count::Gr::VarVarShared::A",IRT_GR);
+CountVarVarSharedA _cgqvvsa("Count::Gq::VarVarShared::A",IRT_GQ);
+
+class CountVarVarSharedB : public IntTest {
+private:
+  IntRelType irt;
+public:
+  CountVarVarSharedB(const char* t, IntRelType irt0)
+    : IntTest(t,5,ds_22), irt(irt0) {}
+  virtual bool solution(const Assignment& x) const {
+    int m = 0;
+    for (int i=0; i<4; i++)
+      if (x[i] == x[4])
+	m++;
+    return compare(m,irt,x[3]);
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    IntVarArgs y(4);
+    for (int i=0; i<4; i++)
+      y[i]=x[i];
+    count(home, y, x[4], irt, x[3]);
+  }
+};
+
+CountVarVarSharedB _ceqvvsb("Count::Eq::VarVarShared::B",IRT_EQ);
+CountVarVarSharedB _cnqvvsb("Count::Nq::VarVarShared::B",IRT_NQ);
+CountVarVarSharedB _clqvvsb("Count::Lq::VarVarShared::B",IRT_LQ);
+CountVarVarSharedB _clevvsb("Count::Le::VarVarShared::B",IRT_LE);
+CountVarVarSharedB _cgrvvsb("Count::Gr::VarVarShared::B",IRT_GR);
+CountVarVarSharedB _cgqvvsb("Count::Gq::VarVarShared::B",IRT_GQ);
+
+class CountVarVarSharedC : public IntTest {
+private:
+  IntRelType irt;
+public:
+  CountVarVarSharedC(const char* t, IntRelType irt0)
+    : IntTest(t,4,ds_22), irt(irt0) {}
+  virtual bool solution(const Assignment& x) const {
+    int m = 0;
+    for (int i=0; i<4; i++)
+      if (x[i] == x[1])
+	m++;
+    return compare(m,irt,x[3]);
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    count(home, x, x[1], irt, x[3]);
+  }
+};
+
+CountVarVarSharedC _ceqvvsc("Count::Eq::VarVarShared::C",IRT_EQ);
+CountVarVarSharedC _cnqvvsc("Count::Nq::VarVarShared::C",IRT_NQ);
+CountVarVarSharedC _clqvvsc("Count::Lq::VarVarShared::C",IRT_LQ);
+CountVarVarSharedC _clevvsc("Count::Le::VarVarShared::C",IRT_LE);
+CountVarVarSharedC _cgrvvsc("Count::Gr::VarVarShared::C",IRT_GR);
+CountVarVarSharedC _cgqvvsc("Count::Gq::VarVarShared::C",IRT_GQ);
+
+
+// STATISTICS: test-int
+

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

@@ -0,0 +1,121 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2005
+ *     Mikael Lagerkvist, 2006
+ *
+ *  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"
+
+namespace {
+  IntSet ds_dense(-2,2);
+  const int v_sparse[5] = {-100,-10,0,10,100};
+  IntSet ds_sparse(v_sparse,5);
+  IntSet ds_rn(-500,500);
+  IntSet ds_rnsmall(-50,50);
+}
+
+class Distinct : public IntTest {
+public:
+  Distinct(const char* t, const IntSet& ds, IntConLevel icl)
+    : IntTest(t,4,ds,false,icl) {}
+  virtual bool solution(const Assignment& x) const {
+    for (int i=0; i<4; i++)
+      for (int j=i+1; j<4; j++)
+	if (x[i]==x[j])
+	  return false;
+    return true;
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    distinct(home, x, icl);
+  }
+};
+
+namespace {
+  Distinct _dist_dom_d("Distinct::Dom::Dense",ds_dense,ICL_DOM);
+  Distinct _dist_bnd_d("Distinct::Bnd::Dense",ds_dense,ICL_BND);
+  Distinct _dist_val_d("Distinct::Val::Dense",ds_dense,ICL_VAL);
+  Distinct _dist_dom_s("Distinct::Dom::Sparse",ds_sparse,ICL_DOM);
+  Distinct _dist_bnd_s("Distinct::Bnd::Sparse",ds_sparse,ICL_BND);
+  Distinct _dist_val_s("Distinct::Val::Sparse",ds_sparse,ICL_VAL);
+}
+
+class DistinctRandom : public IntTest {
+private:
+  IntConLevel icl;
+  int size;
+  IntSet ds;
+protected:
+  virtual Assignment* make_assignment() {
+    return new RandomAssignment(size, ds, 100);
+  }
+  virtual bool do_search_test() { return false; }
+public:
+  DistinctRandom(const char* t, int size0, const IntSet& ds0, IntConLevel icl0)
+    : IntTest(t,size0,ds0,false),
+      icl(icl0), size(size0), ds(ds0) {}
+  virtual bool solution(const Assignment& x) const {
+    for (int i=0; i<x.size(); i++)
+      for (int j=i+1; j<x.size(); j++)
+	if (x[i]==x[j])
+	  return false;
+    return true;
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    distinct(home, x, icl);
+  }
+};
+
+namespace {
+  DistinctRandom _domr("Distinct::Dom::Random", 20, ds_rnsmall, ICL_DOM);
+  DistinctRandom _bndr("Distinct::Bnd::Random", 50, ds_rn, ICL_BND);
+  DistinctRandom _valr("Distinct::Val::Random", 50, ds_rn, ICL_VAL);
+}
+
+class DistinctOffset : public IntTest {
+public:
+  DistinctOffset(const char* t, const IntSet& ds, IntConLevel icl)
+    : IntTest(t,4,ds,false,icl) {}
+  virtual bool solution(const Assignment& x) const {
+    for (int i=0; i<4; i++)
+      for (int j=i+1; j<4; j++)
+	if (x[i]+i==x[j]+j)
+	  return false;
+    return true;
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    IntArgs c(4);
+    for (int i=0; i<4; i++)
+      c[i]=i;
+    distinct(home, c, x, icl);
+  }
+};
+
+namespace {
+  DistinctOffset _disto_dom_d("Distinct::Dom::Offset::Dense",ds_dense,ICL_DOM);
+  DistinctOffset _disto_bnd_d("Distinct::Bnd::Offset::Dense",ds_dense,ICL_BND);
+  DistinctOffset _disto_val_d("Distinct::Val::Offset::Dense",ds_dense,ICL_VAL);
+  DistinctOffset _disto_dom_s("Distinct::Dom::Offset::Sparse",ds_sparse,ICL_DOM);
+  DistinctOffset _disto_bnd_s("Distinct::Bnd::Offset::Sparse",ds_sparse,ICL_BND);
+  DistinctOffset _disto_val_s("Distinct::Val::Offset::Sparse",ds_sparse,ICL_VAL);
+}
+
+
+// STATISTICS: test-int
+