gecoder-with-gecode 0.7.1 → 0.8.0

data/ext/gecode-2.1.1/gecode/kernel/branching.icc

@@ -0,0 +1,447 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *     Guido Tack, 2004
+ *
+ *  Last modified:
+ *     $Date: 2008-02-16 10:42:26 +0100 (Sat, 16 Feb 2008) $ by $Author: tack $
+ *     $Revision: 6185 $
+ *
+ *  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.
+ *
+ */
+
+namespace Gecode {
+
+  /**
+   * \defgroup TaskBranchViewVal Generic branching based on view and value selection
+   *
+   * Implements view-based branching for an array of views and value.
+   * \ingroup TaskActor
+   */
+
+  //@{
+  /// Status returned by member functions of view selection class
+  enum ViewSelStatus {
+    VSS_NONE,   ///< Current view is not better
+    VSS_SELECT, ///< Current view is better
+    VSS_COMMIT  ///< Current view is known to be a best one
+  };
+
+  /**
+   * \brief Generic branching
+   *
+   * Implements view-based branching for an array of views (of type
+   * \a View) and value (of type \a Val). The behaviour is defined by
+   * the class \a ViewSel (which view is selected for branching)
+   * and the class \a ValSel (which value is selected for branching).
+   *
+   * The class \a ViewSel must implement two member functions:
+   *  - Gecode::ViewSelStatus init(const Space* \a home, \a View \a x)
+   *    Initializes view selection with the \a View \a x. If \a x
+   *    is known to be a best one, VSS_COMMIT should be returned.
+   *    Otherwise, either VSS_NONE or VSS_SELECT should be returned.
+   *  - Gecode::ViewSelStatus select(const Space* \a home, \a View \a x)
+   *    If \a x is not better than the previously selected view,
+   *    return VSS_NONE. If it is better, return VSS_SELECT. If
+   *    it is a best view, return VSS_COMMIT.
+   *
+   * The class \a ValSel must implement two member functions:
+   *  - \a Val val(const Space* \a home, View \a x) const
+   *    returns the value (most likely determined by \a x) to branch with.
+   *  - Gecode::ModEvent tell(Space* \a home, unsigned int \a a, \a View \a x, \a Val \a n)
+   *    performs a tell for alternative \a a on \a x with value \a n.
+   *
+   * For examples, see \link int/branch.hh integer branchings \endlink.
+   */
+  template <class View, class Val, class ViewSel, class ValSel>
+  class ViewValBranching : public Branching {
+  protected:
+    ViewArray<View> x;  ///< Views to branch on
+    mutable int start;  ///< Unassigned views start at x[start]
+    /// Constructor for cloning \a b
+    ViewValBranching(Space* home, bool share, ViewValBranching& b);
+  public:
+    /// Constructor for creation
+    ViewValBranching(Space* home, ViewArray<View>& x);
+    /// Check status of branching, return true if alternatives left
+    virtual bool status(const Space* home) const;
+    /// Return branching description (of type Gecode::PosValDesc)
+    virtual const BranchingDesc* description(const Space* home) const;
+    /// Perform commit for branching description \a d and alternative \a a
+    virtual ExecStatus commit(Space* home, const BranchingDesc* d,
+                              unsigned int a);
+    /// Return specification for this branching given a variable map \a m
+    virtual Reflection::ActorSpec spec(const Space* home,
+                                       Reflection::VarMap& m) const;
+    /// Return specification for a branch
+    virtual Reflection::BranchingSpec
+    branchingSpec(const Space* home, 
+                  Reflection::VarMap& m,
+                  const BranchingDesc* d) const;
+    /// Actor type identifier of this branching
+    static Support::Symbol ati(void);
+    /// Post branching according to specification
+    static void post(Space* home, Reflection::VarMap& m,
+                     const Reflection::ActorSpec& spec);
+    /// Perform cloning
+    virtual Actor* copy(Space* home, bool share);
+  };
+
+  /**
+   * \brief Generic assignment
+   *
+   * Implements view-based assignment for an array of views (of type
+   * \a View) and value (of type \a Val). The behaviour is defined by
+   * the class \a ValSel (which value is selected for assignment).
+   *
+   * The class \a ValSel must implement two member functions:
+   *  - \a Val val(const Space* \a home, View \a x) const
+   *    returns the value (most likely determined by \a x) to branch with.
+   *  - Gecode::ModEvent tell(Space* \a home, unsigned int a, \a View \a x, \a Val \a n)
+   *    performs a tell on \a x with value \a n (the value for \a a is
+   *    always 0, it is present such that assignments can use the same
+   *    value selection as branchings).
+   *
+   * For examples, see \link int/branch.hh integer branchings \endlink.
+   */
+  template <class View, class Val, class ValSel>
+  class ViewValAssignment : public Branching {
+  protected:
+    ViewArray<View> x;  ///< Views to branch on
+    mutable int start;  ///< Unassigned views start at x[start]
+    /// Constructor for cloning \a b
+    ViewValAssignment(Space* home, bool share, ViewValAssignment& b);
+  public:
+    /// Constructor for creation
+    ViewValAssignment(Space* home, ViewArray<View>& x);
+    /// Check status of branching, return true if alternatives left
+    virtual bool status(const Space* home) const;
+    /// Return branching description (of type Gecode::PosValDesc)
+    virtual const BranchingDesc* description(const Space* home) const;
+    /// Perform commit for branching description \a d and alternative \a a
+    virtual ExecStatus commit(Space* home, const BranchingDesc* d,
+                              unsigned int a);
+    /// Return specification for this assignment given a variable map \a m
+    virtual Reflection::ActorSpec spec(const Space* home,
+                                        Reflection::VarMap& m) const;
+    /// Return specification for a branch
+    virtual Reflection::BranchingSpec
+    branchingSpec(const Space* home, 
+                  Reflection::VarMap& m,
+                  const BranchingDesc* d) const;
+    /// Actor type identifier of this assignment
+    static Support::Symbol ati(void);
+    /// Post assignment according to specification
+    static void post(Space* home, Reflection::VarMap& m,
+                     const Reflection::ActorSpec& spec);
+    /// Perform cloning
+    virtual Actor* copy(Space* home, bool share);
+  };
+
+  /**
+   * \brief %Branching descriptions storing position and value
+   *
+   * The maximal number of alternatives is defined by \a alt.
+   */
+  template <class Val, unsigned int alt>
+  class PosValDesc : public BranchingDesc {
+  protected:
+    /// Position of view
+    const int _pos;
+    /// Value to assign to
+    const Val _val;
+    /// Start position in view array
+    const int _start;
+  public:
+    /** \brief Initialize description for branching \a b, position \a p, value \a n, and start position \a s.
+      *
+      * The start position can be used in the commit function to eliminate 
+      * assigned variables from the array.
+      */
+    PosValDesc(const Branching* b, const int p, const Val& n, const int s=0);
+    /// Return position in array
+    int pos(void) const;
+    /// Return value to branch with
+    Val val(void) const;
+    /// Return the start index in the array
+    int start(void) const;
+    /// Report size occupied
+    virtual size_t size(void) const;
+  };
+
+  //@}
+
+
+
+
+
+
+  /*
+   * Branching descriptions with position and value
+   *
+   */
+
+  template <class Val, unsigned int alt>
+  forceinline
+  PosValDesc<Val,alt>::PosValDesc(const Branching* b, const int p,
+                                  const Val& n, const int s)
+    : BranchingDesc(b,alt), _pos(p), _val(n), _start(s) {}
+
+  template <class Val, unsigned int alt>
+  forceinline int
+  PosValDesc<Val,alt>::pos(void) const {
+    return _pos;
+  }
+
+  template <class Val, unsigned int alt>
+  forceinline Val
+  PosValDesc<Val,alt>::val(void) const {
+    return _val;
+  }
+
+  template <class Val, unsigned int alt>
+  forceinline int
+  PosValDesc<Val,alt>::start(void) const {
+    return _start;
+  }
+
+  template <class Val, unsigned int alt>
+  size_t
+  PosValDesc<Val,alt>::size(void) const {
+    return sizeof(PosValDesc<Val,alt>);
+  }
+
+
+  /*
+   * Generic branching based on variable/value selection
+   *
+   */
+
+  template <class View, class Val, class ViewSel, class ValSel>
+  forceinline
+  ViewValBranching<View,Val,ViewSel,ValSel>
+  ::ViewValBranching(Space* home, ViewArray<View>& x0)
+    : Branching(home), x(x0), start(0) {}
+
+
+  template <class View, class Val, class ViewSel, class ValSel>
+  forceinline
+  ViewValBranching<View,Val,ViewSel,ValSel>
+  ::ViewValBranching(Space* home, bool share, ViewValBranching& b)
+    : Branching(home,share,b), start(b.start) {
+    x.update(home,share,b.x);
+  }
+
+  template <class View, class Val, class ViewSel, class ValSel>
+  Actor*
+  ViewValBranching<View,Val,ViewSel,ValSel>::copy(Space* home, bool share) {
+    return new (home)
+      ViewValBranching<View,Val,ViewSel,ValSel>(home,share,*this);
+  }
+
+  template <class View, class Val, class ViewSel, class ValSel>
+  bool
+  ViewValBranching<View,Val,ViewSel,ValSel>
+  ::status(const Space*) const {
+    for (int i=start; i < x.size(); i++)
+      if (!x[i].assigned()) {
+        start = i;
+        return true;
+      }
+    return false;
+  }
+
+  template <class View, class Val, class ViewSel, class ValSel>
+  const BranchingDesc*
+  ViewValBranching<View,Val,ViewSel,ValSel>
+  ::description(const Space* home) const {
+    assert(!x[start].assigned());
+    ViewSel vs; // For view selection
+    ValSel  vl; // For value selection
+    int i = start;
+    int b = i++;
+    if (vs.init(home,x[b]) != VSS_COMMIT)
+      for (; i < x.size(); i++)
+        if (!x[i].assigned())
+          switch (vs.select(home,x[i])) {
+          case VSS_SELECT: b=i; break;
+          case VSS_COMMIT: b=i; goto create;
+          case VSS_NONE:   break;
+          default:         GECODE_NEVER;
+          }
+  create:
+    return new PosValDesc<Val,2>(this,b-start,vl.val(home,x[b]),start);
+  }
+
+  template <class View, class Val, class ViewSel, class ValSel>
+  ExecStatus
+  ViewValBranching<View,Val,ViewSel,ValSel>
+  ::commit(Space* home, const BranchingDesc* d, unsigned int a) {
+    const PosValDesc<Val,2>* pvd = static_cast<const PosValDesc<Val,2>*>(d);
+    // Eliminate views from x[0] ... x[d->start()-1]
+    x.drop_fst(pvd->start()); start = 0;
+    ValSel vs;
+    return me_failed(vs.tell(home,a,x[pvd->pos()],pvd->val()))
+      ? ES_FAILED : ES_OK;
+  }
+
+  template <class View, class Val, class ViewSel, class ValSel>
+  Support::Symbol
+  ViewValBranching<View,Val,ViewSel,ValSel>::ati(void) {
+    return Reflection::mangle<View,Val,ViewSel,ValSel>("Gecode::ViewValBranching");
+  }
+
+  template <class View, class Val, class ViewSel, class ValSel>
+  void
+  ViewValBranching<View,Val,ViewSel,ValSel>
+    ::post(Space* home, Reflection::VarMap& vars,
+           const Reflection::ActorSpec& spec) {
+    spec.checkArity(1);
+    ViewArray<View> x(home, vars, spec[0]);
+    (void) new (home) ViewValBranching<View,Val,ViewSel,ValSel>(home, x);
+  }
+
+  template <class View, class Val, class ViewSel, class ValSel>
+  Reflection::ActorSpec
+  ViewValBranching<View,Val,ViewSel,ValSel>::spec(const Space* home,
+    Reflection::VarMap& m) const {
+    Reflection::ActorSpec s(ati());
+    return s << x.spec(home, m);
+  }
+
+  template <class View, class Val, class ViewSel, class ValSel>
+  Reflection::BranchingSpec
+  ViewValBranching<View,Val,ViewSel,ValSel>::branchingSpec(const Space* home, 
+    Reflection::VarMap& m, const BranchingDesc* d) const {
+    Reflection::BranchingSpec bs(d);
+    const PosValDesc<Val,2>* pvd = static_cast<const PosValDesc<Val,2>*>(d);
+    ValSel vs;
+    vs.branchingSpec(home, m, bs, 2, x[pvd->start()+pvd->pos()], pvd->val());
+    return bs;
+  }
+
+  /*
+   * Generic assignment based on value selection
+   *
+   */
+
+  template <class View, class Val, class ValSel>
+  forceinline
+  ViewValAssignment<View,Val,ValSel>
+  ::ViewValAssignment(Space* home, ViewArray<View>& x0)
+    : Branching(home), x(x0), start(0) {}
+
+
+  template <class View, class Val, class ValSel>
+  forceinline
+  ViewValAssignment<View,Val,ValSel>
+  ::ViewValAssignment(Space* home, bool share, ViewValAssignment& b)
+    : Branching(home,share,b), start(b.start) {
+    x.update(home,share,b.x);
+  }
+
+  template <class View, class Val, class ValSel>
+  Actor*
+  ViewValAssignment<View,Val,ValSel>::copy(Space* home, bool share) {
+    return new (home)
+      ViewValAssignment<View,Val,ValSel>(home,share,*this);
+  }
+
+  template <class View, class Val, class ValSel>
+  bool
+  ViewValAssignment<View,Val,ValSel>
+  ::status(const Space*) const {
+    for (int i=start; i < x.size(); i++)
+      if (!x[i].assigned()) {
+        start = i;
+        return true;
+      }
+    return false;
+  }
+
+  template <class View, class Val, class ValSel>
+  const BranchingDesc*
+  ViewValAssignment<View,Val,ValSel>
+  ::description(const Space* home) const {
+    assert(!x[start].assigned());
+    ValSel vl; // For value selection
+    return new PosValDesc<Val,1>(this,0,vl.val(home,x[start]),start);
+  }
+
+  template <class View, class Val, class ValSel>
+  ExecStatus
+  ViewValAssignment<View,Val,ValSel>
+  ::commit(Space* home, const BranchingDesc* d, unsigned int) {
+    const PosValDesc<Val,1>* pvd = static_cast<const PosValDesc<Val,1>*>(d);
+    // Eliminate views from x[0] ... x[d->start()-1]
+    x.drop_fst(pvd->start()); start = 0;
+    ValSel vs;
+    return me_failed(vs.tell(home,0,x[pvd->pos()],pvd->val()))
+      ? ES_FAILED : ES_OK;
+  }
+
+  template <class View, class Val, class ValSel>
+  Support::Symbol
+  ViewValAssignment<View,Val,ValSel>::ati(void) {
+    return Reflection::mangle<View,Val,ValSel>("Gecode::ViewValAssignment");
+  }
+
+  template <class View, class Val, class ValSel>
+  void
+  ViewValAssignment<View,Val,ValSel>
+    ::post(Space* home, Reflection::VarMap& vars,
+           const Reflection::ActorSpec& spec) {
+    spec.checkArity(1);
+    ViewArray<View> x(home, vars, spec[0]);
+    (void) new (home) ViewValAssignment<View,Val,ValSel>(home, x);
+  }
+
+  template <class View, class Val, class ValSel>
+  Reflection::ActorSpec
+  ViewValAssignment<View,Val,ValSel>::spec(const Space* home,
+    Reflection::VarMap& m) const {
+    Reflection::ActorSpec s(ati());
+    return s << x.spec(home, m);
+  }
+
+  template <class View, class Val, class ValSel>
+  Reflection::BranchingSpec
+  ViewValAssignment<View,Val,ValSel>::branchingSpec(const Space* home, 
+    Reflection::VarMap& m, const BranchingDesc* d) const {
+    Reflection::BranchingSpec bs(d);
+    const PosValDesc<Val,1>* pvd = static_cast<const PosValDesc<Val,1>*>(d);
+    ValSel vs;
+    vs.branchingSpec(home, m, bs, 1, x[pvd->start()+pvd->pos()], pvd->val());
+    return bs;
+  }
+
+}
+
+// STATISTICS: kernel-other

data/ext/gecode-2.1.1/gecode/kernel/core.cc

@@ -0,0 +1,473 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2008-02-28 09:12:58 +0100 (Thu, 28 Feb 2008) $ by $Author: tack $
+ *     $Revision: 6338 $
+ *
+ *  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/kernel.hh"
+
+namespace Gecode {
+
+  /*
+   * Variable type disposer
+   *
+   */
+  void
+  VarDisposerBase::dispose(Space*,VarImpBase*) {}
+
+  VarDisposerBase::~VarDisposerBase(void) {}
+
+
+
+  /*
+   * Actor
+   *
+   */
+  Reflection::ActorSpec
+  Actor::spec(const Space*, Reflection::VarMap&) const {
+    throw Reflection::NoReflectionDefinedException();
+  }
+
+  size_t
+  Actor::allocated(void) const {
+    return 0;
+  }
+
+#ifdef __GNUC__
+  /// To avoid warnings from GCC
+  Actor::~Actor(void) {}
+#endif
+
+
+
+  /*
+   * Propagator
+   *
+   */
+  ExecStatus 
+  Propagator::advise(Space*, Advisor*, const Delta*) {
+    assert(false);
+    return ES_FAILED;
+  }
+
+
+
+  /*
+   * Branching
+   *
+   */
+  Reflection::BranchingSpec
+  Branching::branchingSpec(const Space*,
+                           Reflection::VarMap&, const BranchingDesc*) const {
+    throw Reflection::NoReflectionDefinedException();
+  }
+
+
+
+  /*
+   * Space: Misc
+   *
+   */
+  unsigned long int Space::unused_uli;
+
+#ifdef GECODE_HAS_VAR_DISPOSE
+  VarDisposerBase* Space::vd[AllVarConf::idx_d];
+#endif
+
+  Space::Space(void) {
+#ifdef GECODE_HAS_VAR_DISPOSE
+    for (int i=0; i<AllVarConf::idx_d; i++)
+      _vars_d[i] = NULL;
+#endif
+    // Initialize actor and branching links
+    a_actors.init();
+    b_status = b_commit = Branching::cast(&a_actors);
+    // Initialize array for forced deletion to be empty
+    d_fst = d_cur = d_lst = NULL;
+    // Initialize propagator queues
+    pc.p.active = &pc.p.queue[0]-1;
+    for (int i=0; i<=PC_MAX; i++)
+      pc.p.queue[i].init();
+    pc.p.branch_id = 0;
+    pc.p.n_sub = 0;
+  }
+
+  size_t
+  Space::allocated(void) const {
+    size_t s = mm.allocated();
+    Actor** a = d_fst;
+    Actor** e = d_cur;
+    while (a < e) {
+      s += (*a)->allocated(); a++;
+    }
+    return s;
+  }
+
+  void
+  Space::d_resize(void) {
+    if (d_fst == NULL) {
+      // Create new array
+      d_fst = static_cast<Actor**>(alloc(4*sizeof(Actor*)));
+      d_cur = d_fst;
+      d_lst = d_fst+4;
+    } else {
+      // Resize existing array
+      ptrdiff_t n = d_lst - d_fst;
+      assert(n != 0);
+      Actor** a = static_cast<Actor**>(alloc(2*n*sizeof(Actor*)));
+      memcpy(a, d_fst, n*sizeof(Actor*));
+      reuse(d_fst,n*sizeof(Actor*));
+      d_fst = a;
+      d_cur = a+n;
+      d_lst = a+2*n;
+    }
+  }
+  
+  unsigned int
+  Space::propagators(void) const {
+    unsigned int n = 0;
+    for (ActorLink* q = pc.p.active; q >= &pc.p.queue[0]; q--)
+      for (ActorLink* a = q->next(); a != q; a = a->next())
+        n++;
+    for (ActorLink* a = a_actors.next(); 
+         Branching::cast(a) != b_commit; a = a->next())
+      n++;
+    return n;
+  }
+
+  unsigned int
+  Space::branchings(void) const {
+    unsigned int n = 0;
+    for (ActorLink* a = Branching::cast(b_status); 
+         a != &a_actors; a = a->next())
+      n++;
+    return n;
+  }
+
+  void
+  Space::getVars(Reflection::VarMap&, bool) {}
+
+  Reflection::BranchingSpec
+  Space::branchingSpec(Reflection::VarMap& m, const BranchingDesc* d) const {
+    const Branching* b = b_commit;
+    while ((b != Branching::cast(&a_actors)) && (d->_id != b->id))
+      b = Branching::cast(b->next());
+    if (b == Branching::cast(&a_actors))
+      throw SpaceNoBranching();
+    return b->branchingSpec(this, m, d);
+  }
+
+  Space::~Space(void) {
+    // Mark space as failed
+    fail();
+    // Delete actors that must be deleted
+    {
+      Actor** a = d_fst;
+      Actor** e = d_cur;
+      // So that d_unforce knows that deletion is in progress
+      d_fst = NULL;
+      while (a < e) {
+        (void) (*a)->dispose(this);
+        a++;
+      }
+    }
+#ifdef GECODE_HAS_VAR_DISPOSE
+    // Delete variables that were registered for disposal
+    for (int i=AllVarConf::idx_d; i--;)
+      if (_vars_d[i] != NULL)
+        vd[i]->dispose(this, _vars_d[i]);
+#endif
+  }
+
+
+
+  /*
+   * Space: propagation
+   *
+   */
+  SpaceStatus
+  Space::status(unsigned long int& pn) {
+    if (failed())
+      return SS_FAILED;
+    if (!stable()) {
+      assert(pc.p.active >= &pc.p.queue[0]);
+      Propagator* p;
+      ModEventDelta med_o;
+      goto unstable;
+    execute:
+      pn++;
+      // Keep old modification event delta
+      med_o = p->u.med;
+      // Clear med but leave propagator in queue
+      p->u.med = 0;
+      switch (p->propagate(this,med_o)) {
+      case ES_FAILED:
+        fail(); 
+        return SS_FAILED;
+      case ES_NOFIX:
+        // Find next, if possible
+        if (p->u.med != 0) {
+        unstable:
+          // There is at least one propagator in a queue
+          do {
+            assert(pc.p.active >= &pc.p.queue[0]);
+            // First propagator or link back to queue
+            ActorLink* fst = pc.p.active->next();
+            if (pc.p.active != fst) {
+              p = Propagator::cast(fst);
+              goto execute;
+            }
+            pc.p.active--;
+          } while (true);
+          GECODE_NEVER;
+        }
+        // Fall through
+      case ES_FIX:
+        // Clear med and put into idle queue
+        p->u.med = 0; p->unlink(); a_actors.head(p);
+      stable_or_unstable:
+        // There might be a propagator in the queue
+        do {
+          assert(pc.p.active >= &pc.p.queue[0]);
+          // First propagator or link back to queue
+          ActorLink* fst = pc.p.active->next();
+          if (pc.p.active != fst) {
+            p = Propagator::cast(fst);
+            goto execute;
+          }
+        } while (--pc.p.active >= &pc.p.queue[0]);
+        assert(pc.p.active < &pc.p.queue[0]);
+        goto stable;
+      case __ES_SUBSUMED:
+        p->unlink(); reuse(p,p->u.size);
+        goto stable_or_unstable;
+      case __ES_PARTIAL:
+        // Schedule propagator with specified propagator events
+        enqueue(p);
+        goto unstable;
+      default:
+        GECODE_NEVER;
+      }
+    }
+  stable:
+    /*
+     * Find the next branching that has still alternatives left
+     *
+     * It is important to note that branchings reporting to have no more
+     * alternatives left can not be deleted. They can not be deleted
+     * as there might be branching descriptions to be used in commit
+     * that refer to one of these branchings. This e.g. happens when
+     * we combine branch-and-bound search with adaptive recomputation: during 
+     * recomputation, a copy is constrained to be better than the currently 
+     * best solution, then the first half of the BranchingDescs is posted,
+     * and a fixpoint computed (for storing in the middle of the path). Then
+     * the remaining BranchingDescs are posted, and because of the additional
+     * constraints that the space must be better than the previous solution,
+     * the corresponding Branchings may already have no alternatives left.
+     *
+     * A branching reporting that no more alternatives exist will eventually
+     * be deleted in commit. It will be deleted if the first branching
+     * description is used in commit that does not refer to this branching.
+     * As we insist that branching descriptions are used in order of
+     * creation, all further branching descriptions cannot refer to this
+     * branching.
+     *
+     */
+    while (b_status != Branching::cast(&a_actors)) {
+      if (b_status->status(this))
+        return SS_BRANCH;
+      b_status = Branching::cast(b_status->next());
+    }
+    // No branching with alternatives left, space is solved
+    return SS_SOLVED;
+  }
+
+
+  void
+  Space::commit(const BranchingDesc* d, unsigned int a) {
+    if (failed())
+      return;
+    /*
+     * This relies on the fact that branching descriptions must be
+     * used in the order of creation. If a branching description
+     * with an id different from the id of the current branching
+     * is used, it is clear that the current branching can be discarded
+     * as all of its descriptions must have been used already.
+     *
+     */
+    while ((b_commit != Branching::cast(&a_actors)) && 
+           (d->_id != b_commit->id)) {
+      Branching* b = b_commit;
+      b_commit = Branching::cast(b_commit->next());
+      if (b == b_status)
+        b_status = b_commit;
+      b->unlink(); 
+      reuse(b,b->dispose(this));
+    }
+    if (b_commit == Branching::cast(&a_actors))
+      throw SpaceNoBranching();
+    if (a >= d->alternatives())
+      throw SpaceIllegalAlternative();
+    if (b_commit->commit(this,d,a) == ES_FAILED)
+      fail();
+  }
+
+
+
+  /*
+   * Space cloning
+   *
+   * Cloning is performed in two steps:
+   *  - The space itself is copied by the copy constructor. This
+   *    also copies all propagators, branchings, and variables.
+   *    The copied variables are recorded.
+   *  - In the second step the dependency information of the recorded
+   *    variables is updated and their forwarding information is reset.
+   *
+   */
+  Space::Space(bool share, Space& s) 
+    : mm(s.mm,s.pc.p.n_sub*sizeof(Propagator**)) {
+#ifdef GECODE_HAS_VAR_DISPOSE
+    for (int i=0; i<AllVarConf::idx_d; i++)
+      _vars_d[i] = NULL;
+#endif
+    for (int i=0; i<AllVarConf::idx_c; i++)
+      pc.c.vars_u[i] = NULL;
+    pc.c.vars_noidx = NULL;
+    pc.c.shared = NULL;
+    // Copy all actors
+    {
+      ActorLink* p = &a_actors;
+      ActorLink* e = &s.a_actors;
+      for (ActorLink* a = e->next(); a != e; a = a->next()) {
+        Actor* c = Actor::cast(a)->copy(this,share);
+        // Link copied actor
+        p->next(ActorLink::cast(c)); ActorLink::cast(c)->prev(p);
+        // Note that forwarding is done in the constructors
+        p = c;
+      }
+      // Link last actor
+      p->next(&a_actors); a_actors.prev(p);
+    }
+    // Setup array for actor disposal
+    {
+      ptrdiff_t n = s.d_cur - s.d_fst;
+      if (n == 0) {
+        // No actors
+        d_fst = d_cur = d_lst = NULL;
+      } else {
+        // Leave one entry free
+        Actor** a = static_cast<Actor**>(alloc((n+1)*sizeof(Actor*)));
+        d_fst = a;
+        d_cur = a+n;
+        d_lst = a+n+1;
+        Actor** f = s.d_fst;
+        do {
+          n--;
+          a[n] = Actor::cast(f[n]->prev());
+        } while (n != 0);
+      }
+    }
+    // Setup branching pointers
+    if (s.b_status == &s.a_actors) {
+      b_status = Branching::cast(&a_actors);
+    } else {
+      b_status = Branching::cast(s.b_status->prev());
+    }
+    if (s.b_commit == &s.a_actors) {
+      b_commit = Branching::cast(&a_actors);
+    } else {
+      b_commit = Branching::cast(s.b_commit->prev());
+    }
+  }
+
+  Space*
+  Space::clone(bool share) {
+    if (failed())
+      throw SpaceFailed("Space::clone");
+    if (!stable())
+      throw SpaceNotStable("Space::clone");
+
+    // Copy all data structures (which in turn will invoke the constructor)
+    Space* c = copy(share);
+
+    // Update variables without indexing structure
+    VarImp<NoIdxVarImpConf>* x = 
+      static_cast<VarImp<NoIdxVarImpConf>*>(c->pc.c.vars_noidx);
+    while (x != NULL) {
+      VarImp<NoIdxVarImpConf>* n = x->next();
+      x->idx[0] = x->idx[1] = NULL;
+      x = n;
+    }
+    // Update variables with indexing structure
+    c->update(static_cast<ActorLink**>(c->mm.subscriptions()));
+
+    // Re-establish prev links (reset forwarding information)
+    ActorLink* p_a = &a_actors;
+    ActorLink* c_a = p_a->next();
+    // First update propagators and check for advisors that also must be reset
+    while (c_a != b_commit) {
+      Propagator* p = Propagator::cast(c_a);
+      if (p->u.advisors != NULL) {
+        ActorLink* a = p->u.advisors;
+        p->u.advisors = NULL;
+        do {
+          a->prev(p); a = a->next();
+        } while (a != NULL);
+      }
+      c_a->prev(p_a); p_a = c_a; c_a = c_a->next();
+    }
+    // Update branchings
+    while (c_a != &a_actors) {
+      c_a->prev(p_a); p_a = c_a; c_a = c_a->next();
+    }
+    assert(c_a->prev() == p_a);
+
+    // Reset links for shared objects
+    for (SharedHandle::Object* s = c->pc.c.shared; s != NULL; s = s->next)
+      s->fwd = NULL;
+
+    // Initialize propagator queue
+    c->pc.p.active = &c->pc.p.queue[0]-1;
+    for (int i=0; i<=PC_MAX; i++)
+      c->pc.p.queue[i].init();
+    // Copy propagation only data
+    c->pc.p.n_sub = pc.p.n_sub;
+    c->pc.p.branch_id = pc.p.branch_id;
+    return c;
+  }
+
+}
+
+// STATISTICS: kernel-core