dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/examples/black-hole.cpp

@@ -0,0 +1,413 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Mikael Lagerkvist, 2006
+ *
+ *  Last modified:
+ *     $Date: 2011-05-11 20:44:17 +1000 (Wed, 11 May 2011) $ by $Author: tack $
+ *     $Revision: 12001 $
+ *
+ *  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/driver.hh>
+#include <gecode/int.hh>
+
+#include <vector>
+#include <algorithm>
+#include <sstream>
+
+using namespace Gecode;
+
+namespace {
+  using std::vector;
+
+  /// Layout of the cards
+  vector<vector<int> > layout;
+  /// information for locating particular cards in the layout
+  vector<int> layer, pile;
+
+  /** \brief Generates\ref layout.
+   *
+   * This function generates the layeout and intializes \ref layer and
+   * \ref pile from it. The layout is randomly generated from the
+   * supplied seed.
+   */
+  void generate(int seed) {
+    // The layout consists of 17 piles of 3 cards each
+    layout = vector<vector<int> >(17, vector<int>(3));
+    // Deck without the Ace of Spades
+    vector<int> deck(51);
+    for (int i = 51; i--; ) deck[i] = i+1;
+    Support::RandomGenerator rnd(seed+1);
+    std::random_shuffle(deck.begin(), deck.end(), rnd);
+
+    // Place cards from deck
+    int pos = 0;
+    for (int i = 17; i--; )
+      for (int j = 3; j--; )
+        layout[i][j] = deck[pos++];
+
+    // Location-information for each card
+    layer = vector<int>(52);
+    pile  = vector<int>(52);
+    for (int i = 17; i--; ) {
+      for (int j = 3; j--; ) {
+        layer[layout[i][j]] = j;
+        pile[ layout[i][j]] = i;
+      }
+    }
+  }
+}
+
+
+
+/** \brief Custom brancher for black hole patience
+ *
+ * This class implements a custom brancher for BlackHole that
+ * instantiates the variables in lexical order, and chooses the value
+ * with the most cards under it.
+ *
+ * \relates BlackHole
+ */
+class BlackHoleBranch : Brancher {
+protected:
+  /// Views of the brancher
+  ViewArray<Int::IntView> x;
+  /// Cache of first unassigned variable
+  mutable int start;
+  /// %Choice for black hole brancher
+  class Choice : public Gecode::Choice {
+  public:
+    /// Position of variable
+    int pos;
+    /// Value of variable
+    int val;
+    /** Initialize description for brancher \a b, position \a pos0, 
+     *  and value \a val0.
+     */
+    Choice(const Brancher& b, int pos0, int val0)
+      : Gecode::Choice(b,2), pos(pos0), val(val0) {}
+    /// Report size occupied
+    virtual size_t size(void) const {
+      return sizeof(Choice);
+    }
+    /// Archive into \a e
+    virtual void archive(Archive& e) const {
+      Gecode::Choice::archive(e);
+      e << pos << val;
+    }
+  };
+
+  /// Construct brancher
+  BlackHoleBranch(Home home, ViewArray<Int::IntView>& xv)
+    : Brancher(home), x(xv), start(0) {}
+  /// Copy constructor
+  BlackHoleBranch(Space& home, bool share, BlackHoleBranch& b)
+    : Brancher(home, share, b), start(b.start) {
+    x.update(home, share, b.x);
+  }
+
+public:
+  /// Check status of brancher, return true if alternatives left.
+  virtual bool status(const Space&) const {
+    for (int i = start; i < x.size(); ++i)
+      if (!x[i].assigned()) {
+        start = i;
+        return true;
+      }
+    // No non-assigned orders left
+    return false;
+  }
+  /// Return choice
+  virtual Choice* choice(Space&) {
+    int val = -1;
+    int w = 4;
+    for (Int::ViewValues<Int::IntView> vals(x[start]); vals(); ++vals)
+      if (layer[vals.val()] < w) {
+        val = vals.val();
+        if ((w = layer[vals.val()]) == 0) break;
+      }
+
+    assert(val >= 1 && val < 52);
+    return new Choice(*this, start, val);
+  }
+  /// Return choice
+  virtual Choice* choice(const Space&, Archive& e) {
+    int pos, val;
+    e >> pos >> val;
+    return new Choice(*this, pos, val);
+  }
+  /// Perform commit for choice \a _c and alternative \a a.
+  virtual ExecStatus commit(Space& home, const Gecode::Choice& _c,
+                            unsigned int a) {
+    const Choice& c = static_cast<const Choice&>(_c);
+    if (a)
+      return me_failed(x[c.pos].nq(home, c.val)) ? ES_FAILED : ES_OK;
+    else
+      return me_failed(x[c.pos].eq(home, c.val)) ? ES_FAILED : ES_OK;
+  }
+  /// Copy brancher
+  virtual Actor* copy(Space& home, bool share) {
+    return new (home) BlackHoleBranch(home, share, *this);
+  }
+  /// Post brancher
+  static void post(Home home, IntVarArgs x) {
+    ViewArray<Int::IntView> xv(home, x);
+    (void) new (home) BlackHoleBranch(home, xv);
+  }
+  /// Delete brancher and return its size
+  virtual size_t dispose(Space&) {
+    return sizeof(*this);
+  }
+};
+
+
+/**
+ * \brief %Example: Black hole patience
+ *
+ * This example solves instances of the black-hole patience game.
+ *
+ * The model of the problem is mostly taken from "Search in the
+ * Patience Game 'Black Hole'", by Ian P. Gent, Chris Jefferson, Tom
+ * Kelsey, In�s Lynce, Ian Miguel, Peter Nightingale, Barbara
+ * M. Smith, and S. Armagan Tarim.
+ *
+ * The conditional symmetry identified in the above paper can be
+ * eliminated (enabled by default).
+ *
+ * \ingroup Example
+ *
+ */
+class BlackHole : public Script {
+protected:
+  IntVarArray x, ///< Card at position
+    y; ///< Position of card
+
+  /// Return a string representing the card of value val
+  std::string
+  card(int val) const {
+    const char* suit = "SCHD";
+    std::ostringstream o;
+    o << std::setw(2) << (1 + (val%13)) << suit[val/13];
+    return o.str();
+  }
+
+public:
+  /// Symmetry variants
+  enum {
+    SYMMETRY_NONE,       ///< No symmetry breaking
+    SYMMETRY_CONDITIONAL ///< Breaking conditional symmetries
+  };
+  /// Propagation of placement-rules
+  enum {
+    PROPAGATION_REIFIED,  ///< Reified propagation
+    PROPAGATION_DFA,      ///< Extensional propagation using automatons
+    PROPAGATION_TUPLE_SET ///< Extensional propagation using tables
+  };
+  /// Actual model
+  BlackHole(const SizeOptions& opt)
+    : x(*this, 52, 0,51), y(*this, 52, 0,51)
+  {
+    // Black ace at bottom
+    rel(*this, x[0], IRT_EQ, 0);
+
+    // x is order and y is placement
+    channel(*this, x, y, opt.icl());
+
+    // The placement rules: the absolute value of the difference
+    // between two consecutive cards is 1 or 12.
+    if (opt.propagation() == PROPAGATION_REIFIED) {
+      // Build table for accessing the rank of a card
+      IntArgs modtable(52);
+      for (int i = 0; i < 52; ++i) {
+        modtable[i] = i%13;
+      }
+      for (int i = 0; i < 51; ++i) {
+        IntVar x1(*this, 0, 12), x2(*this, 0, 12);
+        element(*this, modtable, x[i], x1);
+        element(*this, modtable, x[i+1], x2);
+        const int dr[2] = {1, 12};
+        IntVar diff(*this, IntSet(dr, 2));
+        rel(*this, abs(x1-x2) == diff, ICL_DOM);
+      }
+    } else if (opt.propagation() == PROPAGATION_DFA) {
+      // Build table for allowed tuples
+      REG expression;
+      for (int r = 13; r--; ) {
+        for (int s1 = 4; s1--; ) {
+          for (int s2 = 4; s2--; ) {
+            for (int i = -1; i <= 1; i+=2) {
+              REG r1 = REG(r+13*s1);
+              REG r2 = REG((r+i+52+13*s2)%52);
+              REG r = r1 + r2;
+              expression |= r;
+            }
+          }
+        }
+      }
+      DFA table(expression);
+
+      for (int i = 51; i--; )
+        extensional(*this, IntVarArgs() << x[i] << x[i+1], table);
+
+    } else { // opt.propagation() == PROPAGATION_TUPLE_SET)
+      // Build table for allowed tuples
+      TupleSet tupleSet;
+      for (int r = 13; r--; )
+        for (int s1 = 4; s1--; )
+          for (int s2 = 4; s2--; )
+            for (int i = -1; i <= 1; i+=2) {
+              tupleSet.add(IntArgs(2, r+13*s1, (r+i+52+13*s2)%52));
+            }
+      tupleSet.finalize();
+
+      for (int i = 51; i--; )
+        extensional(*this, IntVarArgs() << x[i] << x[i+1], tupleSet);
+    }
+
+    // A card must be played before the one under it.
+    for (int i = 17; i--; )
+      for (int j = 2; j--; )
+        rel(*this, y[layout[i][j]] < y[layout[i][j+1]]);
+
+    // Compute and break the conditional symmetries that are dependent
+    // on the current layout.
+    // Two cards with the same rank but different suits are symmetric
+    // with respect to their placement in the black hole if changing
+    // their order does not affect any other card.
+    if (opt.symmetry() == SYMMETRY_CONDITIONAL) {
+      // For all ranks
+      for (int r = 13; r--; ) {
+        // For all pairs of suits
+        for (int s1 = 4; s1--; ) {
+          for (int s2 = s1; s2--; ) {
+            int c1 = 13*s1 + r,
+              c2 = 13*s2 + r;
+            // The ace of spades is already placed
+            if (c1 == 0 || c2 == 0) continue;
+            // Piles are handled by the rules of the game
+            if (pile[c1] == pile[c2]) continue;
+            // Fix the right order of the cards
+            int o1 = c1, o2 = c2;
+            if (pile[c1] > pile[c2] && layer[c2] >= layer[c1])
+              std::swap(o1, o2);
+            // cond is the condition for the symmetry
+            BoolVarArgs ba;
+            // Both cards played after the ones on top of them
+            for (int i = 0; i < layer[o1]; ++i)
+              ba << expr(*this, (y[layout[pile[o1]][i]] < y[o2]));
+            for (int i = 0; i < layer[o2]; ++i)
+              ba << expr(*this, (y[layout[pile[o2]][i]] < y[o1]));
+            // Both cards played before the ones under them
+            for (int i = layer[o1]+1; i < 3; ++i)
+              ba << expr(*this, (y[o2] < y[layout[pile[o1]][i]]));
+            for (int i = layer[o2]+1; i < 3; ++i)
+              ba << expr(*this, (y[o1] < y[layout[pile[o2]][i]]));
+            // Cond holds when all the above holds
+            BoolVar cond(*this, 0, 1);
+            rel(*this, BOT_AND, ba, cond);
+
+            // If cond is fulfilled, then we can order the cards
+            // cond -> (y[o1] < y[o2])
+            rel(*this, !cond || (y[o1] < y[o2]));
+          }
+        }
+      }
+    }
+
+    // Install custom brancher
+    BlackHoleBranch::post(*this, x);
+  }
+
+  /// Print instance and solution
+  virtual void
+  print(std::ostream& os) const {
+    os << "Layout:" << std::endl;
+    for (int i = 0; i < 17; i++) {
+      for (int j = 0; j < 3; j++)
+        os << card(layout[i][j]) << " ";
+      if ((i+1) % 3 == 0)
+        os << std::endl;
+      else
+        os << "  \t";
+    }
+    os << std::endl << std::endl;
+
+    os << "Solution:" << std::endl;
+    for (int i = 0; i < 52; ++i) {
+      if (x[i].assigned())
+        os << card(x[i].val()) << " ";
+      else
+        os << "   ";
+      if ((i + 1) % 13 == 0)
+        os << std::endl;
+    }
+    os << std::endl;
+    os << std::endl;
+  }
+
+  /// Constructor for cloning \a s
+  BlackHole(bool share, BlackHole& s) : Script(share,s) {
+    x.update(*this, share, s.x);
+    y.update(*this, share, s.y);
+  }
+  /// Copy during cloning
+  virtual Space*
+  copy(bool share) {
+    return new BlackHole(share,*this);
+  }
+};
+
+/** \brief Main-function
+ *  \relates BlackHole
+ */
+int
+main(int argc, char* argv[]) {
+  SizeOptions opt("Black Hole patience");
+  opt.symmetry(BlackHole::SYMMETRY_CONDITIONAL);
+  opt.symmetry(BlackHole::SYMMETRY_NONE,"none",
+               "no symmetry breaking");
+  opt.symmetry(BlackHole::SYMMETRY_CONDITIONAL,"conditional",
+               "break conditional symmetries");
+  opt.propagation(BlackHole::PROPAGATION_DFA);
+  opt.propagation(BlackHole::PROPAGATION_REIFIED,
+                  "reified", "use reified propagation");
+  opt.propagation(BlackHole::PROPAGATION_DFA,
+                  "dfa", "use DFA-based extensional propagation");
+  opt.propagation(BlackHole::PROPAGATION_TUPLE_SET,
+                  "tuple-set", "use TupleSet-based extensional propagation");
+  opt.icl(ICL_DOM);
+  opt.parse(argc,argv);
+  // Generates the new board
+  generate(opt.size());
+  Script::run<BlackHole,DFS,SizeOptions>(opt);
+  return 0;
+}
+
+// STATISTICS: example-any

data/ext/libgecode3/vendor/gecode-3.7.3/examples/car-sequencing.cpp

@@ -0,0 +1,653 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Mikael Lagerkvist, 2009
+ *
+ *  Last modified:
+ *     $Date: 2011-09-19 22:02:26 +1000 (Mon, 19 Sep 2011) $ by $Author: schulte $
+ *     $Revision: 12400 $
+ *
+ *  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/driver.hh>
+#include <gecode/int.hh>
+#include <gecode/minimodel.hh>
+
+#include <iomanip>
+
+using namespace Gecode;
+
+// Problems
+namespace {
+  // Problem data
+  extern const int* problems[];
+  // Number of problems
+  extern const unsigned int n_problems;
+}
+
+namespace {
+  /**
+   * \brief %Options for car sequencing problems
+   *
+   * \relates CarSequence
+   */
+  class CarOptions : public SizeOptions {
+  private:
+    /// Max slack parameter
+    Driver::UnsignedIntOption _maxstall;
+
+  public:
+    /// Initialize options for example with name \a s
+    CarOptions(const char* s)
+      : SizeOptions(s),
+        _maxstall("-maxstall", "Maximum numbere of stalls", 30)
+    {
+      // Add options
+      add(_maxstall);
+    }
+    /// Parse options from arguments \a argv (number is \a argc)
+    void parse(int& argc, char* argv[]) {
+      SizeOptions::parse(argc,argv);
+    }
+    /// Get max stalls
+    int maxstall(void) const { return _maxstall.value(); }
+  };
+
+
+  /**
+   * \brief Propagator that pushes all occurences of a value to the end.
+   *
+   * This propagator uses a variable array \f$x=\langle
+   * x_1,x_2,\ldots,x_n\rangle\f$, a variable \f$y\f$, and a value
+   * \f$val\f$. It It makes sure that the last \f$y\f$ variables of
+   * \f$x\f$ are assigned the value, and that the value does not
+   * appear in the rest of the array. Furthermore, the constriant
+   * ensure that \$fval\$f isnot adjacent to \$fval-1\$f.
+   *
+   * Since the propagator is custom-made for the car sequencing
+   * example, it relies on the fact that the value will be equal to
+   * the upper bound to speed up computation. For example, it can
+   * safely rely on only subscribing to bound events.
+   * 
+   * \relates CarSequence 
+   */
+  template <class View>
+  class PushToEnd : public NaryOnePropagator<View,Int::PC_INT_BND> {
+  protected:
+    using NaryOnePropagator<View,Int::PC_INT_BND>::x;
+    using NaryOnePropagator<View,Int::PC_INT_BND>::y;
+    int val;
+
+    /// Constructor for cloning \a p
+    PushToEnd(Space& home, bool share, PushToEnd& p);
+    /// Constructor for posting
+    PushToEnd(Space& home, ViewArray<View>& x0, View y0, int val0);
+  public:
+    /// Constructor for rewriting \a p during cloning
+    PushToEnd(Space& home, bool share, Propagator& p, 
+              ViewArray<View>& x0, View y0, int val0);
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space& home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
+    /// Post propagator
+    static  ExecStatus post(Space& home, 
+                            ViewArray<View>& x0, View y0, int val0);
+  };
+
+  template <class View>
+  inline
+  PushToEnd<View>::PushToEnd(Space& home, 
+                             ViewArray<View>& x0, View y0, int val0)
+    : NaryOnePropagator<View,Int::PC_INT_BND>(home,x0,y0), val(val0) {}
+
+  template <class View>
+  ExecStatus
+  PushToEnd<View>::post(Space& home, 
+                        ViewArray<View>& x0, View y0, int val0) {
+    (void) new (home) PushToEnd<View>(home,x0,y0,val0);
+    return ES_OK;
+  }
+
+  template <class View>
+  inline
+  PushToEnd<View>::PushToEnd(Space& home, bool share, PushToEnd<View>& p)
+    : NaryOnePropagator<View,Int::PC_INT_BND>(home,share,p), val(p.val) {}
+
+  template <class View>
+  inline
+  PushToEnd<View>::PushToEnd(Space& home, bool share, Propagator& p,
+                             ViewArray<View>& x0, View y0, int val0)
+  : NaryOnePropagator<View,Int::PC_INT_BND>(home,share,p,x0,y0), val(val0) {}
+
+  template <class View>
+  Actor*
+  PushToEnd<View>::copy(Space& home, bool share) {
+    return new (home) PushToEnd<View>(home,share,*this);
+  }
+
+  template <class View>
+  ExecStatus
+  PushToEnd<View>::propagate(Space& home, const ModEventDelta&) {
+    // Find number of required positions
+    int min = 0;
+    for (int i = x.size(); i-- && x[i].min() >= val-1; ) {
+      ++min;
+    }
+    // Find number of possible positions
+    int max = 0;
+    {
+      int i = x.size();
+      while (i--) {
+        if (x[i].max() != val) break;
+        ++max;
+        if (max >= y.max()) break;
+      }
+      // No variables later than max can have value val
+      while (i--) {
+        GECODE_ME_CHECK(x[i].le(home, val));
+      }
+    }
+
+    // Constrain y to be in {min..max}
+    GECODE_ME_CHECK(y.gq(home, min));
+    GECODE_ME_CHECK(y.lq(home, max));
+
+    // At least the y.min() last values have value val
+    for (int i = 0, pos = x.size()-1; i < y.min(); ++i, --pos) {
+      GECODE_ME_CHECK(x[pos].eq(home, val));
+    }
+    
+    return y.assigned() ? home.ES_SUBSUMED(*this) : ES_FIX;
+  }
+
+  /** \brief Post PushToEnd propagator.
+   */
+  void pushtoend(Space& home, IntVarArgs x, IntVar y, int val) {
+    ViewArray<Int::IntView> vx(home, x);
+    Int::IntView vy(y);
+    GECODE_ES_FAIL(PushToEnd<Int::IntView>::post(home, vx, vy, val));
+  }
+
+}
+
+
+/**
+ * \brief %Example: Car sequencing
+ *
+ * See problem 1 at http://www.csplib.org/.
+ *
+ * This model uses extra stall-slots instead of violations, as proposed
+ * in "Combining Forces to Solve the Car Sequencing Problem", Perron
+ * and Shaw, CPAIOR 2004.
+ *
+ * \ingroup Example
+ */
+class CarSequencing : public Script {
+public:
+  /// Search variants
+  enum {
+    SEARCH_BAB,    ///< Use branch and bound to optimize
+    SEARCH_RESTART ///< Use restart to optimize
+  };
+  /// Branching variants
+  enum {
+    BRANCH_INORDER,  ///< Branch from left to right
+    BRANCH_MIDDLE  ///< Branch from middle out
+  };
+  /// Propagation variants
+  enum {
+    PROP_REGULAR,  ///< Use regular constraints
+    PROP_CUSTOM    ///< Use custom constraint
+  };
+protected:
+  /// Problem number
+  const int problem;
+  /// Number of cars
+  const int ncars;
+  /// Number of options
+  const int noptions; 
+  /// Number of classes
+  const int nclasses;
+  /// Maximum number of stalls
+  const int maxstall;
+  /// Stall number
+  const int stallval;
+  /// End number
+  const int endval;
+  /// Number of stalls (cost to minimize)
+  IntVar nstall;
+  /// Number of end markers
+  IntVar nend;
+  /// Sequence of cars produced
+  IntVarArray s;
+public:
+  /// Initial model
+  CarSequencing(const CarOptions& opt)
+    : problem(opt.size()),
+      ncars(problems[problem][0]), 
+      noptions(problems[problem][1]), 
+      nclasses(problems[problem][2]),
+      maxstall(opt.maxstall()),
+      stallval(nclasses),
+      endval(nclasses+1),
+      nstall(*this, 0, maxstall),
+      nend(*this, 0, maxstall),
+      s(*this, ncars+maxstall, 0, nclasses+1)
+  {
+    // Read problem
+    const int* probit = problems[problem] + 3;
+
+    // Sequence requirements for the options.
+    IntArgs max(noptions), block(noptions);
+    for (int i = 0; i < noptions; ++i ) {
+      max[i] = *probit++;
+    }
+    for (int i = 0; i < noptions; ++i ) {
+      block[i] = *probit++;
+    }
+    // Number of cars per class
+    IntArgs ncc(nclasses);
+    // What classes require an option
+    IntSetArgs classes(noptions);
+    int** cdata = new int*[noptions]; 
+    for (int i = noptions; i--; ) cdata[i] = new int[nclasses];
+    int* n = new int[noptions];
+    for (int i = noptions; i--; ) n[i] = 0;
+    // Read data
+    for (int c = 0; c < nclasses; ++c) {
+      *probit++;
+      ncc[c] = *probit++;
+      for (int o = 0; o < noptions; ++o) {
+        if (*probit++) {
+          cdata[o][n[o]++] = c;
+        }
+      }
+    }
+    // Transfer specification data to int-sets
+    for (int o = noptions; o--; ) {
+      classes[o] = IntSet(cdata[o], n[o]);
+      delete [] cdata[o];
+    }
+    delete [] cdata;
+    delete [] n;
+
+    // Count the cars
+    {
+      IntSetArgs c(nclasses+2);
+      for (int i = nclasses; i--; ) {
+        c[i] = IntSet(ncc[i], ncc[i]);
+      }
+      c[stallval] = IntSet(0, maxstall);
+      c[  endval] = IntSet(0, maxstall);
+      count(*this, s, c);
+    }
+
+    // Count number of end and stalls
+    count(*this, s, stallval, IRT_EQ, nstall);
+    count(*this, s,   endval, IRT_EQ,   nend);
+    rel(*this, nstall+nend == maxstall);
+
+    // Make sure nothing is overloaded
+    IntSet one(1, 1);
+    for (int o = noptions; o--; ) {
+      // sb[i] reflects if car s[i] has option o
+      BoolVarArgs sb(s.size());
+      for (int i = s.size(); i--; ) {
+        BoolVar b(*this, 0, 1);
+        dom(*this, s[i], classes[o], b);
+        sb[i] = b;
+      }
+      sequence(*this, sb, one, block[o], 0, max[o]);
+    }
+
+    // End-markers located at end only
+    switch (opt.propagation()) {
+    case PROP_REGULAR: {
+      IntArgs notend(nclasses), notstallend(nclasses+1);
+      for (int i = nclasses; i--; ) {
+        notend[i] = i;
+        notstallend[i] = i;
+      }
+      notstallend[nclasses] = stallval;
+      REG r = *REG(notend) + REG(notstallend) + *REG(endval);
+      extensional(*this, s, r);
+      for (int pos = s.size()-1, i = 0; i < maxstall; ++i, --pos) {
+        rel(*this, (nend > i) >> (s[pos]==endval));
+      }
+    } break;
+    case PROP_CUSTOM: {
+      pushtoend(*this, s, nend, endval);
+    } break;
+    }
+    
+
+    // Branching
+    switch (opt.branching()) {
+    case BRANCH_INORDER:
+      branch(*this, s, INT_VAR_NONE, INT_VAL_MIN);
+      break;
+    case BRANCH_MIDDLE: {
+      IntVarArgs m(s.size());
+      int mid = s.size() / 2;
+      int pos = 0;
+      m[pos++] = s[mid];
+      for (int i = 1; i <= m.size()/2; ++i) {
+        if (mid-i >= 0)
+          m[pos++] = s[mid-i];
+        if (mid+i < s.size())
+          m[pos++] = s[mid+i];
+      }
+      assert(pos == m.size());
+      branch(*this, m, INT_VAR_NONE, INT_VAL_MIN);
+      break;
+    }
+    }
+  }
+        
+  /// Return cost
+  virtual void constrain(const Space& _best) {
+    const CarSequencing& best = static_cast<const CarSequencing&>(_best);
+    rel(*this, nstall, IRT_LE, best.nstall.val());
+  }
+
+  /// Print solution
+  virtual void
+  print(std::ostream& os) const {
+    int width = nclasses > 9 ? 2 : 1;
+    const char* space = nclasses > 9 ? " " : "";
+    os << "Stall slots=" << nstall 
+       << ", End slots=" << nend << std::endl;
+    int i = 0;
+    for (; i < s.size(); ++i) {
+      if (s[i].assigned()) {
+        int v = s[i].val();
+        if (v == endval) break;
+        if (v == stallval) os << space << "_ ";
+        else               os << std::setw(width) << v << " ";
+      } else {
+        os << space << "? ";    
+      }
+      if ((i+1)%20 == 0) os << std::endl;
+    }
+    if (i%20)
+      os << std::endl;
+    os << std::endl;
+  }
+
+  /// Constructor for cloning \a s
+  CarSequencing(bool share, CarSequencing& cs)
+    : Script(share,cs), 
+      problem(cs.problem),
+      ncars(cs.ncars),
+      noptions(cs.noptions),
+      nclasses(cs.nclasses),
+      maxstall(cs.maxstall),
+      stallval(cs.stallval),
+      endval(cs.endval)
+  {
+    nstall.update(*this, share, cs.nstall);
+    nend.update(*this, share, cs.nend);
+    s.update(*this, share, cs.s);
+  }
+  /// Copy during cloning
+  virtual Space*
+  copy(bool share) {
+    return new CarSequencing(share,*this);
+  }
+};
+
+/** \brief Main-function
+ *  \relates CarSequencing
+ */
+int
+main(int argc, char* argv[]) {
+  CarOptions opt("CarSequencing");
+  opt.solutions(0);
+  opt.size(0);
+  opt.search(CarSequencing::SEARCH_BAB);
+  opt.search(CarSequencing::SEARCH_BAB, "bab");
+  opt.search(CarSequencing::SEARCH_RESTART, "restart");
+  opt.branching(CarSequencing::BRANCH_INORDER);
+  opt.branching(CarSequencing::BRANCH_INORDER,  "inorder");
+  opt.branching(CarSequencing::BRANCH_MIDDLE, "middle");
+  opt.propagation(CarSequencing::PROP_CUSTOM);
+  opt.propagation(CarSequencing::PROP_REGULAR, "regular");
+  opt.propagation(CarSequencing::PROP_CUSTOM,  "custom");
+  opt.parse(argc,argv);
+  if (opt.size() >= n_problems) {
+    std::cerr << "Error: size must be between 0 and "
+              << n_problems-1 << std::endl;
+    return 1;
+  }
+
+  switch (opt.search()) {
+  case CarSequencing::SEARCH_BAB:
+    Script::run<CarSequencing,BAB,CarOptions>(opt); break;
+  case CarSequencing::SEARCH_RESTART:
+    Script::run<CarSequencing,Restart,CarOptions>(opt); break;
+  }
+  return 0;
+}
+
+
+namespace {
+  /// Problems from CSPLib
+
+  /// Simple initial example
+  const int p0[] = {
+    10, 5, 6,
+    1, 2, 1, 2, 1,
+    2, 3, 3, 5, 5,
+    0, 1, 1, 0, 1, 1, 0, 
+    1, 1, 0, 0, 0, 1, 0, 
+    2, 2, 0, 1, 0, 0, 1, 
+    3, 2, 0, 1, 0, 1, 0, 
+    4, 2, 1, 0, 1, 0, 0, 
+    5, 2, 1, 1, 0, 0, 0
+  };
+
+  // ---------------------------------
+  //  Problem 4/72  (Regin & Puget   // 1)
+  // ---------------------------------
+  const int p1[] = {
+    100, 5, 22,
+    1, 2, 1, 2, 1,
+    2, 3, 3, 5, 5,
+    0, 6, 1, 0, 0, 1, 0, 
+    1, 10, 1, 1, 1, 0, 0, 
+    2, 2, 1, 1, 0, 0, 1, 
+    3, 2, 0, 1, 1, 0, 0, 
+    4, 8, 0, 0, 0, 1, 0, 
+    5, 15, 0, 1, 0, 0, 0, 
+    6, 1, 0, 1, 1, 1, 0, 
+    7, 5, 0, 0, 1, 1, 0, 
+    8, 2, 1, 0, 1, 1, 0, 
+    9, 3, 0, 0, 1, 0, 0, 
+    10, 2, 1, 0, 1, 0, 0, 
+    11, 1, 1, 1, 1, 0, 1, 
+    12, 8, 0, 1, 0, 1, 0, 
+    13, 3, 1, 0, 0, 1, 1, 
+    14, 10, 1, 0, 0, 0, 0, 
+    15, 4, 0, 1, 0, 0, 1, 
+    16, 4, 0, 0, 0, 0, 1, 
+    17, 2, 1, 0, 0, 0, 1, 
+    18, 4, 1, 1, 0, 0, 0, 
+    19, 6, 1, 1, 0, 1, 0, 
+    20, 1, 1, 0, 1, 0, 1, 
+    21, 1, 1, 1, 1, 1, 1, 
+  };
+
+  // --------------------------------
+  //  Problem 6/76, (Regin & Puget   // 2)
+  // --------------------------------
+  const int p2[] = {
+    100, 5, 22,
+    1, 2, 1, 2, 1,
+    2, 3, 3, 5, 5,
+    0, 13, 1, 0, 0, 0, 0, 
+    1, 8, 0, 0, 0, 1, 0, 
+    2, 7, 0, 1, 0, 0, 0, 
+    3, 1, 1, 0, 0, 1, 0, 
+    4, 12, 0, 0, 1, 0, 0, 
+    5, 5, 0, 1, 0, 1, 0, 
+    6, 5, 0, 0, 1, 1, 0, 
+    7, 6, 0, 1, 1, 0, 0, 
+    8, 3, 1, 0, 0, 0, 1, 
+    9, 12, 1, 1, 0, 0, 0, 
+    10, 8, 1, 1, 0, 1, 0, 
+    11, 2, 1, 0, 0, 1, 1, 
+    12, 2, 1, 1, 1, 0, 0, 
+    13, 1, 0, 1, 0, 1, 1, 
+    14, 4, 1, 0, 1, 0, 0, 
+    15, 4, 0, 1, 0, 0, 1, 
+    16, 1, 1, 1, 0, 1, 1, 
+    17, 2, 1, 0, 1, 1, 0, 
+    18, 1, 0, 0, 0, 0, 1, 
+    19, 1, 1, 1, 1, 1, 0, 
+    20, 1, 1, 1, 0, 0, 1, 
+    21, 1, 0, 1, 1, 1, 0, 
+  };
+
+  // ---------------------------------
+  //  Problem 10/93, (Regin & Puget   // 3)
+  // ---------------------------------
+  const int p3[] = {
+    100, 5, 25,
+    1, 2, 1, 2, 1,
+    2, 3, 3, 5, 5,
+    0, 7, 1, 0, 0, 1, 0,
+    1, 11, 1, 1, 0, 0, 0,
+    2, 1, 0, 1, 1, 1, 1,
+    3, 3, 1, 0, 1, 0, 0,
+    4, 15, 0, 1, 0, 0, 0,
+    5, 2, 1, 0, 1, 1, 0,
+    6, 8, 0, 1, 0, 1, 0,
+    7, 5, 0, 0, 1, 0, 0,
+    8, 3, 0, 0, 0, 1, 0,
+    9, 4, 0, 1, 1, 1, 0,
+    10, 5, 1, 0, 0, 0, 0,
+    11, 2, 1, 1, 1, 0, 1,
+    12, 6, 0, 1, 1, 0, 0,
+    13, 2, 0, 0, 1, 0, 1,
+    14, 2, 0, 1, 0, 0, 1,
+    15, 4, 1, 1, 1, 1, 0,
+    16, 3, 1, 0, 0, 0, 1,
+    17, 5, 1, 1, 0, 1, 0,
+    18, 2, 1, 1, 1, 0, 0,
+    19, 4, 1, 1, 0, 0, 1,
+    20, 1, 1, 0, 0, 1, 1,
+    21, 1, 1, 1, 0, 1, 1,
+    22, 1, 0, 1, 0, 1, 1,
+    23, 1, 0, 1, 1, 0, 1,
+    24, 2, 0, 0, 0, 0, 1,
+  };
+
+  // --------------
+  //  Problem 16/81,
+  // --------------
+  const int p4[] = {
+    100, 5, 26,
+    1, 2, 1, 2, 1,
+    2, 3, 3, 5, 5,
+    0, 10, 1, 0, 0, 0, 0,
+    1, 2, 0, 0, 0, 0, 1,
+    2, 8, 0, 1, 0, 1, 0,
+    3, 8, 0, 0, 0, 1, 0,
+    4, 6, 0, 1, 1, 0, 0,
+    5, 11, 0, 1, 0, 0, 0,
+    6, 3, 0, 0, 1, 0, 0,
+    7, 2, 0, 0, 1, 1, 0,
+    8, 7, 1, 1, 0, 0, 0,
+    9, 2, 1, 0, 0, 1, 1,
+    10, 4, 1, 0, 1, 0, 0,
+    11, 7, 1, 0, 0, 1, 0,
+    12, 1, 1, 1, 1, 0, 1,
+    13, 3, 0, 1, 1, 1, 0,
+    14, 4, 0, 1, 0, 0, 1,
+    15, 5, 1, 1, 1, 0, 0,
+    16, 2, 1, 1, 0, 0, 1,
+    17, 1, 1, 0, 1, 1, 1,
+    18, 2, 1, 0, 1, 1, 0,
+    19, 3, 1, 0, 0, 0, 1,
+    20, 2, 0, 1, 1, 0, 1,
+    21, 1, 0, 1, 0, 1, 1,
+    22, 3, 1, 1, 0, 1, 0,
+    23, 1, 0, 0, 1, 1, 1,
+    24, 1, 1, 1, 1, 1, 1,
+    25, 1, 1, 1, 1, 1, 0,
+  };
+
+  // ----------------------------------
+  //  Problem 19/71,  (Regin & Puget   // 4)
+  // ----------------------------------
+  const int p5[] = {
+    100, 5, 23,
+    1, 2, 1, 2, 1,
+    2, 3, 3, 5, 5,
+    0, 2, 0, 0, 0, 1, 1,
+    1, 2, 0, 0, 1, 0, 1,
+    2, 5, 0, 1, 1, 1, 0,
+    3, 4, 0, 0, 0, 1, 0,
+    4, 4, 0, 1, 0, 1, 0,
+    5, 1, 1, 1, 0, 0, 1,
+    6, 3, 1, 1, 1, 0, 1,
+    7, 4, 0, 0, 1, 0, 0,
+    8, 19, 0, 1, 0, 0, 0,
+    9, 7, 1, 1, 0, 1, 0,
+    10, 10, 1, 0, 0, 0, 0,
+    11, 1, 0, 0, 1, 1, 0,
+    12, 5, 1, 1, 1, 1, 0,
+    13, 2, 1, 0, 1, 1, 0,
+    14, 6, 1, 1, 0, 0, 0,
+    15, 4, 1, 1, 1, 0, 0,
+    16, 8, 1, 0, 0, 1, 0,
+    17, 1, 1, 0, 0, 0, 1,
+    18, 4, 0, 1, 1, 0, 0,
+    19, 2, 0, 0, 0, 0, 1,
+    20, 4, 0, 1, 0, 0, 1,
+    21, 1, 1, 1, 0, 1, 1,
+    22, 1, 0, 1, 1, 0, 1,
+  };
+
+  const int* problems[] = {
+    &p0[0],
+    &p1[0],
+    &p2[0],
+    &p3[0],
+    &p4[0],
+    &p5[0],
+  };
+
+    /// The number of instances
+  const unsigned int n_problems = sizeof(problems)/sizeof(int*);
+};
+
+// STATISTICS: example-any
+