gecoder-with-gecode 0.7.1

data/ext/missing.h

@@ -0,0 +1,120 @@
+/**
+ * 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
+**/
+
+#ifndef __MISSING_CLASSES_H
+#define __MISSING_CLASSES_H
+
+#include <ruby.h>
+
+#include <gecode/kernel.hh>
+#include <gecode/int.hh>
+#include <gecode/search.hh>
+#include <gecode/minimodel.hh>
+#include <gecode/set.hh>
+
+#include "vararray.h"
+
+namespace Gecode {
+
+class MBranchingDesc
+{
+	public:
+		MBranchingDesc();
+		~MBranchingDesc();
+		
+		void setPtr(const Gecode::BranchingDesc *);
+		const Gecode::BranchingDesc *ptr() const;
+		
+		int alternatives() const;
+		int size() const;
+		
+	private:
+		struct Private;
+		Private *const d;
+};
+
+class MSpace : public Space
+{
+	public:
+		MSpace();
+		explicit MSpace(MSpace& s, bool share=true);
+		~MSpace();
+		Gecode::Space *copy(bool share);
+		
+		void own(Gecode::MIntVarArray *iva, const char *name);
+		void own(Gecode::MBoolVarArray *bva, const char *name);
+		void own(Gecode::MSetVarArray *sva, const char *name);
+		
+		void gc_mark();
+		
+		void constrain(MSpace* s);
+		
+		Gecode::MIntVarArray *intVarArray(const char *name ) const;
+		Gecode::MBoolVarArray *boolVarArray(const char *name ) const;
+		Gecode::MSetVarArray *setVarArray(const char *name) const;
+		
+		Gecode::MBranchingDesc *mdescription();
+		
+		void debug();
+		
+	private:
+		struct Private;
+		Private *const d;
+};
+
+class MDFS : public Gecode::Search::DFS
+{
+	public:
+		MDFS(MSpace *space, unsigned int c_d, unsigned int a_d, Search::Stop* st = 0);
+		~MDFS();
+};
+class MBAB : public Gecode::BAB<MSpace>
+{
+	public:
+		MBAB(MSpace* space, unsigned int c_d, unsigned int a_d, Search::Stop* st = 0);
+		~MBAB();
+};
+
+namespace Search {
+class MStop : public Gecode::Search::Stop
+{
+	private:
+		MStop(int fails, int time);
+		
+	public:
+		MStop();
+		~MStop();
+		
+		bool stop (const Gecode::Search::Statistics &s);
+		static Gecode::Search::Stop* create(int fails, int time);
+		
+		
+	private:
+		struct Private;
+		Private *const d;
+};
+
+}
+
+
+}
+
+#endif
+
+

data/ext/vararray.cpp

@@ -0,0 +1,330 @@
+/**
+ * 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 "vararray.h"
+#include "gecode.hh"
+
+namespace Gecode {
+
+
+struct MVarArray::Private
+{
+	int count;
+	int size;
+};
+
+MVarArray::MVarArray() : d(new Private)
+{
+}
+
+MVarArray::~MVarArray()
+{
+	delete d;
+}
+
+int MVarArray::count() const
+{
+	return d->count;
+}
+
+int MVarArray::size() const
+{
+	return d->size;
+}
+
+void MVarArray::setCount(int c)
+{
+	d->count = c;
+}
+
+void MVarArray::setSize(int n)
+{
+	d->size = n;
+}
+
+
+// MINTVARARRAY
+
+struct MIntVarArray::Private
+{
+	Gecode::IntVarArray array;
+};
+
+
+MIntVarArray::MIntVarArray() : d(new Private)
+{
+	setArray(Gecode::IntVarArray());
+}
+
+MIntVarArray::MIntVarArray(const Gecode::IntVarArray &arr) : d(new Private)
+{
+	setArray(arr);
+}
+
+MIntVarArray::MIntVarArray (Space *home, int n) : d(new Private)
+{
+	setArray(Gecode::IntVarArray(home, n));
+}
+
+MIntVarArray::MIntVarArray (Space *home, int n, int min, int max) : d(new Private)
+{
+	setArray(Gecode::IntVarArray(home, n, min, max));
+}
+
+MIntVarArray::MIntVarArray (Space *home, int n, const IntSet &s) : d(new Private)
+{
+	setArray(Gecode::IntVarArray(home, n, s));
+}
+
+
+MIntVarArray::~MIntVarArray()
+{
+	delete d;
+}
+
+void MIntVarArray::setArray(const Gecode::IntVarArray &arr)
+{
+	d->array = arr;
+	setSize(arr.size());
+}
+
+void MIntVarArray::enlargeArray(Gecode::Space *parent, int n)
+{
+	Gecode::IntVarArray na(parent, size()+n, 0, 0);
+	for(int i = size(); i--; )
+		na[i] = d->array[i];
+	
+	d->array = na;
+	
+	setSize(size() + n);
+}
+
+Gecode::IntVarArray *MIntVarArray::ptr() const
+{
+	return &d->array;
+}
+
+Gecode::IntVar &MIntVarArray::at(int index)
+{
+	return d->array[index];
+}
+
+IntVar &MIntVarArray::operator [](int index)
+{
+	return d->array[index];
+}
+
+void MIntVarArray::gc_mark()
+{
+  for(int i = size(); i--; ) {
+		rb_gc_mark(Rust_gecode::cxx2ruby(&(d->array[i])));
+	}
+}
+
+void MIntVarArray::debug() const
+{
+	for(int i = 0; i < d->array.size(); i++)
+	{
+		std::cout << d->array[i] << " ";
+	}
+	std::cout << std::endl;
+}
+
+
+// MBOOLVARARRAY
+
+struct MBoolVarArray::Private
+{
+	Gecode::BoolVarArray array;
+};
+
+
+MBoolVarArray::MBoolVarArray() : d(new Private)
+{
+	setArray(Gecode::BoolVarArray());
+}
+
+MBoolVarArray::MBoolVarArray(const Gecode::BoolVarArray &arr) : d(new Private)
+{
+	setArray(arr);
+}
+
+MBoolVarArray::MBoolVarArray (Space *home, int n) : d(new Private)
+{
+	setArray(Gecode::BoolVarArray(home, n));
+}
+
+MBoolVarArray::~MBoolVarArray()
+{
+	delete d;
+}
+
+void MBoolVarArray::setArray(const Gecode::BoolVarArray &arr)
+{
+	d->array = arr;
+	setSize(arr.size());
+}
+
+void MBoolVarArray::enlargeArray(Gecode::Space *parent, int n)
+{
+	Gecode::BoolVarArray na(parent, size()+n, 0, 0);
+	for(int i = size(); i--; )
+		na[i] = d->array[i];
+	
+	d->array = na;
+	
+	setSize(size() + n);
+}
+
+Gecode::BoolVarArray *MBoolVarArray::ptr() const
+{
+	return &d->array;
+}
+
+Gecode::BoolVar &MBoolVarArray::at(int index)
+{
+	return d->array[index];
+}
+
+Gecode::BoolVar &MBoolVarArray::operator[](int index)
+{
+	return d->array[index];
+}
+
+void MBoolVarArray::gc_mark()
+{
+  for(int i = size(); i--; ) {
+		rb_gc_mark(Rust_gecode::cxx2ruby(&(d->array[i])));
+	}
+}
+
+void MBoolVarArray::debug() const
+{
+	for(int i = 0; i < d->array.size(); i++)
+	{
+		std::cout << d->array[i] << " ";
+	}
+	std::cout << std::endl;
+}
+
+
+// SETVARARRAY
+
+struct MSetVarArray::Private
+{
+	Gecode::SetVarArray array;
+};
+
+MSetVarArray::MSetVarArray() : d(new Private)
+{
+	setArray(Gecode::SetVarArray());
+}
+
+MSetVarArray::MSetVarArray(const Gecode::SetVarArray &arr) : d(new Private)
+{
+	setArray(arr);
+}
+
+MSetVarArray::MSetVarArray(Space *home, int n) : d(new Private)
+{
+	setArray(Gecode::SetVarArray(home, n));
+}
+
+MSetVarArray::MSetVarArray(Gecode::Space *home, int n, int glbMin, int glbMax, int lubMin, int lubMax, unsigned int minCard, unsigned int maxCard) : d(new Private)
+{
+	setArray(Gecode::SetVarArray(home, n, glbMin, glbMax, lubMin, lubMax, minCard, maxCard));
+}
+		
+MSetVarArray::MSetVarArray(Gecode::Space *home, int n, const Gecode::IntSet &glb, int lubMin, int lubMax, unsigned int minCard, unsigned int maxCard) : d(new Private)
+{
+	setArray(Gecode::SetVarArray(home, n, glb, lubMin, lubMax, minCard, maxCard));
+}
+
+MSetVarArray::MSetVarArray(Gecode::Space *home, int n, int glbMin, int glbMax, const Gecode::IntSet &lub, unsigned int minCard, unsigned int maxCard) : d(new Private)
+{
+	setArray(Gecode::SetVarArray(home, n, glbMin, glbMax, lub, minCard, maxCard));
+}
+
+MSetVarArray::MSetVarArray(Gecode::Space *home, int n, const Gecode::IntSet &glb, const Gecode::IntSet &lub, unsigned int minCard, unsigned int maxCard) : d(new Private)
+{
+	setArray(Gecode::SetVarArray(home, n, glb, lub, minCard, maxCard));
+}
+
+MSetVarArray::~MSetVarArray()
+{
+	delete d;
+}
+
+void MSetVarArray::setArray(const Gecode::SetVarArray &arr)
+{
+	d->array = arr;
+	setSize(arr.size());
+}
+
+void MSetVarArray::enlargeArray(Gecode::Space *parent, int n)
+{
+	Gecode::SetVarArray na(parent, size()+n);
+	for (int i = size(); i--; )
+		na[i] = d->array[i];
+	
+	d->array = na;
+	
+	setSize(size() + n);
+}
+
+Gecode::SetVarArray *MSetVarArray::ptr() const
+{
+	return &d->array;
+}
+
+Gecode::SetVar &MSetVarArray::at(int index)
+{
+	return d->array[index];
+}
+
+Gecode::SetVar &MSetVarArray::operator[](int index)
+{
+	return d->array[index];
+}
+
+void MSetVarArray::gc_mark()
+{
+  for(int i = size(); i--; ) {
+		rb_gc_mark(Rust_gecode::cxx2ruby(&(d->array[i])));
+	}
+}
+
+void MSetVarArray::debug() const
+{
+	for(int i = 0; i < d->array.size(); i++)
+	{
+		std::cout << d->array[i] << " ";
+	}
+	std::cout << std::endl;
+}
+
+
+}
+
+
+
+
+
+
+