gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/examples/donald.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: DONALD+GERALD=ROBERT puzzle
+ *
+ * Well-known cryptoarithmetic puzzle of unknown origin.
+ *
+ * \ingroup Example
+ *
+ */
+class Donald : public Example {
+private:
+  /// Number of letters
+  static const int nl = 10;
+  /// Array of letters
+  IntVarArray le;
+public:
+  Donald(const Options& opt) :
+    le(this,nl,0,9) {
+    IntVar
+      d(le[0]), o(le[1]), n(le[2]), a(le[3]), l(le[4]),
+      g(le[5]), e(le[6]), r(le[7]), b(le[8]), t(le[9]);
+    rel(this, d, IRT_NQ, 0);
+    rel(this, g, IRT_NQ, 0);
+    rel(this, r, IRT_NQ, 0);
+
+    post(this,    100000*d+10000*o+1000*n+100*a+10*l+d
+                + 100000*g+10000*e+1000*r+100*a+10*l+d
+	       == 100000*r+10000*o+1000*b+100*e+10*r+t,
+	 opt.icl);
+
+    distinct(this, le, opt.icl);
+
+    branch(this, le, BVAR_SIZE_MIN, BVAL_MIN);
+  }
+
+  Donald(bool share, Donald& s) : Example(share,s) {
+    le.update(this, share, s.le);
+  }
+
+  virtual Space*
+  copy(bool share) {
+    return new Donald(share,*this);
+  }
+
+  virtual void
+  print(void) {
+    std::cout << "\t";
+    for (int i = 0; i < nl; i++)
+      std::cout << le[i] << ' ';
+    std::cout << std::endl;
+  }
+
+};
+
+
+/** \brief Main-function
+ *  \relates Donald
+ */
+int
+main(int argc, char** argv) {
+  Options opt("Donald+Gerald=Robert");
+  opt.solutions  = 0;
+  opt.iterations = 1500;
+  opt.parse(argc,argv);
+  Example::run<Donald,DFS>(opt);
+  return 0;
+}
+
+// STATISTICS: example-any
+

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

@@ -0,0 +1,111 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2001
+ *
+ *  Last modified:
+ *     $Date: 2006-03-09 11:12:26 +0100 (Thu, 09 Mar 2006) $ by $Author: zayenz $
+ *     $Revision: 3063 $
+ *
+ *  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: Solving 20 linear equations
+ *
+ * Standard benchmark for solving linear equations.
+ *
+ * \ingroup Example
+ *
+ */
+class Eq20 : public Example {
+private:
+  /// Number of variables
+  static const int x_n = 7;
+  /// Number of equations
+  static const int e_n = 20;
+  /// Variables
+  IntVarArray x;
+public:
+  /// The actual problem
+  Eq20(const Options& opt)
+    : x(this,x_n,0,10) {
+    // Coefficients and constants for the equations
+    int eqs[e_n][x_n+1] = {
+      {876370, -16105, 62397, -6704, 43340, 95100, -68610, 58301},
+      {533909, 51637, 67761, 95951, 3834, -96722, 59190, 15280},
+      {915683, 1671, -34121, 10763, 80609, 42532, 93520, -33488},
+      {129768, 71202, -11119, 73017, -38875, -14413, -29234, 72370},
+      {752447, 8874, -58412, 73947, 17147, 62335, 16005, 8632},
+      {90614, 85268, 54180, -18810, -48219, 6013, 78169, -79785},
+      {1198280, -45086, 51830, -4578, 96120, 21231, 97919, 65651},
+      {18465, -64919, 80460, 90840, -59624, -75542, 25145, -47935},
+      {1503588, -43277, 43525, 92298, 58630, 92590, -9372, -60227},
+      {1244857, -16835, 47385, 97715, -12640, 69028, 76212, -81102},
+      {1410723, -60301, 31227, 93951, 73889, 81526, -72702, 68026},
+      {25334, 94016, -82071, 35961, 66597, -30705, -44404, -38304},
+      {277271, -67456, 84750, -51553, 21239, 81675, -99395, -4254},
+      {249912, -85698, 29958, 57308, 48789, -78219, 4657, 34539},
+      {373854, 85176, -95332, -1268, 57898, 15883, 50547, 83287},
+      {740061, -10343, 87758, -11782, 19346, 70072, -36991, 44529},
+      {146074, 49149, 52871, -7132, 56728, -33576, -49530, -62089},
+      {251591, -60113, 29475, 34421, -76870, 62646, 29278, -15212},
+      {22167, 87059, -29101, -5513, -21219, 22128, 7276, 57308},
+      {821228, -76706, 98205, 23445, 67921, 24111, -48614, -41906}
+    };
+    // Post equation constraints
+    for (int i = e_n; i--; ) {
+      IntArgs c(7,eqs[i][1],eqs[i][2],eqs[i][3],eqs[i][4],
+		eqs[i][5],eqs[i][6],eqs[i][7]);
+      linear(this, c, x, IRT_EQ, eqs[i][0], opt.icl);
+    }
+    branch(this, x, BVAR_NONE, BVAL_MIN);
+  }
+
+  /// Constructor for cloning \a s
+  Eq20(bool share, Eq20& s) : Example(share,s) {
+    x.update(this, share, s.x);
+  }
+  /// Perform copying during cloning
+  virtual Space*
+  copy(bool share) {
+    return new Eq20(share,*this);
+  }
+  /// Print solution
+  virtual void
+  print(void) {
+    std::cout << "\tx[] = {";
+    for (int i = 0; i < x_n; i++)
+      std::cout << x[i] << ((i<x_n-1)?",":"};\n");
+  }
+
+};
+
+/** \brief Main-function
+ *  \relates Eq20
+ */
+int
+main(int argc, char** argv) {
+  Options opt("Eq20");
+  opt.solutions  = 0;
+  opt.iterations = 1000;
+  opt.parse(argc,argv);
+  Example::run<Eq20,DFS>(opt);
+  return 0;
+}
+
+
+
+// STATISTICS: example-any
+

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

@@ -0,0 +1,242 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *     Guido Tack, 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 "gecode/set.hh"
+#include "examples/support.hh"
+
+/**
+ * \name Parameters for golf tournaments
+ *
+ * \relates Golf
+ */
+//@{
+/// Tournament parameters
+struct Tournament {
+  /// Number of groups
+  int groups;
+  /// Number of players in each group
+  int playersInGroup;
+  /// Number of weeks
+  int weeks;
+};
+/// Tournaments
+static const Tournament t[]=
+  { {8,4,9},
+    {5,3,7},
+    {4,3,2}
+  };
+/// Number of tournaments
+static const unsigned int n_examples = sizeof(t) / sizeof(Tournament);
+//@}
+
+/**
+ * \brief %Example: Golf tournament
+ *
+ * Schedule a golf tournament. This is problem 010 from csplib.
+ *
+ * \ingroup Example
+ *
+ */
+class Golf : public Example {
+public:
+  int groups;
+  int playersInGroup;
+  int weeks;
+  int players;
+
+  SetVarArray groupsS;
+  IntVarArray groupsSInv;
+
+  SetVar& group(int w, int g) {
+    return groupsS[w*groups+g];
+  }
+  IntVar& groupInv(int w, int p) {
+    return groupsSInv[w*players+p];
+  }
+
+  Golf(const Options& o) :
+    groups(t[o.size].groups),
+    playersInGroup(t[o.size].playersInGroup),
+    weeks(t[o.size].weeks),
+    players(groups*playersInGroup),
+    groupsS(this,groups*weeks,IntSet::empty,0,players-1,
+	    playersInGroup,playersInGroup),
+    groupsSInv(this, weeks*players, 0, groups-1) {
+
+    SetVar allPlayers(this, 0, players-1, 0, players-1);
+
+    // Groups in one week must be disjoint
+    for (int w=0; w<weeks; w++) {
+      SetVarArgs p(groups);
+      for (int g=0; g < groups; g++)
+       	p[g] = group(w,g);
+
+      rel(this,SOT_DUNION,p,allPlayers);
+    }
+
+    // No two golfers play in the same group more than once
+    for (int w=0; w<weeks; w++) {
+      for (int g=0; g<groups; g++) {
+      	SetVar v = group(w,g);
+      	for (int i=(w+1)*groups; i<weeks*groups; i++) {
+      	  SetVar atMostOne(this,IntSet::empty,0,players-1,0,1);
+	  rel(this, v, SOT_INTER, groupsS[i], SRT_EQ, atMostOne);
+      	}
+      }
+    }
+
+    if (!o.naive) {
+
+      //      atmostOne(this, groupsS, playersInGroup);
+
+      /*
+       * Redundant constraints and static symmetry breaking from
+       * "Solving Kirkman's Schoolgirl Problem in a Few Seconds"
+       * Nicolas Barnier, Pascal Brisset, Constraints, 10, 7-21, 2005
+       *
+       */
+
+      // Redundant constraint:
+      // in each week, one player plays in only one group
+      for (int w=0; w < weeks; w++) {
+ 	for (int p=0; p < players; p++) {
+ 	  BoolVarArgs bs(groups);
+ 	  for (int g=0; g<groups; g++) {
+	    BoolVar b(this,0,1);
+	    dom(this, group(w,g), SRT_SUP, p, b);
+	    bs[g] = b;
+	  }
+ 	  linear(this, bs, IRT_EQ, 1);
+ 	}
+       }
+
+      // Redundant constraint:
+      // any two groups has at most one player in common
+      atmostOne(this, groupsS, playersInGroup);
+
+      // Symmetry breaking: order groups
+      for (int w=0; w<weeks; w++) {
+	for (int g=0; g<groups-1; g++) {
+	  IntVar minG1(this, 0, players-1);
+	  IntVar minG2(this, 0, players-1);
+	  SetVar g1 = group(w,g);
+	  SetVar g2 = group(w,g+1);
+	  min(this, g1, minG1);
+	  min(this, g2, minG2);
+	  rel(this, minG1, IRT_LE, minG2);
+	}
+      }
+
+      // Symmetry breaking: order weeks
+      // minElem(group(w,0)\{0}) < minElem(group(w+1,0)\{0})
+      for (int w=0; w<weeks-1; w++) {
+	SetVar g1(this, IntSet::empty, 1, players-1);
+	SetVar g2(this, IntSet::empty, 1, players-1);
+	SetVar zero1(this, IntSet::empty,0,0);
+	SetVar zero2(this, IntSet::empty,0,0);
+	rel(this, g1, SOT_DUNION, zero1, SRT_EQ, group(w,0));
+	rel(this, g2, SOT_DUNION, zero2, SRT_EQ, group(w+1,0));
+	IntVar minG1(this, 0, players-1);
+	IntVar minG2(this, 0, players-1);
+	min(this, g1, minG1);
+	min(this, g2, minG2);
+	rel(this, minG1, IRT_LE, minG2);
+      }
+
+      // Initialize the dual variables:
+      // groupInv(w,p) is player p's group in week w
+      for (int w=0; w<weeks; w++) {
+	for (int p=0; p<players; p++) {
+	  SetVar thisPlayer(this, p,p, 0, players-1);
+	  SetVarArgs thisWeek(groups);
+	  for (int g=0; g<groups; g++)
+	    thisWeek[g] = group(w,g);
+	  selectSet(this, thisWeek, groupInv(w,p), thisPlayer);
+	}
+      }
+
+      // Symmetry breaking: order players
+      // For all p<groups : groupInv(w,p) <= p
+      for (int w=0; w<weeks; w++) {
+	for (int p=0; p<groups; p++) {
+	  rel(this, groupInv(w,p), IRT_LQ, p);
+	}
+      }
+
+    }
+
+    branch(this, groupsS, SETBVAR_MIN_UNKNOWN_ELEM, SETBVAL_MIN);
+  }
+
+  Golf(bool share, Golf& s) : Example(share,s),
+      groups(s.groups), playersInGroup(s.playersInGroup),
+      weeks(s.weeks), players(s.players) {
+    groupsS.update(this, share, s.groupsS);
+  }
+
+  virtual Space*
+  copy(bool share) {
+    return new Golf(share,*this);
+  }
+
+  virtual void
+  print(void) {
+
+    std::cout << "Tournament plan" << std::endl;
+
+    for (int w=0; w<weeks; w++) {
+      std::cout << "Week " << w << ": " << std::endl << "    ";
+      for (int g=0; g<groups; g++) {
+	SetVarGlbValues glb(group(w,g));
+	std::cout << "(" << glb.val();
+	++glb;
+	while(glb()) {
+	  std::cout << " " << glb.val();
+	  ++glb;
+	}
+	std::cout << ")";
+	if (g < groups-1) std::cout << " ";
+	if (g > 0 && g % 4 == 0) std::cout << std::endl << "    ";
+      }
+      std::cout << std::endl;
+    }
+
+  }
+};
+
+int
+main(int argc, char** argv) {
+  Options o("Golf");
+  o.parse(argc,argv);
+  o.solutions  = 1;
+  if (o.size >= n_examples) {
+    std::cerr << "Error: size must be between 0 and " << n_examples - 1
+	      << std::endl;
+    return 1;
+  }
+  Example::run<Golf,DFS>(o);
+  return 0;
+}
+
+// STATISTICS: example-any
+

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

@@ -0,0 +1,141 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2001
+ *
+ *  Last modified:
+ *     $Date: 2006-07-17 21:26:59 +0200 (Mon, 17 Jul 2006) $ by $Author: schulte $
+ *     $Revision: 3374 $
+ *
+ *  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: Finding optimal %Golomb rulers
+ *
+ * The script makes use of two lower bounds taken from:
+ *   Barbara Smith, Kostas Stergiou, Toby Walsh,
+ *   Modelling the Golomb Ruler Problem.
+ *   In IJCAI 99 Workshop on Non-binary Constraints,
+ *   1999.
+ *
+ * \ingroup Example
+ *
+ */
+class Golomb : public Example {
+protected:
+  /// Number of marks
+  const int n;
+  /// Array for ruler marks
+  IntVarArray m;
+public:
+  /// Return index for mark difference between mark \a i and mark \a j
+  int
+  diag(int i, int j) {
+    return (i*(2*n-i-1)) / 2 + j - i - 1;
+  }
+
+  /// Actual model
+  Golomb(const Options& opt)
+    : n(opt.size), m(this,n,0,n*n) {
+    const int dn = (n*n-n)/2;
+
+    IntVarArgs d(dn);
+
+    // Assume first mark to be zero
+    rel(this, m[0], IRT_EQ, 0);
+
+    // Setup difference constraints
+    for (int j=1; j<n; j++)
+      d[diag(0,j)] = m[j];
+    for (int i=1; i<n-1; i++)
+      for (int j=i+1; j<n; j++)
+	d[diag(i,j)] = minus(this, m[j], m[i]);
+
+    // Order marks
+    for (int i=1; i<n; i++)
+      rel(this, m[i-1], IRT_LE, m[i]);
+
+    if (opt.naive) {
+      // d[diag(i,j)] must be at least sum of first j-i integers
+      for (int i=0; i<n; i++)
+	for (int j=i+1; j<n; j++)
+	  rel(this, d[diag(i,j)], IRT_GQ, (j-i)*(j-i+1)/2);
+    } else {
+      static const int length[] = {
+	// Length 0-9
+	0,0,1,3,6,11,17,25,34,44,
+	// Length 10-
+	55,72,85,106,127};
+
+      // Marks from i to j must be ruler of length j-1+i
+      for (int i=0; i<n; i++)
+	for (int j=i+1; j<n; j++)
+	  rel(this, d[diag(i,j)], IRT_GQ, length[j-i+1]);
+    }
+    distinct(this, d, opt.icl);
+
+    if (n > 2)
+      rel(this, d[diag(0,1)], IRT_LE, d[diag(n-2,n-1)]);
+
+    branch(this, m, BVAR_NONE, BVAL_MIN);
+  }
+
+  /// Add constraint for next better solution
+  void
+  constrain(Space* s) {
+    rel(this, m[n-1], IRT_LE, static_cast<Golomb*>(s)->m[n-1].val());
+  }
+
+  /// Print solution
+  virtual void
+  print(void) {
+    std::cout << "\tm[" << n << "] = {";
+    for (int i = 0; i < n; i++)
+      std::cout << m[i] << ((i<n-1)?",":"};\n");
+  }
+
+
+  /// Constructor for cloning \a s
+  Golomb(bool share, Golomb& s)
+    : Example(share,s), n(s.n) {
+    m.update(this, share, s.m);
+  }
+  /// Copy during cloning
+  virtual Space*
+  copy(bool share) {
+    return new Golomb(share,*this);
+  }
+
+};
+
+/** \brief Main-function
+ *  \relates Golomb
+ */
+int
+main(int argc, char** argv) {
+  Options o("Golomb");
+  o.solutions = 0;
+  o.size      = 10;
+  o.icl       = ICL_BND;
+  o.naive     = true;
+  o.parse(argc,argv);
+  if (o.size > 0)
+    Example::run<Golomb,BAB>(o);
+  return 0;
+}
+
+// STATISTICS: example-any
+