gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/examples/all-interval-sort.cc

@@ -0,0 +1,201 @@
+/*
+ *  Main authors:
+ *     Patrick Pekczynski <pekczynski@ps.uni-sb.de>
+ *
+ *  Copyright:
+ *     Patrick Pekczynski, 2005
+ *
+ *  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.
+ *
+ */	
+
+/**
+ * \brief %Example: %All-Interval Series
+ *
+ * This is  prob007 in the category "combinatorial mathematics" of
+ * http://www.csplib.org/.
+ *
+ * \ingroup Example
+ */
+
+#include "examples/support.hh"
+#include "gecode/minimodel.hh"
+
+class AllInterval : public Example {
+private:
+  int n;
+  IntVarArray x;
+  IntVarArray d;
+public:
+
+  /**
+   * \brief Constrain x to be a permuation of \f$ S_n = \{0, \dots, n - 1\} \f$
+   *
+   * \f$ \forall i, j\in S_n, i\neq j: x_i \neq x_j\f$
+   */
+  void adiff_sn(Space* home, IntVarArray& x) {
+
+    // S_n = \{0, \dots, n - 1\}
+    IntVarArray sn(home, n);
+
+    for (int i = n; i--; ) {
+      sn[i].init(home, i, i);
+    }
+
+    sortedness(home, x, sn);
+  }
+
+  /**
+   * \brief Constrain x to be a permuation of \f$ S^*_n = S_n \setminus \{0\} \f$
+   *
+   * \f$ \forall i, j\in S^*_n, i\neq j: x_i \neq x_j\f$
+   */
+  void adiff_sn_star(Space* home, IntVarArray& x) {
+    // S^*_n = S_n \setminus \{0\} = \{1, \dots, n - 1\}
+    IntVarArray snstar(home, n - 1);
+
+    for (int i = n - 1; i--; ) {
+      snstar[i].init(home, i + 1, i + 1);
+    }
+    sortedness(home, x, snstar);
+  }
+
+  /**
+   * \brief Constrain d to hold the differences of neighboured x-variables
+   *
+   * \f$ \forall i \in S^*_n: d_i = |x_i - x_{i - 1}|\f$
+   */
+  void difference(Space* home, IntVarArray& x, IntVarArray& d) {
+
+    IntVarArray diff(this, n - 1);
+    for (int i = 0; i < n - 1; i++) {
+      diff[i].init(this, 1 - n, n - 1);
+    }
+
+    for (int i = 0; i < n - 1; i++) {
+      post(this, x[i + 1] - x[i] == diff[i]);
+      abs(this, diff[i], d[i]);
+    }
+  }
+
+  /**
+   * \name Static Symmetrie Breaking
+   *
+   * This is taken from: I.P. Gent and I. McDonald and B.M. Smith,
+   * Conditional Symmetry in the All-Interval Series Problem,
+   * Proceedings of the Third International Workshop
+   * on Symmetry in Constraint Satisfaction Problems, pages 55-65, 2003.
+   *
+   */
+
+  //@{
+  /*
+   * \brief Break negation symmetry
+   *
+   *  As we are intereseted in the absolute value of the difference of neighbored values in x
+   *  the following holds:
+   *  If the sequence \f$ \sigma = \langle s_0, \dots, s_{n - 1} \rangle \f$ is a solution to
+   *  the problem so is the negated sequence
+   *  \f$ \phi = \langle (n - 1 - s_0), \dots, (n - 1) - s_{n - 1}\f$. \n
+   */
+  void break_negation(Space* home, IntVarArray& x) {
+    rel(home, x[0], IRT_LE, x[1]);
+  }
+
+  /*
+   * \brief Break reveres symmetry
+   *
+   *  If the sequence \f$ \sigma = \langle s_0, \dots, s_{n - 1} \rangle \f$ is a solution
+   *  so is the reverse sequence \f$\sigma^{-1} = \langle s_{n - 1}, \dots, s_0 \rangle \f$
+   */
+
+  void break_reversal(Space* home, IntVarArray& d) {
+    rel(home, d[0], IRT_LE, d[n - 2]);
+  }
+  //@}
+
+  AllInterval(const Options& op) :
+    n(op.size),
+    x(this, n),
+    d(this, n - 1) {
+
+    IntSet dom_zn   (0, n - 1);
+    IntSet dom_zns  (1, n - 1);
+
+    // initialization of the problem variables
+    for (int i = 0; i < n; i++) {
+      x[i].init(this, dom_zn);
+      if (i < n - 1)
+	d[i].init(this, dom_zns);
+    }
+
+    difference(this, x, d);
+
+    // breaks negation
+    break_negation(this, x);
+
+    // breaks reversal
+    break_reversal(this, d);
+
+
+    adiff_sn(this, x);
+    adiff_sn_star(this, d);
+
+    branch(this, x, BVAR_SIZE_MIN, BVAL_MIN);
+
+  }
+
+  AllInterval(bool share, AllInterval& a)
+    : Example(share, a),
+      n(a.n) {
+    x.update(this, share, a.x);
+    d.update(this, share, a.d);
+  }
+
+  virtual Space*
+  copy(bool share) {
+    return new AllInterval(share, *this);
+  }
+
+  virtual void print(void){
+    std::cout << "Sol:\n";
+    std::cout << "x: ";
+    for (int i = 0; i < n; i++) {
+      std::cout << x[i] << " ";
+    }
+    std::cout <<"\n";
+
+    std::cout << "d: ";
+    for (int i = 0; i < n - 1; i++) {
+      std::cout << d[i] << " ";
+    }
+    std::cout <<"\n";
+
+  }
+};
+
+
+int main(int argc, char** argv){
+  Options opt("All-Interval Series ");
+  opt.size = 12;
+  opt.parse(argc, argv);
+  if (opt.size < 2) {
+    std::cerr << "n must be at least 2!" << std::endl;
+    return -1;
+  }
+  Example::run<AllInterval, DFS>(opt);
+  return 0;
+}
+
+// STATISTICS: example-any
+

data/ext/gecode-1.3.1/examples/all-interval.cc

@@ -0,0 +1,114 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2006
+ *
+ *  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"
+
+#include <cstdlib>
+
+/**
+ * \brief %Example: All-interval Series
+ *
+ * An all-interval series of length \f$n\f$ is a sequence
+ * \f[
+ * (x_0,x_1,\ldots,n_{n-1})
+ * \f]
+ * where each \f$x_i\f$ is an integer between \f$0\f$ and \f$n-1\f$
+ * such that the following conditions hold:
+ *  - the \f$x_i\f$ are a permutation of \f$\{0,1,\ldots,n-1\}\f$
+ *    (that is, they are pairwise distinct and take values from
+ *    \f$\{0,1,\ldots,n-1\}\f$).
+ *  - the differences between adjacent values \f$(d_1,d_2,\ldots,d_{n-1})\f$
+ *    with \f$d_i=\operatorname{abs}(x_i-x_{i-1})\f$ form a permutation of
+ *    \f$\{1,2,\ldots,n-1\}\f$.
+ *
+ * Read more about this problem as prob007 in the category
+ * "combinatorial mathematics" of http://www.csplib.org/.
+ *
+ * \ingroup Example
+ */
+class AllInterval : public Example {
+private:
+  /// The numbers
+  IntVarArray x;
+public:
+  /// Actual model
+  AllInterval(const Options& opt) :
+    x(this, opt.size, 0, opt.size - 1) {
+    const int n = x.size();
+
+    IntVarArgs d(n-1);
+
+    // Set up variables for distance
+    for (int i=0; i<n-1; i++)
+      d[i] = abs(this, minus(this,x[i+1],x[i],opt.icl),opt.icl);
+
+    // Constrain them to be between 1 and n-1
+    dom(this, d, 1, n-1);
+
+    distinct(this, x, opt.icl);
+    distinct(this, d, opt.icl);
+
+    // Break mirror symmetry
+    rel(this, x[0], IRT_LE, x[1]);
+    // Break symmetry of dual solution
+    rel(this, d[0], IRT_GR, d[n-2]);
+
+    branch(this, x, BVAR_SIZE_MIN, BVAL_SPLIT_MIN);
+  }
+  /// Constructor for cloning \a e
+  AllInterval(bool share, AllInterval& e)
+    : Example(share, e) {
+    x.update(this, share, e.x);
+  }
+  /// Copy during cloning
+  virtual Space*
+  copy(bool share) {
+    return new AllInterval(share, *this);
+  }
+  /// Print solution
+  virtual void
+  print(void) {
+    const int n = x.size();
+    std::cout << "\tx[" << n << "] = {";
+    for (int i = 0; i < n-1; i++)
+      std::cout << x[i] << "(" << abs(x[i+1].val()-x[i].val()) << "),";
+    std::cout << x[n-1] << "}" << std::endl;
+  }
+};
+
+
+int main(int argc, char** argv){
+  Options opt("All-interval Series");
+  opt.size       = 1000;
+  opt.iterations = 5;
+  opt.icl        = ICL_BND;
+  opt.parse(argc, argv);
+  if (opt.size < 2) {
+    std::cerr << "n must be at least 2!" << std::endl;
+    return -1;
+  }
+  Example::run<AllInterval,DFS>(opt);
+  return 0;
+}
+
+// STATISTICS: example-any
+

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

@@ -0,0 +1,112 @@
+/*
+ *  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: %Alpha puzzle
+ *
+ * Well-known cryptoarithmetic puzzle of unknown origin.
+ *
+ * \ingroup Example
+ *
+ */
+class Alpha : public Example {
+protected:
+  /// Alphabet has 26 letters
+  static const int n = 26;
+  /// Array for letters
+  IntVarArray      le;
+public:
+  /// Actual model
+  Alpha(const Options& opt) : le(this,n,1,n) {
+    IntVar
+      a(le[ 0]), b(le[ 1]), c(le[ 2]), e(le[ 4]), f(le[ 5]),
+      g(le[ 6]), h(le[ 7]), i(le[ 8]), j(le[ 9]), k(le[10]),
+      l(le[11]), m(le[12]), n(le[13]), o(le[14]), p(le[15]),
+      q(le[16]), r(le[17]), s(le[18]), t(le[19]), u(le[20]),
+      v(le[21]), w(le[22]), x(le[23]), y(le[24]), z(le[25]);
+
+    post(this, b+a+l+l+e+t       == 45,  opt.icl);
+    post(this, c+e+l+l+o         == 43,  opt.icl);
+    post(this, c+o+n+c+e+r+t     == 74,  opt.icl);
+    post(this, f+l+u+t+e         == 30,  opt.icl);
+    post(this, f+u+g+u+e         == 50,  opt.icl);
+    post(this, g+l+e+e           == 66,  opt.icl);
+    post(this, j+a+z+z           == 58,  opt.icl);
+    post(this, l+y+r+e           == 47,  opt.icl);
+    post(this, o+b+o+e           == 53,  opt.icl);
+    post(this, o+p+e+r+a         == 65,  opt.icl);
+    post(this, p+o+l+k+a         == 59,  opt.icl);
+    post(this, q+u+a+r+t+e+t     == 50,  opt.icl);
+    post(this, s+a+x+o+p+h+o+n+e == 134, opt.icl);
+    post(this, s+c+a+l+e         == 51,  opt.icl);
+    post(this, s+o+l+o           == 37,  opt.icl);
+    post(this, s+o+n+g           == 61,  opt.icl);
+    post(this, s+o+p+r+a+n+o     == 82,  opt.icl);
+    post(this, t+h+e+m+e         == 72,  opt.icl);
+    post(this, v+i+o+l+i+n       == 100, opt.icl);
+    post(this, w+a+l+t+z         == 34,  opt.icl);
+
+    distinct(this, le, opt.icl);
+
+    branch(this, le, opt.naive ? BVAR_NONE : BVAR_SIZE_MIN, BVAL_MIN);
+  }
+
+  /// Constructor for cloning \a s
+  Alpha(bool share, Alpha& s) : Example(share,s) {
+    le.update(this, share, s.le);
+  }
+  /// Copy during cloning
+  virtual Space*
+  copy(bool share) {
+    return new Alpha(share,*this);
+  }
+  /// Print solution
+  virtual void
+  print(void) {
+    std::cout << "\t";
+    for (int i = 0; i < n; i++) {
+      std::cout << ((char) (i+'a')) << '=' << le[i] << ((i<n-1)?", ":"\n");
+      if ((i+1) % 8 == 0)
+	std::cout << std::endl << "\t";
+    }
+    std::cout << std::endl;
+  }
+};
+
+/** \brief Main-function
+ *  \relates Alpha
+ */
+int
+main(int argc, char** argv) {
+  Options opt("Alpha");
+  opt.solutions  = 0;
+  opt.iterations = 10;
+  opt.naive      = true;
+  opt.parse(argc,argv);
+  Example::run<Alpha,DFS>(opt);
+  return 0;
+}
+
+// STATISTICS: example-any
+

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

@@ -0,0 +1,71 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2006
+ *
+ *  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 "examples/support.hh"
+
+/**
+ * \brief %Example: Baseline test
+ *
+ * \ingroup Example
+ *
+ */
+class Baseline : public Example {
+protected:
+  /// Variables
+  IntVarArray x;
+public:
+  /// The actual problem
+  Baseline(const Options& opt)
+    : x(this,1,0,1) {
+    branch(this, x, BVAR_NONE, BVAL_MIN);
+  }
+
+  /// Constructor for cloning \a s
+  Baseline(bool share, Baseline& s) : Example(share,s) {
+    x.update(this, share, s.x);
+  }
+
+  /// Perform copying during cloning
+  virtual Space*
+  copy(bool share) {
+    return new Baseline(share,*this);
+  }
+
+  /// Print solution
+  virtual void
+  print(void) {}
+};
+
+/** \brief Main-function
+ *  \relates Baseline
+ */
+int
+main(int argc, char** argv) {
+  Options opt("Baseline");
+  opt.iterations = 2000;
+  opt.solutions  = 0;
+  opt.parse(argc,argv);
+  Example::run<Baseline,DFS>(opt);
+  return 0;
+}
+
+// STATISTICS: example-any
+