gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/examples/magic-sequence-gcc.cc

@@ -0,0 +1,93 @@
+/*
+ *  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: Magic sequence
+ *
+ * Find a magic sequence of length \f$n\f$. A magic sequence of
+ * length \f$n\f$ is a sequence \f[x_0,x_1, \ldots, x_{n-1}\f]
+ * of integers such that for every \f$i=0,\ldots,n-1\f$:
+ *  - \f$x_i\f$ is an integer between \f$0\f$ and \f$n-1\f$.
+ *  - the number \f$i\f$ occurs exactly \f$x_i\f$ times in the sequence.
+ *
+ * \ingroup Example
+ *
+ */
+class MagicSequence : public Example {
+private:
+  /// Length of sequence
+  const int n;
+  /// Sequence
+  IntVarArray s;
+public:
+  /// The actual model
+  MagicSequence(const Options& opt)
+    : n(opt.size), s(this,n,0,n-1) {
+    gcc(this, s, s, 0, n-1, ICL_BND);
+    IntArgs c(n);
+    for (int j = n; j--; )
+      c[j] = j-1;
+    linear(this, c, s, IRT_EQ, 0);
+    branch(this, s, BVAR_NONE, BVAL_SPLIT_MAX);
+  }
+
+  /// Constructor for cloning \a e
+  MagicSequence(bool share, MagicSequence& e) : Example(share,e), n(e.n) {
+    s.update(this, share, e.s);
+  }
+  /// Copy during cloning
+  virtual Space*
+  copy(bool share) {
+    return new MagicSequence(share,*this);
+  }
+  /// Print sequence
+  virtual
+  void print(void) {
+    std::cout << "\t";
+    for (int i = 0; i<n; i++) {
+      std::cout << s[i] << ", ";
+      if ((i+1) % 20 == 0)
+	std::cout << std::endl << "\t";
+    }
+    std::cout << std::endl;
+  }
+
+};
+
+/** \brief Main-function
+ *  \relates MagicSequence
+ */
+int
+main(int argc, char** argv) {
+  Options opt("MagicSequence");
+  opt.solutions  = 0;
+  opt.iterations = 4;
+  opt.size       = 500;
+  opt.parse(argc,argv);
+  Example::run<MagicSequence,DFS>(opt);
+  return 0;
+}
+
+// STATISTICS: example-any
+

data/ext/gecode-1.3.1/examples/magic-sequence.cc

@@ -0,0 +1,108 @@
+/*
+ *  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: Magic sequence
+ *
+ * Find a magic sequence of length \f$n\f$. A magic sequence of
+ * length \f$n\f$ is a sequence \f[x_0,x_1, \ldots, x_{n-1}\f]
+ * of integers such that for every \f$i=0,\ldots,n-1\f$:
+ *  - \f$x_i\f$ is an integer between \f$0\f$ and \f$n-1\f$.
+ *  - the number \f$i\f$ occurs exactly \f$x_i\f$ times in the sequence.
+ *
+ * \ingroup Example
+ *
+ */
+class MagicSequence : public Example {
+private:
+  /// Length of sequence
+  const int n;
+  /// Sequence
+  IntVarArray s;
+public:
+  /// Naive version for counting number of ocurrences of \a i
+  void
+  exactly(IntVarArray& v, IntVar& x, int i) {
+    // I occurs in V X times
+    BoolVarArgs b(v.size());
+    for (int j = v.size(); j--; )
+      b[j] = post(this, ~(v[j] == i));
+    linear(this, b, IRT_EQ, x);
+  }
+  /// The actual model
+  MagicSequence(const Options& opt)
+    : n(opt.size), s(this,n,0,n-1) {
+    if (opt.naive)
+      for (int i=n; i--; )
+	exactly(s, s[i], i);
+    else
+      for (int i=n; i--; )
+	count(this, s, i, IRT_EQ, s[i]);
+    linear(this, s, IRT_EQ, n);
+    IntArgs c(n);
+    for (int j = n; j--; )
+      c[j] = j-1;
+    linear(this, c, s, IRT_EQ, 0);
+    branch(this, s, BVAR_NONE, BVAL_SPLIT_MAX);
+  }
+
+  /// Constructor for cloning \a e
+  MagicSequence(bool share, MagicSequence& e) : Example(share,e), n(e.n) {
+    s.update(this, share, e.s);
+  }
+  /// Copy during cloning
+  virtual Space*
+  copy(bool share) {
+    return new MagicSequence(share,*this);
+  }
+  /// Print sequence
+  virtual
+  void print(void) {
+    std::cout << "\t";
+    for (int i = 0; i<n; i++) {
+      std::cout << s[i] << ", ";
+      if ((i+1) % 20 == 0)
+	std::cout << std::endl << "\t";
+    }
+    std::cout << std::endl;
+  }
+
+};
+
+/** \brief Main-function
+ *  \relates MagicSequence
+ */
+int
+main(int argc, char** argv) {
+  Options opt("MagicSequence");
+  opt.solutions  = 0;
+  opt.iterations = 4;
+  opt.size       = 500;
+  opt.parse(argc,argv);
+  Example::run<MagicSequence,DFS>(opt);
+  return 0;
+}
+
+// STATISTICS: example-any
+

data/ext/gecode-1.3.1/examples/magic-square.cc

@@ -0,0 +1,120 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2001
+ *
+ *  Last modified:
+ *     $Date: 2006-04-11 15:58:37 +0200 (Tue, 11 Apr 2006) $ by $Author: tack $
+ *     $Revision: 3188 $
+ *
+ *  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: Magic squares
+ *
+ * Compute magic squares of arbitrary size
+ *
+ * \ingroup Example
+ *
+ */
+class MagicSquare : public Example {
+private:
+  /// Size of magic square
+  const int n;
+  /// Fields of square
+  IntVarArray x;
+
+public:
+  /// Post constraints
+  MagicSquare(const Options& opt)
+    : n(opt.size), x(this,n*n,1,n*n) {
+    // Number of fields on square
+    const int nn = n*n;
+
+    // Sum of all a row, column, or diagonal
+    const int s  = nn*(nn+1) / (2*n);
+
+    // Matrix-wrapper for the square
+    MiniModel::Matrix<IntVarArray> m(x, n, n);
+
+    for (int i = n; i--; ) {
+	linear(this, m.row(i), IRT_EQ, s, opt.icl);
+	linear(this, m.col(i), IRT_EQ, s, opt.icl);
+    }
+    // Both diagonals must have sum s
+    {
+      IntVarArgs d1y(n);
+      IntVarArgs d2y(n);
+      for (int i = n; i--; ) {
+	d1y[i] = m(i,i);
+	d2y[i] = m(n-i-1,i);
+      }
+      linear(this, d1y, IRT_EQ, s, opt.icl);
+      linear(this, d2y, IRT_EQ, s, opt.icl);
+    }
+
+    // All fields must be distinct
+    distinct(this, x, opt.icl);
+
+    // Break some (few) symmetries
+    rel(this, m(0,0), IRT_GR, m(0,n-1));
+    rel(this, m(0,0), IRT_GR, m(n-1,0));
+
+    branch(this, x, BVAR_SIZE_MIN, BVAL_SPLIT_MIN);
+  }
+
+  /// Constructor for cloning \a s
+  MagicSquare(bool share, MagicSquare& s) : Example(share,s), n(s.n) {
+    x.update(this, share, s.x);
+  }
+
+  /// Copy during cloning
+  virtual Space*
+  copy(bool share) {
+    return new MagicSquare(share,*this);
+  }
+  /// Print solution
+  virtual void
+  print(void) {
+    // Matrix-wrapper for the square
+    MiniModel::Matrix<IntVarArray> m(x, n, n);
+    for (int i = 0; i<n; i++) {
+      std::cout << "\t";
+      for (int j = 0; j<n; j++) {
+	std::cout.width(2);
+	std::cout << m(i,j) << "  ";
+      }
+      std::cout << std::endl;
+    }
+  }
+
+};
+
+/** \brief Main-function
+ *  \relates MagicSquare
+ */
+int
+main(int argc, char** argv) {
+  Options opt("MagicSquare");
+  opt.iterations = 1;
+  opt.size       = 7;
+  opt.parse(argc,argv);
+  Example::run<MagicSquare,DFS>(opt);
+  return 0;
+}
+
+// STATISTICS: example-any
+

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

@@ -0,0 +1,92 @@
+/*
+ *  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: SEND+MORE=MONEY puzzle
+ *
+ * Well-known cryptoarithmetic puzzle.
+ * Henry Dudeney, Strand Magazine, July 1924.
+ *
+ * \ingroup Example
+ *
+ */
+class Money : public Example {
+protected:
+  /// Number of letters
+  static const int nl = 8;
+  /// Array of letters
+  IntVarArray le;
+public:
+  /// Actual model
+  Money(const Options& opt) : le(this,nl,0,9) {
+    IntVar
+      s(le[0]), e(le[1]), n(le[2]), d(le[3]),
+      m(le[4]), o(le[5]), r(le[6]), y(le[7]);
+
+    rel(this, s, IRT_NQ, 0);
+    rel(this, m, IRT_NQ, 0);
+
+    post(this,            1000*s+100*e+10*n+d
+                +         1000*m+100*o+10*r+e
+	       == 10000*m+1000*o+100*n+10*e+y,
+	 opt.icl);
+
+    distinct(this, le, opt.icl);
+    branch(this, le, BVAR_SIZE_MIN, BVAL_MIN);
+  }
+  /// Print solution
+  virtual void
+  print(void) {
+    std::cout << "\t";
+    for (int i = 0; i < nl; i++)
+      std::cout << le[i] << " ";
+    std::cout << std::endl;
+  }
+
+  /// Constructor for cloning \a s
+  Money(bool share, Money& s) : Example(share,s) {
+    le.update(this, share, s.le);
+  }
+  /// Copy during cloning
+  virtual Space*
+  copy(bool share) {
+    return new Money(share,*this);
+  }
+};
+
+/** \brief Main-function
+ *  \relates Money
+ */
+int
+main(int argc, char** argv) {
+  Options opt("SEND+MORE=MONEY");
+  opt.solutions  = 0;
+  opt.iterations = 20000;
+  opt.parse(argc,argv);
+  Example::run<Money,DFS>(opt);
+  return 0;
+}
+
+// STATISTICS: example-any
+

data/ext/gecode-1.3.1/examples/ortho-latin.cc

@@ -0,0 +1,156 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-08-31 17:36:38 +0200 (Thu, 31 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3579 $
+ *
+ *  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"
+
+/**
+ * \brief %Example: Orthogonal latin squares
+ *
+ * \ingroup Examples
+ */
+class OrthoLatinSquare : public Example {
+protected:
+  /// Size of squares
+  const int n;
+  /// Fields of first square
+  IntVarArray x1;
+  /// Fields of second square
+  IntVarArray x2;
+
+public:
+  /// Access field at position \a i and \a j in first square
+  IntVar& y1(int i, int j) {
+    return x1[i*n+j];
+  }
+  /// Access field at position \a i and \a j in second square
+  IntVar& y2(int i, int j) {
+    return x2[i*n+j];
+  }
+
+  /// Actual model
+  OrthoLatinSquare(const Options& opt)
+    : n(opt.size),
+      x1(this,n*n,1,n), x2(this,n*n,1,n) {
+    const int nn = n*n;
+    IntVarArray z(this,nn,0,n*n-1);
+
+    distinct(this, z, opt.icl);
+    // Connect
+    {
+      IntArgs mod(n*n);
+      IntArgs div(n*n);
+      for (int i=0; i<n; i++)
+	for (int j=0; j<n; j++) {
+	  mod[i*n+j] = j+1;
+	  div[i*n+j] = i+1;
+	}
+      for (int i = nn; i--; ) {
+	element(this, div, z[i], x2[i]);
+	element(this, mod, z[i], x1[i]);
+      }
+    }
+
+    // Rows
+    for (int i = n; i--; ) {
+      IntVarArgs ry(n);
+      for (int j = n; j--; )
+	ry[j] = y1(i,j);
+      distinct(this, ry, opt.icl);
+      for (int j = n; j--; )
+	ry[j] = y2(i,j);
+      distinct(this, ry, opt.icl);
+    }
+    for (int j = n; j--; ) {
+      IntVarArgs cy(n);
+      for (int i = n; i--; )
+	cy[i] = y1(i,j);
+      distinct(this, cy, opt.icl);
+      for (int i = n; i--; )
+	cy[i] = y2(i,j);
+      distinct(this, cy, opt.icl);
+    }
+
+    for (int i = 1; i<n; i++) {
+      IntVarArgs ry1(n);
+      IntVarArgs ry2(n);
+      for (int j = n; j--; ) {
+	ry1[j] = y1(i-1,j);
+	ry2[j] = y2(i,j);
+      }
+      rel(this, ry1, IRT_GQ, ry2);
+    }
+
+    branch(this, z, BVAR_SIZE_MIN, BVAL_SPLIT_MIN);
+  }
+
+  /// Constructor for cloning \a s
+  OrthoLatinSquare(bool share, OrthoLatinSquare& s)
+    : Example(share,s), n(s.n) {
+      x1.update(this, share, s.x1);
+      x2.update(this, share, s.x2);
+  }
+
+  /// Copy during cloning
+  virtual Space*
+  copy(bool share) {
+    return new OrthoLatinSquare(share,*this);
+  }
+  /// Print solution
+  virtual void
+  print(void) {
+    for (int i = 0; i<n; i++) {
+      std::cout << "\t";
+      for (int j = 0; j<n; j++) {
+	std::cout.width(2);
+	std::cout << y1(i,j) << "  ";
+      }
+      std::cout << std::endl;
+    }
+    std::cout << std::endl;
+    for (int i = 0; i<n; i++) {
+      std::cout << "\t";
+      for (int j = 0; j<n; j++) {
+	std::cout.width(2);
+	std::cout << y2(i,j) << "  ";
+      }
+      std::cout << std::endl;
+    }
+    std::cout << std::endl;
+  }
+
+};
+
+/**
+ * \brief Main function
+ * \relates OrthoLatinSquare
+ */
+int
+main(int argc, char** argv) {
+  Options opt("OrthoLatinSquare");
+  opt.size = 7;
+  opt.icl  = ICL_DOM;
+  opt.parse(argc,argv);
+  Example::run<OrthoLatinSquare,DFS>(opt);
+  return 0;
+}
+
+// STATISTICS: example-any
+