BranchingDesc -> Choice

git-svn-id: file:///Users/tack/GecodeGitMigration/gecode-svn-mirror/gecode/trunk@9628 e85b7adc-8362-4630-8c63-7469d557c915

Author: Christian Schulte

changelog.in

@@ -72,6 +72,17 @@ Date: ?
 [DESCRIPTION]
 The next release.
 
+[ENTRY]
+Module: kernel
+What:   change
+Rank:   major
+[DESCRIPTION]
+A branching is now a brancher and a branching description is now a choice. 
+[MORE]
+Classes and member functions have been renamed accordingly. The
+change is necessary due to proper explanation in the forthcoming
+"Programming with Gecode".
+
 [ENTRY]
 Module: search
 What:   bug

doxygen/doxygen.hh.in

@@ -524,16 +524,14 @@ class Gecode::Branching. A common abstraction for defining
 branchings based on view and value selection is provided by the
 class Gecode::ViewValBranching.
 
-\section GlossaryBranchingDesc Branching description
+\section GlossaryChoice Choice
 
-A branching description speeds up recomputation by providing
-batch recomputation. It is created by a branching (\ref
+A choice speeds up recomputation by providing
+path recomputation. It is created by a branching (\ref
 GlossaryBranching) and allows to replay the effect of that
 branching without the need to first perform constraint
-propagation. The base-class for branching descriptions is
-Gecode::BranchingDesc. An example for a branching description
-that works together with branchings based on view and value
-selection is Gecode::PosValDesc.
+propagation. The base-class for choices is
+Gecode::Choice.
 
 \section GlossarySpace Computation space
 

examples/black-hole.cpp

@@ -101,21 +101,21 @@ class BlackHoleBranch : Branching {
   ViewArray<Int::IntView> x;
   /// Cache of last computed decision
   mutable int pos, val;
-  /// Branching description
-  class Description : public BranchingDesc {
+  /// Choice
+  class Choice : public Gecode::Choice {
   public:
     /// Position of variable
     int pos;
     /// Value of variable
     int val;
-    /** Initialize description for branching \a b, number of
-     *  alternatives \a a, position \a pos0, and value \a val0.
+    /** Initialize description for branching \a b, position \a pos0, 
+     *  and value \a val0.
      */
-    Description(const Branching& b, unsigned int a, int pos0, int val0)
-      : BranchingDesc(b,a), pos(pos0), val(val0) {}
+    Choice(const Branching& b, int pos0, int val0)
+      : Gecode::Choice(b,2), pos(pos0), val(val0) {}
     /// Report size occupied
     virtual size_t size(void) const {
-      return sizeof(Description);
+      return sizeof(Choice);
     }
   };
 
@@ -131,38 +131,33 @@ class BlackHoleBranch : Branching {
 public:
   /// Check status of branching, return true if alternatives left.
   virtual bool status(const Space&) const {
-    for (pos = 0; pos < x.size(); ++pos) {
+    for (pos = 0; pos < x.size(); ++pos)
       if (!x[pos].assigned()) {
         int w = 4;
-        for (Int::ViewValues<Int::IntView> vals(x[pos]); vals(); ++vals) {
+        for (Int::ViewValues<Int::IntView> vals(x[pos]); vals(); ++vals)
           if (layer[vals.val()] < w) {
             val = vals.val();
             if ((w = layer[vals.val()]) == 0) break;
           }
-        }
         return true;
       }
-    }
     // No non-assigned variables left
     return false;
   }
-  /// Return branching description
-  virtual BranchingDesc* description(Space&) {
+  /// Return choice
+  virtual Choice* choice(Space&) {
     assert(pos >= 0 && pos < x.size() && val >= 1 && val < 52);
-    return new Description(*this, 2, pos, val);
+    return new Choice(*this, pos, val);
   }
-  /// Perform commit for branching description \a d and alternative \a a.
-  virtual ExecStatus commit(Space& home, const BranchingDesc& d,
+  /// Perform commit for choice \a _c and alternative \a a.
+  virtual ExecStatus commit(Space& home, const Gecode::Choice& _c,
                             unsigned int a) {
-    const Description& desc =
-      static_cast<const Description&>(d);
+    const Choice& c = static_cast<const Choice&>(_c);
     pos = val = -1;
     if (a)
-      return me_failed(x[desc.pos].nq(home, desc.val))
-        ? ES_FAILED : ES_OK;
+      return me_failed(x[c.pos].nq(home, c.val)) ? ES_FAILED : ES_OK;
     else
-      return me_failed(x[desc.pos].eq(home, desc.val))
-        ? ES_FAILED : ES_OK;
+      return me_failed(x[c.pos].eq(home, c.val)) ? ES_FAILED : ES_OK;
   }
   /// Copy branching
   virtual Actor* copy(Space& home, bool share) {

examples/knights.cpp

@@ -59,21 +59,21 @@ class Warnsdorff : public Branching {
   ViewArray<Int::IntView> x;
   /// Next variable to branch on
   mutable int start;
-  /// Branching description
-  class Description : public BranchingDesc {
+  /// Choice
+  class Choice : public Gecode::Choice {
   public:
     /// Position of variable
     int pos;
     /// Value of variable
     int val;
-    /** Initialize description for branching \a b, number of
-     *  alternatives \a a, position \a pos0, and value \a val0.
+    /** Initialize choice for branching \a b, position \a pos0, 
+     *  and value \a val0.
      */
-    Description(const Branching& b, unsigned int a, int pos0, int val0)
-      : BranchingDesc(b,a), pos(pos0), val(val0) {}
+    Choice(const Branching& b, int pos0, int val0)
+      : Gecode::Choice(b,2), pos(pos0), val(val0) {}
     /// Report size occupied
     virtual size_t size(void) const {
-      return sizeof(Description);
+      return sizeof(Choice);
     }
   };
 
@@ -97,8 +97,8 @@ class Warnsdorff : public Branching {
         return false;
     }
   }
-  /// Return branching description
-  virtual BranchingDesc* description(Space&) {
+  /// Return choice
+  virtual Gecode::Choice* choice(Space&) {
     Int::ViewValues<Int::IntView> iv(x[start]);
     int n = iv.val();
     unsigned int min = x[n].size();
@@ -111,18 +111,16 @@ class Warnsdorff : public Branching {
       }
       ++iv;
     }
-    return new Description(*this, 2, start, n);
+    return new Choice(*this, start, n);
   }
-  /// Perform commit for branching description \a d and alternative \a a
-  virtual ExecStatus commit(Space& home, const BranchingDesc& d, 
+  /// Perform commit for choice \a _c and alternative \a a
+  virtual ExecStatus commit(Space& home, const Gecode::Choice& _c, 
                             unsigned int a) {
-    const Description& desc = static_cast<const Description&>(d);
+    const Choice& c = static_cast<const Choice&>(_c);
     if (a == 0)
-      return me_failed(x[desc.pos].eq(home, desc.val)) 
-        ? ES_FAILED : ES_OK;
+      return me_failed(x[c.pos].eq(home, c.val)) ? ES_FAILED : ES_OK;
     else 
-      return me_failed(x[desc.pos].nq(home, desc.val)) 
-        ? ES_FAILED : ES_OK;
+      return me_failed(x[c.pos].nq(home, c.val)) ? ES_FAILED : ES_OK;
   }
   /// Copy branching
   virtual Actor* copy(Space& home, bool share) {

examples/queen-armies.cpp

@@ -158,7 +158,7 @@ class QueenArmies : public MaximizeScript {
     os << "Number of white queens: " << q << std::endl << std::endl;
   }
 
-  /** \brief Custom branching for Peacaeble queens.
+  /** \brief Custom branching for Peacable queens
    *
    *  Custom branching that tries to place white queens so that they
    *  maximise the amount of un-attacked squares that become attacked.
@@ -169,21 +169,21 @@ class QueenArmies : public MaximizeScript {
   private:
     /// Cache of last computed decision
     mutable int pos;
-    /// Branching description
-    class Description : public BranchingDesc {
+    /// Choice
+    class Choice : public Gecode::Choice {
     public:
       /// Position of variable
       int pos;
       /// Value of variable
       bool val;
-      /** Initialize description for branching \a b, number of
-       *  alternatives \a a, position \a pos0, and value \a val0.
+      /** Initialize choice for branching \a b, position \a pos0, 
+       *  and value \a val0.
        */
-      Description(const Branching& b, unsigned int a, int pos0, bool val0)
-        : BranchingDesc(b,a), pos(pos0), val(val0) {}
+      Choice(const Branching& b, int pos0, bool val0)
+        : Gecode::Choice(b,2), pos(pos0), val(val0) {}
       /// Report size occupied
       virtual size_t size(void) const {
-        return sizeof(Description);
+        return sizeof(Choice);
       }
     };
 
@@ -215,20 +215,20 @@ class QueenArmies : public MaximizeScript {
       if (pos == -1) return false;
       return true;
     }
-    /// Return branching description
-    virtual BranchingDesc* description(Space&) {
+    /// Return choice
+    virtual Gecode::Choice* choice(Space&) {
       assert(pos != -1);
-      return new Description(*this, 2, pos, true);
+      return new Choice(*this, pos, true);
     }
-    /** \brief Perform commit for branching description \a d and
+    /** \brief Perform commit for choice \a _c and
      * alternative \a a.
      */
-    virtual ExecStatus commit(Space& home, const BranchingDesc& d,
+    virtual ExecStatus commit(Space& home, const Gecode::Choice& _c,
                               unsigned int a) {
       QueenArmies& q = static_cast<QueenArmies&>(home);
-      const Description& pvd = static_cast<const Description&>(d);
-      bool val = a == 0 ? pvd.val : !pvd.val;
-      return me_failed(Int::BoolView(q.w[pvd.pos]).eq(q, val))
+      const Choice& c = static_cast<const Choice&>(_c);
+      bool val = (a == 0) ? c.val : !c.val;
+      return me_failed(Int::BoolView(q.w[c.pos]).eq(q, val))
         ? ES_FAILED
         : ES_OK;
     }

examples/radiotherapy.cpp

@@ -217,17 +217,17 @@ class Radiotherapy : public MinimizeScript {
     };
     /// Weighted ordering of rows
     SharedArray<Idx> index;
-    /// Description that only signals failure or success
-    class Description : public BranchingDesc {
+    /// Choice that only signals failure or success
+    class Choice : public Gecode::Choice {
     public:
       /// Whether branching should fail
       bool fail;
-      /// Initialize description for branching \a b
-      Description(const Branching& b, bool fail0)
-      : BranchingDesc(b,1), fail(fail0) {}
+      /// Initialize choice for branching \a b
+      Choice(const Branching& b, bool fail0)
+      : Gecode::Choice(b,1), fail(fail0) {}
       /// Report size occupied
       virtual size_t size(void) const {
-        return sizeof(Description);
+        return sizeof(Choice);
       }
     };
     /// Construct branching
@@ -270,7 +270,7 @@ class Radiotherapy : public MinimizeScript {
       return ri;
     }
 
-    virtual BranchingDesc* description(Space& home) {
+    virtual Gecode::Choice* choice(Space& home) {
       done = true;
       Radiotherapy& rt = static_cast<Radiotherapy&>(home);
 
@@ -300,10 +300,10 @@ class Radiotherapy : public MinimizeScript {
         }      
       }
 
-      return new Description(*this, fail);
+      return new Choice(*this, fail);
     }
-    virtual ExecStatus commit(Space&, const BranchingDesc& d, unsigned int) {
-      return static_cast<const Description&>(d).fail ? ES_FAILED : ES_OK;
+    virtual ExecStatus commit(Space&, const Gecode::Choice& _c, unsigned int) {
+      return static_cast<const Choice&>(_c).fail ? ES_FAILED : ES_OK;
     }
     /// Copy branching
     virtual Actor* copy(Space& home, bool share) {

examples/steel-mill.cpp

@@ -320,21 +320,21 @@ class SteelMill : public MinimizeScript {
   protected:
     /// Cache of first unassigned value
     mutable int start;
-    /// Branching description
-    class Description : public BranchingDesc {
+    /// Choice
+    class Choice : public Gecode::Choice {
     public:
       /// Position of variable
       int pos;
       /// Value of variable
       int val;
-      /** Initialize description for branching \a b, number of
+      /** Initialize choice for branching \a b, number of
        *  alternatives \a a, position \a pos0, and value \a val0.
        */
-      Description(const Branching& b, unsigned int a, int pos0, int val0)
-        : BranchingDesc(b,a), pos(pos0), val(val0) {}
+      Choice(const Branching& b, unsigned int a, int pos0, int val0)
+        : Gecode::Choice(b,a), pos(pos0), val(val0) {}
       /// Report size occupied
       virtual size_t size(void) const {
-        return sizeof(Description);
+        return sizeof(Choice);
       }
     };
 
@@ -358,8 +358,8 @@ class SteelMill : public MinimizeScript {
       // No non-assigned orders left
       return false;
     }
-    /// Return branching description
-    virtual BranchingDesc* description(Space& home) {
+    /// Return choice
+    virtual Gecode::Choice* choice(Space& home) {
       SteelMill& sm = static_cast<SteelMill&>(home);
       assert(!sm.slab[start].assigned());
       // Find order with a) minimum size, b) largest weight
@@ -386,19 +386,18 @@ class SteelMill : public MinimizeScript {
         ++firstzero;
       assert(pos < sm.nslabs &&
              val < sm.norders);
-      return new Description(*this, val<firstzero ? 2 : 1, pos, val);
+      return new Choice(*this, (val<firstzero) ? 2 : 1, pos, val);
     }
-    /// Perform commit for branching description \a d and alternative \a a.
-    virtual ExecStatus commit(Space& home, const BranchingDesc& d,
+    /// Perform commit for choice \a _c and alternative \a a
+    virtual ExecStatus commit(Space& home, const Gecode::Choice& _c,
                               unsigned int a) {
       SteelMill& sm = static_cast<SteelMill&>(home);
-      const Description& desc =
-        static_cast<const Description&>(d);
+      const Choice& c = static_cast<const Choice&>(_c);
       if (a)
-        return me_failed(Int::IntView(sm.slab[desc.pos]).nq(home, desc.val))
+        return me_failed(Int::IntView(sm.slab[c.pos]).nq(home, c.val))
           ? ES_FAILED : ES_OK;
       else
-        return me_failed(Int::IntView(sm.slab[desc.pos]).eq(home, desc.val))
+        return me_failed(Int::IntView(sm.slab[c.pos]).eq(home, c.val))
           ? ES_FAILED : ES_OK;
     }
     /// Copy branching