gecoder-with-gecode 0.9.0 → 0.9.1

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

@@ -0,0 +1,220 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2001
+ *
+ *  Last modified:
+ *     $Date: 2007-11-30 13:58:34 +0100 (Fri, 30 Nov 2007) $ by $Author: tack $
+ *     $Revision: 5524 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include "examples/support.hh"
+#include "gecode/minimodel.hh"
+
+/// Base-class for Knights tour example
+class Knights : public Example {
+protected:
+  /// Size of board
+  const int n;
+  /// Maps board field to successor field
+  IntVarArray succ;
+public:
+  /// Propagation to use for model
+  enum {
+    PROP_REIFIED, ///< Use reified constraints
+    PROP_CIRCUIT  ///< Use single circuit constraints
+  };
+  /// Return field at position \a x, \a y
+  int
+  field(int x, int y) {
+    return x*n+y;
+  }
+  /// Compute array of neighbours
+  void
+  neighbours(int f, int nbs[8], int& n_nbs) {
+    n_nbs=0;
+    int x = f / n;
+    int y = f % n;
+    for (int i=0;i<8;i++) {
+      static const int moves[8][2] = {
+        {-2,-1}, {-2,1}, {-1,-2}, {-1,2}, {1,-2}, {1,2}, {2,-1}, {2,1}
+      };
+      int nx=x+moves[i][0];
+      int ny=y+moves[i][1];
+      if ((nx >= 0) && (nx < n) && (ny >= 0) && (ny < n))
+        nbs[n_nbs++]=field(nx,ny);
+    }
+  }
+  /// Constructor
+  Knights(const SizeOptions& opt)
+    : n(opt.size()), succ(this,n*n,0,n*n-1) {}
+  /// Constructor for cloning \a s
+  Knights(bool share, Knights& s) : Example(share,s), n(s.n) {
+    succ.update(this, share, s.succ);
+  }
+  /// Print board
+  virtual void
+  print(std::ostream& os) {
+    int* jump = new int[n*n];
+    {
+      int j=0;
+      for (int i=0; i<n*n; i++) {
+        jump[j]=i; j=succ[j].min();
+      }
+    }
+    os << "\t";
+    for (int i = 0; i < n; i++) {
+      for (int j = 0; j < n; j++) {
+        os.width(3);
+        os << jump[field(i,j)] << " ";
+        }
+        os << std::endl << "\t";
+    }
+    os << std::endl;
+    delete [] jump;
+  }
+};
+
+/**
+ * \brief %Example: n-%Knights tour (Simple Model)
+ *
+ * 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 ExProblem
+ *
+ */
+class KnightsReified : public Knights {
+public:
+  KnightsReified(const SizeOptions& opt) : Knights(opt) {
+    const int nn = n*n;
+
+    // Map knight to its predecessor of succesor on board
+    IntVarArgs jump(nn);
+    IntVarArgs pred(nn);
+
+    for (int i = nn; i--; ) {
+      IntVar p(this,0,nn-1); pred[i]=p;
+      IntVar j(this,0,nn-1); jump[i]=j;
+    }
+
+    // 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());
+    channel(this, succ, pred, opt.icl());
+
+    for (int f = 0; f < nn; f++) {
+      // Array of neighbours
+      int nbs[8]; int n_nbs = 0;
+      neighbours(f, nbs, n_nbs);
+      for (int i=n_nbs; i--; )
+        rel(this,
+            post(this, ~(jump[nbs[i]]-jump[f] == 1)),
+            BOT_XOR,
+            post(this, ~(jump[nbs[i]]-jump[f] == 1-nn)),
+            post(this, ~(succ[f] == nbs[i])));
+
+      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, INT_VAR_NONE, INT_VAL_MIN);
+  }
+  /// Constructor for cloning \a s
+  KnightsReified(bool share, KnightsReified& s) : Knights(share,s) {}
+  /// Copy during cloning
+  virtual Space*
+  copy(bool share) {
+    return new KnightsReified(share,*this);
+  }
+};
+
+/**
+ * \brief %Example: n-%Knights tour (Model using Circuit)
+ *
+ * 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).
+ *
+ * \ingroup ExProblem
+ *
+ */
+class KnightsCircuit : public Knights {
+public:
+  KnightsCircuit(const SizeOptions& opt) : Knights(opt) {
+    // Fix the first move
+    rel(this, succ[0], IRT_EQ, field(1,2));
+
+    circuit(this, succ, opt.icl());
+
+    for (int f = 0; f < n*n; f++) {
+      // Array of neighbours
+      int nbs[8]; int n_nbs = 0;
+      neighbours(f, nbs, n_nbs);
+      IntSet ds(nbs, n_nbs);
+      dom(this, succ[f], ds);
+    }
+    branch(this, succ, INT_VAR_NONE, INT_VAL_MIN);
+  }
+  /// Constructor for cloning \a s
+  KnightsCircuit(bool share, KnightsCircuit& s) : Knights(share,s) {}
+  /// Copy during cloning
+  virtual Space*
+  copy(bool share) {
+    return new KnightsCircuit(share,*this);
+  }
+};
+
+/** \brief Main-function
+ *  \relates Knights
+ */
+int
+main(int argc, char* argv[]) {
+  SizeOptions opt("Knights");
+  opt.iterations(100);
+  opt.size(8);
+  opt.propagation(Knights::PROP_CIRCUIT);
+  opt.propagation(Knights::PROP_REIFIED, "reified");
+  opt.propagation(Knights::PROP_CIRCUIT, "circuit");
+  opt.parse(argc,argv);
+  if (opt.propagation() == Knights::PROP_REIFIED) {
+    Example::run<KnightsReified,DFS,SizeOptions>(opt);
+  } else {
+    Example::run<KnightsCircuit,DFS,SizeOptions>(opt);
+  }
+  return 0;
+}
+
+// STATISTICS: example-any
+

data/ext/gecode-2.2.0/examples/langford-number.cc

@@ -0,0 +1,225 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Patrick Pekczynski <pekczynski@ps.uni-sb.de>
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Patrick Pekczynski, 2004
+ *     Mikael Lagerkvist, 2006
+ *     Christian Schulte, 2007
+ *
+ *  Last modified:
+ *     $Date: 2008-07-30 22:00:09 +0200 (Wed, 30 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7474 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */        
+
+#include "examples/support.hh"
+#include "gecode/minimodel.hh"
+
+/**
+ * \brief Options taking two additional parameters
+ *
+ * \relates LangfordNumber
+ */
+class LangfordNumberOptions : public Options {
+public:
+  int k, n; /// Parameters to be given on the command line
+  /// Initialize options for example with name \a s
+  LangfordNumberOptions(const char* s, int k0, int n0) 
+    : Options(s), k(k0), n(n0) {}
+  /// Parse options from arguments \a argv (number is \a argc)
+  void parse(int& argc, char* argv[]) {
+    Options::parse(argc,argv);
+    if (argc < 3)
+      return;
+    n = atoi(argv[1]);
+    k = atoi(argv[2]);
+  }
+  /// Print help message
+  virtual void help(void) {
+    Options::help();
+    std::cerr << "\t(unsigned int) default: " << n << std::endl
+              << "\t\tparameter n" << std::endl
+              << "\t(unsigned int) default: " << k << std::endl
+              << "\t\tparameter k" << std::endl;
+  }
+};
+
+/**
+ * \brief %Example: Langford's number problem
+ *
+ * See problem 24 at http://www.csplib.org/.
+ *
+ * \ingroup ExProblem
+ */
+class LangfordNumber : public Example {
+protected:
+  int k, n;      ///< Problem parameters
+  IntVarArray y; ///< Sequence variables
+
+public:
+  /// Propagation to use for model
+  enum {
+    PROP_REIFIED,            ///< Use reified constraints
+    PROP_EXTENSIONAL,        ///< Use extensional constraints
+    PROP_EXTENSIONAL_CHANNEL ///< Use extensional and channel constraints
+  };
+  /// Construct model
+  LangfordNumber(const LangfordNumberOptions& opt)
+    : k(opt.k), n(opt.n), y(this,k*n,1,n) {
+
+    switch (opt.propagation()) {
+    case PROP_REIFIED:
+      {
+        /// Position of values in sequence
+        IntVarArgs p(k*n);
+        for (int i=k*n; i--; )
+          p[i].init(this,0,k*n-1);
+        
+        /* 
+         * The occurences of v in the Langford sequence are v numbers apart.
+         *
+         * Let \#(i, v) denote the position of the i-th occurence of 
+         * value v in the Langford Sequence. Then 
+         *
+         * \f$ \forall i, j \in \{1, \dots, k\}, i \neq j:
+         *     \forall v \in \{1, \dots, n\}: \#(i, v) + (v + 1) = \#(j, v)\f$
+         *
+         */
+        for (int i=n; i--; )
+          for (int j=k-1; j--; )
+            post(this, p[i*k+j] + (i+2) == p[i*k+j+1]);
+        
+        distinct(this, p, opt.icl());
+        
+        // Channel positions <-> values
+        for (int i=n; i--; )
+          for (int j=k; j--; )
+            element(this, y, p[i*k+j], i+1);
+      }
+      break;
+    case PROP_EXTENSIONAL:
+      {
+        IntArgs a(n-1);
+        for (int v=2; v<=n; v++)
+          a[v-2]=v;
+        for (int v=1; v<=n; v++) {
+          // Construct regular expression for all symbols but v
+          if (v > 1)
+            a[v-2]=v-1;
+          REG ra(a), rv(v);
+          extensional(this, y, *ra+rv+(ra(v,v)+rv)(k-1,k-1)+*ra);
+        }
+      }
+      break;
+    case PROP_EXTENSIONAL_CHANNEL:
+      {
+        // Boolean variables for channeling
+        BoolVarArgs b(k*n*n);
+        for (int i=n*n*k; i--; )
+          b[i].init(this,0,1);
+        
+        // Post channel constraints
+        for (int i=n*k; i--; ) {
+          BoolVarArgs c(n);
+          for (int j=n; j--; ) 
+            c[j]=b[i*n+j];
+          channel(this, c, y[i], 1);
+        }
+        
+        // For placing two numbers three steps apart, we construct the
+        // regular expression 0*100010*, and apply it to the projection of
+        // the sequence on the value.
+        REG r0(0), r1(1);
+        for (int v=1; v<=n; v++) {
+          // Projection for value v
+          BoolVarArgs c(k*n);
+          for (int i = k*n; i--; )
+            c[i] = b[i*n+(v-1)];
+          extensional(this, c, *r0 + r1 + (r0(v,v) + r1)(k-1,k-1) + *r0);
+        }
+      }
+      break;
+    }
+      
+    // Symmetry breaking
+    rel(this, y[0], IRT_LE, y[n*k-1]);
+    
+    // Branching
+    branch(this, y, INT_VAR_SIZE_MIN, INT_VAL_MAX);
+  }
+
+  /// Print solution
+  virtual void print(std::ostream& os){
+    os << "\t" << y << std::endl;
+  }
+
+  /// Constructor for cloning \a l
+  LangfordNumber(bool share, LangfordNumber& l)
+    : Example(share, l), k(l.k), n(l.n) {
+    y.update(this, share, l.y);
+
+  }
+  /// Copy during cloning
+  virtual Space*
+  copy(bool share) {
+    return new LangfordNumber(share, *this);
+  }
+};
+
+
+/** \brief Main-function
+ *  \relates LangfordNumber
+ */
+int 
+main(int argc, char* argv[]) {
+  LangfordNumberOptions opt("Langford Numbers",3,9);
+  opt.icl(ICL_DOM);
+  opt.propagation(LangfordNumber::PROP_EXTENSIONAL_CHANNEL);
+  opt.propagation(LangfordNumber::PROP_REIFIED, 
+                  "reified");
+  opt.propagation(LangfordNumber::PROP_EXTENSIONAL, 
+                  "extensional");
+  opt.propagation(LangfordNumber::PROP_EXTENSIONAL_CHANNEL, 
+                  "extensional-channel");
+  opt.parse(argc, argv);
+  if (opt.k < 1) {
+    std::cerr << "k must be at least 1!" << std::endl;
+    return 1;
+  }
+  if (opt.k > opt.n) {
+    std::cerr << "n must be at least k!" << std::endl;
+    return 1;
+  }
+  Example::run<LangfordNumber,DFS,LangfordNumberOptions>(opt);
+  return 0;
+}
+
+// STATISTICS: example-any
+

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

@@ -0,0 +1,146 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2001
+ *     Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2007-11-30 13:58:34 +0100 (Fri, 30 Nov 2007) $ by $Author: tack $
+ *     $Revision: 5524 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#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.
+ *
+ * See problem 19 at http://www.csplib.org/.
+ *
+ * \ingroup ExProblem
+ *
+ */
+class MagicSequence : public Example {
+private:
+  /// Length of sequence
+  const int n;
+  /// Sequence
+  IntVarArray s;
+public:
+  /// Propagation to use for model
+  enum {
+    PROP_REIFIED, ///< Use reified constraints
+    PROP_COUNT,   ///< Use count constraints
+    PROP_GCC      ///< Use single global cardinality constraint
+  };
+  /// 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 SizeOptions& opt)
+    : n(opt.size()), s(this,n,0,n-1) {
+    switch (opt.propagation()) {
+    case PROP_REIFIED:
+      for (int i=n; i--; )
+        exactly(s, s[i], i);
+      linear(this, s, IRT_EQ, n);
+      break;
+    case PROP_COUNT:
+      for (int i=n; i--; )
+        count(this, s, i, IRT_EQ, s[i]);
+      linear(this, s, IRT_EQ, n);
+      break;
+    case PROP_GCC:
+      count(this, s, s, opt.icl());
+      break;
+    }
+    IntArgs c(n);
+    for (int j = n; j--; )
+      c[j] = j-1;
+    linear(this, c, s, IRT_EQ, 0);
+    branch(this, s, INT_VAR_NONE, INT_VAL_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(std::ostream& os) {
+    os << "\t";
+    for (int i = 0; i<n; i++) {
+      os << s[i] << ", ";
+      if ((i+1) % 20 == 0)
+        os << std::endl << "\t";
+    }
+    os << std::endl;
+  }
+
+};
+
+/** \brief Main-function
+ *  \relates MagicSequence
+ */
+int
+main(int argc, char* argv[]) {
+  SizeOptions opt("MagicSequence");
+  opt.solutions(0);
+  opt.iterations(4);
+  opt.size(500);
+  opt.propagation(MagicSequence::PROP_COUNT);
+  opt.propagation(MagicSequence::PROP_REIFIED, "reified");
+  opt.propagation(MagicSequence::PROP_COUNT,   "count");
+  opt.propagation(MagicSequence::PROP_GCC,     "gcc");
+  opt.parse(argc,argv);
+  Example::run<MagicSequence,DFS,SizeOptions>(opt);
+  return 0;
+}
+
+// STATISTICS: example-any
+