gecoder-with-gecode 0.9.0 → 0.9.1

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

@@ -0,0 +1,342 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Patrick Pekczynski <pekczynski@ps.uni-sb.de>
+ *
+ *  Contributing authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Patrick Pekczynski, 2004
+ *     Christian Schulte, 2007
+ *
+ *  Last modified:
+ *     $Date: 2008-02-01 11:40:25 +0100 (Fri, 01 Feb 2008) $ by $Author: tack $
+ *     $Revision: 6033 $
+ *
+ *  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"
+
+#include <algorithm>
+#include <iomanip>
+
+/// Entry in round robin schedule
+class Play {
+public:
+  int h; ///< home team
+  int a; ///< away team
+  int g; ///< game number
+};
+
+/// Round robin schedule
+class RRS {
+protected:
+  /// Number of teams
+  const int teams;
+  /// Play information
+  Play* plays; 
+  /// Return number of weeks
+  int weeks(void) const {
+    return teams-1;
+  }
+  /// Return number of periods
+  int periods(void) const {
+    return teams/2;
+  }
+  /// Game number for game between home team \a h and away team \a a
+  int gn(int h, int a) const {
+    return teams*(h-1) + a;
+  }
+  /// Play for period \a p and week \a w
+  Play& play(int p, int w) {
+    return plays[p*weeks() + w];
+  }
+public:
+  /**
+   * \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$
+   *
+   *
+   */
+  RRS(int t) : teams(t), plays(new Play[periods()*weeks()])  {
+    // Initialize array
+    for (int p=0; p<periods(); p++)
+      for (int w=0; w<weeks(); w++)
+        play(p,w).h = play(p,w).a = play(p,w).g = 0;
+    
+    // Determine the first game (week 0 period 0)
+    play(0,0).h = 1;
+    play(0,0).a = 2;
+    play(0,0).g = 2;
+
+    // Determine the other games of the first week
+    for (int p=1; p<periods(); p++) {
+      play(p,0).h = (p + 1) + 1;
+      play(p,0).a = teams - (p + 1 - 2);
+      play(p,0).g = gn(play(p,0).h,play(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 (play(p,w-1).h == teams) {
+          play(p,w).h = 2;
+        } else if (play(p,w-1).h == 1) {
+          play(p,w).h = 1;
+        } else {
+          play(p,w).h = play(p,w-1).h + 1;
+        }
+
+        if (play(p,w-1).a == teams) {
+          play(p,w).a = 2;
+        } else {
+          play(p,w).a = play(p,w-1).a + 1;
+        }
+
+        // maintain symmetry for (h,a): h < a
+        if (play(p,w).h > play(p,w).a)
+          std::swap(play(p,w).h,play(p,w).a);
+
+        play(p,w).g = gn(play(p,w).h,play(p,w).a);
+      }
+    }
+
+  }
+  /// Home, away, and game information
+  void hag(int w, IntArgs& h, IntArgs& a, IntArgs& g) {
+    for (int p=0; p<periods(); p++) {
+      h[p] = play(p,w).h;
+      a[p] = play(p,w).a;
+      g[p] = play(p,w).g;
+    }
+  }
+  /// Delete schedule
+  ~RRS(void) {
+    delete [] plays;
+  }
+};
+
+
+
+/**
+ * \brief %Example: %Sports League Scheduling
+ *
+ * -# 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.
+ *
+ * See also problem 26 at http://www.csplib.org/.
+ *
+ * \ingroup ExProblem
+ */
+class SportsLeague : public Example {
+protected:
+  const int teams;  ///< number of teams
+  IntVarArray home; ///< home teams
+  IntVarArray away; ///< away teams
+  IntVarArray game; ///< game numbers
+
+  /// Return number of weeks
+  int weeks(void) const {
+    return teams-1;
+  }
+  /// Return number of periods
+  int periods(void) const {
+    return teams/2;
+  }
+  /// Home team in period \a p and week \a w
+  IntVar& h(int p, int w) {
+    return home[p*teams + w];
+  }
+  /// Away team in period \a p and week \a w
+  IntVar& a(int p, int w) {
+    return away[p*teams + w];
+  }
+  /// Return game number for game in period \a p and week \a w
+  IntVar& g(int p, int w) {
+    return game[p*weeks() + w];
+  }
+
+public:
+  /// Setup model
+  SportsLeague(const SizeOptions& opt) :
+    teams(opt.size()),
+    home(this, periods() * teams, 1, weeks()),
+    away(this, periods() * teams, 2, weeks()+1),
+    game(this, weeks()*periods(), 2, teams*weeks())
+  {
+    // Initialize round robin schedule
+    RRS r(teams);
+
+    // Domain for gamenumber of period
+    for (int w=0; w<weeks(); w++) {
+      IntArgs rh(periods()), ra(periods()), rg(periods());
+      IntVarArgs n(periods());
+
+      for (int p=0; p<periods(); p++)
+        n[p].init(this,0,periods()-1);
+      distinct(this, n, opt.icl());
+
+      r.hag(w,rh,ra,rg);
+        
+      for (int p=0; p<periods(); p++) {
+        element(this, rh, n[p], h(p,w));
+        element(this, ra, n[p], a(p,w));
+        element(this, rg, n[p], g(p,w));
+      }
+    }
+
+    /// (h,a) and (a,h) are the same game, focus on home (that is, h<a)
+    for (int p=0; p<periods(); p++)
+      for (int w=0; w<teams; w++)
+        rel(this, h(p,w), IRT_LE, a(p,w));
+
+    // Home teams in first week are ordered
+    for (int p=0; p<periods()-1; p++)
+      rel(this, h(p,0), IRT_LE, h(p+1,0));
+
+    // Fix first pair
+    rel(this, h(0,0), IRT_EQ, 1);
+    rel(this, a(0,0), IRT_EQ, 2);
+
+    /// Column constraint: each team occurs exactly once
+    for (int w=0; w<teams; w++) {
+      IntVarArgs c(teams);
+      for (int p=0; p<periods(); p++) {
+        c[2*p] = h(p,w); c[2*p+1] = a(p,w);
+      }
+      distinct(this, c, opt.icl());
+    }
+
+    /// Row constraint: no team appears more than twice
+    for (int p=0; p<periods(); p++) {
+      IntVarArgs r(2*teams);
+      for (int t=0; t<teams; t++) {
+        r[2*t]   = h(p,t);
+        r[2*t+1] = a(p,t);
+      }
+      IntArgs values(teams);
+      for (int i=1; i<=teams; i++)
+        values[i-1] = i;
+      count(this, r, IntSet(2,2), values, opt.icl());
+    }
+
+    // Redundant constraint
+    for (int p=0; p<periods(); p++)
+      for (int w=0; w<weeks(); w ++)
+        post(this, teams * h(p,w) + a(p,w) - g(p,w) == teams);
+
+    distinct(this, game, opt.icl());
+
+    branch(this, game, INT_VAR_NONE, INT_VAL_SPLIT_MIN);
+  }
+  /// Constructor for cloning \a s
+  SportsLeague(bool share, SportsLeague& s)
+    : Example(share, s), teams(s.teams) {
+    home.update(this, share, s.home);
+    away.update(this, share, s.away);
+    game.update(this, share, s.game);
+  }
+  /// Copy during cloning
+  virtual Space*
+  copy(bool share) {
+    return new SportsLeague(share, *this);
+  }
+  /// Print solution
+  virtual void print(std::ostream& os) {
+    // print period index
+    os << "\t       ";
+    for (int p=0; p<periods(); p++) {
+      os << "P[";
+      os.width(2);
+      os << p << "] ";
+      }
+    os << std::endl;
+    // print entries
+    for (int w=0; w<weeks(); w++) {
+      os << "\tW[";
+      os.width(2);
+      os << w+1 << "]: ";
+      for (int p=0; p<periods(); p++) {
+        os.width(2); 
+        os << h(p,w).val() << '-';
+        os.width(2);
+        os << a(p,w).val() << " ";
+      }
+      os << std::endl;
+    }
+  }
+};
+
+
+/** \brief Main-function
+ *  \relates SportsLeague
+ */
+int 
+main(int argc, char* argv[]) {
+  SizeOptions opt("Sports League Scheduling");
+  opt.icl(ICL_DOM);
+  opt.size(18);
+  opt.parse(argc,argv);
+  if (opt.size() < 5) {
+    std::cerr<< "No Solution for less than 5 teams!" << std::endl;
+    return 1;
+  }
+  if (opt.size() % 2 != 0) {
+    std::cerr << "Number of teams has to be even!" << std::endl;
+    return 1;
+  }
+  Example::run<SportsLeague, DFS,SizeOptions>(opt);
+  return 0;
+}
+
+// STATISTICS: example-any

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

@@ -0,0 +1,192 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *
+ *  Last modified:
+ *     $Date: 2008-03-05 16:11:06 +0100 (Wed, 05 Mar 2008) $ by $Author: tack $
+ *     $Revision: 6428 $
+ *
+ *  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 "gecode/set.hh"
+#include "examples/support.hh"
+
+/**
+ * \brief %Example: Steiner triples
+ *
+ * See also problem 044 at http://www.csplib.org/.
+ *
+ * \ingroup ExProblem
+ *
+ */
+class Steiner : public Example {
+public:
+
+  /// Model variants
+  enum {
+    MODEL_NONE,   ///< Use simple relation constraint
+    MODEL_MATCHING, ///< Use matching constraints
+    MODEL_SEQ ///< Use sequence constraints
+  };
+
+  /// Order of the Steiner problem
+  int n;
+  /// Number of Steiner triples
+  int noOfTriples;
+
+  /// The steiner triples
+  SetVarArray triples;
+
+  /// Actual model
+  Steiner(const SizeOptions& opt)
+    : n(opt.size()), noOfTriples((n*(n-1))/6),
+      triples(this, noOfTriples, IntSet::empty, 1, n, 3, 3) {
+
+    for (int i=0; i<noOfTriples; i++) {
+      for (int j=i+1; j<noOfTriples; j++) {
+        SetVar x = triples[i];
+        SetVar y = triples[j];
+
+        SetVar atmostOne(this,IntSet::empty,1,n,0,1);
+        cardinality(this, atmostOne,0,1);
+        rel(this, x, SOT_INTER, y, SRT_EQ, atmostOne);
+
+        IntVar x1(this,1,n);
+        IntVar x2(this,1,n);
+        IntVar x3(this,1,n);
+        IntVar y1(this,1,n);
+        IntVar y2(this,1,n);
+        IntVar y3(this,1,n);
+
+        if (opt.model() == MODEL_NONE) {
+          /* Naive alternative:
+           * just including the ints in the set
+           */
+          rel(this, x, SRT_SUP, x1);
+          rel(this, x, SRT_SUP, x2);
+          rel(this, x, SRT_SUP, x3);
+          rel(this, y, SRT_SUP, y1);
+          rel(this, y, SRT_SUP, y2);
+          rel(this, y, SRT_SUP, y3);
+                    
+        } else  if (opt.model() == MODEL_MATCHING) {
+          /* Smart alternative:
+           * Using matching constraints
+           */
+        
+          IntVarArgs xargs(3);
+          xargs[0] = x1; xargs[1] = x2; xargs[2] = x3;
+          match(this, x,xargs);
+        
+          IntVarArgs yargs(3);
+          yargs[0] = y1; yargs[1] = y2; yargs[2] = y3;
+          match(this, y,yargs);
+        } else if (opt.model() == MODEL_SEQ) {
+          SetVar tmp20(this,IntSet::empty,1,n);
+          SetVar tmp21(this,IntSet::empty,1,n);
+          SetVar tmp22(this,IntSet::empty,1,n);
+          SetVar tmp23(this,IntSet::empty,1,n);
+          SetVar tmp24(this,IntSet::empty,1,n);
+          SetVar tmp25(this,IntSet::empty,1,n);
+          rel(this, tmp20, SRT_EQ, x1);
+          rel(this, tmp21, SRT_EQ, x2);
+          rel(this, tmp22, SRT_EQ, x3);
+          rel(this, tmp23, SRT_EQ, y1);
+          rel(this, tmp24, SRT_EQ, y2);
+          rel(this, tmp25, SRT_EQ, y3);
+          SetVarArgs xargs(3);
+          xargs[0] = tmp20; xargs[1] = tmp21; xargs[2] = tmp22;
+          SetVarArgs yargs(3);
+          yargs[0] = tmp23; yargs[1] = tmp24; yargs[2] = tmp25;
+          sequentialUnion(this,xargs,x);
+          sequentialUnion(this,yargs,y);          
+        }
+        
+        /* Breaking symmetries */
+        
+        rel(this, x1,IRT_LE,x2);
+        rel(this, x2,IRT_LE,x3);
+        rel(this, x1,IRT_LE,x3);
+        
+        rel(this, y1,IRT_LE,y2);
+        rel(this, y2,IRT_LE,y3);
+        rel(this, y1,IRT_LE,y3);
+        
+        IntArgs ia(6,(n+1)*(n+1),n+1,1,-(n+1)*(n+1),-(n+1),-1);
+        IntVarArgs iva(6);
+        iva[0]=x1; iva[1]=x2; iva[2]=x3;
+        iva[3]=y1; iva[4]=y2; iva[5]=y3;
+        linear(this, ia, iva, IRT_LE, 0);
+      }
+    }
+
+    branch(this, triples, SET_VAR_NONE, SET_VAL_MIN);
+  }
+
+  /// Print solution
+  virtual void
+  print(std::ostream& os) {
+    for (int i=0; i<noOfTriples; i++) {
+      os << "\t[" << i << "] = " << triples[i] << std::endl;
+    }
+  }
+
+  /// Constructor for copying \a s
+  Steiner(bool share, Steiner& s) : Example(share,s), n(s.n), noOfTriples(s.noOfTriples) {
+    triples.update(this, share, s.triples);
+  }
+  /// Copy during cloning
+  virtual Space*
+  copy(bool share) {
+    return new Steiner(share,*this);
+  }
+
+};
+
+/** \brief Main-function
+ *  \relates Steiner
+ */
+int
+main(int argc, char* argv[]) {
+  SizeOptions opt("Steiner");
+  opt.model(Steiner::MODEL_NONE);
+  opt.model(Steiner::MODEL_NONE, "rel", "Use simple relation constraints");
+  opt.model(Steiner::MODEL_MATCHING, "matching", "Use matching constraints");
+  opt.model(Steiner::MODEL_SEQ, "sequence", "Use sequence constraints");
+  opt.size(9);
+  opt.iterations(20);
+  opt.parse(argc,argv);
+  Example::run<Steiner,DFS,SizeOptions>(opt);
+  return 0;
+}
+
+
+// STATISTICS: example-any
+