gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/examples/queen-armies.cc

@@ -0,0 +1,240 @@
+/*
+ *  Main authors:
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Mikael Lagerkvist, 2006
+ *
+ *  Last modified:
+ *     $Date: 2006-10-25 10:29:03 +0200 (Wed, 25 Oct 2006) $ by $Author: tack $
+ *     $Revision: 3783 $
+ *
+ *  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/set.hh"
+#include "gecode/minimodel.hh"
+
+
+/** \name Constant sets for attacking queens.
+ *
+ * \relates QueenArmies
+ */
+IntSet *A;
+
+/**
+ * \brief %Example: Peacable co-existing armies of queens.
+ *
+ * The goal of this problem is to place as many white and black queens
+ * on a chess-board without any two queens of different color
+ * attacking each other. The number of  black queens should
+ * be greater than or equal to the number of white queens.
+ *
+ * This model is based on the one presented in "Models and Symmetry
+ * Breaking for 'Peaceable Armies of Queens'", by Barbara M. Smith, Karen
+ * E. Petrie, and Ian P. Gent.
+ *
+ * The smart version uses a custom branching implementing a heuristic
+ * from the above paper, that helps speeding up the proof of
+ * optimality.
+ *
+ * \ingroup Example
+ *
+ */
+class QueenArmies : public Example {
+public:
+  const int n;
+  SetVar U, ///< Set of un-attacked squares
+    W; ///< Set of squares occupied by white queens
+  BoolVarArray w, ///< The placement of the white queens
+    b; ///< The placement of the black queens
+  IntVar q; ///< The number of white queens placed.
+
+  QueenArmies(const Options& o) :
+    n(o.size),
+    U(this, IntSet::empty, IntSet(0, n*n)),
+    W(this, IntSet::empty, IntSet(0, n*n)),
+    w(this, n*n, 0, 1),
+    b(this, n*n, 0, 1),
+    q(this, 0, n*n)
+  {
+    // Basic rules of the model
+    for (int i = n*n; i--; ) {
+      // w[i] means that no blacks are allowed on A[i]
+      dom(this, U, SRT_DISJ, A[i], w[i]);
+      // Make sure blacks and whites are disjoint.
+      post(this, w[i] + b[i] <= 1);
+      // If i in U, then b[i] has a piece.
+      dom(this, U, SRT_SUP, i, b[i]);
+    }
+
+    // Connect optimization variable to number of pieces
+    linear(this, w, IRT_EQ, q);
+    linear(this, b, IRT_GQ, q);
+
+    // Connect cardinality of U to the number of black pieces.
+    IntVar unknowns(this, 0, n*n);
+    cardinality(this, U, unknowns);
+    post(this, q <= unknowns);
+    linear(this, b, IRT_EQ, unknowns);
+
+    if (o.naive) {
+      branch(this, w, BVAR_NONE, BVAL_MAX);
+      branch(this, b, BVAR_NONE, BVAL_MAX);
+    } else {
+      QueenBranch::post(this);
+      assign(this, b, AVAL_MAX);
+    }
+  }
+
+  QueenArmies(bool share, QueenArmies& s)
+    : Example(share,s), n(s.n)
+  {
+    U.update(this, share, s.U);
+    W.update(this, share, s.W);
+    w.update(this, share, s.w);
+    b.update(this, share, s.b);
+    q.update(this, share, s.q);
+  }
+
+  virtual Space*
+  copy(bool share) {
+    return new QueenArmies(share,*this);
+  }
+
+  void
+  constrain(Space* s) {
+    rel(this, q, IRT_GR, static_cast<QueenArmies*>(s)->q.val());
+  }
+
+
+  virtual void
+  print(void) {
+    std::cout << '\t';
+    for (int i = 0; i < n*n; ++i) {
+      if (w[i].val()) std::cout << "W";
+      else if (b[i].val()) std::cout << "B";
+      else std::cout << ".";
+      if ((i+1)%n == 0) std::cout << std::endl << (i!=(n*n-1)?"\t":"");
+    }
+    std::cout << "Number of white queens: " << q << std::endl << std::endl;
+  }
+
+  /** \brief Custom branching for Peacable queens.
+   *
+   *  Custom branching that tries to place white queens so that they
+   *  maximise the amount of un-attacked squares that become attacked.
+   */
+  class QueenBranch : Branching {
+    mutable int pos;
+    QueenBranch(Space* home)
+      : Branching(home), pos(-1) {}
+    QueenBranch(Space* home, bool share, QueenBranch& b)
+      : Branching(home, share, b), pos(b.pos) {}
+
+  public:
+    virtual bool status(const Space* home) const {
+      const QueenArmies *q = static_cast<const QueenArmies*>(home);
+      int maxsize = -1;
+      pos = -1;
+
+      for (int i = q->n*q->n; i--; ) {
+	if (q->w[i].assigned()) continue;
+	IntSetRanges ai(A[i]);
+	SetVarUnknownRanges qU(q->U);
+	Iter::Ranges::Inter<IntSetRanges, SetVarUnknownRanges> r(ai, qU);
+	int size = Iter::Ranges::size(r);
+	if (size > maxsize) {
+	  maxsize = size;
+	  pos = i;
+	}
+      }
+      if (pos == -1) return false;
+      return true;
+    }
+    virtual BranchingDesc* description(const Space*) const {
+      assert(pos != -1);
+      return new PosValDesc<bool>(this, pos, true);
+    }
+    virtual ExecStatus commit(Space* home, const BranchingDesc* d, unsigned int a) {
+      QueenArmies *q = static_cast<QueenArmies*>(home);
+      const PosValDesc<bool> *pvd = static_cast<const PosValDesc<bool>*>(d);
+      bool val = a == 0 ? pvd->val() : !pvd->val();
+      return me_failed(Int::BoolView(q->w[pvd->pos()]).eq(q, val))
+	? ES_FAILED
+	: ES_OK;
+    }
+    virtual Actor* copy(Space *home, bool share) {
+      return new (home) QueenBranch(home, share, *this);
+    }
+
+    static void post(QueenArmies* home) {
+      (void) new (home) QueenBranch(home);
+    }
+  };
+};
+
+/// Position of a piece in a square board
+int pos(int i, int j, int n) {
+  return i*n + j;
+}
+
+/** \brief Main-function
+ *  \relates QueenArmies
+ */
+int
+main(int argc, char** argv) {
+  Options o("QueenArmies");
+  o.size      = 6;
+  o.naive     = false;
+  o.solutions = 0;
+  o.parse(argc,argv);
+
+  // Set up the A-sets
+  // A[i] will contain the values attacked by a queen at position i
+  int n = o.size;
+  A = new IntSet[n*n];
+  int *p = new int[std::max(n*n, 25)];
+  int pn = 0;
+  for (int i = n; i--; ) {
+    for (int j = n; j--; ) {
+      int dir[][2] = {
+	{ 0,  1},
+	{ 1,  1},
+	{ 1,  0},
+	{ 0, -1},
+	{-1, -1},
+	{-1,  0},
+	{ 1, -1},
+	{-1,  1}
+      };
+      p[pn++] = pos(i, j, n);
+      for (int k = 8; k--; ) {
+	for (int l = 0; l < n
+	       && 0 <= (i+l*dir[k][0]) && (i+l*dir[k][0]) < n
+	       && 0 <= (j+l*dir[k][1]) && (j+l*dir[k][1]) < n; ++l) {
+	  p[pn++] = pos(i+l*dir[k][0], j+l*dir[k][1], n);
+	}
+      }
+
+      A[pos(i, j, n)] = IntSet(p, pn);
+
+      pn = 0;
+    }
+  }
+  delete [] p;
+
+  Example::run<QueenArmies,BAB>(o);
+  return 0;
+}
+
+// STATISTICS: example-any

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

@@ -0,0 +1,99 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2001
+ *
+ *  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"
+#include "gecode/minimodel.hh"
+
+/**
+ * \brief %Example: n-%Queens puzzle
+ *
+ * Place n queens on an n times n chessboard such that they do not
+ * attack each other.
+ *
+ * \ingroup Example
+ *
+ */
+class Queens : public Example {
+protected:
+  /// Position of queens on boards
+  IntVarArray q;
+public:
+  /// The actual problem
+  Queens(const Options& opt)
+    : q(this,opt.size,0,opt.size-1) {
+    const int n = q.size();
+    if (opt.naive) {
+      for (int i = 0; i<n; i++)
+	for (int j = i+1; j<n; j++) {
+	  post(this, q[i] != q[j]);
+	  post(this, q[i]+i != q[j]+j);
+	  post(this, q[i]-i != q[j]-j);
+	}
+    } else {
+      IntArgs c(n);
+      for (int i = n; i--; ) c[i] = i;
+      distinct(this, c,q, opt.icl);
+      for (int i = n; i--; ) c[i] = -i;
+      distinct(this, c,q, opt.icl);
+      distinct(this, q, opt.icl);
+    }
+    branch(this, q, BVAR_SIZE_MIN, BVAL_MIN);
+  }
+
+  /// Constructor for cloning \a s
+  Queens(bool share, Queens& s) : Example(share,s) {
+    q.update(this, share, s.q);
+  }
+
+  /// Perform copying during cloning
+  virtual Space*
+  copy(bool share) {
+    return new Queens(share,*this);
+  }
+
+  /// Print solution
+  virtual void
+  print(void) {
+    std::cout << "\t";
+    for (int i = 0; i < q.size(); i++) {
+      std::cout << q[i] << ", ";
+      if ((i+1) % 10 == 0)
+	std::cout << std::endl << "\t";
+    }
+    std::cout << std::endl;
+    }
+};
+
+/** \brief Main-function
+ *  \relates Alpha
+ */
+int
+main(int argc, char** argv) {
+  Options opt("Queens");
+  opt.iterations = 500;
+  opt.size       = 100;
+  opt.parse(argc,argv);
+  Example::run<Queens,DFS>(opt);
+  return 0;
+}
+
+// STATISTICS: example-any
+

data/ext/gecode-1.3.1/examples/sports-league.cc

@@ -0,0 +1,454 @@
+/*
+ *  Main authors:
+ *     Patrick Pekczynski <pekczynski@ps.uni-sb.de>
+ *
+ *  Copyright:
+ *     Patrick Pekczynski, 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 "examples/support.hh"
+#include "gecode/minimodel.hh"
+
+/**
+ * \brief Triple forming an entry in the round robin schedule
+ * \relates SportsLeague
+ *
+ */
+
+struct Play {
+  /// number of the home team
+  int h;
+  /// number of the away team
+  int a;
+  /// game number
+  int g;
+};
+
+typedef PrimArgArray<Play> RRSArray;
+
+/**
+ * \brief %Example: %Sports League Scheduling
+ *
+ * Prob026: round robin tournaments from http://www.csplip.org
+ *
+ *
+ * -# There are \f$ t \f$ teams (\f$ t \f$  even).
+ * -# The season lasts \f$ t - 1 \f$ weeks.
+ * -# Each game between two different teams occurs exactly once.
+ * -# Every team plays one game in each week of the season.
+ * -# There are \f$ \displaystyle\frac{t}{2} \f$ periods and each week
+ *    every period is scheduled for one game.
+ * -# No team plays more than twice in the same period over
+ *    the course of the season.
+ *
+ * \ingroup Example
+ */
+class SportsLeague : public Example {
+private:
+  /// require t to be even and t!=4 (has only failures)
+  /// number of considered teams
+  int t;
+  /// number of weeks
+  int weeks;
+  /// inserting a dummy week according to R�gin
+  int eweeks;
+  /// number of periods
+  int periods;
+  /// the whole season
+  int season;
+  /// the maximum value a game number can take
+  int value;
+  /// variables for home teams
+  IntVarArray home;
+  /// variables for away teams
+  IntVarArray away;
+  /// variables for game numbers
+  IntVarArray game;
+  /// \brief Round robin schedule
+  RRSArray rrs_array;
+protected:
+  // return the number of digits of n
+  int digit(int n) {
+    int f = n;
+    int fdigit = 0;
+    while (f / 10) {
+      fdigit++;
+      f = f / 10;
+    }
+    return fdigit;
+  }
+
+  // printing function that makes the schedule more readable
+  void blank(int n) {
+    for (int d = digit(t) - digit(n); d--; ) {
+      std::cout << " ";
+    }
+    std::cout << n;
+  }
+
+  void blankv(int n) {
+    for (int d = digit(value) - digit(n); d--; ) {
+      std::cout << " ";
+    }
+    std::cout << n;
+  }
+
+  void blank_only(int n) {
+    for (int i = digit(n); i--; ) {
+      std::cout << " ";
+    }
+  }
+
+public:
+  /// Access the home team in period \a p and week \a w
+  IntVar& h (int p, int w) {
+    return home[p * eweeks + w];
+  }
+
+  /// Access the away team in period \a p and week \a w
+  IntVar& a (int p, int w) {
+    return away[p * eweeks + w];
+  }
+
+  /**
+   * \brief Access the game number associated with the game
+   * in period \a p and week \a w
+   */
+  IntVar& g (int p, int w) {
+    return game[p * weeks + w];
+  }
+
+  /**
+   * \brief Access the entry in the round robin schedule for
+   *  period \a p and week \a w
+   */
+  Play& rrs(int p, int w) {
+    return rrs_array[p * weeks + w];
+  }
+
+  /**
+   * \brief Compute game numbers
+   *
+   * Given the game \f$ (h,a) \f$ between a
+   * home team \f$ h \f$ and an away team \f$ a \f$ this function
+   * computes the unique game number
+   * \f$g = (h - 1) * t + a  \Leftrightarrow  t = t * h + a - g\f$
+   */
+
+  int gn(int h, int a) {
+    return (t * (h - 1) + a);
+  }
+
+  /**
+   * \brief Build a feasible schedule
+   *
+   * The games of the first week are fixed as:
+   * \f$ \langle 1,2 \rangle \cup
+   * \{\langle p + 2, t - p + 1\rangle | p \geq 1\}\f$. \n
+   * The remaining games are computed by transforming a game
+   * \f$ \langle h, a, g \rangle \f$ from the previous week
+   * in a new game \f$ \langle h', a'\rangle \f$, where: \n
+   * \f$ h' = \left\{
+   *  \begin{tabular}{l c l}
+   *   1 & & if $h = 1$ \\
+   *   2 & & if $h = t$ \\
+   *   $h + 1$ & & otherwise
+   *  \end{tabular}\right.
+   * \f$ and
+   * \f$ a' = \left\{
+   *  \begin{tabular}{l c l}
+   *   2 & & if $h = t$ \\
+   *   a + 1 & & otherwise
+   *  \end{tabular}\right.
+   * \f$
+   *
+   *
+   */
+
+  void init_rrs(void) {
+
+    // Initialize the array
+    for(int p = 0; p < periods; p++)
+      for (int w = 0; w < weeks; w++) {
+	rrs(p, w).h = 0;
+	rrs(p, w).a = 0;
+	rrs(p, w).g = 0;
+      }
+
+    // Determine the first game (week 0 period 0)
+    rrs(0, 0).h = 1;
+    rrs(0, 0).a = 2;
+    rrs(0, 0).g = 2;
+
+    // Determine the other games of the first week
+    for(int p = 1; p < periods; p++){
+      rrs(p, 0).h = (p + 1) + 1;
+      rrs(p, 0).a = t - (p + 1 - 2);
+      rrs(p, 0).g = gn(rrs(p, 0).h, rrs(p, 0).a);
+    }
+
+    // Compute the games for the subsequent weeks
+    for (int w = 1; w < weeks; w++) {
+      for (int p = 0; p < periods; p++) {
+	if (rrs(p, w - 1).h == t) {
+	  rrs(p, w).h = 2;
+	} else {
+	  if (rrs(p, w - 1).h == 1) {
+	    rrs(p, w).h = 1;
+	  } else {
+	    rrs(p, w).h = rrs(p, w - 1).h + 1;
+	  }
+	}
+	if (rrs(p, w - 1).a == t) {
+	  rrs(p, w).a = 2;
+	} else {
+	  rrs(p, w).a = rrs(p, w - 1).a + 1;
+	}
+
+	// maintain symmetry for (h, a): h < a
+	if (rrs(p, w).h > rrs(p, w).a) {
+	  int buffer  = rrs(p, w).h;
+	  rrs(p, w).h = rrs(p, w).a;
+	  rrs(p, w).a = buffer;
+	}
+	rrs(p, w).g = gn(rrs(p, w).h, rrs(p, w).a);
+      }
+    }
+  }
+
+  SportsLeague(const Options& op) :
+    t       (op.size),
+    weeks   (t - 1),
+    eweeks  (t),
+    periods (t / 2),
+    season  (weeks * periods),
+    value   (t * (t - 2) + t),
+    home    (this, periods * eweeks),
+    away    (this, periods * eweeks),
+    game    (this, season),
+    rrs_array     (periods * weeks){
+
+    IntSet dom_all   (1, t);
+    IntSet dom_game  (2, value);
+    IntSet dom_home  (1, t - 1);
+    IntSet dom_away  (2, t);
+    IntSet dom_index (0, periods - 1);
+
+    for (int i = eweeks * periods; i--; ) {
+      home[i].init(this, dom_home);
+      away[i].init(this, dom_away);
+    }
+    for (int i = season; i--; ) {
+      game[i].init(this, dom_game);
+    }
+
+
+    // Initialize the round robin schedule
+    init_rrs();
+
+    //    domain for the gamenumber of period
+    for (int w = 0; w < weeks; w++) {
+      IntArgs gamenum(periods);
+      IntArgs fst(periods);
+      IntArgs snd(periods);
+
+      for(int p = 0; p < periods; p++){
+	gamenum[p] = rrs(p, w).g;
+	fst[p]     = rrs(p, w).h;
+	snd[p]     = rrs(p, w).a;
+      }
+
+      IntVarArray n(this, periods, 0, periods - 1);
+      distinct(this, n, ICL_DOM);
+	
+      for(int p = 0; p < periods; p++){
+	element(this, gamenum, n[p], g(p, w), op.icl);
+	element(this, fst,     n[p], h(p, w), op.icl);
+	element(this, snd,     n[p], a(p, w), op.icl);
+      }
+    }
+
+
+    /**
+     * Symmetrie breaking:
+     * we consider (h, a) and (a, h) as the same game and focus
+     * on the home game for h, i.e. (h, a) with h < a
+     */
+
+    // fix the first pair
+    rel(this, h(0,0), IRT_EQ, 1);
+    rel(this, a(0,0), IRT_EQ, 2);
+
+    for (int p = 0; p < periods; p++) {
+      for (int w = 0; w < eweeks; w++) {
+    	rel(this, h(p, w), IRT_LE, a(p, w));
+      }
+    }
+
+    // home teams in the first week are ordered
+    for (int p = 0; p < periods - 1; p++) {
+      rel(this, h(p, 0), IRT_LE, h(p + 1, 0));
+    }
+
+    /**
+     * Constraint on each column:
+     * each team occurs exactly once.
+     * (you need two teams in order to form a match).
+     */
+
+    for(int w = 0; w < eweeks; w++ ) {
+      IntVarArray col(this, t);
+      int k = 0;
+      for( int p = 0; p < periods; p++ ) {
+	col[k] = h(p, w);
+	k++;
+	col[k] = a(p, w);
+	k++;
+      }
+      distinct(this, col, ICL_DOM);
+    }
+
+    /**
+     * Constraint on each row:
+     * no team appears more than twice
+     * (you do not want a team to play more than twice a week in the same slot
+     * the same time.)
+     *
+     */
+
+    for(int p = 0; p < periods; p++) {
+      IntVarArray row(this, 2 * eweeks);
+      for (int w = 0; w < 2 * eweeks; w +=2) {
+	row[w]     = h(p, w / 2);
+	row[w + 1] = a(p, w / 2);
+      }
+      gcc(this, row, 2, op.icl); // cardvars
+    }
+
+
+
+    for(int p = 0; p < periods; p++) {
+      for(int w = 0; w < weeks; w ++) {
+	post(this, t * h(p, w) + 1 * a(p, w) - 1* g(p, w) == t);
+      }
+    }
+
+    distinct(this, game, ICL_DOM);
+
+    branch(this, game, BVAR_NONE, BVAL_MIN);
+
+  }
+
+  SportsLeague(bool share, SportsLeague& s)
+    : Example(share, s),
+      t(s.t), weeks(s.weeks), eweeks(s.eweeks),
+      periods(s.periods), season(s.season),
+      value(s.value), rrs_array(s.rrs_array) {
+    home.update(this, share, s.home);
+    away.update(this, share, s.away);
+    game.update(this, share, s.game);
+  }
+
+  virtual Space*
+  copy(bool share) {
+    return new SportsLeague(share, *this);
+  }
+
+  virtual void print(void){
+    // print feasible schedule
+    // t is the number of the greatest game
+    std::cout << "\nSchedule for " << t << " teams"
+	      << " and "<< weeks << " weeks:" << std::endl;
+    // print period index
+    std::cout << " ";
+    blank_only(t);
+    std::cout << "     ";
+    for (int p = 0; p < periods; p++) {
+      blank_only(t);
+      std::cout << "P[";
+      blank(p);
+      std::cout <<"]";
+      blank_only(t);
+    }
+    std::cout <<"\n";
+
+    // print entries
+    for(int w = 0; w < weeks; w++){
+      std::cout << "W[";
+      blank(w + 1);
+      std::cout <<"]: ";
+      for(int p = 0; p < periods; p++){
+	if (h(p, w).assigned() && a(p, w).assigned()) {
+	  std::cout <<" ";
+	  blank(h(p, w).val());
+	  std::cout <<",";
+	  blank(a(p, w).val());
+	  std::cout <<" ";
+	} else {
+	  blank_only(t);
+	  std::cout << " x ";
+	  blank_only(t);
+	}
+      }
+      std::cout << "\n";
+    }
+    std::cout << "\n";
+
+    //print gamenumbers
+    std::cout << "\nUnique game numbers:\n";
+    std::cout <<"\n";
+    for(int p = 0; p < periods; p++){
+      std::cout << "Period[";
+      blank(p + 1);
+      std::cout <<"]: " ;
+      for(int w = 0; w < weeks; w++){
+	if (g(p, w).assigned()) {
+	  blankv(g(p, w).val());
+	  std::cout << " ";
+	} else {
+	  for (int i = digit(value); i--; ) {
+	    std::cout << " ";
+	  }
+	  std::cout << " ";
+	}
+      }
+      std::cout << "\n";
+    }
+    std::cout << "\n";
+
+  }
+};
+
+
+int main(int argc, char** argv){
+  Options o("Sports League Scheduling ");
+  o.solutions = 1;
+  o.size      = 18;
+  o.parse(argc, argv);
+  if (o.size == 4) {
+    std::cerr<< "No Solution for t = 4!\n";
+    return -1;
+  }
+  if (o.size % 2 != 0) {
+    std::cerr << "Number of t has to be even!\n";
+    return -1;
+  }
+  Example::run<SportsLeague, DFS>(o);
+  return 0;
+}
+
+// STATISTICS: example-any
+