gecoder-with-gecode 0.7.1

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

@@ -0,0 +1,69 @@
+/*
+ *  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 const int d1r[4][2] = {
+  {-4,-3},{-1,-1},{1,1},{3,5}
+};
+static IntSet d1(d1r,4);
+
+static IntSet ds_66(-6,6);
+
+class DomRange : public IntTest {
+public:
+  DomRange(const char* t)
+    : IntTest(t,1,ds_66,true) {}
+  virtual bool solution(const Assignment& x) const {
+    return (x[0] >= -2) && (x[0] <= 2);
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    Gecode::dom(home, x[0], -2, 2);
+  }
+  virtual void post(Space* home, IntVarArray& x, BoolVar b) {
+    Gecode::dom(home, x[0], -2, 2, b);
+  }
+};
+DomRange _domrange("Dom::Range");
+
+
+class DomDom : public IntTest {
+public:
+  DomDom(const char* t)
+    : IntTest(t,1,ds_66,true) {}
+  virtual bool solution(const Assignment& x) const {
+    return
+      (((x[0] >= -4) && (x[0] <= -3)) ||
+       ((x[0] >= -1) && (x[0] <= -1)) ||
+       ((x[0] >=  1) && (x[0] <=  1)) ||
+       ((x[0] >=  3) && (x[0] <=  5)));
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    Gecode::dom(home, x[0], d1);
+  }
+  virtual void post(Space* home, IntVarArray& x, BoolVar b) {
+    Gecode::dom(home, x[0], d1, b);
+  }
+};
+DomDom _domdom("Dom::Dom");
+
+// STATISTICS: test-int
+

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

@@ -0,0 +1,132 @@
+/*
+ *  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"
+
+class ElementInt : public IntTest {
+private:
+  const int* c;
+  const int n;
+public:
+  ElementInt(const char* t, const IntSet& is, const int* c0, int n0)
+    : IntTest(t,2,is), c(c0), n(n0) {}
+  virtual bool solution(const Assignment& x) const {
+    return (x[0]>= 0) && (x[0]<n) && c[x[0]]==x[1];
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    IntArgs ia(n,c);
+    element(home, ia, x[0], x[1]);
+  }
+};
+static IntSet is1(-4,8);
+static const int c1[5] = {-1,1,-3,3,-4};
+static ElementInt _elinta("Element::Int::A",is1,&c1[0],5);
+static IntSet is2(-4,8);
+static const int c2[8] = {-1,1,-1,1,-1,1,0,0};
+static ElementInt _elintb("Element::Int::B",is2,&c2[0],8);
+static IntSet is3(-4,8);
+static const int c3[1] = {-1};
+static ElementInt _elintc("Element::Int::C",is3,&c3[0],1);
+
+class ElementShareInt : public IntTest {
+private:
+  const int* c;
+  const int n;
+public:
+  ElementShareInt(const char* t, const IntSet& is, const int* c0, int n0)
+    : IntTest(t,1,is), c(c0), n(n0) {}
+  virtual bool solution(const Assignment& x) const {
+    return (x[0]>= 0) && (x[0]<n) && c[x[0]]==x[0];
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    IntArgs ia(n,c);
+    element(home, ia, x[0], x[0]);
+  }
+};
+
+static IntSet is4(-4,8);
+static const int c4[7] = {0,-1,2,-2,4,-3,6};
+static ElementShareInt _elintd("Element::Int::D",is3,&c4[0],7);
+
+class ElementVar : public IntTest {
+private:
+  const int n;
+public:
+  ElementVar(const char* t, const IntSet& is, int n0, IntConLevel icl)
+    : IntTest(t,n0+2,is,false,icl), n(n0) {}
+  virtual bool solution(const Assignment& x) const {
+    return (x[0]>= 0) && (x[0]<n) && x[2+x[0]]==x[1];
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    Log::log("", icl == ICL_BND
+	     ? "\tIntConLevel icl = ICL_BND;"
+	     : "\tIntConLevel icl = ICL_DOM;");
+    Log::log("post element",
+	     "\tint n = x.size()-2;\n"
+	     "\tIntVarArgs ia(n);\n"
+	     "\tfor (int i=0;i<n;i++)\n"
+	     "\t  ia[i]=x[2+i];\n"
+	     "\telement(this, ia, x[0], x[1], icl);");
+    IntVarArgs ia(n);
+    for (int i=0;i<n;i++)
+      ia[i]=x[2+i];
+    element(home, ia, x[0], x[1], icl);
+  }
+};
+
+class ElementShareVar : public IntTest {
+private:
+  const int n;
+  IntConLevel icl;
+public:
+  // This is actually not domain consistent!
+  ElementShareVar(const char* t, const IntSet& is, int n0, IntConLevel icl0)
+    : IntTest(t,n0+1,is,false), n(n0), icl(icl0) {}
+  virtual bool solution(const Assignment& x) const {
+    return (x[0]>= 0) && (x[0]<n) && x[1+x[0]]==x[0];
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    Log::log("", icl == ICL_BND
+	     ? "\tIntConLevel icl = ICL_BND;"
+	     : "\tIntConLevel icl = ICL_DOM;");
+    Log::log("post element",
+	     "\tint n = x.size()-1;\n"
+	     "\tIntVarArgs ia(n);\n"
+	     "\tfor (int i=0;i<n;i++)\n"
+	     "\t  ia[i]=x[1+i];\n"
+	     "\telement(this, ia, x[0], x[0], icl);");
+    IntVarArgs ia(n);
+    for (int i=0;i<n;i++)
+      ia[i]=x[1+i];
+    element(home, ia, x[0], x[0], icl);
+  }
+};
+static IntSet iv1(-1,3);
+static ElementVar _elvarbnda("Element::Var::Bnd::A",iv1,3,ICL_BND);
+static ElementVar _elvardoma("Element::Var::Dom::A",iv1,3,ICL_DOM);
+static ElementShareVar _elsvarbnda("Element::Var::Bnd::B",iv1,3,ICL_BND);
+static ElementShareVar _elsvardoma("Element::Var::Dom::B",iv1,3,ICL_DOM);
+
+
+
+// STATISTICS: test-int
+

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

@@ -0,0 +1,592 @@
+/*
+ *  Main authors:
+ *     Patrick Pekczynski <pekczynski@ps.uni-sb.de>
+ *
+ *  Copyright:
+ *     Patrick Pekczynski, 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/int/gcc.hh"
+
+static IntSet ds_02(0,2);
+static IntSet ds_03(0,3);
+static IntSet ds_04(0,4);
+static IntSet ds_12(1,2);
+static IntSet ds_14(1,4);
+static IntSet ds_18(1,8);
+
+class GCCAssignment : public Assignment {
+  int problow;
+  int probup;
+  int cardlow;
+  int cardup;
+  int xsize;
+public:
+  GCCAssignment(int xlow, int xup,
+		int clow, int cup,
+		int xs,
+		int n0, const IntSet& d0)
+    : Assignment(n0, d0),
+      problow(xlow), probup(xup),
+      cardlow(clow), cardup(cup),
+      xsize(xs) {
+    reset();
+  }
+
+  void reset(void) {
+    done = false;
+    IntSet card_dom(cardlow, cardup);
+    IntSet var_dom(problow, probup);
+    for (int i = xsize; i < n; i++) {
+      dsv[i].init(card_dom);
+    }
+    for (int i = 0; i < xsize; i++ )
+      dsv[i].init(var_dom);
+  }
+  void operator++(void) {
+    IntSet card_dom(cardlow, cardup);
+    IntSet var_dom(problow, probup);
+    int i = n-1;
+    while (true) {
+      ++dsv[i];
+      if (dsv[i]())
+	return;
+      if (i >= xsize && i < n) {
+	dsv[i].init(card_dom);
+      } else {
+	dsv[i].init(var_dom);
+      }
+      --i;
+      if (i<0) {
+	done = true;
+	return;
+      }
+    }
+  }
+};
+
+
+class GCC_FC_AllLbUb : public IntTest {
+public:
+  GCC_FC_AllLbUb(const char* t, IntConLevel icl)
+    : IntTest(t, 4, ds_14, false, icl) {}
+  virtual bool solution(const Assignment& x) const {
+    int n[4];
+    for (int i=4; i--; )
+      n[i] = 0;
+    for (int i=x.size(); i--; )
+      n[x[i] - 1]++;
+    for (int i=4; i--;)
+      if (n[i] > 2)
+	return false;
+    return true;
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    gcc(home, x, 0, 2, icl);
+  }
+};
+
+class GCC_FC_AllTriple : public IntTest {
+public:
+  GCC_FC_AllTriple(const char* t, IntConLevel icl)
+    : IntTest(t, 4, ds_14, false, icl) {}
+  virtual bool solution(const Assignment& x) const {
+    int n[4];
+    for (int i=4; i--; )
+      n[i] = 0;
+    for (int i=x.size(); i--; )
+      n[x[i] - 1]++;
+    for (int i=4; i--;)
+      if (n[i] > 2)
+	return false;
+    return true;
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    IntArgs card(12, 1,0,2, 2,0,2, 3,0,2, 4,0,2);
+    gcc(home, x, card, 12, 2, true, 1, 4, icl);
+  }
+};
+
+class GCC_FC_SomeTriple : public IntTest {
+public:
+  GCC_FC_SomeTriple(const char* t, IntConLevel icl)
+    : IntTest(t, 4, ds_14, false, icl) {}
+  virtual bool solution(const Assignment& x) const {
+    int n[4];
+    for (int i=4; i--; )
+      n[i] = 0;
+    for (int i=x.size(); i--; )
+      n[x[i] - 1]++;
+    if (n[0] < 2 || n[1] < 2 ||
+	n[2] > 0 || n[3] > 0)
+      return false;
+    return true;
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    IntArgs card(6, 1,0,2, 2,0,2);
+    gcc(home, x, card, 6, 0, false, 1, 4, icl);
+  }
+};
+
+class GCC_FC_AllEqUb : public IntTest {
+public:
+  GCC_FC_AllEqUb(const char* t, IntConLevel icl)
+    : IntTest(t, 4, ds_12, false, icl) {}
+  virtual bool solution(const Assignment& x) const {
+    int n[2];
+    for (int i=2; i--; )
+      n[i] = 0;
+    for (int i=x.size(); i--; )
+      n[x[i] - 1]++;
+    if (n[0] != 2 || n[1] != 2)
+      return false;
+    return true;
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    gcc(home, x, 2, icl);
+  }
+};
+
+
+class GCC_FC_Shared_AllLbUb : public IntTest {
+public:
+  GCC_FC_Shared_AllLbUb(const char* t, IntConLevel icl)
+    : IntTest(t,2,ds_14,false, icl) {}
+  virtual bool solution(const Assignment& x) const {
+    if (x[0] != x[1]) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    IntVarArgs y(6);
+    for (int i = 0; i < 6; i++) {
+      if (i < 3) {
+	y[i] = x[0];
+      } else {
+	y[i] = x[1];
+      }
+    }
+    gcc(home, y, 0, 3, icl);
+  }
+};
+
+class GCC_FC_Shared_SomeTrip : public IntTest {
+public:
+  GCC_FC_Shared_SomeTrip(const char* t, IntConLevel icl)
+    : IntTest(t,1,ds_14,false,icl) {}
+  virtual bool solution(const Assignment& x) const {
+    if (x[0] == 1) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    IntArgs c(3, 1,4,4);
+
+    IntVarArgs y(4);
+    for (int i = 0; i < 4; i++) {
+      y[i] = x[0];
+    }
+    gcc(home, y, c, 3, 0, false, 1, 4, icl);
+  }
+};
+
+
+class GCC_VC_AllLbUb : public IntTest {
+private:
+  static const int lb = 0;
+  static const int rb = 2;
+
+  static const int xs = 7;
+  static const int ve = 4;
+
+  static const int minocc = 0;
+  static const int maxocc = 2;
+
+
+  Assignment* make_assignment() {
+    return new GCCAssignment(lb, rb, minocc, maxocc, ve, xs, dom);
+  }
+
+
+public:
+  GCC_VC_AllLbUb(const char* t, IntConLevel icl)
+    : IntTest(t, xs, ds_02, false,icl) {}
+  virtual bool solution(const Assignment& x) const {
+//     std::cout << "GCC-Sol: ";
+//     for (int i = 0; i < xs; i++) {
+//       if (i == ve) std::cout << "||";
+//       std::cout << x[i] << " ";
+//     }
+//     std::cout << "...";
+
+    for (int i = 0; i < ve; i++) {
+      if ( x[i] < lb || x[i] > rb) {
+// 	std::cout << "wrong bounds\n";
+	return false;
+      }
+    }
+
+    GECODE_AUTOARRAY(int, count, xs - ve);
+    for (int i = ve; i < xs; i++) {
+      count[i - ve] = 0;
+      if (x[i] < minocc || x[i] > maxocc) {
+// 	std::cout << "min-max-occ\n";
+	return false;
+      }
+    }
+
+    for (int i = 0; i < ve; i++) {
+      count[x[i]]++;
+    }
+
+    for (int i = 0; i < xs - ve; i++) {
+      if (count[i] != x[i + ve]) {
+// 	std::cout << "counting failed\n";
+	return false;
+      }
+    }
+
+//     std::cout << "valid\n";
+    return true;
+  }
+
+  virtual void post(Space* home, IntVarArray& x) {
+    // std::cout << "test_post\n";
+
+    // get the number of used values
+    GECODE_AUTOARRAY(bool, done, xs - ve);
+    for (int i = 0; i < xs - ve; i++) {
+      done[i] = false;
+    }
+
+//     int nov = 0;
+//     for (int i = 0; i < xs - ve; i++) {
+//       for (int j = 0; j < ve; j++) {
+// 	if (x[j].in(i) && !done[i]) {
+// 	  nov++;
+// 	  done[i] = true;
+// 	}
+//       }
+//     }
+
+//     std::cout << "nov = "<<nov<<"\n";
+//     for (int i = ve; i < ve + nov; i++) {
+    IntVarArgs y(xs - ve);
+    for (int i = ve; i < xs; i++) {
+      y[i - ve] = x[i];
+//       rel(home, y[i - ve], IRT_LQ, maxocc);
+//       rel(home, y[i - ve], IRT_GQ, minocc);
+    }
+
+    IntVarArgs z(ve);
+    for (int i = 0; i < ve; i++) {
+//       std::cout << x[i] << " ";
+      z[i] = x[i];
+    }
+//     std::cout <<"\n";
+//     gcc(home, z, c, 12, 2, icl);
+    gcc(home, z, y, 0, 2, icl);
+  }
+};
+
+
+class GCC_VC_AllTriple : public IntTest {
+private:
+  static const int lb = 0;
+  static const int rb = 2;
+
+  static const int xs = 7;
+  static const int ve = 4;
+
+  static const int minocc = 0;
+  static const int maxocc = 2;
+
+  Assignment* make_assignment() {
+    return new GCCAssignment(lb, rb, minocc, maxocc, ve, xs, dom);
+  }
+
+
+public:
+  GCC_VC_AllTriple(const char* t, IntConLevel icl)
+    : IntTest(t, xs, ds_02, false,icl) {}
+  virtual bool solution(const Assignment& x) const {
+//     std::cout << "GCC-Sol: ";
+//     for (int i = 0; i < xs; i++) {
+//       if (i == ve) std::cout << "||";
+//       std::cout << x[i] << " ";
+//     }
+//     std::cout << "\n";
+
+    for (int i = 0; i < ve; i++) {
+      if ( x[i] < lb || x[i] > rb) {
+	// std::cout << "wrong bounds\n";
+	return false;
+      }
+    }
+
+    GECODE_AUTOARRAY(int, count, xs - ve);
+    for (int i = ve; i < xs; i++) {
+      count[i - ve] = 0;
+      if (x[i] < minocc || x[i] > maxocc) {
+	// std::cout << "min-max-occ\n";
+	return false;
+      }
+    }
+
+    for (int i = 0; i < ve; i++) {
+      count[x[i]]++;
+    }
+
+    // std::cout << "count: ";
+    for (int i = 0; i < xs - ve; i++) {
+      // std::cout << count[i] << " ";
+    }
+    // std::cout << "\n";
+
+    for (int i = 0; i < xs - ve; i++) {
+      // std::cout << "comp: "<< count[i] <<" & "<<x[i + ve] << "\n";
+      if (count[i] != x[i + ve]) {
+	// std::cout << "count not met\n";
+	return false;
+      }
+    }
+
+    // std::cout << "valid\n";
+    return true;
+  }
+
+  virtual void post(Space* home, IntVarArray& x) {
+    // std::cout << "test_post\n";
+
+    // get the number of used values
+    GECODE_AUTOARRAY(bool, done, xs - ve);
+    for (int i = 0; i < xs - ve; i++) {
+      done[i] = false;
+    }
+
+    IntVarArgs y(xs - ve);
+    for (int i = ve; i < xs; i++) {
+      y[i - ve] = x[i];
+      rel(home, y[i - ve], IRT_LQ, maxocc);
+      rel(home, y[i - ve], IRT_GQ, minocc);
+    }
+
+    IntVarArgs z(ve);
+    for (int i = 0; i < ve; i++) {
+      z[i] = x[i];
+    }
+
+    IntArgs value(3, 0, 1, 2);
+//     std::cout <<"\n";
+//     gcc(home, z, c, 12, 2, icl);
+    gcc(home, z, value, y, 3, 2, true, 0,2,  icl);
+  }
+};
+
+
+class GCC_VC_SomeTriple : public IntTest {
+private:
+  static const int lb = 0;
+  static const int rb = 2;
+
+  static const int xs = 6;
+  static const int ve = 4;
+
+  static const int minocc = 0;
+  static const int maxocc = 2;
+
+  Assignment* make_assignment() {
+    return new GCCAssignment(lb, rb, minocc, maxocc, ve, xs, dom);
+  }
+
+public:
+  GCC_VC_SomeTriple(const char* t, IntConLevel icl)
+    : IntTest(t, xs, ds_02, false,icl) {}
+  virtual bool solution(const Assignment& x) const {
+//     std::cout << "GCC-Sol: ";
+//     for (int i = 0; i < xs; i++) {
+//       if (i == ve) std::cout << "||";
+//       std::cout << x[i] << " ";
+//     }
+//     std::cout << "\n";
+
+    for (int i = 0; i < ve; i++) {
+      if ( x[i] < lb || x[i] > rb) {
+// 	std::cout << "wrong bounds\n";
+	return false;
+      }
+    }
+
+    GECODE_AUTOARRAY(int, count, xs - ve);
+    for (int i = ve; i < xs; i++) {
+      count[i - ve] = 0;
+      if (x[i] < minocc || x[i] > maxocc) {
+// 	std::cout << "min-max-occ\n";
+	return false;
+      }
+    }
+
+    for (int i = 0; i < ve; i++) {
+      if (x[i] == 0) {
+	count[0]++;
+      }
+      if (x[i] == 1) {
+	count[1]++;
+      }
+    }
+
+    for (int i = 0; i < ve; i++) {
+      if (x[i] == 2) {
+// 	std::cout << "2 not allowed!\n";
+	return false;
+      }
+    }
+//     std::cout << "\n";
+
+    for (int i = 0; i < xs - ve; i++) {
+//       std::cout << "comp: "<< count[i] <<" & "<<x[i + ve] << "\n";
+      if (count[i] != x[i + ve]) {
+// 	std::cout << "count not met\n";
+	return false;
+      }
+    }
+
+//     std::cout << "valid\n";
+    return true;
+  }
+
+  virtual void post(Space* home, IntVarArray& x) {
+
+    IntVarArgs y(xs - ve);
+    for (int i = ve; i < xs; i++) {
+      y[i - ve] = x[i];
+      rel(home, y[i - ve], IRT_LQ, maxocc);
+      rel(home, y[i - ve], IRT_GQ, minocc);
+    }
+
+    IntVarArgs z(ve);
+    for (int i = 0; i < ve; i++) {
+      z[i] = x[i];
+    }
+
+    IntArgs value(2, 0, 1);
+    gcc(home, z, value, y, 2, 0, false, 0,2,  icl);
+  }
+};
+
+
+class GCC_VC_Shared_SomeTriple : public IntTest {
+public:
+  GCC_VC_Shared_SomeTriple(const char* t, IntConLevel icl)
+    : IntTest(t,3,ds_04,false,icl) {}
+  virtual bool solution(const Assignment& x) const {
+    if ( (x[0] != 1 && x[0] != 3) ||
+	 (x[1] != 1 && x[1] != 3)) {
+      return false;
+    }
+    if (x[0] == x[1]) {
+      return false;
+    }
+    if (x[0] < 1 || x[1] < 1) {
+      return false;
+    }
+    if (x[2] != 3) {
+      return false;
+    }
+    return true;
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    IntVarArgs y(6);
+    for (int i = 0; i < 6; i++) {
+      if (i < 3) {
+	y[i] = x[0];
+      } else {
+	y[i] = x[1];
+      }
+      rel(home, y[i], IRT_GQ, 1);
+    }
+    IntArgs value(2, 1, 3);
+    IntVarArgs z(2);
+    z[0] = x[2];
+    z[1] = x[2];
+    rel(home, z[0], IRT_EQ, 3);
+    rel(home, z[1], IRT_EQ, 3);
+
+    gcc(home, y, value, z, 2, 0, false, 1, 4, icl);
+  }
+};
+
+
+
+
+
+// Testing with Fixed Cardinalities
+// FixCard::\(\(Shared::\)*\(All\|Some\)::\([lubv,()]+\)\)::\(Bnd\|Dom\|Val\)
+// VarCard::\(\(Shared::\)*\(All\|Some\)::\([lubv,()]+\)\)::\(Bnd\|Dom\|Val\)
+
+GCC_FC_AllLbUb _gccbnd_all("GCC::FixCard::Bnd::All::(lb,ub)",ICL_BND);
+GCC_FC_AllLbUb _gccdom_all("GCC::FixCard::Dom::All::(lb,ub)",ICL_DOM);
+GCC_FC_AllLbUb _gccval_all("GCC::FixCard::Val::All::(lb,ub)",ICL_VAL);
+
+GCC_FC_AllEqUb _gccbnd_alleq("GCC::FixCard::Bnd::All::ub",ICL_BND);
+GCC_FC_AllEqUb _gccdom_alleq("GCC::FixCard::Dom::All::ub",ICL_DOM);
+GCC_FC_AllEqUb _gccval_alleq("GCC::FixCard::Val::All::ub",ICL_VAL);
+
+GCC_FC_AllTriple _gccbnd_alltrip("GCC::FixCard::Bnd::All::(v,lb,ub)",ICL_BND);
+GCC_FC_AllTriple _gccdom_alltrip("GCC::FixCard::Dom::All::(v,lb,ub)",ICL_DOM);
+GCC_FC_AllTriple _gccval_alltrip("GCC::FixCard::Val::All::(v,lb,ub)",ICL_VAL);
+
+GCC_FC_SomeTriple _gccbnd_sometrip("GCC::FixCard::Bnd::Some::(v,lb,ub)",ICL_BND);
+GCC_FC_SomeTriple _gccdom_sometrip("GCC::FixCard::Dom::Some::(v,lb,ub)",ICL_DOM);
+GCC_FC_SomeTriple _gccval_sometrip("GCC::FixCard::Val::Some::(v,lb,ub)",ICL_VAL);
+
+
+// GCC_FC_Shared_AllLbUb _gccbnd_shared_all("GCC::FixCard::Bnd::Shared::All::(lb,ub)",ICL_BND);
+// GCC_FC_Shared_AllLbUb _gccdom_shared_all("GCC::FixCard::Dom::Shared::All::(lb,ub)",ICL_DOM);
+// GCC_FC_Shared_AllLbUb _gccval_shared_all("GCC::FixCard::Val::Shared::All::(lb,ub)",ICL_VAL);
+
+// GCC_FC_Shared_SomeTrip _gccbnd_shared_tripsome("GCC::FixCard::Bnd::Shared::Some::(v,lb,ub)",ICL_BND);
+// GCC_FC_Shared_SomeTrip _gccdom_shared_tripsome("GCC::FixCard::Dom::Shared::Some::(v,lb,ub)",ICL_DOM);
+// GCC_FC_Shared_SomeTrip _gccval_shared_tripsome("GCC::FixCard::Val::Shared::Some::(v,lb,ub)",ICL_VAL);
+
+// Testing with Cardinality Variables
+
+GCC_VC_AllLbUb _gccbnd_all_var("GCC::VarCard::Bnd::All::(lb,ub)",ICL_BND);
+GCC_VC_AllLbUb _gccdom_all_var("GCC::VarCard::Dom::All::(lb,ub)",ICL_DOM);
+GCC_VC_AllLbUb _gccval_all_var("GCC::VarCard::Val::All::(lb,ub)",ICL_VAL);
+
+GCC_VC_AllTriple _gccbnd_alltrip_var("GCC::VarCard::Bnd::All::(v,lb,ub)",ICL_BND);
+GCC_VC_AllTriple _gccdom_alltrip_var("GCC::VarCard::Dom::All::(v,lb,ub)",ICL_DOM);
+GCC_VC_AllTriple _gccval_alltrip_var("GCC::VarCard::Val::All::(v,lb,ub)",ICL_VAL);
+
+GCC_VC_SomeTriple _gccbnd_sometrip__var("GCC::VarCard::Bnd::Some::(v,lb,ub)",ICL_BND);
+GCC_VC_SomeTriple _gccdom_sometrip__var("GCC::VarCard::Dom::Some::(v,lb,ub)",ICL_DOM);
+GCC_VC_SomeTriple _gccval_sometrip__var("GCC::VarCard::Val::Some::(v,lb,ub)",ICL_VAL);
+
+GCC_VC_Shared_SomeTriple _gccbnd_shared_sometrip_var("GCC::VarCard::Bnd::Shared::Some::(lb,ub)",ICL_BND);
+GCC_VC_Shared_SomeTriple _gccdom_shared_sometrip_var("GCC::VarCard::Dom::Shared::Some::(lb,ub)", ICL_DOM);
+GCC_VC_Shared_SomeTriple _gccval_shared_sometrip_var("GCC::VarCard::Val::Shared::Some::(lb,ub)", ICL_VAL);
+
+
+
+// STATISTICS: test-int
+