gecoder-with-gecode 0.7.1

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

@@ -0,0 +1,233 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *     Guido Tack, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-10-25 10:39:24 +0200 (Wed, 25 Oct 2006) $ by $Author: tack $
+ *     $Revision: 3784 $
+ *
+ *  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.
+ *
+ */
+
+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 \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 VarSel 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);
+    /// Perform cloning
+    virtual Actor* copy(Space* home, bool share);
+  };
+
+  /**
+   * \brief %Branching descriptions storing position and value
+   *
+   */
+  template <class Val>
+  class PosValDesc : public BranchingDesc {
+  protected:
+    const int _pos;
+    const Val _val;
+    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>
+  forceinline
+  PosValDesc<Val>::PosValDesc(const Branching* b, const int p, const Val& n, 
+			      const int s)
+    : BranchingDesc(b,2), _pos(p), _val(n), _start(s) {}
+
+  template <class Val>
+  forceinline int
+  PosValDesc<Val>::pos(void) const {
+    return _pos;
+  }
+
+  template <class Val>
+  forceinline Val
+  PosValDesc<Val>::val(void) const {
+    return _val;
+  }
+
+  template <class Val>
+  forceinline int
+  PosValDesc<Val>::start(void) const {
+    return _start;
+  }
+
+  template <class Val>
+  size_t
+  PosValDesc<Val>::size(void) const {
+    return sizeof(PosValDesc<Val>);
+  }
+
+
+  /*
+   * 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>(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>* pvd = static_cast<const PosValDesc<Val>*>(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;
+  }
+
+}
+
+// STATISTICS: kernel-other

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

@@ -0,0 +1,417 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2006-08-21 11:34:39 +0200 (Mon, 21 Aug 2006) $ by $Author: tack $
+ *     $Revision: 3550 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+#include "gecode/kernel.hh"
+
+namespace Gecode {
+
+  unsigned long int Space::unused_uli;
+
+  /*
+   * Spaces
+   *
+   */
+
+  VarTypeProcessorBase* Space::vtp[VTI_LAST];
+
+  VarTypeProcessorBase::~VarTypeProcessorBase(void) {}
+
+  Space::Space(void) {
+    // Initialize variable entry points
+    for (int i=0; i<VTI_LAST; i++) {
+      vars[i]=NULL;
+      vars_dispose[i]=NULL;
+    }
+    vars_noidx = NULL;
+    // Initialize propagator pool
+    pool_next = 0;
+    for (int i=0; i<=PC_MAX; i++)
+      pool[i].init();
+    // Initialize actor and branching links
+    a_actors.init();
+    a_actors.init_delete();
+    b_status = static_cast<Branching*>(&a_actors);
+    b_commit = static_cast<Branching*>(&a_actors);
+    n_sub = 0;
+    sub = NULL;
+  }
+
+
+
+  /*
+   * Space deletion
+   *
+   */
+
+  void
+  Actor::flush(void) {}
+
+  size_t
+  Actor::cached(void) const {
+    return 0;
+  }
+
+  void
+  Space::flush(void) {
+    // Flush actors registered for deletion
+    ActorDeleteLink* e = &a_actors;
+    ActorDeleteLink* a = e->next_delete();
+    while (a != e) {
+      static_cast<Actor*>(a)->flush(); a = a->next_delete();
+    }
+  }
+
+  size_t
+  Space::cached(void) const {
+    size_t s = 0;
+    const ActorDeleteLink* e = &a_actors;
+    const ActorDeleteLink* a = e->next_delete();
+    while (a != e) {
+      s += static_cast<const Actor*>(a)->cached();
+      a = a->next_delete();
+    }
+    return s;
+  }
+
+  Space::~Space(void) {
+    // Mark space as failed
+    fail();
+    // Delete actors that must be deleted
+    ActorDeleteLink* e = &a_actors;
+    ActorDeleteLink* a = e->next_delete();
+    while (a != e) {
+      Actor* d = static_cast<Actor*>(a);
+      a = a->next_delete();
+      d->dispose(this);
+    }
+    // Delete variables that were registered for deletion
+    for (int vti=VTI_LAST; vti--;)
+      if (vars_dispose[vti] != NULL)
+        vtp[vti]->dispose(this, vars_dispose[vti]);
+    if (sub != NULL)
+      Memory::free(sub);
+  }
+
+
+  /*
+   * Performing propagation
+   *
+   */
+
+  forceinline void
+  Space::process(void) {
+    for (int vti=VTI_LAST; vti--; ) {
+      VarBase* vs = vars[vti];
+      if (vs != NULL) {
+	vars[vti] = NULL; vtp[vti]->process(this,vs);
+      }
+    }
+  }
+
+  forceinline bool
+  Space::pool_get(Propagator*& p) {
+    for (int c = pool_next+1; c--; ) {
+      // Head of the queue
+      ActorLink* lnk = &pool[c];
+      // First propagator or link back to queue
+      ActorLink* fst = lnk->next();
+      if (lnk != fst) {
+	pool_next = c;
+	// Unlink first propagator from queue
+	ActorLink* snd = fst->next();
+	lnk->next(snd); snd->prev(lnk);
+	p = static_cast<Propagator*>(fst);
+	return true;
+      }
+    }
+    pool_next = 0;
+    return false;
+  }
+
+  unsigned long int
+  Space::propagate(void) {
+    if (failed())
+      return 0;
+    const PropModEvent PME_NONE = 0;
+    const PropModEvent PME_ASSIGNED  =
+      ((ME_GEN_ASSIGNED <<  0) | (ME_GEN_ASSIGNED <<  4) |
+       (ME_GEN_ASSIGNED <<  8) | (ME_GEN_ASSIGNED << 12) |
+       (ME_GEN_ASSIGNED << 16) | (ME_GEN_ASSIGNED << 20) |
+       (ME_GEN_ASSIGNED << 24) | (ME_GEN_ASSIGNED << 28));
+    /*
+     * Count the number of propagation steps performed
+     *
+     */
+    unsigned long int pn = 0;
+    /*
+     * Process modified variables, there might be modified variables
+     * either from initializing the space or from a commit operation
+     *
+     */
+    process();
+    Propagator* p;
+    while (pool_get(p)) {
+      pn++;
+      switch (p->propagate(this)) {
+      case ES_FAILED:
+	fail();
+	return pn;
+      case ES_FIX:
+	{
+	  // Put propagator in idle queue
+	  propagator(p);
+	  // Prevent that propagator gets rescheduled (turn on all events)
+	  p->pme = PME_ASSIGNED;
+	  process();
+	  p->pme = PME_NONE;
+	}
+	break;
+      case ES_NOFIX:
+	{
+	  // Propagator is currently in no queue, put in into idle
+	  propagator(p);
+	  p->pme = PME_NONE;
+	  process();
+	}
+	break;
+      case ES_SUBSUMED:
+	{
+	  // Prevent that propagator gets rescheduled (turn on all events)
+	  p->pme = PME_ASSIGNED;
+	  process();
+	  p->destruct(this);
+	}
+	break;
+      case __ES_FIX_PARTIAL:
+	{
+	  // Remember the event set to be kept after processing
+	  PropModEvent keep = p->pme;
+	  // Prevent that propagator gets rescheduled (turn on all events)
+	  p->pme = PME_ASSIGNED;
+	  process();
+	  p->pme = keep;
+	  assert(p->pme);
+	  pool_put(p);
+	}
+	break;
+      case __ES_NOFIX_PARTIAL:
+	{
+	  // Start from the specified propagator events
+	  pool_put(p);
+	  process();
+	}
+	break;
+      default:
+	GECODE_NEVER;
+      }
+    }
+    return pn;
+  }
+
+  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 != &a_actors) && (d->id != b_commit->id)) {
+      Branching* b = b_commit;
+      b_commit = static_cast<Branching*>(b_commit->next());
+      if (b == b_status)
+	b_status = b_commit;
+      b->unlink(); b->destruct(this);
+    }
+    if (b_commit == &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 by the variable processor.
+   *  - 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) {
+    // Initialize variable entry points
+    for (int i=0; i<VTI_LAST; i++) {
+      vars[i]=NULL;
+      vars_dispose[i]=NULL;
+    }
+    vars_noidx = NULL;
+    // Initialize propagator pool
+    pool_next = 0;
+    for (int i=0; i<=PC_MAX; i++)
+      pool[i].init();
+    // Copy all actors
+    {
+      ActorLink* p  = &a_actors;
+      ActorLink* e  = &s.a_actors;
+      for (ActorLink* a = e->next(); a != e; a = a->next()) {
+	ActorLink* c = static_cast<Actor*>(a)->copy(this,share);
+	// Link copied actor
+	p->next(c); c->prev(p);
+	// Forward
+	a->prev(c);
+	//
+	static_cast<ActorDeleteLink*>(c)->init_delete();
+	p = c;
+      }
+      // Link last actor
+      p->next(&a_actors); a_actors.prev(p);
+    }
+    // Setup delete links
+    {
+      ActorDeleteLink* p  = &a_actors;
+      ActorDeleteLink* e  = &s.a_actors;
+      for (ActorDeleteLink* a = e->next_delete(); a != e;
+	   a = a->next_delete()) {
+	ActorDeleteLink* c = static_cast<ActorDeleteLink*>(a->prev());
+	// Link copied actor
+	p->next_delete(c); c->prev_delete(p);
+	// Forward
+	p = c;
+      }
+      // Link last actor
+      p->next_delete(&a_actors); a_actors.prev_delete(p);
+    }
+    // Setup branching pointers
+    if (s.b_status == &s.a_actors) {
+      b_status = static_cast<Branching*>(&a_actors);
+    } else {
+      b_status = static_cast<Branching*>(s.b_status->prev());
+    }
+    if (s.b_commit == &s.a_actors) {
+      b_commit = static_cast<Branching*>(&a_actors);
+    } else {
+      b_commit = static_cast<Branching*>(s.b_commit->prev());
+    }
+  }
+
+
+  /*
+   * Stage 2: updating variables
+   *
+   */
+
+  /// A fake combination class
+  class __Combine {
+  public:
+    ModEvent operator()(ModEvent,ModEvent) {
+      GECODE_NEVER;
+      return ME_GEN_ASSIGNED;
+    }
+  };
+
+  Space*
+  Space::clone(bool share, unsigned long int& pn) {
+    pn += propagate();
+    if (failed())
+      throw SpaceFailed("Space::clone");
+
+    /*
+     * Stage one
+     *
+     * Copy all data structures (which in turn will invoke the
+     * constructor Space::Space.
+     */
+    Space* c = copy(share);
+
+    /*
+     * Stage two
+     *
+     * Update subscriptions and reset forwarding pointers
+     *
+     */
+    // Update variables without indexing structure
+    for (Variable<VTI_NOIDX,0,__Combine>* x
+	   = static_cast<Variable<VTI_NOIDX,0,__Combine>*>(c->vars_noidx);
+	 x != NULL; x = x->next())
+      x->u.free_me = 0;
+    c->vars_noidx = NULL;
+    // Update variables with indexing structure
+    Propagator** s;
+    if (n_sub > 0)
+      s = reinterpret_cast<Propagator**>
+	(Memory::malloc(n_sub*sizeof(Propagator*)));
+    else
+      s = NULL;
+    c->sub = s;
+    for (int vti=VTI_LAST; vti--; ) {
+      VarBase* vs = c->vars[vti];
+      if (vs != NULL) {
+	c->vars[vti] = NULL; vtp[vti]->update(vs,s);
+      }
+    }
+    // Update the number of subscriptions (both in copy and original)
+    // Remember: this is a conservative estimate
+    unsigned int n = s - c->sub;
+    assert(n <= n_sub);
+    c->n_sub = n; n_sub = n;
+    // Re-establish prev links (reset forwarding information)
+    ActorLink* p = &a_actors;
+    ActorLink* a = p->next();
+    while (a != &a_actors) {
+      a->prev(p); p = a; a = a->next();
+    }
+    assert(a->prev() == p);
+    return c;
+  }
+
+  unsigned int
+  Space::propagators(void) const {
+    if (failed())
+      throw SpaceFailed("Space::propagators");
+    unsigned int n = 0;
+    for (const ActorLink* a = a_actors.next(); a != b_commit; a = a->next())
+      n++;
+    return n;
+  }
+
+  unsigned int
+  Space::branchings(void) const {
+    if (failed())
+      throw SpaceFailed("Space::branchings");
+    unsigned int n = 0;
+    for (const ActorLink* a = b_status; a != &a_actors; a = a->next())
+      n++;
+    return n;
+  }
+
+}
+
+// STATISTICS: kernel-core
+