gecoder-with-gecode 0.9.0 → 0.9.1

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

@@ -0,0 +1,226 @@
+/* -*- 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: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.
+ *
+ */
+
+#include "examples/support.hh"
+
+#include <iostream>
+#include <iomanip>
+
+#include <cstdlib>
+#include <cstring>
+
+void 
+StringOption::add(int v, const char* o, const char* h) {
+  Value* n = new Value;
+  n->val  = v;
+  n->opt  = o;
+  n->help = h;
+  n->next = NULL;
+  if (fst == NULL) {
+    fst = n;
+  } else {
+    lst->next = n; 
+  }
+  lst = n;
+}
+
+bool
+StringOption::parse(int& argc, char* argv[]) {
+  if ((argc < 2) || strcmp(argv[1],opt))
+    return false;
+  if (argc == 2) {
+    std::cerr << "Missing argument for option \"" << opt << "\"" << std::endl;
+    exit(EXIT_FAILURE);
+  }
+  for (Value* v = fst; v != NULL; v = v->next)
+    if (!strcmp(argv[2],v->opt)) {
+      cur = v->val;
+      // Remove options
+      argc -= 2;
+      for (int i=1; i<argc; i++)
+        argv[i] = argv[i+2];
+      return true;
+    }
+  std::cerr << "Wrong argument \"" << argv[2] 
+            << "\" for option \"" << opt << "\"" 
+            << std::endl;
+  exit(EXIT_FAILURE);
+}
+
+void 
+StringOption::help(void) {
+  if (fst == NULL)
+    return;
+  std::cerr << '\t' << opt << " (";
+  const char* d = NULL;
+  for (Value* v = fst; v != NULL; v = v->next) {
+    std::cerr << v->opt << ((v->next != NULL) ? ", " : "");
+    if (v->val == cur)
+      d = v->opt;
+  }
+  std::cerr << ")";
+  if (d != NULL) 
+    std::cerr << " default: " << d;
+  std::cerr << std::endl << "\t\t" << exp << std::endl;
+  for (Value* v = fst; v != NULL; v = v->next)
+    if (v->help != NULL)
+      std::cerr << "\t\t  " << v->opt << ": " << v->help << std::endl;
+}
+
+StringOption::~StringOption(void) {
+  Value* v = fst;
+  while (v != NULL) {
+    Value* n = v->next;
+    delete v;
+    v = n;
+  }
+}
+
+
+bool
+UnsignedIntOption::parse(int& argc, char* argv[]) {
+  if ((argc < 2) || strcmp(argv[1],opt))
+    return false;
+  if (argc == 2) {
+    std::cerr << "Missing argument for option \"" << opt << "\"" << std::endl;
+    exit(EXIT_FAILURE);
+  }
+  cur = atoi(argv[2]);
+  // Remove options
+  argc -= 2;
+  for (int i=1; i<argc; i++)
+    argv[i] = argv[i+2];
+  return true;
+}
+
+void 
+UnsignedIntOption::help(void) {
+  using namespace std;
+  cerr << '\t' << opt << " (unsigned int) default: " << cur << endl
+       << "\t\t" << exp << endl;
+}
+
+
+
+Options::Options(const char* n)
+  : fst(NULL), lst(NULL),
+
+    _name(n),
+
+    _model("-model","model variants"),
+    _propagation("-propagation","propagation variants"),
+    _pk("-pk","propagation kind",PK_DEF),
+    _icl("-icl","integer consistency level",ICL_DEF),
+    _branching("-branching","branching variants"),
+    
+    _search("-search","search engine variants"),
+    _solutions("-solutions","number of solutions (0 = all)",1),
+    _c_d("-c-d","recomputation copy distance",Search::Config::c_d),
+    _a_d("-a-d","recomputation adaption distance",Search::Config::a_d),
+    _fail("-fail","failure cutoff (0 = none, solution mode)"),
+    _time("-time","time (in ms) cutoff (0 = none, solution mode)"),
+
+    _mode("-mode","how to execute example",EM_SOLUTION),
+    _samples("-samples","how many samples (time mode)",1),
+    _iterations("-iterations","iterations per sample (time mode)",1)
+{
+
+  _pk.add(PK_DEF, "def"); _pk.add(PK_SPEED, "speed");
+  _pk.add(PK_MEMORY, "memory");
+
+  _icl.add(ICL_DEF, "def"); _icl.add(ICL_VAL, "val");
+  _icl.add(ICL_BND, "bnd"); _icl.add(ICL_DOM, "dom");
+
+  _mode.add(EM_SOLUTION, "solution"); 
+  _mode.add(EM_TIME, "time");
+  _mode.add(EM_STAT, "stat");
+#ifdef GECODE_HAS_GIST
+  _mode.add(EM_GIST, "gist");
+#endif
+
+  add(_model); add(_propagation); add(_pk); add(_icl); add(_branching);
+  add(_search); add(_solutions); add(_c_d); add(_a_d); add(_fail); add(_time);
+  add(_mode); add(_iterations); add(_samples);
+}
+
+void
+Options::help(void) {
+  std::cerr << "Options for " << name() << ":" << std::endl
+            << "\t-help, --help, -?" << std::endl
+            << "\t\tprint this help message" << std::endl;
+  for (BaseOption* o = fst; o != NULL; o = o->next)
+    o->help();
+}
+
+void
+Options::parse(int& argc, char* argv[]) {
+ next:
+  for (BaseOption* o = fst; o != NULL; o = o->next)
+    if (o->parse(argc,argv))
+      goto next;
+  if (argc < 2)
+    return;
+  if (!strcmp(argv[1],"-help") || !strcmp(argv[1],"--help") ||
+      !strcmp(argv[1],"-?")) {
+    help();
+    exit(EXIT_SUCCESS);
+  }
+  return;
+}
+
+
+SizeOptions::SizeOptions(const char* e) 
+  : Options(e), _size(0) {}
+
+void
+SizeOptions::help(void) {
+  Options::help();
+  std::cerr << "\t(unsigned int) default: " << size() << std::endl
+            << "\t\twhich version/size for example" << std::endl;
+}
+
+void
+SizeOptions::parse(int& argc, char* argv[]) {
+  Options::parse(argc,argv);
+  if (argc < 2)
+    return;
+  size(atoi(argv[1]));
+}
+
+
+// STATISTICS: example-any

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

@@ -0,0 +1,276 @@
+/* -*- 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.
+ *
+ */
+
+/*
+ * Option baseclass
+ *
+ */
+inline
+BaseOption::BaseOption(const char* o, const char* e) 
+  : opt(o), exp(e) {}
+inline
+BaseOption::~BaseOption(void) {
+}
+
+
+/*
+ * String option
+ *
+ */
+inline
+StringOption::StringOption(const char* o, const char* e, int v) 
+  : BaseOption(o,e), cur(v), fst(NULL), lst(NULL) {}
+inline void 
+StringOption::value(int v) {
+  cur = v;
+}
+inline int 
+StringOption::value(void) const {
+  return cur;
+}
+
+/*
+ * Unsigned integer option
+ *
+ */
+inline
+UnsignedIntOption::UnsignedIntOption(const char* o, const char* e, 
+                                     unsigned int v) 
+  : BaseOption(o,e), cur(v) {}
+inline void 
+UnsignedIntOption::value(unsigned int v) {
+  cur = v;
+}
+inline unsigned int 
+UnsignedIntOption::value(void) const {
+  return cur;
+}
+
+
+/*
+ * Options
+ *
+ */
+inline void
+Options::add(BaseOption& o) {
+  o.next = NULL;
+  if (fst == NULL) {
+    fst=&o;
+  } else {
+    lst->next=&o;
+  }
+  lst=&o;
+}
+inline const char*
+Options::name(void) const {
+  return _name;
+}
+
+/*
+ * Model options
+ *
+ */
+inline void
+Options::model(int v) {
+  _model.value(v);
+}
+inline void
+Options::model(int v, const char* o, const char* h) {
+  _model.add(v,o,h);
+}
+inline int
+Options::model(void) const {
+  return _model.value();
+}
+
+inline void
+Options::propagation(int v) {
+  _propagation.value(v);
+}
+inline void
+Options::propagation(int v, const char* o, const char* h) {
+  _propagation.add(v,o,h);
+}
+inline int
+Options::propagation(void) const {
+  return _propagation.value();
+}
+
+inline void
+Options::pk(PropKind p) {
+  _pk.value(p);
+}
+inline PropKind
+Options::pk(void) const {
+  return static_cast<PropKind>(_pk.value());
+}
+
+inline void
+Options::icl(IntConLevel i) {
+  _icl.value(i);
+}
+inline IntConLevel
+Options::icl(void) const {
+  return static_cast<IntConLevel>(_icl.value());
+}
+
+inline void
+Options::branching(int v) {
+  _branching.value(v);
+}
+inline void
+Options::branching(int v, const char* o, const char* h) {
+  _branching.add(v,o,h);
+}
+inline int
+Options::branching(void) const {
+  return _branching.value();
+}
+
+/*
+ * Search options
+ *
+ */
+inline void
+Options::search(int v) {
+  _search.value(v);
+}
+inline void
+Options::search(int v, const char* o, const char* h) {
+  _search.add(v,o,h);
+}
+inline int
+Options::search(void) const {
+  return _search.value();
+}
+
+inline void
+Options::solutions(unsigned int n) {
+  _solutions.value(n);
+}
+inline unsigned int
+Options::solutions(void) const {
+  return _solutions.value();
+}
+
+inline void
+Options::c_d(unsigned int d) {
+  _c_d.value(d);
+}
+inline unsigned int
+Options::c_d(void) const {
+  return _c_d.value();
+}
+
+inline void
+Options::a_d(unsigned int d) {
+  _a_d.value(d);
+}
+inline unsigned int
+Options::a_d(void) const {
+  return _a_d.value();
+}
+
+inline void
+Options::fail(unsigned int n) {
+  _fail.value(n);
+}
+inline unsigned int
+Options::fail(void) const {
+  return _fail.value();
+}
+
+inline void
+Options::time(unsigned int t) {
+  _time.value(t);
+}
+inline unsigned int
+Options::time(void) const {
+  return _time.value();
+}
+
+
+
+/*
+ * Execution options
+ *
+ */
+inline void
+Options::mode(ExampleMode em) {
+  _mode.value(em);
+}
+inline ExampleMode
+Options::mode(void) const {
+  return static_cast<ExampleMode>(_mode.value());
+}
+
+inline void
+Options::iterations(unsigned int i) {
+  _iterations.value(i);
+}
+inline unsigned int
+Options::iterations(void) const {
+  return _iterations.value();
+}
+
+inline void
+Options::samples(unsigned int s) {
+  _samples.value(s);
+}
+inline unsigned int
+Options::samples(void) const {
+  return _samples.value();
+}
+
+inline
+Options::~Options(void) {}
+
+/*
+ * Options with additional size argument
+ *
+ */
+inline void
+SizeOptions::size(unsigned int s) {
+  _size = s;
+}
+inline unsigned int
+SizeOptions::size(void) const {
+  return _size;
+}
+
+// STATISTICS: example-any