gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/examples/hamming.cc

@@ -0,0 +1,107 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-08-03 13:51:17 +0200 (Thu, 03 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3506 $
+ *
+ *  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/set.hh"
+#include "examples/support.hh"
+#include "gecode/minimodel.hh"
+
+/**
+ * \brief %Example: Generating hamming codes
+ *
+ * Generate a Hamming code that fits in b-bit words to code n symbols where
+ * the Hamming distance between every two symbol codes is at least d.
+ * The Hamming distance between to words is the number of bit positions
+ * where they differ.
+ *
+ * This instance fixes b to 20 and d to 3.
+ *
+ * \ingroup Example
+ *
+ */
+class Hamming : public Example {
+public:
+  SetVarArray xs;
+
+  static const int bits = 20;
+  static const int dist = 3;
+
+  Hamming(const Options& o) :
+    xs(this,o.size,IntSet::empty,1,bits) {
+    SetVarArray cxs(this,xs.size());
+    for (int i=0; i<xs.size(); i++)
+      rel(this, xs[i], SRT_CMPL, cxs[i]);
+
+    for (int i=0; i<xs.size(); i++) {
+      SetVar y = xs[i];
+      SetVar cy = cxs[i];
+      for (int j=i+1; j<xs.size(); j++) {
+        SetVar x = xs[j];
+        SetVar cx = cxs[j];
+
+        SetVar xIntCy(this);
+        SetVar yIntCx(this);
+
+	rel(this, x, SOT_INTER, cy, SRT_EQ, xIntCy);
+	rel(this, y, SOT_INTER, cx, SRT_EQ, yIntCx);
+        IntVar diff1(this,0,1024);
+        IntVar diff2(this,0,1204);
+        cardinality(this, xIntCy,diff1);
+        cardinality(this, yIntCx,diff2);
+        post(this, diff1+diff2 >= dist);
+
+      }
+    }
+
+    branch(this, xs, SETBVAR_NONE, SETBVAL_MIN);
+  }
+
+  Hamming(bool share, Hamming& s) : Example(share,s) {
+    xs.update(this, share, s.xs);
+  }
+
+  virtual Space*
+  copy(bool share) {
+    return new Hamming(share,*this);
+  }
+
+  virtual void
+  print(void) {
+    for (int i=0; i<xs.size(); i++) {
+      std::cout << "\t[" << i << "]" << xs[i] << std::endl;
+    }
+  }
+};
+
+
+int
+main(int argc, char** argv) {
+  Options o("Hamming");
+  o.size = 32;
+  o.parse(argc,argv);
+  Example::run<Hamming,DFS>(o);
+  return 0;
+}
+
+
+// STATISTICS: example-any
+

data/ext/gecode-1.3.1/examples/ind-set.cc

@@ -0,0 +1,130 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:06:52 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3517 $
+ *
+ *  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 "examples/support.hh"
+#include "gecode/minimodel.hh"
+
+/**
+ * \name Graph specification for independent sets
+ *
+ * \relates IndSet
+ */
+//@{
+/// Graph specification
+class Graph {
+public:
+  const int  n_v; ///< Number of vertices
+  const int  n_e; ///< Number of edges
+  const int* e;   ///< Arrays of edges (as vertex pairs)
+  Graph(const int n_v0, const int n_e0, const int* e0)
+    : n_v(n_v0), n_e(n_e0), e(e0) {}
+};
+
+static const int e_20_10[] = {
+  0, 4,  2,12,  12,14,  18,19,   7,10,
+  9,12,  5,11,   6,15,   3,18,   7,16
+};
+
+static const Graph g_20_10(20,10,e_20_10);
+
+static const int e_40_20[] = {
+  21,30,   11,30,   19,38,   20,25,   11,24,
+  20,33,    8,39,    4, 5,    6,16,    5,32,
+  0, 9,    5,24,   25,28,   36,38,   14,20,
+  19,25,   11,22,   13,30,    7,36,   15,33
+};
+
+static const Graph g_40_20(40, 20, e_40_20);
+//@}
+
+
+/**
+ * \brief %Example: Independent Sets in a %Graph
+ *
+ * \ingroup Example
+ *
+ */
+class IndSet : public Example {
+protected:
+  /// Graph used
+  const Graph& g;
+  /// Whether vertex included in independent set
+  BoolVarArray v;
+  /// How many elements has indipendent set
+  IntVar       k;
+public:
+  /// Actual model
+  IndSet(const Options& opt)
+    : g(opt.size == 0 ?  g_20_10 : g_40_20),
+      v(this,g.n_v,0,1), k(this,0,g.n_e) {
+    const int* e = g.e;
+    const int* e1 = e++; const int* e2 = e++;
+    for (int i = g.n_e; i--; )
+      bool_and(this, v[*e1],v[*e2],false);
+    linear(this, v, IRT_EQ, k);
+    branch(this, v, BVAR_NONE, BVAL_MIN);
+  }
+
+  /// Constructor for cloning \a s
+  IndSet(bool share, IndSet& s) : Example(share,s), g(s.g) {
+    v.update(this, share, s.v);
+    k.update(this, share, s.k);
+  }
+  /// Copy during cloning
+  virtual Space*
+  copy(bool share) {
+    return new IndSet(share,*this);
+  }
+
+  /// Print solution
+  virtual void
+  print(void) {
+    std::cout << "\tk = " << k << std::endl
+	      << "\tv[] = {";
+    for (int i = 0; i < v.size(); i++)
+      std::cout << v[i] << ", ";
+    std::cout << "};" << std::endl;
+  }
+
+  /// Add constraint for next better solution
+  void
+  constrain(Space* s) {
+    rel(this, k, IRT_GR, static_cast<IndSet*>(s)->k.val());
+  }
+};
+
+
+/** \brief Main-function
+ *  \relates IndSet
+ */
+int
+main(int argc, char** argv) {
+  Options opt("IndSet");
+  opt.solutions  = 0;
+  opt.size       = 1;
+  opt.iterations = 2000;
+  opt.parse(argc,argv);
+  Example::run<IndSet,BAB>(opt);
+  return 0;
+}
+
+// STATISTICS: example-any
+

data/ext/gecode-1.3.1/examples/knights.cc

@@ -0,0 +1,146 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2001
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:06:52 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3517 $
+ *
+ *  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 "examples/support.hh"
+#include "gecode/minimodel.hh"
+
+/**
+ * \brief %Example: n-%Knights tour
+ *
+ * Fill an n times n chess board with knights such that the
+ * knights do a full tour by knights move (last knight reaches
+ * first knight again). The formulation is due to Gert Smolka.
+ *
+ * \ingroup Example
+ *
+ */
+class Knights : public Example {
+private:
+  /// Size of board
+  const int n;
+  /// Maps board field to number of knight on board
+  IntVarArray jump;
+public:
+
+  /// Return field at position \a i, \a j
+  int
+  field(int i, int j) {
+    return i*n+j;
+  }
+
+  /// The actual model
+  Knights(const Options& opt)
+    : n(opt.size), jump(this,n*n,0,n*n-1) {
+    const int nn = n*n;
+
+    // Map knight to its predecessor of succesor on board
+    IntVarArgs pred(nn);
+    IntVarArgs succ(nn);
+    for (int i = nn; i--; ) {
+      IntVar p(this,0,nn-1);
+      IntVar s(this,0,nn-1);
+      pred[i]=p; succ[i]=s;
+    }
+
+    // Place the first two knights
+    rel(this, jump[field(0,0)], IRT_EQ, 0);
+    rel(this, jump[field(1,2)], IRT_EQ, 1);
+
+    distinct(this, jump, opt.icl);
+
+    for (int f = 0; f < nn; f++) {
+      int i = f / n;
+      int j = f % n;
+      // Compute array of neighbours
+      int nbs[8];
+      int n_nbs = 0;
+
+      static const int moves[8][2] = {
+	{-2,-1}, {-2,1}, {-1,-2}, {-1,2}, {1,-2}, {1,2}, {2,-1}, {2,1}
+      };
+
+      for (int nij = 0; nij<8 ; nij++) {
+	int id = i + moves[nij][0];
+	int jd = j + moves[nij][1];
+	
+	if ((id >= 0) && (jd >= 0) && (id < n) && (jd < n)) {
+	  int g = field(id,jd);
+	  nbs[n_nbs++] = g;
+	
+	  BoolVar b(this,0,1);
+
+	  rel(this, succ[f], IRT_EQ, g, b);
+	  rel(this, pred[g], IRT_EQ, f, b);
+
+	  bool_xor(this,
+		   post(this, ~(jump[g]-jump[f] == 1)),
+		   post(this, ~(jump[g]-jump[f] == 1-nn)),
+		   b);
+	}
+      }
+	
+      IntSet ds(nbs, n_nbs);
+      dom(this, pred[f], ds);
+      dom(this, succ[f], ds);
+      rel(this, succ[f], IRT_NQ, pred[f]);
+    }
+    branch(this, succ, BVAR_NONE, BVAL_MIN);
+  }
+
+  /// Constructor for cloning \a s
+  Knights(bool share, Knights& s) : Example(share,s), n(s.n) {
+    jump.update(this, share, s.jump);
+  }
+  /// Copy during cloning
+  virtual Space*
+  copy(bool share) {
+    return new Knights(share,*this);
+  }
+  /// Print board
+  virtual void
+  print(void) {
+    std::cout << "\t";
+    for (int i = 0; i < n; i++) {
+      for (int j = 0; j < n; j++) {
+	std::cout.width(3);
+	std::cout << jump[field(i,j)] << " ";
+      }
+      std::cout << std::endl << "\t";
+    }
+    std::cout << std::endl;
+  }
+};
+
+/** \brief Main-function
+ *  \relates Knights
+ */
+int
+main(int argc, char** argv) {
+  Options opt("Knights");
+  opt.iterations = 100;
+  opt.size       = 8;
+  opt.parse(argc,argv);
+  Example::run<Knights,DFS>(opt);
+  return 0;
+}
+
+// STATISTICS: example-any
+

data/ext/gecode-1.3.1/examples/langfordnum.cc

@@ -0,0 +1,244 @@
+/*
+ *  Main authors:
+ *     Patrick Pekczynski <pekczynski@ps.uni-sb.de>
+ *
+ *  Copyright:
+ *     Patrick Pekczynski, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:06:52 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3517 $
+ *
+ *  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 "examples/support.hh"
+#include "gecode/minimodel.hh"
+
+/**
+ * \brief Extended Options taking two parameters instead of only one
+ *
+ * This is needed in order to parameters
+ *
+ * \relates LangfordNum
+ */
+class ExtOptions : public Options {
+public:
+  ExtOptions(const char* s) : Options(s) {}
+  int n;
+  int k;
+};
+
+/**
+ * \brief %Example: Langford's number problem
+
+ * Problem 024 in the categoy "combinatorial mathematics"
+ * of http://www.csplib.org/.
+ *
+ * For a detailed problem analysis see
+ * http://www.lclark.edu/~miller/langford.html
+ *
+ * \ingroup Example
+ */
+class LangfordNum : public Example {
+private:
+  int n;
+  int k;
+
+  /// Problem variables
+  /// pos contains the position of the values in seqence
+  IntVarArray pos;
+  IntVarArray y;
+  /// pi makes the permutation explicit
+  IntVarArray pi;
+
+public:
+
+  /**
+   * \brief Constrain x to be a permutation of \f$ S_{kn} = \{0, \dots, n*k - 1\}\f$
+   *
+   * \f$ \forall i, j\in S_{kn}, i\neq j: x_i \neq x_j \f$
+   */
+
+  void adiff_skn(Space* home, IntVarArray& x, IntVarArray& pi) {
+
+    IntVarArray skn(home, k * n);
+    for (int i = k * n; i--; ) {
+      skn[i].init(home, i, i);
+    }
+
+    for (int i = k * n; i--; ) {
+      pi[i].init (home, 0, k * n - 1);
+    }
+
+    sortedness(home, x, skn, pi);
+  }
+
+  /**
+   * \brief Returns the position of the j-th occurence of value \f$ v =(i + 1)\f$
+   *
+   */
+  IntVar& p(int i, int j) {
+    return pos[i * k + j];
+  }
+
+  IntVar& ys(int i, int j) {
+    return y[i * k + j];
+  }
+
+  /**
+   * \brief The occurences of a value v in the Langford sequence are v numbers apart.
+   *
+   * Let \f$ \#(i, v) \f$ denote the position of the i-th occurence of value v
+   * in the Langford Sequence. Then this function posts the constraint that
+   * \f$ \forall i, j \in \{1, \dots, k\}, i \neq j:
+   *     \forall v \in \{1, \dots, n\}: \#(i, v) + (v + 1) = \#(j, v)\f$
+   *
+   */
+
+  void distance(Space* home) {
+    // p(i, j) denotes the j-th occurence of value i + 1
+    for (int i = 0; i < n; i++) {
+      int v = i + 1;
+      for (int j = 0; j < k - 1; j++) {
+	post(home, p(i, j) + (v + 1) == p(i, j + 1));
+      }
+    }
+  }
+
+  LangfordNum(const Options& op) {
+
+    const ExtOptions* eop = NULL;
+    eop = reinterpret_cast<const ExtOptions*> (&op);
+    n = eop->n;
+    k = eop->k;
+
+//     seq  = IntVarArray(this, k * n);
+    y    = IntVarArray(this, k * n);
+    pos  = IntVarArray(this, k * n);
+    pi   = IntVarArray(this, k * n);
+
+    IntSet dom_val(1, n);
+    IntSet dom_idx(0, k * n - 1);
+
+    for (int i = 0; i < n; i++) {
+      for (int j = 0; j < k; j++) {
+	p(i, j).init(this, dom_idx);
+	y[i*k + j].init(this, dom_val);
+      }
+    }
+
+    distance(this);
+    adiff_skn(this, pos, pi);
+
+    rel(this, y[0], IRT_LE, y[n*k - 1]);
+
+    // dual  using gcc
+    // gcc(this, y, k, eop->icl);
+    // lack of distance constraints for the dual model
+
+    // channeling
+    for (int i = 0; i < n; i++) {
+      for (int j = 0; j < k; j++) {
+	element(this, y, p(i, j), IntVar(this, i + 1, i + 1));
+      }
+    }
+
+    branch(this, pos, BVAR_SIZE_MIN, BVAL_MIN);
+  }
+
+  LangfordNum(bool share, LangfordNum& l)
+    : Example(share, l), n(l.n), k(l.k) {
+    pos.update(this, share, l.pos);
+    pi.update (this, share, l.pi);
+    y.update(this, share, l.y);
+
+  }
+
+  virtual Space*
+  copy(bool share) {
+    return new LangfordNum(share, *this);
+  }
+
+  virtual void print(void){
+    std::cout << "\nL(" << k << "," << n <<"):\n";
+
+    GECODE_AUTOARRAY(int, values, k*n);
+    for (int i = 0; i < n; i++) {
+      for (int j = 0; j < k; j++) {
+	values[i * k + j] = i + 1;
+      }
+    }
+
+    std::cout << "seq: ";
+    for(int c = 0; c < k * n; c++) {
+      int i = 0;
+      while (pos[i].assigned() && pos[i].val() != c) {
+	i++;
+      }
+      std::cout << values[i] << " ";
+    }
+    std::cout <<"\n";
+
+//     std::cout << "val: ";
+//     for (int i = 0; i < k * n; i++) {
+//       std::cout << values[i] << " ";
+//     }
+//     std::cout <<"\n";
+
+//     std::cout << "y  : ";
+//     for (int i = 0; i < k * n; i++) {
+//       std::cout << y[i] << " ";
+//     }
+//     std::cout <<"\n";
+
+    std::cout << "pos: ";
+    for (int i = 0; i < k * n; i++) {
+      std::cout << pos[i] << " ";
+    }
+    std::cout <<"\n";
+
+//     std::cout << "pi : ";
+//     for (int i = 0; i < k * n; i++) {
+//       std::cout << pi[i] << " ";
+//     }
+//     std::cout <<"\n";
+
+  }
+};
+
+int main(int argc, char** argv){
+  ExtOptions o("Langford Numbers");
+  if (argc < 2) {
+    std::cerr << "specify parameters k and n\n";
+    std::cerr << "usage is: ./langfordnum k n [gecode options] \n";
+    return -1;
+  }
+  char* name = argv[0];
+  o.k = atoi(argv[1]);
+  o.n = atoi(argv[2]);
+  argv[2] = name;
+  argv++;
+  argv++;
+  if (o.k < 1) {
+    std::cerr << "k must be at least 1!\n";
+    return -1;
+  }
+  if (o.k > o.n) {
+    std::cerr << "n must be at least k!\n";
+    return -1;
+  }
+  o.parse(argc - 2, argv);
+  Example::run<LangfordNum, DFS>(o);
+  return 0;
+}
+
+// STATISTICS: example-any
+