All scripts now have a constructor taking options as argumenrs and supporting a floating point step value

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

Author: Christian Schulte

gecode/driver.hh

@@ -334,6 +334,7 @@ namespace Gecode {
     Driver::StringOption      _branching;   ///< Branching options
     Driver::DoubleOption      _decay;       ///< Decay option
     Driver::UnsignedIntOption _seed;        ///< Seed option
+    Driver::DoubleOption      _step;        ///< Step option
     //@}
 
     /// \name Search options
@@ -412,6 +413,11 @@ namespace Gecode {
     void seed(unsigned int s);
     /// Return seed value
     unsigned int seed(void) const;
+
+    /// Set default step value
+    void step(double s);
+    /// Return step value
+    double step(void) const;
     //@}
 
     /// \name Search options
@@ -614,51 +620,80 @@ namespace Gecode {
 
 #include <gecode/driver/options.hpp>
 
-namespace Gecode {
+namespace Gecode { namespace Driver {
 
-  namespace Driver {
-    /**
-     * \brief Parametric base-class for scripts
+  /**
+   * \brief Parametric base-class for scripts
+   *
+   * All scripts must inherit from this class
+   *  - adds printing and comparison for Gist to scripts
+   *  - run allows to execute scripts
+   */
+  template<class BaseSpace>
+  class ScriptBase : public BaseSpace {
+  public:
+    /// Constructor
+    ScriptBase(const Options& opt);
+    /// Constructor used for cloning
+    ScriptBase(bool share, ScriptBase& e);
+    /// Print a solution to \a os
+    virtual void print(std::ostream& os) const;
+    /// Compare with \a s
+    virtual void compare(const Space& home, std::ostream& os) const;
+    /// Choose output stream according to \a name
+    static std::ostream& select_ostream(const char* name, std::ofstream& ofs);
+    /** Run script with search engine \a Engine and options \a opt
+     *
+     * In the solution and stat modes, search can be aborted by sending
+     * SIGINT to the process (i.e., pressing Ctrl-C on the command
+     * line).
      *
-     * All scripts must inherit from this class
-     *  - adds printing and comparison for Gist to scripts
-     *  - run allows to execute scripts
+     * In case \a s is different from NULL, the search engine uses
+     * \a s as root of the search tree.
      */
-    template<class BaseSpace>
-    class ScriptBase : public BaseSpace {
-    public:
-      /// Default constructor
-      ScriptBase(void) {}
-      /// Constructor used for cloning
-      ScriptBase(bool share, ScriptBase& e) 
-        : BaseSpace(share,e) {}
-      /// Print a solution to \a os
-      virtual void print(std::ostream& os) const { (void) os; }
-      /// Compare with \a s
-      virtual void compare(const Space&, std::ostream& os) const {
-        (void) os;
-      }
-      /// Choose output stream according to \a name
-      static std::ostream& select_ostream(const char* name, std::ofstream& ofs);
-      /** Run script with search engine \a Engine and options \a opt
-       *
-       * In the solution and stat modes, search can be aborted by sending
-       * SIGINT to the process (i.e., pressing Ctrl-C on the command
-       * line).
-       *
-       * In case \a s is different from NULL, the search engine uses
-       * \a s as root of the search tree.
-       */
-      template<class Script, template<class> class Engine, class Options>
-      static void run(const Options& opt, Script* s=NULL);
-    private:
-      template<class Script, template<class> class Engine, class Options,
-               template<template<class> class,class> class Meta>
-      static void runMeta(const Options& opt, Script* s);
-      /// Catch wrong definitions of copy constructor
-      explicit ScriptBase(ScriptBase& e);
-    };
-  }
+    template<class Script, template<class> class Engine, class Options>
+    static void run(const Options& opt, Script* s=NULL);
+  private:
+    template<class Script, template<class> class Engine, class Options,
+             template<template<class> class,class> class Meta>
+             static void runMeta(const Options& opt, Script* s);
+    /// Catch wrong definitions of copy constructor
+    explicit ScriptBase(ScriptBase& e);
+  };
+
+#ifdef GECODE_HAS_FLOAT_VARS 
+
+  /// Class to extract the step option value
+  template<class BaseSpace>
+  class ExtractStepOption : public BaseSpace {
+  public:
+    /// Constructor that extracts the step value
+    ExtractStepOption(const Options& opt) 
+      : BaseSpace(opt.step()) {}
+    /// Constructor used for cloning
+    ExtractStepOption(bool share, BaseSpace& e) 
+      : BaseSpace(share,e) {}
+  };
+
+#endif
+
+  /// Class to ignore the step option value
+  template<class BaseSpace>
+  class IgnoreStepOption : public BaseSpace {
+  public:
+    /// Constructor
+    IgnoreStepOption(const Options& opt) {}
+    /// Constructor used for cloning
+    IgnoreStepOption(bool share, BaseSpace& e) 
+      : BaseSpace(share,e) {}
+  };
+
+
+}}
+
+#include <gecode/driver/script.hpp>
+
+namespace Gecode {
 
   /**
    * \defgroup TaskDriverScript Script classes
@@ -669,47 +704,52 @@ namespace Gecode {
    * \brief Base-class for scripts
    * \ingroup TaskDriverScript
    */
-  typedef Driver::ScriptBase<Space> Script;
+  typedef Driver::ScriptBase<Driver::IgnoreStepOption<Space> > 
+    Script;
   /**
    * \brief Base-class for scripts for finding solution of lowest integer cost
    * \ingroup TaskDriverScript
    */
-  typedef Driver::ScriptBase<MinimizeSpace> MinimizeScript;
+  typedef Driver::ScriptBase<Driver::IgnoreStepOption<MinimizeSpace> > 
+    MinimizeScript;
   /**
    * \brief Base-class for scripts for finding solution of highest integer cost
    * \ingroup TaskDriverScript
    */
-  typedef Driver::ScriptBase<MaximizeSpace> MaximizeScript;
+  typedef Driver::ScriptBase<Driver::IgnoreStepOption<MaximizeSpace> > 
+    MaximizeScript;
   /**
    * \brief Base-class for scripts for finding solution of lowest integer cost
    * \ingroup TaskDriverScript
    */
-  typedef Driver::ScriptBase<IntMinimizeSpace> IntMinimizeScript;
+  typedef Driver::ScriptBase<Driver::IgnoreStepOption<IntMinimizeSpace> > 
+    IntMinimizeScript;
   /**
    * \brief Base-class for scripts for finding solution of highest integer cost
    * \ingroup TaskDriverScript
    */
-  typedef Driver::ScriptBase<IntMaximizeSpace> IntMaximizeScript;
+  typedef Driver::ScriptBase<Driver::IgnoreStepOption<IntMaximizeSpace> > 
+    IntMaximizeScript;
 
 #ifdef GECODE_HAS_FLOAT_VARS 
 
   /**
    * \brief Base-class for scripts for finding solution of lowest float cost
    * \ingroup TaskDriverScript
    */
-  typedef Driver::ScriptBase<FloatMinimizeSpace> FloatMinimizeScript;
+  typedef Driver::ScriptBase<Driver::ExtractStepOption<FloatMinimizeSpace> > 
+    FloatMinimizeScript;
   /**
    * \brief Base-class for scripts for finding solution of highest float cost
    * \ingroup TaskDriverScript
    */
-  typedef Driver::ScriptBase<FloatMaximizeSpace> FloatMaximizeScript;
+  typedef Driver::ScriptBase<Driver::ExtractStepOption<FloatMaximizeSpace> > 
+    FloatMaximizeScript;
 
 #endif
 
 }
 
-#include <gecode/driver/script.hpp>
-
 #endif
 
 // STATISTICS: driver-any

gecode/driver/options.cpp

@@ -366,6 +366,7 @@ namespace Gecode {
       _branching("-branching","branching variants"),
       _decay("-decay","decay factor",1.0),
       _seed("-seed","random number generator seed",1U),
+      _step("-step","step distance for float optimization",0.0),
 
       _search("-search","search engine variants"),
       _solutions("-solutions","number of solutions (0 = all)",1),
@@ -412,7 +413,7 @@ namespace Gecode {
     _restart.add(RM_GEOMETRIC,"geometric");
 
     add(_model); add(_symmetry); add(_propagation); add(_icl); 
-    add(_branching); add(_decay); add(_seed);
+    add(_branching); add(_decay); add(_seed); add(_step);
     add(_search); add(_solutions); add(_threads); add(_c_d); add(_a_d);
     add(_node); add(_fail); add(_time); add(_interrupt);
     add(_restart); add(_r_base); add(_r_scale); 

gecode/driver/options.hpp

@@ -230,6 +230,15 @@ namespace Gecode {
     return _seed.value();
   }
 
+  inline void
+  Options::step(double s) {
+    _step.value(s);
+  }
+  inline double
+  Options::step(void) const {
+    return _step.value();
+  }
+  
 
   /*
    * Search options

gecode/driver/script.hpp

@@ -206,9 +206,27 @@ namespace Gecode { namespace Driver {
 #endif
 
 
-  template<class Space>
+  template<class BaseSpace>
+  forceinline
+  ScriptBase<BaseSpace>::ScriptBase(const Options& opt) 
+    : BaseSpace(opt) {}
+
+  template<class BaseSpace>
+  forceinline
+  ScriptBase<BaseSpace>::ScriptBase(bool share, ScriptBase& e) 
+    : BaseSpace(share,e) {}
+
+  template<class BaseSpace>
+  void
+  ScriptBase<BaseSpace>::print(std::ostream&) const {}
+
+  template<class BaseSpace>
+  void 
+  ScriptBase<BaseSpace>::compare(const Space&, std::ostream&) const {}
+
+  template<class BaseSpace>
   std::ostream&
-  ScriptBase<Space>::select_ostream(const char* name, std::ofstream& ofs) {
+  ScriptBase<BaseSpace>::select_ostream(const char* name, std::ofstream& ofs) {
     if (strcmp(name, "stdout") == 0) {
       return std::cout;
     } else if (strcmp(name, "stdlog") == 0) {
@@ -221,6 +239,7 @@ namespace Gecode { namespace Driver {
     }
   }
 
+
   /**
    * \brief Wrapper class to add engine template argument
    */
@@ -230,22 +249,22 @@ namespace Gecode { namespace Driver {
     EngineToMeta(T* s, const Search::Options& o) : E<T>(s,o) {}
   };
 
-  template<class Space>
+  template<class BaseSpace>
   template<class Script, template<class> class Engine, class Options>
   void
-  ScriptBase<Space>::run(const Options& o, Script* s) {
+  ScriptBase<BaseSpace>::run(const Options& o, Script* s) {
     if (o.restart()==RM_NONE) {
       runMeta<Script,Engine,Options,EngineToMeta>(o,s);
     } else {
       runMeta<Script,Engine,Options,RBS>(o,s);
     }
   }
 
-  template<class Space>
+  template<class BaseSpace>
   template<class Script, template<class> class Engine, class Options,
            template<template<class> class,class> class Meta>
   void
-  ScriptBase<Space>::runMeta(const Options& o, Script* s) {
+  ScriptBase<BaseSpace>::runMeta(const Options& o, Script* s) {
     using namespace std;
 
     ofstream sol_file, log_file;