gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/test/test.cc

@@ -0,0 +1,215 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *     Mikael Lagerkvist, 2005
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:07:12 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3518 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+#include "test/test.hh"
+#include "test/log.hh"
+
+#ifdef GECODE_HAVE_MTRACE
+#include <mcheck.h>
+#endif
+
+#include <iostream>
+
+#include <cstdlib>
+#include <string>
+#include <cstring>
+#include <ctime>
+#include <vector>
+#include <utility>
+
+using std::vector;
+using std::make_pair;
+using std::pair;
+
+vector<pair<bool, const char*> > testpat;
+
+Test* Test::all = NULL;
+Support::RandomGenerator Test::randgen = Support::RandomGenerator();
+
+
+namespace {
+
+  void report_error(const Options& o, std::string name) {
+    std::cout << "Options: -seed " << o.seed;
+    if (o.fixprob != o.deffixprob)
+      std::cout << "  -fixprob " << o.fixprob;
+    if (o.flushprob != o.defflushprob)
+      std::cout << "  -flushprob " << o.flushprob;
+    std::cout << "  -test " << name << std::endl;
+    if (o.log)
+      Log::print(o.display);
+  }
+}
+
+int
+main(int argc, char** argv) {
+#ifdef GECODE_HAVE_MTRACE
+  mtrace();
+#endif
+
+  Options o;
+  o.parse(argc, argv);
+  Test::randgen.seed(o.seed);
+  Log::logging(o.log);
+
+  for (Test* t = Test::tests(); t != NULL; t = t->next()) {
+    std::string name(t->module()); name += "::"; name += t->test();
+    try {
+      if (testpat.size() != 0) {
+	bool match_found   = false;
+	bool some_positive = false;
+	for (unsigned int i = 0; i < testpat.size(); ++i) {
+	  if (testpat[i].first) { // Negative pattern
+	    if (name.find(testpat[i].second) != std::string::npos)
+	      goto next;
+	  } else {               // Positive pattern
+	    some_positive = true;
+	    if (name.find(testpat[i].second) != std::string::npos)
+	      match_found = true;
+	  }
+	}
+	if (some_positive && !match_found) goto next;
+      }
+      std::cout << name << ": ";
+      std::cout.flush();
+      for (int i = o.iter; i--; ) {
+	o.seed = Test::randgen.seed();
+	if (t->run(o)) {
+	  std::cout << "+";
+	  std::cout.flush();
+	} else {
+	  std::cout << "-" << std::endl;
+	  report_error(o, name);
+	  if(o.stop_on_error) return 1;
+	}
+      }
+    std::cout << std::endl;
+    } catch (Gecode::Exception e) {
+      std::cout << "Exception in \"Gecode::" << e.what()
+		<< "." << std::endl
+		<< "Stopping..." << std::endl;
+	  report_error(o, name);
+	  if(o.stop_on_error) return 1;
+    }
+  next:;
+  }
+  return 0;
+}
+
+void
+Options::parse(int argc, char** argv) {
+  using namespace std;
+  static const char* bool2str[] =
+    { "false", "true" };
+  int i = 1;
+  const char* e = NULL;
+  while (i < argc) {
+    if (!strcmp(argv[i],"-help") || !strcmp(argv[i],"--help")) {
+      std::cerr << "Options for testing:" << std::endl
+		<< "\t-seed (unsigned int|\"time\") default: " <<seed<< std::endl
+		<< "\t\tthe seed for the random numbers (an integer),"
+		<< std::endl
+		<< "\t\tor the word time for a random seed based on the "
+		<< "current time" << std::endl
+		<< "\t-fixprob (unsigned int) default: " <<fixprob<< std::endl
+		<< "\t\t1/fixprob is the probability of fixpoint recalculations"
+		<< std::endl
+		<< "\t-flushprob (unsigned int) default: " <<flushprob<< std::endl
+		<< "\t\t1/flushprob is the probability of flushing the the caches"
+		<< std::endl
+		<< "\t-iter (unsigned int) default: " <<iter<< std::endl
+		<< "\t\tthe number of iterations" << std::endl
+		<< "\t-test (string) default: (none)" << std::endl
+		<< "\t\tsimple pattern for the tests to run" << std::endl
+		<< "\t\tprefixing the pattern by a - negates the pattern"
+		<< std::endl
+		<< "\t\tmultiple pattern-options may be given" << std::endl
+		<< "\t-log (opt \"text\"|\"code\") default: off"
+		<< std::endl
+		<< "\t\tif given, logging will be printed for failures"
+		<< std::endl
+		<< "\t\tthe optional argument determines the style of the log"
+		<< std::endl
+		<< "\t\twith text as the default style"
+		<< std::endl
+		<< "\t-stop (boolean) default: "
+		<< bool2str[stop_on_error] << std::endl
+		<< "\t\tstop on first error or continue" << std::endl;
+      exit(EXIT_SUCCESS);
+    } else if (!strcmp(argv[i],"-seed")) {
+      if (++i == argc) goto missing;
+      if (!strcmp(argv[i],"time")) {
+	seed = static_cast<int>(time(NULL));
+      } else {
+	seed = atoi(argv[i]);
+      }
+    } else if (!strcmp(argv[i],"-iter")) {
+      if (++i == argc) goto missing;
+      iter = atoi(argv[i]);
+    } else if (!strcmp(argv[i],"-fixprob")) {
+      if (++i == argc) goto missing;
+      fixprob = atoi(argv[i]);
+    } else if (!strcmp(argv[i],"-flushprob")) {
+      if (++i == argc) goto missing;
+      flushprob = atoi(argv[i]);
+    } else if (!strcmp(argv[i],"-test")) {
+      if (++i == argc) goto missing;
+      int offset = 0;
+      bool negative = false;
+      if (argv[i][0] == '-') {
+	negative = true;
+	offset = 1;
+      }
+      testpat.push_back(make_pair(negative, argv[i] + offset));
+    } else if (!strcmp(argv[i],"-log")) {
+      log = true;
+      if (i+1 != argc) {
+	if(argv[i+1][0] == 't') {
+	  display = true; ++i;
+	} else if (argv[i+1][0] == 'c') {
+	  display = false; ++i;
+	}
+      }
+    } else if (!strcmp(argv[i],"-stop")) {
+      if (++i == argc) goto missing;
+      if(argv[i][0] == 't') {
+	stop_on_error = true;
+      } else if (argv[i][0] == 'f') {
+	stop_on_error = false;
+      }
+    } else {
+      i++;
+      goto error;
+    }
+    i++;
+  }
+  return;
+ missing:
+  e = "missing parameter";
+ error:
+  std::cerr << "Erroneous argument (" << argv[i-1] << ")" << std::endl
+       << e << std::endl;
+  exit(EXIT_FAILURE);
+}
+
+// STATISTICS: test-core

data/ext/gecode-1.3.1/test/test.hh

@@ -0,0 +1,107 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Contributing authors:
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2005
+ *     Mikael Lagerkvist, 2005
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:07:12 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3518 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+#ifndef __GECODE_TEST_TEST_HH__
+#define __GECODE_TEST_TEST_HH__
+
+#include "gecode/kernel.hh"
+#include "gecode/search.hh"
+
+#include "gecode/support/random.hh"
+
+using namespace Gecode;
+
+class Options {
+public:
+  static const int defiter = 5,
+    deffixprob = 10,
+    defflushprob = 10;
+
+  int   seed;
+  int   iter;
+  int   fixprob;
+  int   flushprob;
+  bool  log, display;
+  bool  stop_on_error;
+  Options(void)
+    : seed(0), iter(defiter), fixprob(deffixprob), flushprob(defflushprob),
+      log(false), display(true), stop_on_error(true)
+  {}
+
+  void parse(int argc, char **argv);
+};
+
+class Test {
+private:
+  const char* m;
+  const char* t;
+  Test* n;
+  static Test* all;
+public:
+  /// Return number between 0..m-1
+  static Support::RandomGenerator randgen;
+
+  Test(const char* module, const char* test)
+    : m(module), t(test) {
+    if (all == NULL) {
+      all = this; n = NULL;
+    } else {
+      // Search alphabetically
+      Test* p = NULL;
+      Test* c = all;
+      while ((c != NULL) &&
+	     ((strcmp(m,c->m)>0)
+	      || ((strcmp(m,c->m)==0) && (strcmp(t,c->t)>0)))) {
+	p = c; c = c->n;
+      }
+      if (c == NULL) {
+	p->n = this; n = NULL;
+      } else if (c == all) {
+	n = all; all = this;
+      } else {
+	p->n = this; n = c;
+      }
+    }
+  }
+  static Test* tests(void) {
+    return all;
+  }
+  Test* next(void) const {
+    return n;
+  }
+  const char* module(void) const {
+    return m;
+  }
+  const char* test(void) const {
+    return t;
+  }
+  virtual bool run(const Options& opt) = 0;
+  virtual ~Test(void) {}
+};
+
+#endif
+
+
+// STATISTICS: test-core

data/ext/missing.cpp

@@ -0,0 +1,328 @@
+/**
+ * Gecode/R, a Ruby interface to Gecode.
+ * Copyright (C) 2007 The Gecode/R development team.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+**/
+
+#include "missing.h"
+#include "gecode.hh"
+
+#include <iostream>
+#include <map>
+
+namespace Gecode {
+
+struct MBranchingDesc::Private
+{
+	const Gecode::BranchingDesc *ptr;
+};
+
+MBranchingDesc::MBranchingDesc() : d(new Private)
+{
+
+}
+
+MBranchingDesc::~MBranchingDesc()
+{
+	delete d;
+}
+
+void MBranchingDesc::setPtr(const Gecode::BranchingDesc *desc)
+{
+	d->ptr = desc;
+}
+
+const Gecode::BranchingDesc *MBranchingDesc::ptr() const
+{
+	return d->ptr;
+}
+
+int MBranchingDesc::alternatives() const
+{
+	if(d->ptr) return d->ptr->alternatives();
+	
+	return -1;
+}
+
+int MBranchingDesc::size() const
+{
+	if(d->ptr) return d->ptr->size();
+	
+	return -1;
+}
+
+
+///////////////////////////////////// 
+
+struct ltstr
+{
+	bool operator()(const char* s1, const char* s2) const
+	{
+		return strcmp(s1, s2) < 0;
+	}
+};
+
+typedef std::map<const char *, MIntVarArray *, ltstr> IntVarArrays;
+typedef std::map<const char *, MBoolVarArray *, ltstr> BoolVarArrays;
+typedef std::map<const char *, MSetVarArray *, ltstr> SetVarArrays;
+
+struct MSpace::Private
+{
+	Private()
+	{
+		description = new MBranchingDesc;;
+	}
+	
+	~Private()
+	{
+// 		{
+// 			IntVarArrays::iterator it, eend = intArrays.end();
+// 			
+// 			for(it = intArrays.begin(); it != eend; it++)
+// 			{
+// 				delete (*it).second;
+// 			}
+// 		}
+// 		{
+// 			SetVarArrays::iterator it, eend = setArrays.end();
+// 			
+// 			for(it = setArrays.begin(); it != eend; it++)
+// 			{
+// 				delete (*it).second;
+// 			}
+// 		}
+// 		
+// 		{
+// 			BoolVarArrays::iterator it, eend = boolArrays.end();
+// 			
+// 			for(it = boolArrays.begin(); it != eend; it++)
+// 			{
+// 				delete (*it).second;
+// 			}
+// 		}
+		
+		delete description;
+	}
+	
+	IntVarArrays intArrays;
+	BoolVarArrays boolArrays;
+	SetVarArrays setArrays;
+	
+	MBranchingDesc *description;
+};
+
+MSpace::MSpace() : d(new Private())
+{
+}
+
+MSpace::MSpace(MSpace& s, bool share) : Gecode::Space(share, s), d(new Private)
+{
+	{
+		IntVarArrays::iterator it, eend = s.d->intArrays.end();
+		
+		for(it = s.d->intArrays.begin(); it != eend; it++)
+		{
+			Gecode::MIntVarArray *iva = new Gecode::MIntVarArray(this, (*it).second->ptr()->size());
+			
+			iva->ptr()->update(this, share, *(*it).second->ptr() );
+			
+			own(iva, (*it).first);
+		}
+	}
+	{
+		BoolVarArrays::iterator it, eend = s.d->boolArrays.end();
+		
+		for(it = s.d->boolArrays.begin(); it != eend; it++)
+		{
+			Gecode::MBoolVarArray *bva = new Gecode::MBoolVarArray(this, (*it).second->ptr()->size());
+			
+			bva->ptr()->update(this, share, *(*it).second->ptr() );
+			
+			own(bva, (*it).first);
+		}
+	}
+	{
+		SetVarArrays::iterator it, eend = s.d->setArrays.end();
+		
+		for(it = s.d->setArrays.begin(); it != eend; it++)
+		{
+			Gecode::MSetVarArray *sva = new Gecode::MSetVarArray(this, (*it).second->ptr()->size());
+			sva->ptr()->update(this, share, *(*it).second->ptr() );
+			
+			own(sva, (*it).first);
+		}
+	}
+}
+
+
+
+MSpace::~MSpace()
+{
+	delete d;
+}
+
+Gecode::Space *MSpace::copy(bool share)
+{
+	return new MSpace(*this,share);
+}
+
+void MSpace::own(Gecode::MIntVarArray *iva, const char *name)
+{
+	d->intArrays[name] = iva;
+}
+
+void MSpace::own(Gecode::MBoolVarArray *bva, const char *name)
+{
+	d->boolArrays[name] = bva;
+}
+
+void MSpace::own(Gecode::MSetVarArray *sva, const char *name)
+{
+	d->setArrays[name] = sva;
+}
+
+void MSpace::gc_mark()
+{
+  {
+		IntVarArrays::iterator it, eend = d->intArrays.end();
+		for(it = d->intArrays.begin(); it != eend; it++)
+		{
+			rb_gc_mark(Rust_gecode::cxx2ruby((*it).second));
+		}
+	}
+	{
+		BoolVarArrays::iterator it, eend = d->boolArrays.end();
+		for(it = d->boolArrays.begin(); it != eend; it++)
+		{
+			rb_gc_mark(Rust_gecode::cxx2ruby((*it).second));
+		}
+	}
+	{
+		SetVarArrays::iterator it, eend = d->setArrays.end();
+		for(it = d->setArrays.begin(); it != eend; it++)
+		{
+			rb_gc_mark(Rust_gecode::cxx2ruby((*it).second));
+		}
+	}
+}
+
+// For BAB.
+void MSpace::constrain(MSpace* s)
+{
+  // Call Ruby's constrain.
+  rb_funcall(Rust_gecode::cxx2ruby(this), rb_intern("constrain"), 1,
+    Rust_gecode::cxx2ruby(s, false)); 
+}
+
+Gecode::MIntVarArray *MSpace::intVarArray(const char *name) const
+{
+	if ( d->intArrays.find(name) == d->intArrays.end() ) return 0;
+	return d->intArrays[name];
+}
+
+Gecode::MBoolVarArray *MSpace::boolVarArray(const char *name ) const
+{
+	if ( d->boolArrays.find(name) == d->boolArrays.end() ) return 0;
+	return d->boolArrays[name];
+}
+
+Gecode::MSetVarArray *MSpace::setVarArray(const char *name ) const
+{
+	if ( d->setArrays.find(name) == d->setArrays.end() ) return 0;
+	return d->setArrays[name];
+}
+
+Gecode::MBranchingDesc *MSpace::mdescription()
+{
+	if(!this->failed() || !d->description->ptr() )
+	{
+		d->description->setPtr(this->description());
+	}
+	return d->description;
+}
+
+void MSpace::debug()
+{
+	std::cout << "DEBUG: "<< d->intArrays["default"]->ptr()->size() << std::endl;
+}
+
+
+// DFS
+MDFS::MDFS(MSpace *space, unsigned int c_d, unsigned int a_d, Search::Stop* st) : Gecode::Search::DFS(space, c_d, a_d, st, sizeof(space))
+{
+}
+
+MDFS::~MDFS()
+{
+}
+
+
+// BAB
+MBAB::MBAB(MSpace *space, unsigned int c_d, unsigned int a_d, Search::Stop* st) : Gecode::BAB<MSpace>(space, c_d, a_d, st)
+{
+}
+
+MBAB::~MBAB()
+{
+}
+
+namespace Search {
+
+// Stop
+
+struct MStop::Private
+{
+	Gecode::Search::TimeStop *ts;
+    Gecode::Search::FailStop *fs;
+};
+
+MStop::MStop() : d(new Private)
+{
+	d->ts = 0;
+	d->fs = 0;
+}
+
+MStop::MStop(int fails, int time) : d(new Private)
+{
+	d->ts = new Search::TimeStop(time);
+	d->fs = new Search::FailStop(fails);
+}
+
+MStop::~MStop()
+{
+}
+
+bool MStop::stop(const Gecode::Search::Statistics &s)
+{
+	if (!d->fs || d->ts)
+		return false;
+	return d->fs->stop(s) || d->ts->stop(s);
+}
+
+Gecode::Search::Stop* MStop::create(int fails, int time)
+{
+	if (fails < 0 && time < 0) return 0;
+	if (fails < 0) return new Search::TimeStop( time );
+	
+	if (time  < 0) return new Search::FailStop(fails);
+	
+	return new MStop(fails, time);
+}
+
+
+}
+
+}