gecoder-with-gecode 0.7.1

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

@@ -0,0 +1,249 @@
+/*
+ *  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"
+#include "test/log.hh"
+
+namespace TestsForSetsAndInts {
+
+  static const int d1r[4][2] = {
+    {-4,-3},{-1,-1},{1,1},{3,5}
+  };
+  static IntSet d1(d1r,4);
+
+  static IntSet d2(-1,3);
+  static IntSet d3(0,3);
+
+  static IntSet ds_33(-3,3);
+
+  class Card : public SetTest {
+  public:
+    Card(const char* t)
+      : SetTest(t,1,ds_33,false,1) {}
+    virtual bool solution(const SetAssignment& x) const {
+      unsigned int s = 0;
+      for (CountableSetRanges xr(x.lub, x[0]);xr();++xr) s+= xr.width();
+      if (x.intval() < 0)
+	return false;
+      return s==(unsigned int)x.intval();
+    }
+    virtual void post(Space* home, SetVarArray& x, IntVarArray& y) {
+      Gecode::cardinality(home, x[0], y[0]);
+    }
+  };
+  Card _card("Int::Card");
+
+  class Min : public SetTest {
+  public:
+    Min(const char* t)
+      : SetTest(t,1,ds_33,false,1) {}
+    virtual bool solution(const SetAssignment& x) const {
+      CountableSetRanges xr0(x.lub, x[0]);
+      return xr0() && xr0.min()==x.intval();
+    }
+    virtual void post(Space* home, SetVarArray& x, IntVarArray& y) {
+      Gecode::min(home, x[0], y[0]);
+    }
+  };
+  Min _min("Int::Min");
+
+  class Max : public SetTest {
+  public:
+    Max(const char* t)
+      : SetTest(t,1,ds_33,false,1) {}
+    virtual bool solution(const SetAssignment& x) const {
+      CountableSetRanges xr0(x.lub, x[0]);
+      IntSet x0(xr0);
+      return x0.size() > 0 && x0.max()==x.intval();
+    }
+    virtual void post(Space* home, SetVarArray& x, IntVarArray& y) {
+      Gecode::max(home, x[0], y[0]);
+    }
+  };
+  Max _max("Int::Max");
+
+  class Elem : public SetTest {
+  public:
+    Elem(const char* t)
+      : SetTest(t,1,ds_33,true,1) {}
+    virtual bool solution(const SetAssignment& x) const {
+      for(CountableSetValues xr(x.lub, x[0]);xr();++xr)
+	if (xr.val()==x.intval())
+	  return true;
+      return false;
+    }
+    virtual void post(Space* home, SetVarArray& x, IntVarArray& y) {
+      Gecode::rel(home, x[0], SRT_SUP, y[0]);
+    }
+    virtual void post(Space* home, SetVarArray& x, IntVarArray& y, BoolVar b) {
+      Gecode::rel(home, x[0], SRT_SUP, y[0], b);
+    }
+  };
+  Elem _elem("Int::Elem");
+
+  class NoElem : public SetTest {
+  public:
+    NoElem(const char* t)
+      : SetTest(t,1,ds_33,true,1) {}
+    virtual bool solution(const SetAssignment& x) const {
+      for(CountableSetValues xr(x.lub, x[0]);xr();++xr)
+	if (xr.val()==x.intval())
+	  return false;
+      return true;
+    }
+    virtual void post(Space* home, SetVarArray& x, IntVarArray& y) {
+      Gecode::rel(home, x[0], SRT_DISJ, y[0]);
+    }
+    virtual void post(Space* home, SetVarArray& x, IntVarArray& y, BoolVar b) {
+      Gecode::rel(home, x[0], SRT_DISJ, y[0], b);
+    }
+  };
+  NoElem _noelem("Int::NoElem");
+
+  class The : public SetTest {
+  public:
+    The(const char* t)
+      : SetTest(t,1,ds_33,true,1) {}
+    virtual bool solution(const SetAssignment& x) const {
+      CountableSetRanges xr0(x.lub, x[0]);
+      IntSet x0(xr0);
+      return x0.size()==1 && x0.min()==x0.max() &&
+	x0.max()==x.intval();
+    }
+    virtual void post(Space* home, SetVarArray& x, IntVarArray& y) {
+      Gecode::rel(home, x[0], SRT_EQ, y[0]);
+    }
+    virtual void post(Space* home, SetVarArray& x, IntVarArray& y, BoolVar b) {
+      Gecode::rel(home, x[0], SRT_EQ, y[0], b);
+    }
+  };
+  The _the("Int::The");
+
+  template <class I>
+  int weightI(const IntArgs& elements,
+	      const IntArgs& weights,
+	      I& iter) {
+    int sum = 0;
+    int i = 0;
+    for (Iter::Ranges::ToValues<I> v(iter); v(); ++v) {
+      // Skip all elements below the current
+      while (elements[i]<v.val()) i++;
+      assert(elements[i] == v.val());
+      sum += weights[i];
+    }
+    return sum;
+  }
+
+  class Weights : public SetTest {
+  public:
+    IntArgs elements;
+    IntArgs weights;
+
+    Weights(const char* t)
+      : SetTest(t,1,ds_33,false,1),
+	elements(7), weights(7) {
+      for (int i=-3; i<=3; i++)
+	elements[i+3] = i;
+      for (int i=0; i<7; i++)
+	weights[i] = 1;
+      weights[1] = -2;
+      weights[5] = 6;
+    }
+    virtual bool solution(const SetAssignment& x) const {
+      CountableSetRanges x0(x.lub, x[0]);
+      return x.intval()==weightI(elements,weights,x0);
+    }
+    virtual void post(Space* home, SetVarArray& x, IntVarArray& y) {
+      Gecode::weights(home, elements, weights, x[0], y[0]);
+    }
+  };
+  Weights _weights("Int::Weights");
+
+  class Match : public SetTest {
+  public:
+    Match(const char* t)
+      : SetTest(t,1,ds_33,false,3) {}
+    virtual bool solution(const SetAssignment& x) const {
+      if (x.ints()[0]>=x.ints()[1] ||
+	  x.ints()[1]>=x.ints()[2])
+	return false;
+      CountableSetValues xr(x.lub, x[0]);
+      if (!xr())
+	return false;
+      if (xr.val() != x.ints()[0])
+	return false;
+      ++xr;
+      if (!xr())
+	return false;
+      if (xr.val() != x.ints()[1])
+	return false;
+      ++xr;
+      if (!xr())
+	return false;
+      if (xr.val() != x.ints()[2])
+	return false;
+      ++xr;
+      if (xr())
+	return false;
+      return true;
+    }
+    virtual void post(Space* home, SetVarArray& x, IntVarArray& y) {
+      Gecode::match(home, x[0], y);
+    }
+  };
+  Match _match("Int::Match");
+
+  class Channel : public SetTest {
+  private:
+    int ssize, isize;
+  public:
+    Channel(const char* t, const IntSet& d, int _ssize, int _isize)
+      : SetTest(t,_ssize,d,false,_isize), ssize(_ssize), isize(_isize) {}
+    virtual bool solution(const SetAssignment& x) const {
+      for (int i=0; i<isize; i++) {
+	if (x.ints()[i] < 0 || x.ints()[i] >= ssize)
+	  return false;
+	Iter::Ranges::Singleton single(i,i);
+	CountableSetRanges csr(x.lub, x[x.ints()[i]]);
+	if (!Iter::Ranges::subset(single, csr))
+	  return false;
+      }
+      for (int i=0; i<ssize; i++) {
+	int size = 0;
+	for (CountableSetValues csv(x.lub, x[i]); csv(); ++csv) {
+	  if (csv.val() < 0 || csv.val() >= isize) return false;
+	  if (x.ints()[csv.val()] != i) return false;
+	  size++;
+	}
+      }
+      return true;
+    }
+    virtual void post(Space* home, SetVarArray& x, IntVarArray& y) {
+      Gecode::channel(home, y, x);
+    }
+  };
+
+  Channel _channel1("Int::Channel::1", d2, 2, 3);
+  Channel _channel2("Int::Channel::2", d3, 3, 3);
+
+}
+
+// STATISTICS: test-set

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

@@ -0,0 +1,333 @@
+/*
+ *  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"
+#include "gecode/set/projectors.hh"
+#include "gecode/minimodel.hh"
+
+static IntSet ds_22(-2,2);
+static IntSet ds_33(-3,3);
+
+namespace Projection {
+
+  class RelBinNEq : public SetTest {
+  public:
+    RelBinNEq(const char* t)
+      : SetTest(t,2,ds_33) {}
+    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::Projector p(0, Gecode::SetExpr(1), Gecode::SetExpr(1));
+      Gecode::Projector q(1, Gecode::SetExpr(0), Gecode::SetExpr(0));
+      Gecode::ProjectorSet ps;
+      ps.add(p); ps.add(q);
+      Gecode::projector(home, x[0], x[1], ps, true);
+    }
+  };
+  RelBinNEq _relneq("Proj::Rel::BinNEq");
+
+  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::SetExpr xe(0);
+      Gecode::SetExpr ye(1);
+      Gecode::Projector p(0, ye, ye);
+      Gecode::Projector q(1, xe, xe);
+      Gecode::ProjectorSet ps;
+      ps.add(p);
+      ps.add(q);
+      Gecode::projector(home, x[0], x[1], ps);
+    }
+    virtual void post(Space* home, SetVarArray& x, IntVarArray&, BoolVar b) {
+      Gecode::Projector p(0, Gecode::SetExpr(1), Gecode::SetExpr(1));
+      Gecode::Projector q(1, Gecode::SetExpr(0), Gecode::SetExpr(0));
+      Gecode::ProjectorSet ps;
+      ps.add(p); ps.add(q);
+      Gecode::projector(home, x[0], x[1], b, ps);
+    }
+  };
+  RelBinEq _releq("Proj::Rel::BinEq");
+
+  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::Projector p(0, Gecode::SetExpr(), Gecode::SetExpr(1));
+      Gecode::Projector q(1, Gecode::SetExpr(0), -Gecode::SetExpr());
+      Gecode::ProjectorSet ps;
+      ps.add(p); ps.add(q);
+      Gecode::projector(home, x[0], x[1], ps);
+    }
+    virtual void post(Space* home, SetVarArray& x, IntVarArray&, BoolVar b) {
+      Gecode::Projector p(0, Gecode::SetExpr(), Gecode::SetExpr(1));
+      Gecode::Projector q(1, Gecode::SetExpr(0), -Gecode::SetExpr());
+      Gecode::ProjectorSet ps;
+      ps.add(p); ps.add(q);
+      Gecode::projector(home, x[0], x[1], b, ps);
+    }
+  };
+  RelBinSub _relsub("Proj::Rel::BinSub");
+
+  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::Projector p(0, Gecode::SetExpr(), -Gecode::SetExpr(1));
+      Gecode::Projector q(1, Gecode::SetExpr(), -Gecode::SetExpr(0));
+      Gecode::ProjectorSet ps;
+      ps.add(p); ps.add(q);
+      Gecode::projector(home, x[0], x[1], ps);
+    }
+    virtual void post(Space* home, SetVarArray& x, IntVarArray&, BoolVar b) {
+      Gecode::Projector p(0, Gecode::SetExpr(), -Gecode::SetExpr(1));
+      Gecode::Projector q(1, Gecode::SetExpr(), -Gecode::SetExpr(0));
+      Gecode::ProjectorSet ps;
+      ps.add(p); ps.add(q);
+      Gecode::projector(home, x[0], x[1], b, ps);
+    }
+  };
+  RelBinDisj _reldisj("Proj::Rel::BinDisj");
+
+  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::Projector p(0, -Gecode::SetExpr(1), -Gecode::SetExpr(1));
+      Gecode::Projector q(1, -Gecode::SetExpr(0), -Gecode::SetExpr(0));
+      Gecode::ProjectorSet ps;
+      ps.add(p); ps.add(q);
+      Gecode::projector(home, x[0], x[1], ps);
+    }
+    virtual void post(Space* home, SetVarArray& x, IntVarArray&, BoolVar b) {
+      Gecode::Projector p(0, -Gecode::SetExpr(1), -Gecode::SetExpr(1));
+      Gecode::Projector q(1, -Gecode::SetExpr(0), -Gecode::SetExpr(0));
+      Gecode::ProjectorSet ps;
+      ps.add(p); ps.add(q);
+      Gecode::projector(home, x[0], x[1], b, ps);
+    }
+  };
+  RelBinCompl _relcompl("Proj::Rel::BinCompl");
+
+  class RelUnionEq : public SetTest {
+  public:
+    RelUnionEq(const char* t)
+      : SetTest(t,3,ds_22,true) {}
+    virtual bool solution(const SetAssignment& x) const {
+      CountableSetRanges xr0(x.lub, x[0]);
+      CountableSetRanges xr1(x.lub, x[1]);
+      CountableSetRanges xr2(x.lub, x[2]);
+      Iter::Ranges::Union<CountableSetRanges, CountableSetRanges> u(xr0,xr1);
+      return Iter::Ranges::equal(xr2, u);
+    }
+    virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+      Gecode::Projector p0(0,
+			   Gecode::SetExpr(2) - Gecode::SetExpr(1),
+			   Gecode::SetExpr(2)
+			   );
+      Gecode::Projector p1(1,
+			   Gecode::SetExpr(2) - Gecode::SetExpr(0),
+			   Gecode::SetExpr(2)
+			   );
+      Gecode::Projector p2(2,
+			   Gecode::SetExpr(0) || Gecode::SetExpr(1),
+			   Gecode::SetExpr(0) || Gecode::SetExpr(1)
+			   );
+      Gecode::ProjectorSet ps;
+      ps.add(p0); ps.add(p1); ps.add(p2);
+      Gecode::projector(home, x[0], x[1], x[2], ps);
+
+      IntVar x0c(home, 0, 10);
+      IntVar x1c(home, 0, 10);
+      IntVar x2c(home, 0, 10);
+      Gecode::cardinality(home, x[0], x0c);
+      Gecode::cardinality(home, x[1], x1c);
+      Gecode::cardinality(home, x[2], x2c);
+
+      Gecode::Projector p3(2,
+			   Gecode::SetExpr(0) && Gecode::SetExpr(1),
+			   Gecode::SetExpr(0) && Gecode::SetExpr(1)
+			   );
+      IntVar x0ix1c(home, 0, 20);
+      Gecode::projector(home, x[0], x[1], x[2], x0ix1c, p3);
+      Gecode::post(home, x2c == x0c + x1c - x0ix1c);
+
+      Gecode::Projector p4(2,
+			   Gecode::SetExpr(0) - Gecode::SetExpr(1),
+			   Gecode::SetExpr(0) - Gecode::SetExpr(1)
+			   );
+      IntVar x0mx1c(home, 0, 20);
+      Gecode::projector(home, x[0], x[1], x[2], x0mx1c, p4);
+      Gecode::post(home, x1c == x2c - x0mx1c);
+
+      Gecode::Projector p5(2,
+			   Gecode::SetExpr(1) - Gecode::SetExpr(0),
+			   Gecode::SetExpr(1) - Gecode::SetExpr(0)
+			   );
+      IntVar x1mx0c(home, 0, 20);
+      Gecode::projector(home, x[0], x[1], x[2], x1mx0c, p5);
+      Gecode::post(home, x0c == x2c - x1mx0c);
+    }
+    virtual void post(Space* home, SetVarArray& x, IntVarArray&, BoolVar b) {
+      Gecode::Projector p0(0,
+			   Gecode::SetExpr(2) - Gecode::SetExpr(1),
+			   Gecode::SetExpr(2)
+			   );
+      Gecode::Projector p1(1,
+			   Gecode::SetExpr(2) - Gecode::SetExpr(0),
+			   Gecode::SetExpr(2)
+			   );
+      Gecode::Projector p2(2,
+			   Gecode::SetExpr(0) || Gecode::SetExpr(1),
+			   Gecode::SetExpr(0) || Gecode::SetExpr(1)
+			   );
+      Gecode::ProjectorSet ps;
+      ps.add(p0); ps.add(p1); ps.add(p2);
+      Gecode::projector(home, x[0], x[1], x[2], b, ps);
+    }
+  };
+  RelUnionEq _relunioneq("Proj::RelOp::UnionEq");
+
+  class RelInterEqCard : public SetTest {
+  public:
+    RelInterEqCard(const char* t)
+      : SetTest(t,3,ds_22,false) {}
+    virtual bool solution(const SetAssignment& x) const {
+      CountableSetRanges xr0(x.lub, x[0]);
+      CountableSetRanges xr1(x.lub, x[1]);
+      CountableSetRanges xr2(x.lub, x[2]);
+      Iter::Ranges::Inter<CountableSetRanges, CountableSetRanges> u(xr0,xr1);
+      return Iter::Ranges::equal(xr2, u);
+    }
+    virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+      Gecode::Projector p0(0,
+			   Gecode::SetExpr(2),
+			   Gecode::SetExpr(2) || -Gecode::SetExpr(1)
+			   );
+      Gecode::Projector p1(1,
+			   Gecode::SetExpr(2),
+			   Gecode::SetExpr(2) || -Gecode::SetExpr(0)
+			   );
+      Gecode::Projector p2(2,
+			   Gecode::SetExpr(0) && Gecode::SetExpr(1),
+			   Gecode::SetExpr(0) && Gecode::SetExpr(1)
+			   );
+      Gecode::ProjectorSet ps;
+      ps.add(p0); ps.add(p1); ps.add(p2);
+      Gecode::projector(home, x[0], x[1], x[2], ps);
+
+      IntVar x0c(home, 0, 10);
+      IntVar x1c(home, 0, 10);
+      IntVar x2c(home, 0, 10);
+      Gecode::cardinality(home, x[0], x0c);
+      Gecode::cardinality(home, x[1], x1c);
+      Gecode::cardinality(home, x[2], x2c);
+
+      Gecode::Projector p3(2,
+			   Gecode::SetExpr(0) || Gecode::SetExpr(1),
+			   Gecode::SetExpr(0) || Gecode::SetExpr(1)
+			   );
+      IntVar x0ux1c(home, 0, 20);
+      Gecode::projector(home, x[0], x[1], x[2], x0ux1c, p3);
+      Gecode::post(home, x2c == x0c + x1c - x0ux1c);
+
+      Gecode::Projector p4(2,
+			   Gecode::SetExpr(0) - Gecode::SetExpr(1),
+			   Gecode::SetExpr(0) - Gecode::SetExpr(1)
+			   );
+      IntVar x0mx1c(home, 0, 20);
+      Gecode::projector(home, x[0], x[1], x[2], x0mx1c, p4);
+      Gecode::post(home, x2c == x0c - x0mx1c);
+
+      Gecode::Projector p5(2,
+			   Gecode::SetExpr(1) - Gecode::SetExpr(0),
+			   Gecode::SetExpr(1) - Gecode::SetExpr(0)
+			   );
+      IntVar x1mx0c(home, 0, 20);
+      Gecode::projector(home, x[0], x[1], x[2], x1mx0c, p5);
+      Gecode::post(home, x2c == x1c - x1mx0c);
+
+    }
+  };
+  RelInterEqCard _relintereqcard("Proj::RelOp::InterEqCard");
+
+  class NegRelUnionEq : public SetTest {
+  public:
+    NegRelUnionEq(const char* t)
+      : SetTest(t,3,ds_22) {}
+    virtual bool solution(const SetAssignment& x) const {
+      CountableSetRanges xr0(x.lub, x[0]);
+      CountableSetRanges xr1(x.lub, x[1]);
+      CountableSetRanges xr2(x.lub, x[2]);
+      Iter::Ranges::Union<CountableSetRanges, CountableSetRanges> u(xr0,xr1);
+      return !Iter::Ranges::equal(xr2, u);
+    }
+    virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+      Gecode::Projector p0(0,
+			   Gecode::SetExpr(2) - Gecode::SetExpr(1),
+			   Gecode::SetExpr(2)
+			   );
+      Gecode::Projector p1(1,
+			   Gecode::SetExpr(2) - Gecode::SetExpr(0),
+			   Gecode::SetExpr(2)
+			   );
+      Gecode::Projector p2(2,
+			   Gecode::SetExpr(0) || Gecode::SetExpr(1),
+			   Gecode::SetExpr(0) || Gecode::SetExpr(1)
+			   );
+      Gecode::ProjectorSet ps;
+      ps.add(p0); ps.add(p1); ps.add(p2);
+      Gecode::projector(home, x[0], x[1], x[2], ps, true);
+    }
+  };
+  NegRelUnionEq _negrelunioneq("Proj::RelOp::NegUnionEq");
+
+}
+
+// STATISTICS: test-set