Add Sense and compare_int for objective comparison

Implementing Space::compare for an integer objective took four lines of
value comparisons, against a single rel call in constrain. compare_int
compares two values for a Sense, an optimization direction now shared by the
kernel, MiniModel, FlatZinc, and the experimental heuristic guidance, which
had its own MINIMIZE/MAXIMIZE enum.

Author: zayenz

changelog.in

@@ -84,7 +84,8 @@ Add Space::compare(), which ranks two solutions without modifying them.
 Best-solution search uses it to choose between solutions, for example in
 parallel BAB, portfolios, external incumbents, and the experimental A* and
 CABS engines. constrain() still prunes the search. Optimization models with a
-custom constrain() must now also override compare(). Search
+custom constrain() must now also override compare(). compare_int()
+compares two integer objective values for a given Sense. Search
 engines throw Search::Incomparable when compare() reports incomparable
 solutions.
 

examples/car-sequencing.cpp

@@ -371,13 +371,8 @@ class CarSequencing : public Script {
 
   /// Compare objective values
   virtual SpaceComparison compare(const Space& _other) const {
-    const CarSequencing& other =
-      dynamic_cast<const CarSequencing&>(_other);
-    if (nstall.val() < other.nstall.val())
-      return SC_BETTER;
-    if (nstall.val() > other.nstall.val())
-      return SC_WORSE;
-    return SC_EQUIVALENT;
+    const CarSequencing& other = static_cast<const CarSequencing&>(_other);
+    return compare_int(nstall.val(), other.nstall.val(), Sense::minimize);
   }
 
   /// Print solution

examples/fifteen-puzzle.cpp

@@ -418,7 +418,7 @@ run(PuzzleOptions& opt) {
   case PuzzleOptions::SEARCH_ASTAR:
   case PuzzleOptions::SEARCH_CABS:
     {
-      Search::HeuristicGuidance guidance(Search::HeuristicGuidance::MINIMIZE,
+      Search::HeuristicGuidance guidance(Sense::minimize,
         [](const Space& home) -> std::int64_t {
           return static_cast<const Model&>(home).bound();
         });

examples/tsptw.cpp

@@ -381,7 +381,7 @@ main(int argc, char* argv[]) {
   case TSPTW::SEARCH_ASTAR:
   case TSPTW::SEARCH_CABS:
     {
-      Search::HeuristicGuidance g(Search::HeuristicGuidance::MINIMIZE,
+      Search::HeuristicGuidance g(Sense::minimize,
         [](const Space& s) -> std::int64_t {
           return static_cast<const TSPTW&>(s).cost().min();
         });

gecode/flatzinc/flatzinc.cpp

@@ -2092,10 +2092,8 @@ namespace Gecode { namespace FlatZinc {
         ((_method != MIN) && (_method != MAX)))
       throw DynamicCastFailed("FlatZincSpace::compare");
     if (_optVarIsInt) {
-      int a=iv[_optVar].val(), b=other->iv[other->_optVar].val();
-      if (a == b)
-        return SC_EQUIVALENT;
-      return ((a < b) == (_method == MIN)) ? SC_BETTER : SC_WORSE;
+      return compare_int(iv[_optVar].val(),other->iv[other->_optVar].val(),
+                         (_method == MIN) ? Sense::minimize : Sense::maximize);
     }
 #ifdef GECODE_HAS_FLOAT_VARS
     if (step != other->step)

gecode/kernel/core.hpp

@@ -61,6 +61,20 @@ namespace Gecode {
     SC_INCOMPARABLE ///< Neither objective dominates the other
   };
 
+  /// Optimization direction
+  enum class Sense {
+    minimize, ///< Smaller objective values are better
+    maximize  ///< Larger objective values are better
+  };
+
+  /// Compare objective value \a x with \a y for direction \a s
+  forceinline SpaceComparison
+  compare_int(int x, int y, Sense s) {
+    if (x == y)
+      return SC_EQUIVALENT;
+    return ((x < y) == (s == Sense::minimize)) ? SC_BETTER : SC_WORSE;
+  }
+
   class Space;
 
   /**

gecode/minimodel/optimize.cpp

@@ -35,13 +35,6 @@
 
 namespace Gecode {
 
-  static SpaceComparison
-  compare_int(int x, int y, bool minimize) {
-    if (x == y)
-      return SC_EQUIVALENT;
-    return ((x < y) == minimize) ? SC_BETTER : SC_WORSE;
-  }
-
   void
   IntMinimizeSpace::constrain(const Space& _best) {
     const IntMinimizeSpace* best =
@@ -56,7 +49,7 @@ namespace Gecode {
     const IntMinimizeSpace* s = dynamic_cast<const IntMinimizeSpace*>(&other);
     if (s == nullptr)
       throw DynamicCastFailed("IntMinimizeSpace::compare");
-    return compare_int(cost().val(),s->cost().val(),true);
+    return compare_int(cost().val(),s->cost().val(),Sense::minimize);
   }
 
 
@@ -74,7 +67,7 @@ namespace Gecode {
     const IntMaximizeSpace* s = dynamic_cast<const IntMaximizeSpace*>(&other);
     if (s == nullptr)
       throw DynamicCastFailed("IntMaximizeSpace::compare");
-    return compare_int(cost().val(),s->cost().val(),false);
+    return compare_int(cost().val(),s->cost().val(),Sense::maximize);
   }
 
 
@@ -103,7 +96,7 @@ namespace Gecode {
     for (int i=0; i<a.size(); i++) {
       int av=a[i].val(), bv=b[i].val();
       if (av != bv)
-        return compare_int(av,bv,true);
+        return compare_int(av,bv,Sense::minimize);
     }
     return SC_EQUIVALENT;
   }
@@ -133,7 +126,7 @@ namespace Gecode {
     for (int i=0; i<a.size(); i++) {
       int av=a[i].val(), bv=b[i].val();
       if (av != bv)
-        return compare_int(av,bv,false);
+        return compare_int(av,bv,Sense::maximize);
     }
     return SC_EQUIVALENT;
   }

gecode/search.hh

@@ -1260,8 +1260,6 @@ namespace Gecode { namespace Search {
    */
   class HeuristicGuidance {
   public:
-    /// Objective direction
-    enum Sense { MINIMIZE, MAXIMIZE };
     /// Function evaluating a stable space
     typedef std::function<std::int64_t(const Space&)> Evaluate;
     /// Objective direction

gecode/search/heuristic.hh

@@ -46,8 +46,8 @@ namespace Gecode { namespace Search {
 
   /// Whether bound \a a is better than bound \a b for objective direction \a s
   forceinline bool
-  better(HeuristicGuidance::Sense s, std::int64_t a, std::int64_t b) {
-    return (s == HeuristicGuidance::MINIMIZE) ? (a < b) : (a > b);
+  better(Sense s, std::int64_t a, std::int64_t b) {
+    return (s == Sense::minimize) ? (a < b) : (a > b);
   }
 
   /// Open node of a heuristic search engine
@@ -71,7 +71,7 @@ namespace Gecode { namespace Search {
   class Priority {
   public:
     /// Objective direction
-    HeuristicGuidance::Sense sense;
+    Sense sense;
     /// Whether to order by rank only (CABS with rank)
     bool rank_only;
     /// Test whether \a a is preferred to \a b
@@ -93,15 +93,15 @@ namespace Gecode { namespace Search {
   class Incumbent {
   public:
     /// Objective direction
-    HeuristicGuidance::Sense sense;
+    Sense sense;
     /// The solution (if any)
     std::unique_ptr<Space> space;
     /// Its objective value
     std::int64_t bound;
     /// Incremented for every new incumbent
     unsigned long long int revision;
     /// Initialize without incumbent
-    Incumbent(HeuristicGuidance::Sense s)
+    Incumbent(Sense s)
       : sense(s), bound(0), revision(0) {}
     /// Whether a node with bound \a b can improve the incumbent
     bool improves(std::int64_t b) const {

test/search.cpp

@@ -162,8 +162,7 @@ namespace Test {
       static Gecode::Search::HeuristicGuidance
       guidance(bool max, bool ranked, bool dominance, bool keyed) {
         using Gecode::Search::HeuristicGuidance;
-        HeuristicGuidance g(max ? HeuristicGuidance::MAXIMIZE :
-                                  HeuristicGuidance::MINIMIZE,
+        HeuristicGuidance g(max ? Sense::maximize : Sense::minimize,
           [](const Space& s) -> std::int64_t {
             const TreeSpace& t = static_cast<const TreeSpace&>(s);
             return t.maximize ? -t.node().bound : t.node().bound;
@@ -1380,7 +1379,7 @@ namespace Test {
         if (!rejects_incomparable(Gecode::Search::babengine(&im,Gecode::Search::Options())))
           return false;
 #ifdef GECODE_HAS_EXPERIMENTAL
-        Gecode::Search::HeuristicGuidance g(Gecode::Search::HeuristicGuidance::MINIMIZE,
+        Gecode::Search::HeuristicGuidance g(Gecode::Sense::minimize,
           [](const Space& s) -> std::int64_t {
             return static_cast<const ExternalObjective&>(s).x.min();
           });
@@ -1841,6 +1840,13 @@ namespace Test {
         if ((high.compare(low) != SC_BETTER) ||
             (low.compare(high) != SC_WORSE))
           return false;
+        if ((compare_int(1,2,Sense::minimize) != SC_BETTER) ||
+            (compare_int(2,1,Sense::minimize) != SC_WORSE) ||
+            (compare_int(1,1,Sense::minimize) != SC_EQUIVALENT) ||
+            (compare_int(2,1,Sense::maximize) != SC_BETTER) ||
+            (compare_int(1,2,Sense::maximize) != SC_WORSE) ||
+            (compare_int(1,1,Sense::maximize) != SC_EQUIVALENT))
+          return false;
         LexObjective lp(1,0,2), lq(2,0,2);
         if ((lp.compare(lq) != SC_BETTER) ||
             (lq.compare(lp) != SC_WORSE))