gecoder-with-gecode 0.7.1

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

@@ -0,0 +1,165 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2003
+ *
+ *  Last modified:
+ *     $Date: 2005-10-19 14:46:42 +0200 (Wed, 19 Oct 2005) $ by $Author: schulte $
+ *     $Revision: 2376 $
+ *
+ *  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"
+
+/**
+ * \name Machine capabilities
+ * \relates Cars
+ */
+//@{
+IntArgs l1(6, 1,0,0,0,1,1);
+IntArgs l2(6, 0,0,1,1,0,1);
+IntArgs l3(6, 1,0,0,0,1,0);
+IntArgs l4(6, 1,1,0,1,0,0);
+IntArgs l5(6, 0,0,1,0,0,0);
+//@}
+
+/**
+ * \brief %Example: Car sequencing
+ *
+ * Schedule a sequence of cars to be produced. This is problem 001 from
+ * csplib.
+ *
+ * \ingroup Example
+ *
+ */
+class Cars : public Example {
+private:
+  IntVarArray x; BoolVarArray y;
+public:
+
+  BoolVar& o(int i, int j) {
+    return y[(i-1)*5+j-1];
+  }
+
+  void
+  atmost(int n, int m) {
+    count(this, x, m, IRT_LQ, n);
+  }
+
+  void ele(const IntArgs& l, int i, int j, int k) {
+    element(this, l, x[i-1], o(j,k));
+  }
+
+  void sum(int n, BoolVar& b0, BoolVar& b1) {
+    BoolVarArgs b(2);
+    b[0]=b0; b[1]=b1;
+    linear(this, b,IRT_LQ,n);
+  }
+
+  void sum(int n, BoolVar& b0, BoolVar& b1, BoolVar& b2) {
+    BoolVarArgs b(3);
+    b[0]=b0; b[1]=b1; b[2]=b2;
+    linear(this, b,IRT_LQ,n);
+  }
+
+  void sum(int n,
+	   BoolVar& b0, BoolVar& b1, BoolVar& b2, BoolVar& b3, BoolVar& b4) {
+    BoolVarArgs b(5);
+    b[0]=b0; b[1]=b1; b[2]=b2; b[3]=b3; b[4]=b4;
+    linear(this, b,IRT_LQ,n);
+  }
+
+  Cars(const Options&)
+    : x(this,10,0,5), y(this,50,0,1) {
+    atmost(1,0);
+    atmost(1,1);
+    atmost(2,2);
+    atmost(2,3);
+    atmost(2,4);
+    atmost(2,5);
+
+    for (int i = 1; i < 11; i++) {
+      ele(l1,i,i,1);
+      ele(l2,i,i,2);
+      ele(l3,i,i,3);
+      ele(l4,i,i,4);
+      ele(l5,i,i,5);
+    }
+
+    for (int i = 1; i <= 9; i++)
+      sum(1,o(i,1),o(i+1,1));
+    for (int i = 1; i <= 8; i++)
+      sum(2,o(i,2),o(i+1,2),o(i+2,2));
+    for (int i = 1; i <= 8; i++)
+      sum(1,o(i,3),o(i+1,3),o(i+2,3));
+    for (int i = 1; i <= 6; i++)
+      sum(2,o(i,4),o(i+1,4),o(i+2,4),o(i+3,4),o(i+4,4));
+    for (int i = 1; i <= 6; i++)
+      sum(1,o(i,5),o(i+1,5),o(i+2,5),o(i+3,5),o(i+4,5));
+
+    // redundant constraints
+
+    /*
+      O11+O21+O31+O41+O51+O61+O71+O81 #>= 4,
+      O11+O21+O31+O41+O51+O61         #>= 3,
+      O11+O21+O31+O41                 #>= 2,
+      O11+O21                         #>= 1,
+
+      O12+O22+O32+O42+O52+O62+O72     #>= 4,
+      O12+O22+O32+O42                 #>= 2,
+      O12                             #>= 0,
+
+      O13+O23+O33+O43+O53+O63+O73     #>= 2,
+      O13+O23+O33+O43                 #>= 1,
+      O13                             #>= 0,
+
+      O14+O24+O34+O44+O54             #>= 2,
+
+      O15+O25+O35+O45+O55             #>= 1,
+    */
+
+    branch(this, x, BVAR_SIZE_MIN, BVAL_MIN);
+  }
+
+  Cars(bool share, Cars& s)
+    : Example(share,s) {
+    x.update(this,share,s.x);
+    y.update(this,share,s.y);
+  }
+
+  virtual Space*
+  copy(bool share) {
+    return new Cars(share,*this);
+  }
+
+  virtual void
+  print(void) {
+    std::cout << "\t";
+    for (int i = 0; i < x.size(); i++)
+      std::cout << x[i] << ", ";
+    std::cout << std::endl;
+  }
+};
+
+int
+main(int argc, char** argv) {
+  Options o("Cars");
+  o.solutions  = 0;
+  o.iterations = 100;
+  o.parse(argc,argv);
+  Example::run<Cars,DFS>(o);
+  return 0;
+}
+
+// STATISTICS: example-any
+

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

@@ -0,0 +1,220 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 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"
+
+typedef enum {
+  Tom, David, Jeremy, Ron,
+  Joe, Bill, Fred,
+  Bob, Mario, Ed,
+  Carol, Janet, Tracy,
+  Marilyn, Carolyn, Cathy,
+  Inez, Jean, Heather, Juliet
+} Employees;
+
+const Employees employees[] =
+  { Tom, David, Jeremy, Ron,
+    Joe, Bill, Fred,
+    Bob, Mario, Ed,
+    Carol, Janet, Tracy,
+    Marilyn, Carolyn, Cathy,
+    Inez, Jean, Heather, Juliet };
+const int lastEmployee = Juliet;
+
+const char*
+employeeToName(Employees e) {
+  switch(e) {
+  case Tom : return "Tom";
+  case David : return "David";
+  case Jeremy: return "Jeremy";
+  case Ron: return "Ron";
+  case Joe: return "Joe";
+  case Bill: return "Bill";
+  case Fred: return "Fred";
+  case Bob: return "Bob";
+  case Mario: return "Mario";
+  case Ed: return "Ed";
+  case Carol: return "Carol";
+  case Janet: return "Janet";
+  case Tracy: return "Tracy";
+  case Marilyn: return "Marilyn";
+  case Carolyn: return "Carolyn";
+  case Cathy: return "Cathy";
+  case Inez: return "Inez";
+  case Jean: return "Jean";
+  case Heather: return "Heather";
+  case Juliet: return "Juliet";
+  }
+  return "None";
+}
+
+// these have to be sorted!
+const Employees stewards[] =
+  {Tom, David, Jeremy, Ron, Joe, Bill, Fred, Bob, Mario, Ed};
+const int noOfStewards = 10;
+const Employees hostesses[] =
+  { Carol, Janet, Tracy, Marilyn, Carolyn, Cathy, Inez,
+    Jean, Heather, Juliet };
+const int noOfHostesses = 10;
+const Employees frenchSpeaking[] =
+  { Bill, Inez, Jean, Juliet };
+const int noOfFrenchSpeaking = 4;
+const Employees germanSpeaking[] =
+  { Tom, Jeremy, Mario, Cathy, Juliet };
+const int noOfGermanSpeaking = 5;
+const Employees spanishSpeaking[] =
+  { Joe, Bill, Fred, Mario, Marilyn, Inez, Heather };
+const int noOfSpanishSpeaking = 7;
+
+const int flights[][7] =
+  { {1,4,1,1,1,1,1},
+    {2,5,1,1,1,1,1},
+    {3,5,1,1,1,1,1},
+    {4,6,2,2,1,1,1},
+    {5,7,3,3,1,1,1},
+    {6,4,1,1,1,1,1},
+    {7,5,1,1,1,1,1},
+    {8,6,1,1,1,1,1},
+    {9,6,2,2,1,1,1},
+    {10,7,3,3,1,1,1} };
+
+const int len = 10;
+
+
+/**
+ * \brief %Example: Airline crew allocation
+ *
+ * Assign 20 flight attendants to 10 flights. Each flight needs a certain
+ * number of cabin crew, and they have to speak certain languages.
+ * Every cabin crew member has two flights off after an attended flight.
+ *
+ * \ingroup Example
+ *
+ */
+class Crew : public Example {
+public:
+  SetVarArray root;
+
+  Crew(const Options& o) :
+    root(this,len,IntSet::empty,0,lastEmployee)
+  {
+    IntSet stewardsDS((int*)stewards,noOfStewards);
+    IntSet hostessesDS((int*)hostesses,noOfHostesses);
+    IntSet spanishDS((int*)spanishSpeaking, noOfSpanishSpeaking);
+    IntSet frenchDS((int*)frenchSpeaking, noOfFrenchSpeaking);
+    IntSet germanDS((int*)germanSpeaking, noOfGermanSpeaking);
+
+    for (int i=0; i<len; i++) {
+      IntVarArray ia(this,5,0,lastEmployee);
+      SetVar team = root[i];
+      const int* flight = flights[i];
+
+      const int N        = flight[1];
+      const int NStew    = flight[2];
+      const int NHost    = flight[3];
+      const int NFrench  = flight[4];
+      const int NSpanish = flight[5];
+      const int NGerman  = flight[6];
+
+      cardinality(this, team,N,N);
+      SetVar stewardsInFS(this);
+      SetVar hostessesInFS(this);
+      SetVar spanishInFS(this);
+      SetVar frenchInFS(this);
+      SetVar germanInFS(this);
+
+      rel(this, team, SOT_INTER, stewardsDS, SRT_EQ, stewardsInFS);
+      rel(this, team, SOT_INTER, hostessesDS, SRT_EQ, hostessesInFS);
+      rel(this, team, SOT_INTER, spanishDS, SRT_EQ, spanishInFS);
+      rel(this, team, SOT_INTER, frenchDS, SRT_EQ, frenchInFS);
+      rel(this, team, SOT_INTER, germanDS, SRT_EQ, germanInFS);
+
+      cardinality(this, stewardsInFS, ia[0]);
+      cardinality(this, hostessesInFS, ia[1]);
+      cardinality(this, spanishInFS, ia[2]);
+      cardinality(this, frenchInFS, ia[3]);
+      cardinality(this, germanInFS, ia[4]);
+
+      rel(this, ia[0], IRT_GQ, NStew);
+      rel(this, ia[1], IRT_GQ, NHost);
+      rel(this, ia[2], IRT_GQ, NSpanish);
+      rel(this, ia[3], IRT_GQ, NFrench);
+      rel(this, ia[4], IRT_GQ, NGerman);
+
+    }
+
+    for (int i=0; i<len-2; i++) {
+      rel(this, root[i], SRT_DISJ, root[i+1]);
+      rel(this, root[i], SRT_DISJ, root[i+2]);
+    }
+    rel(this, root[len-2], SRT_DISJ, root[len-1]);
+
+    branch(this, root, SETBVAR_NONE, SETBVAL_MIN);
+  }
+
+  Crew(bool share, Crew& s)
+    : Example(share,s) {
+    root.update(this,share,s.root);
+  }
+
+  virtual
+  Space *copy(bool share) {
+    return new Crew(share,*this);
+  }
+
+  virtual void
+  print(void) {
+    for (int i=0; i<len; i++) {
+      SetVarGlbValues d(root[i]);
+
+      std::cout << "\tFlight " << i+1 << ":" << std::endl;
+      std::cout << "\t\tCrew\tStew.\tHost.\tFrench\tSpanish\tGerman"
+		<< std::endl << "\t";
+      for (int j=1; j<7; j++)
+        std::cout << "\t" << flights[i][j];
+      std::cout << std::endl;
+
+      std::cout << "\t\tSchedule:" << std::endl << "\t\t";
+      for (;d();++d) {
+        std::cout << employeeToName((Employees)d.val()) << " ";
+      }
+      std::cout << std::endl << std::endl;
+    }
+
+  }
+};
+
+int
+main(int argc, char** argv) {
+  Options o("Crew");
+  o.iterations = 100;
+  o.parse(argc,argv);
+  Example::run<Crew,DFS>(o);
+  return 0;
+}
+
+
+// STATISTICS: example-any
+

data/ext/gecode-1.3.1/examples/crowded-chess.cc

@@ -0,0 +1,312 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2001
+ *     Mikael Lagerkvist, 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.
+ *
+ */
+
+#include "examples/support.hh"
+#include "gecode/minimodel.hh"
+
+/// The maximum number of knights placeable
+const int kval[] = {
+  0,   0,  0,  0,  5,
+  9,  15, 21, 29, 37,
+  47, 57, 69, 81, 94,
+  109
+};
+const int nkval = 16;
+
+/**
+   \brief %Example: Crowded Chessboard
+
+   "You are given a chessboard together with 8 queens, 8 rooks, 14
+   bishops, and 21 knights. The puzzle is to arrange the 51 pieces on
+   the chessboard so that no queen shall attack another queen, no rook
+   attack another rook, no bishop attack another bishop, and no knight
+   attack another knight. No notice is to be taken of the intervention
+   of pieces of another type from that under consideration - that is,
+   two queens will be considered to attack one another although there
+   may be, say, a rook, a bishop, and a knight between them. It is not
+   difficult to dispose of each type of piece separately; the
+   difficulty comes in when you have to find room for all the
+   arrangements on the board simultaneously."
+   <em>Dudeney, H.E., (1917), Amusements in Mathematics,
+   Thomas Nelson and Sons.</em>
+
+   This puzzle can be generalized to chess-boards of size \f$n\f$, where the
+   number of pieces to place are:
+     - \f$ n \f$ queens
+     - \f$ n \f$ rooks
+     - \f$ 2n-1 \f$ bishops
+     - \f$ k \f$ knights
+   where k is a number to maximize.
+
+   The maximum k for some different values of \f$ n \f$ are presented
+   below (from Jesper Hansen and Joachim Schimpf, <a
+   href="http://www.icparc.ic.ac.uk/eclipse/examples/crowded_chess.ecl.txt">
+   ECLiPSe solution</a>
+   <TABLE>
+   <TR> <TD> n </TD> <TD> k </TD> </TR>
+   <TR> <TD> 8 </TD> <TD> 21 </TD> </TR>
+   <TR> <TD> 9 </TD> <TD> 29 </TD> </TR>
+   <TR> <TD> 10 </TD> <TD> 37 </TD> </TR>
+   <TR> <TD> 11 </TD> <TD> 47 </TD> </TR>
+   <TR> <TD> 12 </TD> <TD> 57 </TD> </TR>
+   <TR> <TD> 13 </TD> <TD> 69 </TD> </TR>
+   <TR> <TD> 14 </TD> <TD> 81 </TD> </TR>
+   <TR> <TD> 15 </TD> <TD> 94 </TD> </TR>
+   <TR> <TD> 16 </TD> <TD> 109 </TD> </TR>
+   </TABLE>
+
+   A solution for n = 8 is:
+   <TABLE>
+   <TR><TD>Q</TD><TD>B</TD><TD>K</TD><TD>.</TD>
+   <TD>K</TD><TD>B</TD><TD>K</TD><TD>R</TD></TR>
+   <TR><TD>.</TD><TD>K</TD><TD>.</TD><TD>K</TD>
+   <TD>Q</TD><TD>K</TD><TD>R</TD><TD>B</TD></TR>
+   <TR><TD>B</TD><TD>.</TD><TD>K</TD><TD>R</TD>
+   <TD>K</TD><TD>.</TD><TD>K</TD><TD>Q</TD></TR>
+   <TR><TD>B</TD><TD>K</TD><TD>R</TD><TD>K</TD>
+   <TD>.</TD><TD>Q</TD><TD>.</TD><TD>B</TD></TR>
+   <TR><TD>B</TD><TD>R</TD><TD>Q</TD><TD>.</TD>
+   <TD>K</TD><TD>.</TD><TD>K</TD><TD>B</TD></TR>
+   <TR><TD>R</TD><TD>K</TD><TD>.</TD><TD>K</TD>
+   <TD>.</TD><TD>K</TD><TD>Q</TD><TD>B</TD></TR>
+   <TR><TD>B</TD><TD>Q</TD><TD>K</TD><TD>.</TD>
+   <TD>K</TD><TD>R</TD><TD>K</TD><TD>.</TD></TR>
+   <TR><TD>B</TD><TD>K</TD><TD>B</TD><TD>Q</TD>
+   <TD>R</TD><TD>K</TD><TD>B</TD><TD>B</TD></TR>
+ </TABLE>
+
+ \todo Currently this script finds a solution. Instead, it should find
+ the maximum number of knights for a given size.
+
+   \ingroup Example
+*/
+class CrowdedChess : public Example {
+protected:
+  const int n;          ///< Board-size
+  IntVarArray s;        ///< The board
+  IntVarArray queens,   ///< Row of queen in column x
+    rooks;              ///< Row of rook in column x
+  BoolVarArray knights; ///< True iff the corresponding place has a knight
+
+  /** Symbolic names of pieces. The order determines which piece will
+   * be placed first.
+   */
+  enum
+    {Q,   ///< Queen
+     R,   ///< Rook
+     B,   ///< Bishop
+     K,   ///< Knight
+     E,   ///< Empty square
+     PMAX ///< Number of pieces (including empty squares)
+    } piece;
+
+  // Is (i,j) a valid position on the board?
+  bool valid_pos(int i, int j) {
+    return (i >= 0 && i < n) &&
+      (j >= 0 && j < n);
+  }
+
+  /// Post knight-constraints
+  void knight_constraints() {
+    static const int kmoves[4][2] = {
+      {-1,2}, {1,2}, {2,-1}, {2,1}
+    };
+    MiniModel::Matrix<BoolVarArray> kb(knights, n, n);
+    for (int x = n; x--; )
+      for (int y = n; y--; )
+	for (int i = 4; i--; )
+	  if (valid_pos(x+kmoves[i][0], y+kmoves[i][1])) {
+	    IntVarArgs places(2);
+	    places[0] = kb(x, y);
+	    places[1] = kb(x+kmoves[i][0], y+kmoves[i][1]);
+	    linear(this, places, IRT_LQ, 1);
+	  }
+  }
+
+
+public:
+  /// The model of the problem
+  CrowdedChess(const Options& o)
+    : n(o.size), s(this, n*n, 0, PMAX-1), queens(this, n, 0, n-1),
+      rooks(this, n, 0, n-1), knights(this, n*n, 0, 1) {
+    const int nn = n*n, q = n, r = n, b = (2*n)-2,
+      k = n <= nkval ? kval[n-1] : kval[nkval-1];
+    const int e = nn - (q + r + b + k);
+
+    assert(nn == (e + q + r + b + k));
+
+    MiniModel::Matrix<IntVarArray> m(s, n);
+
+    // ***********************
+    // Basic model
+    // ***********************
+
+    count(this, s, E, IRT_EQ, e, o.icl);
+    count(this, s, Q, IRT_EQ, q, o.icl);
+    count(this, s, R, IRT_EQ, r, o.icl);
+    count(this, s, B, IRT_EQ, b, o.icl);
+    count(this, s, K, IRT_EQ, k, o.icl);
+
+    // Integer variables for use with the element constraint
+    IntVar queen(this, Q, Q), rook(this, R, R);
+
+    // Collect rows and columns for handling rooks and queens.
+    for (int i = 0; i < n; ++i) {
+      IntVarArgs aa = m.row(i), bb = m.col(i);
+
+      count(this, aa, Q, IRT_EQ, 1, o.icl);
+      count(this, bb, Q, IRT_EQ, 1, o.icl);
+      count(this, aa, R, IRT_EQ, 1, o.icl);
+      count(this, bb, R, IRT_EQ, 1, o.icl);
+
+      //Connect (queens|rooks)[i] to the row it is in
+      element(this, aa, queens[i], queen, ICL_DOM);
+      element(this, aa,  rooks[i],  rook, ICL_DOM);
+    }
+
+    // N-queens constraints
+    distinct(this, queens, ICL_DOM);
+    IntArgs koff(n);
+    for (int i = n; i--; ) koff[i] = i;
+    distinct(this, koff, queens, ICL_DOM);
+    for (int i = n; i--; ) koff[i] = -i;
+    distinct(this, koff, queens, ICL_DOM);
+
+    // N-rooks constraints
+    distinct(this,  rooks, ICL_DOM);
+
+    // Collect diagonals for handling queens and bishops
+    for (int l = n; l--; ) {
+      const int il = (n-1) - l;
+      IntVarArgs d1(l+1), d2(l+1), d3(l+1), d4(l+1);
+      for (int i = 0; i <= l; ++i) {
+	d1[i] = m(i+il, i);
+	d2[i] = m(i, i+il);
+	d3[i] = m((n-1)-i-il, i);
+	d4[i] = m((n-1)-i, i+il);
+      }
+
+      count(this, d1, Q, IRT_LQ, 1, o.icl);
+      count(this, d2, Q, IRT_LQ, 1, o.icl);
+      count(this, d3, Q, IRT_LQ, 1, o.icl);
+      count(this, d4, Q, IRT_LQ, 1, o.icl);
+      count(this, d1, B, IRT_LQ, 1, o.icl);
+      count(this, d2, B, IRT_LQ, 1, o.icl);
+      count(this, d3, B, IRT_LQ, 1, o.icl);
+      count(this, d4, B, IRT_LQ, 1, o.icl);
+    }
+
+    // Handle knigths
+    //Connect knigths to board
+    for(int i = n*n; i--; )
+      knights[i] = post(this, ~(s[i] == K));
+    knight_constraints();
+
+
+    // ***********************
+    // Redundant constraints
+    // ***********************
+
+    // Queens and rooks not in the same place
+    // Faster than going through the channeled board-connection
+    for (int i = n; i--; ) {
+      rel(this, queens[i], IRT_NQ, rooks[i]);
+    }
+
+    // Place bishops in two corners (from Schimpf and Hansens solution)
+    // Avoids some symmetries of the problem
+    rel(this, m(n-1,   0), IRT_EQ, B);
+    rel(this, m(n-1, n-1), IRT_EQ, B);
+
+
+    // ***********************
+    // Branchings
+    // ***********************
+    //Place each piece in turn
+    branch(this, s, BVAR_MIN_MIN, BVAL_MIN);
+  }
+
+  /// Constructor for cloning e
+  CrowdedChess(bool share, CrowdedChess& e)
+    : Example(share,e), n(e.n) {
+    s.update(this, share, e.s);
+    queens.update(this, share, e.queens);
+    rooks.update(this, share, e.rooks);
+    knights.update(this, share, e.knights);
+  }
+
+  /// Copy during cloning
+  virtual Space*
+  copy(bool share) {
+    return new CrowdedChess(share,*this);
+  }
+
+  /// Print solution
+  virtual void
+  print(void) {
+    MiniModel::Matrix<IntVarArray> m(s, n);
+    char *names = static_cast<char*>(Memory::malloc(PMAX));
+    const char *sep   = n < 8 ? "\t\t" : "\t";
+    names[E] = '.'; names[Q] = 'Q'; names[R] = 'R';
+    names[B] = 'B'; names[K] = 'K';
+
+    for (int r = 0; r < n; ++r){
+      // Print main board
+      std::cout << '\t';
+      for (int c = 0; c < n; ++c) {
+	std::cout << names[m(r, c).val()];
+      }
+      // Print each piece on its own
+      for (int p = 0; p < PMAX; ++p) {
+	if (p == E) continue;
+	std::cout << sep;
+	for (int c = 0; c < n; ++c) {
+	  if (m(r, c).val() == p) std::cout << names[p];
+	  else                   std::cout << names[E];
+	}
+      }
+      std::cout << std::endl;
+    }
+    std::cout << std::endl;
+  }
+};
+
+/** \brief Main function
+ * \relates CrowdedChess
+ */
+int
+main(int argc, char** argv) {
+  Options o("CrowdedChess");
+  o.icl        = ICL_DOM;
+  o.size       = 7;
+  o.parse(argc,argv);
+  if(o.size < 5) {
+    std::cerr << "Error: Size must be at least 5" << std::endl;
+    return 1;
+  }
+  Example::run<CrowdedChess,DFS>(o);
+  return 0;
+}
+
+// STATISTICS: example-any
+