gecoder-with-gecode 0.7.1

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

@@ -0,0 +1,272 @@
+/*
+ *  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/support/sort.hh"
+
+static IntSet ds_12(1,2);
+static IntSet ds_13(1,3);
+static IntSet ds_14(1,4);
+static IntSet ds_03(0,3);
+
+class IntSortMin {
+public:
+  bool operator()(const int& x, const int& y) {
+    return x < y;
+  }
+};
+
+class SortPermAssignment : public Assignment{
+  int problow;
+  int probup;
+  int permlow;
+  int permup;
+  int xsize;
+public:
+  SortPermAssignment(int xlow, int xup,
+		     int plow, int pup,
+		     int xs,
+		     int n0, const IntSet& d0)
+    : Assignment(n0, d0),
+      problow(xlow), probup(xup),
+      permlow(plow), permup(pup),
+      xsize(xs) {
+    reset();
+  }
+  void reset(void) {
+    done = false;
+    IntSet perm_dom(permlow, permup);
+    IntSet var_dom(problow, probup);
+    for (int i = 2*xsize; i < n; i++) {
+      dsv[i].init(perm_dom);
+    }
+    for (int i=0; i < 2*xsize; i++)
+      dsv[i].init(var_dom);
+  }
+  void operator++(void) {
+    IntSet perm_dom(permlow, permup);
+    IntSet var_dom(problow, probup);
+    int i = n-1;
+    while (true) {
+      ++dsv[i];
+      if (dsv[i]())
+	return;
+      dsv[i].init(d);
+      if (i >= 2*xsize && i < n) {
+	dsv[i].init(perm_dom);
+      } else {
+	dsv[i].init(var_dom);
+      }
+      --i;
+      if (i<0) {
+	done = true;
+	return;
+      }
+    }
+  }
+};
+
+class Sortedness_NoVar : public IntTest {
+private:
+  IntConLevel icl;
+  static const int xs = 6;
+  static const int ve = xs /2;
+
+public:
+  Sortedness_NoVar(const char* t, IntConLevel icl0)
+    : IntTest(t, xs, ds_13), icl(icl0) {}
+  virtual bool solution(const Assignment& x) const {
+    int sortx[ve];
+    for (int i = 0; i < ve; i++) {
+      sortx[i] = x[i];
+    }
+    IntSortMin min_inc;
+    Support::quicksort<int, IntSortMin> (&sortx[0], ve, min_inc);
+
+//     std::cout << "defined sol: ";
+//     for (int i = 0; i < xs; i++) {
+//       if (i == ve) std::cout << "||";
+//       if (i < ve) {
+// 	std::cout << sortx[i]<<" ";
+//       } else {
+// 	std::cout <<x[i] << " ";
+//       }
+//     }
+//     std::cout <<"...";
+
+
+    for (int i = ve; i < xs - 1; i++) {
+      if ( !(x[i] <= x[i + 1]) ) {
+	// std::cout << "y not sorted\n";
+	return false;
+      }
+    }
+
+    for (int i = ve; i < xs; i++) {
+      if (sortx[i - ve] != x[i]) {
+	// std::cout << "no sorting poss\n";
+	return false;
+      }
+    }
+
+    // std::cout << "valid\n";
+    return true;
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    IntVarArgs z(ve);
+    for (int i = 0; i < ve; i++) {
+      z[i] = x[i];
+    }
+
+    IntVarArgs y(ve);
+    for (int i = ve; i < xs; i++) {
+      y[i - ve] = x[i];
+    }
+
+    sortedness(home, z, y, icl);
+  }
+};
+
+
+class Sortedness_PermVar : public IntTest {
+private:
+  IntConLevel icl;
+  static const int xs = 9;
+  static const int ve1 = xs / 3;
+  static const int ve2 = 2 * ve1;
+
+  static const int xlow  = 1;
+  static const int xup   = 3;
+  static const int plow  = 0;
+  static const int pup   = 2;
+  static const int xsize = 3;
+
+  Assignment* make_assignment() {
+    return new SortPermAssignment(1, 3, 0, 2, 3, 9, dom);
+  }
+
+public:
+  Sortedness_PermVar(const char* t, IntConLevel icl0)
+    : IntTest(t, xs, ds_03), icl(icl0) {}
+  virtual bool solution(const Assignment& x) const {
+
+
+    int sortx[ve1];
+    for (int i = 0; i < ve1; i++) {
+      sortx[i] = x[i];
+    }
+
+    IntSortMin imin;
+    Support::quicksort<int, IntSortMin> (&sortx[0], ve1, imin);
+
+//     std::cout << "perm issol: ";
+//     for (int i = 0; i < xs; i++) {
+//       if (i == ve1 || i == ve2) std::cout << "||";
+//       std::cout <<x[i] << " ";
+// 	}
+//     std::cout <<"...";
+
+    // ys have to be sorted
+    for (int i = ve1; i < ve2 - 1; i++) {
+      if ( !(x[i] <= x[i + 1]) ) {
+// 	std::cout << "y not sorted\n";
+	return false;
+      }
+    }
+
+
+    // assert correct domains
+    for (int i = 0; i < ve2; i++) {
+      if (!(x[i] > 0)) {
+// 	std::cout << "false domain\n";
+	return false;
+      }
+    }
+
+    for (int i = ve2; i < xs; i++) {
+      if (! (x[i] < 3)) {
+// 	std::cout << "false domain 2\n";
+	return false;
+      }
+    }
+
+    // perm index
+    for (int i = 0; i < ve1; i++) {
+      if (x[i] != x[ve1 + x[i + ve2]]) {
+// 	std::cout << "wrong index\n";
+	return false;
+      }
+    }
+
+    // perm distinct
+    for (int i = ve2; i < xs - 1; i++) {
+      for (int j = i + 1; j < xs; j++) {
+	if (x[i] == x[j]) {
+// 	  std::cout << "no perm\n";
+	  return false;
+	}
+      }
+    }
+
+
+    for (int i = ve1; i < ve2; i++) {
+      if (sortx[i - ve1] != x[i]) {
+// 	std::cout << "no sorting poss\n";
+	return false;
+      }
+    }
+
+//     std::cout << "valid\n";
+    return true;
+  }
+  virtual void post(Space* home, IntVarArray& x) {
+    IntVarArgs z(ve1);
+    for (int i = 0; i < ve1; i++) {
+      z[i] = x[i];
+    }
+
+    IntVarArgs y(ve1);
+    for (int i = ve1; i < ve2; i++) {
+      y[i - ve1] = x[i];
+    }
+
+    IntVarArgs p(ve1);
+    for (int i = ve2; i < xs; i++) {
+      p[i - ve2] = x[i];
+    }
+
+    for (int i = 0; i < ve1; i++) {
+      rel(home, z[i], IRT_GQ, 1);
+      rel(home, y[i], IRT_GQ, 1);
+      rel(home, p[i], IRT_LQ, 2);
+    }
+    Log::log("Post sortedness", "\tsortedness(this, ...);");
+    sortedness(home, z, y, p, icl);
+  }
+};
+
+
+Sortedness_NoVar  _sort_novar("Sortedness::NoPermutationVariables::Bnd",ICL_BND);
+Sortedness_PermVar  _sort_permvar("Sortedness::WithPermutationVariables::Bnd",ICL_BND);
+
+// STATISTICS: test-int
+

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

@@ -0,0 +1,40 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2005
+ *
+ *  Last modified:
+ *     $Date: 2006-07-12 15:53:12 +0200 (Wed, 12 Jul 2006) $ by $Author: tack $
+ *     $Revision: 3349 $
+ *
+ *  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 "gecode/int.hh"
+#include "test.hh"
+
+using namespace Gecode;
+
+class IntSetTest : public Test {
+public:
+  IntSetTest(void) : Test("IntSet","Test") {}
+  bool run(const Options&)  {
+    IntSet bi2(1,1);
+    IntSet ci2;
+    ci2.update(false, bi2);
+    return true;
+  }
+};
+
+IntSetTest _intset;
+
+// STATISTICS: test-set

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

@@ -0,0 +1,515 @@
+/*
+ *  Main authors:
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     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 "log.hh"
+
+#include <vector>
+#include <string>
+#include <iostream>
+#include <sstream>
+#include <utility>
+
+namespace {
+  using namespace std;
+  vector<string> hinitial;
+  vector<string> hops;
+  vector<string> cdecla;
+  vector<string> cinitlist;
+  vector<string> cinit;
+  vector<string> cupdate;
+  vector<string> cops;
+  typedef pair<string, bool> psb;
+  vector<psb> cnames;
+
+  string space = ""
+  "#include \"kernel.hh\" \n"
+  "#include \"int.hh\" \n"
+  "#include \"set.hh\" \n"
+  "#include <iostream> \n"
+  " \n"
+  "using namespace Gecode; \n"
+  " \n"
+  "  unsigned int tmp; \n"
+  " \n"
+  "  class ErrorSpace : public Space { \n"
+  "  public: \n"
+  "DECL"
+  "    ErrorSpace() : \n"
+  "INITLIST \n"
+  "    { \n"
+  "INIT"
+  "    } \n"
+  "    ErrorSpace(bool share, ErrorSpace& s) : Space(share,s) { \n"
+  "UPDATE"
+  "    } \n"
+  "    virtual Space* copy(bool share) { \n"
+  "      return new ErrorSpace(share,*this); \n"
+  "    } \n"
+  "    void print() {\n"
+  "PRINTOPS"
+  "    }\n"
+  "    void run() { \n"
+  "OPERATIONS"
+  "    } \n"
+  "  }; \n"
+  "  int main() { \n"
+  "    ErrorSpace es; \n"
+  "    es.run(); \n"
+  "    switch (es.status(tmp)) { \n"
+  "    case SS_FAILED: \n"
+  "      std::cout << \"Failed.\" << std::endl; \n"
+  "      break; \n"
+  "    case SS_SOLVED: \n"
+  "      std::cout << \"Solved.\" << std::endl; \n"
+  "      break; \n"
+  "    default: \n"
+  "      std::cout << \"Other\" << std::endl; \n"
+  "      break; \n"
+  "    } \n"
+  "  } \n";
+
+  string printloop = ""
+  "\tstd::cout << \"NAME[] = {\";\n"
+  "\tfor (int i = 0; i < NAME.size(); ++i) {\n"
+  "\t\tstd::cout << NAME[i];\n"
+  "\t\tif (i != NAME.size()-1) std::cout << \", \";\n"
+  "\t}\n"
+  "\tstd::cout << \"}\" << std::endl;\n";
+
+  string printcmd = ""
+  "\tstd::cout << \"NAME = \" << NAME << std::endl;\n";
+
+  bool do_logging = false;
+}
+
+
+namespace Log {
+  using namespace std;
+  void logging(bool val) {
+    do_logging = val;
+  }
+
+  bool logging() {
+    return do_logging;
+  }
+
+  void reset() {
+    if (!do_logging) return;
+    hinitial.clear();
+    hops.clear();
+    cdecla.clear();
+    cinitlist.clear();
+    cinit.clear();
+    cupdate.clear();
+    cops.clear();
+    cnames.clear();
+  }
+
+  void print(/*ostream& o, */bool for_display) {
+    if (!do_logging) return;
+    if (for_display) {
+      cout << "Initial configuration" << endl;
+      for (unsigned int i = 0; i < hinitial.size(); ++i) {
+	cout << hinitial[i] << endl;
+      }
+      cout << endl;
+
+      cout << "Operations" << endl;
+      for (unsigned int i = 0; i < hops.size(); ++i) {
+	cout << hops[i] << endl;
+      }
+      cout << endl;
+    } else {
+      string error_space = space;
+
+      ostringstream decl;
+      for (unsigned int i = 0; i < cdecla.size(); ++i) {
+	decl << cdecla[i] << endl;
+      }
+      error_space.replace(error_space.find("DECL"), 4,
+			  decl.str(), 0, decl.str().length());
+
+      ostringstream initlist; initlist << "\t";
+      for (unsigned int i = 0; i < cinitlist.size(); ++i) {
+	initlist << cinitlist[i];
+	if (i+1 != cinitlist.size()) initlist << ", ";
+      }
+      error_space.replace(error_space.find("INITLIST"), 9,
+			  initlist.str(), 0, initlist.str().length());
+
+      ostringstream init;
+      for (unsigned int i = 0; i < cinit.size(); ++i) {
+	init << cinit[i] << endl;
+      }
+      error_space.replace(error_space.find("INIT"), 4,
+			  init.str(), 0, init.str().length());
+
+      ostringstream update;
+      for (unsigned int i = 0; i < cupdate.size(); ++i) {
+	update << cupdate[i] << endl;
+      }
+      error_space.replace(error_space.find("UPDATE"), 6,
+			  update.str(), 0, update.str().length());
+
+      ostringstream operations;
+      for (unsigned int i = 0; i < cops.size(); ++i) {
+	if (cops[i].size() > 0) {
+	  if (cops[i][0] != '\t' && cops[i][0] != ' ')
+	    operations << '\t';
+	  operations << cops[i] << endl;
+	}
+      }
+      error_space.replace(error_space.find("OPERATIONS"), 10,
+			  operations.str(), 0, operations.str().length());
+
+      ostringstream printops;
+      for (unsigned int i = 0; i < cnames.size(); ++i) {
+	string pop = cnames[i].second ? printloop : printcmd,
+	  name = cnames[i].first;
+	while (pop.find("NAME") != string::npos)
+	  pop.replace(pop.find("NAME"), 4, name, 0, name.length());
+	printops << pop;
+      }
+      error_space.replace(error_space.find("PRINTOPS"), 8,
+			  printops.str(), 0, printops.str().length());
+
+      cout << error_space;
+    }
+
+  }
+
+  std::string mk_name(const char* arr, int idx) {
+    if (!do_logging) return string("");
+    ostringstream res;
+    res << arr << "[" << idx << "]";
+    return res.str();
+  }
+
+
+  void initial(const IntVarArray& a, const char* name) {
+    if (!do_logging) return;
+    // Display
+    ostringstream hiva;
+    hiva << "IntVarArray " << name << " = ";
+    hinitial.push_back(hiva.str());
+
+    for (int i = 0; i < a.size(); ++i) {
+      ostringstream ai;
+      ai << "\t" << name << "[" << i << "]="
+	 << a[i];
+      hinitial.push_back(ai.str());
+    }
+
+    // Execution
+    ostringstream civa;
+    civa << "\tIntVarArray " << name << ";";
+    cdecla.push_back(civa.str());
+
+    ostringstream initlist;
+    initlist << name << "(this," << a.size() << ")";
+    cinitlist.push_back(initlist.str());
+
+    ostringstream update;
+    update << "\t" <<  name << ".update(this, share, s." << name << ");";
+    cupdate.push_back(update.str());
+
+    cnames.push_back(psb(name, true));
+
+    for (int i = 0; i < a.size(); ++i) {
+      ostringstream init;
+      init << "\tconst int arr" << i << "[][2] = {";
+      int n = 0;
+      for (IntVarRanges it(a[i]); it(); ++it, ++n) {
+	if (n) init << ",";
+	init << "{" << it.min() << "," << it.max() << "}";
+      }
+      init << "};\n\t"
+	   << name << "[" << i << "] = IntVar(this, IntSet(arr"
+	   << i << ", " << n << "));";
+      cinit.push_back(init.str());
+    }
+  }
+
+
+  void initial(const BoolVar& a, const char* name) {
+    if (!do_logging) return;
+    // Display
+    ostringstream hiva;
+    hiva << "BoolVar " << name << " = " << a;
+    hinitial.push_back(hiva.str());
+
+    // Execution
+    ostringstream civa;
+    civa << "\tBoolVar " << name << ";";
+    cdecla.push_back(civa.str());
+
+    ostringstream initlist;
+    initlist << name << "(this," << a.size() << ", 0, 1)";
+    cinitlist.push_back(initlist.str());
+
+    ostringstream update;
+    update << "\t" <<  name << ".update(this, share, s." << name << ");";
+    cupdate.push_back(update.str());
+
+    cnames.push_back(psb(name, false));
+  }
+
+#ifdef GECODE_HAVE_SET_VARS
+  void initial(const SetVarArray& a, const char* name) {
+    if (!do_logging) return;
+    // Display
+    ostringstream hiva;
+    hiva << "SetVarArray " << name << " = ";
+    hinitial.push_back(hiva.str());
+
+    for (int i = 0; i < a.size(); ++i) {
+      ostringstream ai;
+      ai << "\t" << name << "[" << i << "]="
+	 << a[i];
+      hinitial.push_back(ai.str());
+    }
+
+    // Execution
+    ostringstream civa;
+    civa << "\tSetVarArray " << name << ";";
+    cdecla.push_back(civa.str());
+
+    ostringstream initlist;
+    initlist << name << "(this," << a.size() << ")";
+    cinitlist.push_back(initlist.str());
+
+    ostringstream update;
+    update << "\t" <<  name << ".update(this, share, s." << name << ");";
+    cupdate.push_back(update.str());
+
+    cnames.push_back(psb(name, true));
+
+    for (int i = 0; i < a.size(); ++i) {
+      ostringstream init;
+      init << "\tconst int arrGlb" << i << "[][2] = {";
+      int n = 0;
+      for (SetVarGlbRanges it(a[i]); it(); ++it, ++n) {
+	if (n) init << ",";
+	init << "{" << it.min() << "," << it.max() << "}";
+      }
+      init << "};\n";
+      init << "\tconst int arrLub" << i << "[][2] = {";
+      int m = 0;
+      for (SetVarLubRanges it(a[i]); it(); ++it, ++m) {
+	if(m) init << ",";
+	init << "{" << it.min() << "," << it.max() << "}";
+      }
+      init << "};\n\t";
+      init << name << "[" << i << "] = SetVar(this, IntSet(arrGlb"
+	   << i << ", " << n << "), IntSet(arrLub"
+	   << i << ", " << m << "), " << a[i].cardMin()
+	   << ", " << a[i].cardMax() << ");";
+      cinit.push_back(init.str());
+    }
+  }
+#endif
+
+  void log(const std::string hlog, const std::string clog = "") {
+    if (!do_logging) return;
+    hops.push_back(hlog);
+    if (clog != "")
+      cops.push_back(clog);
+  }
+
+  void assign(std::string name, int val) {
+    if (!do_logging) return;
+    ostringstream h;
+    h << "Assign val=" << val << " to " << name;
+    hops.push_back(h.str());
+
+    ostringstream c;
+    c << "\trel(this, " << name << ", IRT_EQ, " << val << ");";
+    cops.push_back(c.str());
+  }
+
+  void assign(std::string name, const IntSet& val) {
+    if (!do_logging) return;
+    ostringstream h;
+    h << "Assign val=" << val << " to " << name;
+    hops.push_back(h.str());
+
+    ostringstream c;
+
+    c << "\t{ const int arr[][2] = {";
+    int n = 0;
+    for (IntSetRanges it(val); it(); ++it, ++n) {
+      if(n) c << ",";
+      c << "{" << it.min() << "," << it.max() << "}";
+    }
+    c << "};\n";
+    if (n==0) {
+      c << "\t  IntSet is(IntSet::empty);\n";
+    } else {
+      c << "\t  IntSet is(arr, " << n << ");\n";
+    }
+    c << "\t dom(this, " << name << ", SRT_EQ, " << "is); }";
+    cops.push_back(c.str());
+  }
+
+  void prune(const IntVar& v, std::string name, IntRelType irt, int val) {
+    if (!do_logging) return;
+    ostringstream h;
+    switch (irt) {
+    case IRT_NQ:
+      h << "Prune val=" << val << " from " << name << " =" << v;
+      break;
+    case IRT_LE:
+      h << "Prune vals above " << val << " from " << name << " =" << v;
+      break;
+    case IRT_GR:
+      h << "Prune vals below " << val << " from " << name << " =" << v;
+      break;
+    default: break;
+    }
+    hops.push_back(h.str());
+
+    ostringstream c;
+    switch (irt) {
+    case IRT_NQ:
+      c << "\trel(this, " << name << ", IRT_NQ, " << val << ");";
+      break;
+    case IRT_LE:
+      c << "\trel(this, " << name << ", IRT_LE, " << val << ");";
+      break;
+    case IRT_GR:
+      c << "\trel(this, " << name << ", IRT_GR, " << val << ");";
+      break;
+    default: break;
+    }
+    cops.push_back(c.str());
+  }
+
+#ifdef GECODE_HAVE_SET_VARS
+  void prune(const SetVar& v, std::string name, SetRelType srt, int val) {
+    if(!do_logging) return;
+    ostringstream h;
+    switch(srt) {
+    case SRT_SUP:
+      h << "Include val=" << val << " in " << name << " =" << v;
+      break;
+    case SRT_DISJ:
+      h << "Exclude val=" << val << " from " << name << " =" << v;
+      break;
+    default: break;
+    }
+    hops.push_back(h.str());
+
+    ostringstream c;
+    switch(srt) {
+    case SRT_SUP:
+      c << "\tdom(this, " << name << ", SRT_SUP, " << val << ");";
+      break;
+    case SRT_DISJ:
+      c << "\tdom(this, " << name << ", SRT_DISJ, " << val << ");";
+      break;
+    default: break;
+    }
+    cops.push_back(c.str());
+  }
+
+  void prune(const SetVar& v, std::string name,
+	     unsigned int cardMin, unsigned int cardMax) {
+    if(!do_logging) return;
+    ostringstream h;
+    h << "Prune cardinality of " << name << " to "
+      << cardMin << "/" << cardMax;
+    hops.push_back(h.str());
+
+    ostringstream c;
+    c << "\tcardinality(this, " << name << ", "
+      << cardMin << ", " << cardMax << ");";
+    cops.push_back(c.str());
+  }
+#endif
+
+  void prune_result(const IntVar& v) {
+    if (!do_logging) return;
+    ostringstream h;
+    h << "\tPruning resulted in domain " << v;
+    hops.push_back(h.str());
+  }
+
+#ifdef GECODE_HAVE_SET_VARS
+  void prune_result(const SetVar& v) {
+    if (!do_logging) return;
+    ostringstream h;
+    h << "\tPruning resulted in domain " << v;
+    hops.push_back(h.str());
+  }
+#endif
+
+  void flush() {
+    if (!do_logging) return;
+    hops.push_back("Flush caches");
+    cops.push_back("\tflush();");
+  }
+
+  void fixpoint() {
+    if (!do_logging) return;
+    hops.push_back("Compute fixpoint");
+    cops.push_back("\tstatus(tmp);");
+  }
+
+  void print(const IntVarArray& a, const char* name) {
+    if (!do_logging) return;
+    ostringstream h;
+    if (name) h << name << "[] = ";
+    h << "{";
+    for (int i = 0; i < a.size(); ++i) {
+      h << a[i];
+      if (i != a.size()-1) h << ", ";
+    }
+    h << "}";
+    hops.push_back(h.str());
+    cops.push_back("\tprint();");
+  }
+
+  void print(const BoolVar& a, const char* name) {
+    if (!do_logging) return;
+    ostringstream h;
+    if (name) h << name << " = ";
+    h << a;
+    hops.push_back(h.str());
+    cops.push_back("\tprint();");
+  }
+
+#ifdef GECODE_HAVE_SET_VARS
+  void print(const SetVarArray& a, const char* name) {
+    if (!do_logging) return;
+    ostringstream h;
+    if (name) h << name << "[] = ";
+    h << "{";
+    for (int i = 0; i < a.size(); ++i) {
+      h << a[i];
+      if (i != a.size()-1) h << ", ";
+    }
+    hops.push_back(h.str());
+    cops.push_back("\tprint();");
+  }
+#endif
+
+}
+
+// STATISTICS: test-core