gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.2.0/examples/support.hh

@@ -0,0 +1,338 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2007
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 10:47:54 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7347 $
+ *
+ *  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.
+ *
+ */
+
+#ifndef __GECODE_EXAMPLES_SUPPORT_HH__
+#define __GECODE_EXAMPLES_SUPPORT_HH__
+
+#include "gecode/kernel.hh"
+#include "gecode/int.hh"
+#include "gecode/search.hh"
+
+#ifdef GECODE_HAS_GIST
+#include "gecode/gist.hh"
+#endif
+
+using namespace Gecode;
+
+/*
+ * Options for running the examples
+ *
+ */
+
+/// Different modes for executing examples
+enum ExampleMode {
+  EM_SOLUTION, ///< Print solution and some statistics
+  EM_TIME,     ///< Measure average runtime
+  EM_STAT      ///< Print statistics for example
+#ifdef GECODE_HAS_GIST
+  ,
+  EM_GIST      ///< Run example in Gist
+#endif
+};
+
+class Options;
+
+/**
+ * \brief Base class for options
+ *
+ */
+class BaseOption {
+  friend class Options;
+protected:
+  const char* opt;  ///< String for option (including hyphen)
+  const char* exp;  ///< Short explanation
+  BaseOption* next; ///< Next option
+public:
+  /// Initialize for option \a o and explanation \a e
+  BaseOption(const char* o, const char* e);
+  /// Parse option at first position and possibly delete
+  virtual bool parse(int& argc, char* argv[]) = 0;
+  /// Print help text
+  virtual void help(void) = 0;
+  /// Destructor
+  virtual ~BaseOption(void);
+};
+
+/**
+ * \brief String-valued option
+ *
+ */
+class StringOption : public BaseOption {
+protected:
+  /// Option value
+  class Value {
+  public:
+    int         val;  ///< Value for an option value
+    const char* opt;  ///< String for option value
+    const char* help; ///< Optional help text
+    Value*      next; ///< Next option value
+  };
+  int    cur; ///< Current value
+  Value* fst; ///< First option value
+  Value* lst; ///< Last option value
+public:
+  /// Initialize for option \a o and explanation \a e and default value \a v
+  StringOption(const char* o, const char* e, int v=0);
+  /// Set default value to \a v
+  void value(int v);
+  /// Return current option value
+  int value(void) const;
+  /// Add option value for value \a v, string \a o, and help text \a h
+  void add(int v, const char* o, const char* h = NULL);
+  /// Parse option at first position
+  virtual bool parse(int& argc, char* argv[]);
+  /// Print help text
+  virtual void help(void);
+  /// Destructor
+  virtual ~StringOption(void);
+};
+
+
+/**
+ * \brief Unsigned integer option
+ *
+ */
+class UnsignedIntOption : public BaseOption {
+protected:
+  unsigned int cur; ///< Current value
+public:
+  /// Initialize for option \a o and explanation \a e and default value \a v
+  UnsignedIntOption(const char* o, const char* e, unsigned int v=0);
+  /// Set default value to \a v
+  void value(unsigned int v);
+  /// Return current option value
+  unsigned int value(void) const;
+  /// Parse option at first position
+  virtual bool parse(int& argc, char* argv[]);
+  /// Print help text
+  virtual void help(void);
+};
+
+
+/**
+ * \brief Options for examples
+ *
+ */
+class Options {
+protected:
+  BaseOption* fst;   ///< First registered option
+  BaseOption* lst;   ///< Last registered option
+  const char* _name; ///< Example name
+
+  /// \name Model options
+  //@{
+  StringOption _model;       ///< General model options
+  StringOption _propagation; ///< Propagation options
+  StringOption _pk;          ///< Propagation kind
+  StringOption _icl;         ///< Integer consistency level
+  StringOption _branching;   ///< Branching options
+  //@}
+
+  /// \name Search options
+  //@{
+  StringOption      _search;    ///< Search options
+  UnsignedIntOption _solutions; ///< How many solutions
+  UnsignedIntOption _c_d;       ///< Copy recomputation distance
+  UnsignedIntOption _a_d;       ///< Adaptive recomputation distance
+  UnsignedIntOption _fail;      ///< Cutoff for number of failures
+  UnsignedIntOption _time;      ///< Cutoff for time
+  //@}
+
+  /// \name Execution options
+  //@{
+  StringOption      _mode;       ///< Example mode to run
+  UnsignedIntOption _samples;    ///< How many samples
+  UnsignedIntOption _iterations; ///< How many iterations per sample
+  //@}
+
+public:
+  /// Initialize options for example with name \a s
+  Options(const char* s);
+  /// Add new option \a o
+  void add(BaseOption& o);
+  /// Print help text
+  virtual void help(void);
+  /// Parse options from arguments \a argv (number is \a argc)
+  void parse(int& argc, char* argv[]);
+
+  /// Return name of example
+  const char* name(void) const;
+
+  /// \name Model options
+  //@{
+  /// Set default model value
+  void model(int v);
+  /// Add model option value for value \a v, string \a o, and help \a h
+  void model(int v, const char* o, const char* h = NULL);
+  /// Return model value
+  int model(void) const;
+
+  /// Set default propagation value
+  void propagation(int v);
+  /// Add propagation option value for value \a v, string \a o, and help \a h
+  void propagation(int v, const char* o, const char* h = NULL);
+  /// Return propagation value
+  int propagation(void) const;
+
+  /// Set default propagation kind
+  void pk(PropKind p);
+  /// Return propagation kind
+  PropKind pk(void) const;
+
+  /// Set default integer consistency level
+  void icl(IntConLevel i);
+  /// Return integer consistency level
+  IntConLevel icl(void) const;
+
+  /// Set default branching value
+  void branching(int v);
+  /// Add branching option value for value \a v, string \a o, and help \a h
+  void branching(int v, const char* o, const char* h = NULL);
+  /// Return branching value
+  int branching(void) const;
+  //@}
+
+  /// \name Search options
+  //@{
+  /// Set default search value
+  void search(int v);
+  /// Add search option value for value \a v, string \a o, and help \a h
+  void search(int v, const char* o, const char* h = NULL);
+  /// Return search value
+  int search(void) const;
+
+  /// Set default number of solutions to search for
+  void solutions(unsigned int n);
+  /// Return number of solutions to search for
+  unsigned int solutions(void) const;
+
+  /// Set default copy recomputation distance
+  void c_d(unsigned int d);
+  /// Return copy recomputation distance
+  unsigned int c_d(void) const;
+
+  /// Set default adaptive recomputation distance
+  void a_d(unsigned int d);
+  /// Return adaptive recomputation distance
+  unsigned int a_d(void) const;
+
+  /// Set default failure cutoff
+  void fail(unsigned int n);
+  /// Return failure cutoff
+  unsigned int fail(void) const;
+
+  /// Set default time cutoff
+  void time(unsigned int t);
+  /// Return time cutoff
+  unsigned int time(void) const;
+  //@}
+
+  /// \name Execution options
+  //@{
+  /// Set default mode
+  void mode(ExampleMode em);
+  /// Return mode
+  ExampleMode mode(void) const;  
+
+  /// Set default number of iterations
+  void iterations(unsigned int i);
+  /// Return number of iterations
+  unsigned int iterations(void) const;
+
+  /// Set default number of samples
+  void samples(unsigned int s);
+  /// Return number of samples
+  unsigned int samples(void) const;
+  //@}
+
+  /// Destructor
+  virtual ~Options(void);
+};
+
+/**
+ * \brief Options for examples with additional size parameter
+ *
+ */
+class SizeOptions : public Options {
+protected:
+  unsigned int _size; ///< Size value
+public:
+  /// Initialize options for example with name \a s
+  SizeOptions(const char* s);
+  /// Print help text
+  virtual void help(void);
+  /// Parse options from arguments \a argv (number is \a argc)
+  void parse(int& argc, char* argv[]);
+
+  /// Set default size
+  void size(unsigned int s);
+  /// Return size
+  unsigned int size(void) const;
+};
+
+#include "examples/support/options.icc"
+
+
+/**
+ * \brief Base-class for %Gecode examples
+ *
+ * All examples must inherit from this class
+ *  - adds printing to examples
+ *  - run allows to execute examples
+ *
+ */
+class Example : public Space {
+public:
+  /// Default constructor
+  Example(void) {}
+  /// Constructor used for cloning
+  Example(bool share, Example& e) : Space(share,e) {}
+  /// Print a solution to \a os
+  virtual void print(std::ostream& os) { (void)os; }
+  /// Run example with search engine \a Engine and options \a opt
+  template <class Script, template<class> class Engine, class Options>
+  static void run(const Options& opt);
+ private:
+  /// Catch wrong definitions of copy constructor
+  explicit Example(Example& e);
+};
+
+#include "examples/support/example.icc"
+
+#endif
+
+// STATISTICS: example-any

data/ext/gecode-2.2.0/examples/support/example.cc

@@ -0,0 +1,64 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 10:45:19 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7344 $
+ *
+ *  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 "examples/support.hh"
+
+double
+am(double t[], int n) {
+  if (n < 1)
+    return 0.0;
+  double s = 0;
+  for (int i=n; i--; )
+    s += t[i];
+  return s / n;
+}
+
+double
+dev(double t[], int n) {
+  if (n < 2)
+    return 0.0;
+  double m = am(t,n);
+  double s = 0.0;
+  for (int i=n; i--; ) {
+    double d = t[i]-m;
+    s += d*d;
+  }
+  return sqrt(s / (n-1)) / m;
+}
+
+// STATISTICS: example-any

data/ext/gecode-2.2.0/examples/support/example.icc

@@ -0,0 +1,321 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 10:45:19 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7344 $
+ *
+ *  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 <iostream>
+#include <iomanip>
+
+#include <ctime>
+#include <cmath>
+
+namespace {
+
+  /**
+   * \brief Stop object based on both time and failures
+   *
+   */
+  class FailTimeStop : public Search::Stop {
+  private:
+    Search::TimeStop *ts; ///< Used time stop object
+    Search::FailStop *fs; ///< Used fail stop object
+    /// Initialize stop object
+    FailTimeStop(int fails, int time) {
+      ts = new Search::TimeStop(time);
+      fs = new Search::FailStop(fails);
+    }
+  public:
+    /// Test whether search must be stopped
+    virtual bool stop(const Search::Statistics& s) {
+      return fs->stop(s) || ts->stop(s);
+    }
+    /// Create appropriate stop-object
+    static Search::Stop* create(unsigned int fail, unsigned int time) {
+      if ((fail == 0) && (time == 0)) 
+        return NULL;
+      if (fail == 0) 
+        return new Search::TimeStop(time);
+      if (time  == 0) 
+        return new Search::FailStop(fail);
+      return new FailTimeStop(fail,time);
+    }
+  };
+
+  /// Timer interface used for examples
+  class Timer {
+  private:
+    clock_t t0; ///< Start time
+  public:
+    /// Start timer
+    void start(void) {
+      t0 = clock();
+    }
+    /// Stop timer
+    double stop(void) {
+      return (static_cast<double>(clock()-t0) / CLOCKS_PER_SEC) * 1000.0;
+    }
+    /// Stop timer and print user friendly time information
+    void stop(std::ostream& os) {
+      double t = stop();
+      double sec = floor(t / 1000.0);
+      int o_msec = static_cast<int>(t - 1000.0*sec);
+      double min = floor(sec / 60.0);
+      int o_sec = static_cast<int>(sec - 60.0*min);
+      double hour = floor(min / 60.0);
+      int o_min = static_cast<int>(min - 60.0*hour);
+      double day = floor(hour / 24.0);
+      int o_hour = static_cast<int>(hour - 24.0*day);
+      int o_day = static_cast<int>(day);
+      if (o_day)
+        os << o_day << " days, ";
+      if (o_hour)
+        os << o_hour << ":";
+      if (o_min) {
+        if (o_hour) {
+          os.width(2); os.fill('0');
+        }
+        os << o_min << ":";
+        os.width(2); os.fill('0');
+      }
+      os << o_sec << ".";
+      os.width(3); os.fill('0');
+      os << o_msec
+         << " ("
+         << std::showpoint << std::fixed
+         << std::setprecision(6) << t << " ms)";
+    }
+  };
+  
+}
+
+
+/**
+ * \brief Compute arithmetic mean of \a n elements in \a t
+ * \relates Timer
+ */
+double
+am(double t[], int n);
+
+/**
+ * \brief Compute deviation of \a n elements in \a t
+ * \relates Timer
+ */
+double
+dev(double t[], int n);
+
+#ifdef GECODE_HAS_GIST
+
+/**
+ * \brief Traits class for search engines
+ */
+template <class Engine>
+class GistEngine {
+};
+
+/// Specialization for DFS
+template <typename S>
+class GistEngine<DFS<S> > {
+public:
+  static void explore(S* root, Gist::Inspector* i) {
+    (void) Gecode::explore(root, i);
+  }
+};
+
+/// Specialization for LDS
+template <typename S>
+class GistEngine<LDS<S> > {
+public:
+  static void explore(S* root, Gist::Inspector* i) {
+    (void) Gecode::explore(root, i);
+  }
+};
+
+/// Specialization for BAB
+template <typename S>
+class GistEngine<BAB<S> > {
+public:
+  static void explore(S* root, Gist::Inspector* i) {
+    (void) exploreBest(root, i);
+  }
+};
+
+/// Specialization for Restart
+template <typename S>
+class GistEngine<Restart<S> > {
+public:
+  static void explore(S* root, Gist::Inspector* i) {
+    (void) exploreBest(root, i);
+  }
+};
+
+#endif
+
+template <class Script, template<class> class Engine, class Options>
+void
+Example::run(const Options& o) {
+  using namespace std;
+  try {
+    switch (o.mode()) {
+    case EM_SOLUTION:
+      {
+        cout << o.name() << endl;
+        Timer t;
+        int i = o.solutions();
+        t.start();
+        Script* s = new Script(o);
+        unsigned int n_p = s->propagators();
+        unsigned int n_b = s->branchings();
+        unsigned long int p = 0;
+        Search::Options so;
+        so.c_d  = o.c_d();
+        so.a_d  = o.a_d();
+        so.stop = FailTimeStop::create(o.fail(), o.time());
+        Engine<Script> e(s,so);
+        delete s;
+        do {
+          Example* ex = e.next();
+          if (ex == NULL)
+            break;
+          ex->print(std::cout);
+          delete ex;
+        } while (--i != 0);
+        Search::Statistics stat = e.statistics();
+        cout << endl;
+        cout << "Initial" << endl
+             << "\tpropagators:   " << n_p << endl
+             << "\tbranchings:    " << n_b << endl
+             << endl
+             << "Summary" << endl
+             << "\truntime:       ";
+        t.stop(cout); 
+        cout << endl
+             << "\tsolutions:     " 
+             << abs(static_cast<int>(o.solutions()) - i) << endl
+             << "\tpropagations:  " << p+stat.propagate << endl
+             << "\tfailures:      " << stat.fail << endl
+             << "\tclones:        " << stat.clone << endl
+             << "\tcommits:       " << stat.commit << endl
+             << "\tpeak memory:   "
+             << static_cast<int>((stat.memory+1023) / 1024) << " KB"
+             << endl;
+      }
+      break;
+    case EM_STAT:
+      {
+        cout << o.name() << endl;
+        int i = o.solutions();
+        Script* s = new Script(o);
+        unsigned int n_p = s->propagators();
+        unsigned int n_b = s->branchings();
+        unsigned long int p = 0;
+        Search::Options so;
+        so.c_d  = o.c_d();
+        so.a_d  = o.a_d();
+        Engine<Script> e(s,so);
+        delete s;
+        do {
+          Example* ex = e.next();
+          if (ex == NULL)
+            break;
+          delete ex;
+        } while (--i != 0);
+        Search::Statistics stat = e.statistics();
+        cout << endl
+             << "\tpropagators:   " << n_p << endl
+             << "\tbranchings:    " << n_b << endl
+             << "\tsolutions:     " 
+             << abs(static_cast<int>(o.solutions()) - i) << endl
+             << "\tpropagations:  " << p+stat.propagate << endl
+             << "\tfailures:      " << stat.fail << endl
+             << "\tclones:        " << stat.clone << endl
+             << "\tcommits:       " << stat.commit << endl
+             << "\tpeak memory:   "
+             << static_cast<int>((stat.memory+1023) / 1024) << " KB"
+             << endl;
+      }
+      break;
+    case EM_TIME:
+      {
+        cout << o.name() << endl;
+        Timer t;
+        GECODE_AUTOARRAY(double,ts,o.samples());
+        for (unsigned int s = o.samples(); s--; ) {
+          t.start();
+          for (unsigned int k = o.iterations(); k--; ) {
+            unsigned int i = o.solutions();
+            Script* s = new Script(o);
+            Search::Options so;
+            so.c_d  = o.c_d();
+            so.a_d  = o.a_d();
+            Engine<Script> e(s,so);
+            delete s;
+            do {
+              Example* ex = e.next();
+              if (ex == NULL)
+                break;
+              delete ex;
+            } while (--i != 0);
+          }
+          ts[s] = t.stop() / o.iterations();
+        }
+        double m = am(ts,o.samples());
+        double d = dev(ts,o.samples()) * 100.0;
+        cout << "\tRuntime: "
+             << setw(20) << right
+             << showpoint << fixed
+             << setprecision(6) << m << "ms"
+             << setprecision(2) << " (" << d << "% deviation)"
+             << endl;
+      }
+      break;
+#ifdef GECODE_HAS_GIST
+    case EM_GIST:
+      {
+        Gist::PrintingInspector<Script> pi(o.name());
+        Script* s = new Script(o);
+        (void) GistEngine<Engine<Script> >::explore(s, &pi);
+        delete s;
+      }
+      break;
+#endif
+    }
+  } catch (Exception e) {
+    cout << "Exception: " << e.what() << "." << endl
+         << "Stopping..." << endl;
+  }
+}
+
+// STATISTICS: example-any