dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/contribs/qecode/README

@@ -0,0 +1,6 @@
+QeCode is a quantified constraint satisfaction problems (QCSP) solver based on Gecode. 
+It can also solve QCSP+, an extension of QCSP where quantifiers can be restricted and QCOP+, a quantified optimizaion problem formalism which scopes multi-level programming problems. 
+
+QeCode have been developped at Universite d'Orleans by Jeremie Vautard, Arnaud Lallouet and Marco Benedetti. More info is available on
+http://www.univ-orleans.fr/lifo/software/qecode/
+

data/ext/libgecode3/vendor/gecode-3.7.3/contribs/qecode/Strategy.cc

@@ -0,0 +1,253 @@
+/****   , [ bobocheTree.cc ], 
+ Copyright (c) 2008 Universite d'Orleans - Jeremie Vautard 
+ 
+ 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 "Strategy.hh"
+
+StrategyImp::StrategyImp() {
+	cout<<"Default constructor of StrategyImp should not be called !"<<endl;
+	pointers=1;
+	zetag=StrategyNode::Dummy();
+	todos=0;
+	father=NULL;
+}	
+	
+void StrategyImp::todosUpdate(int i) {
+	todos += i;
+	if (father != NULL) father->todosUpdate(i);
+}
+
+StrategyImp::StrategyImp(StrategyNode tag) {
+	//    cout<<"Strategy imp constructor"<<endl;
+	pointers=1;
+	zetag=tag;
+	todos=0;
+	father=NULL;
+	//    cout<<"strategyimp constructor fini"<<endl;
+}
+
+
+StrategyImp::~StrategyImp() {
+	for (vector<Strategy>::iterator i = nodes.begin();i != nodes.end();i++) {
+		if (((*i).imp->father) == this) {
+			(*i).imp->father = NULL;
+		}
+	}
+}
+
+
+Strategy::Strategy() {
+	//    cout<<"strategy default"<<endl;
+	StrategyNode tag = StrategyNode::Dummy();
+	imp = new StrategyImp(tag);
+}
+
+Strategy::Strategy(StrategyNode tag) {
+	//    cout<<"Strategy with tag"<<endl;
+	imp = new StrategyImp(tag);
+	//cout<<"passed imp creation. End of strategy creator"<<endl;
+}
+
+Strategy::Strategy(StrategyImp* imp) {
+	this->imp = imp;
+	this->imp->pointers++;
+}
+
+Strategy::Strategy(bool qt,int VMin, int VMax, int scope, vector<int> values) {
+	//    cout<<"strategy with values"<<endl;
+	StrategyNode tag(2,qt,VMin,VMax,scope);
+	tag.valeurs=values;
+	imp = new StrategyImp(tag);
+	
+}
+
+
+Strategy::Strategy(const Strategy& tree) {
+	//    cout<<"Strategy copy"<<endl;
+	imp = tree.imp;
+	(imp->pointers)++;
+}
+
+
+Strategy& Strategy::operator = (const Strategy& rvalue) {
+	//    cout<<"Strategy = "<<endl;
+	if (imp != NULL) {
+		(imp->pointers)--;
+		if ( (imp->pointers) == 0) {
+			//        cout<<"no more references for the imp. Delete"<<endl;
+			delete imp;
+		}
+	}
+	imp = rvalue.imp;
+	(imp->pointers)++;
+	return *this;
+}
+
+
+Strategy::~Strategy() {
+	//    cout<<"strategy destructor"<<endl;
+	(imp->pointers)--;
+	if ( (imp->pointers) == 0) {
+		//        cout<<"no more references for the imp. Delete"<<endl;
+		delete imp;
+	}
+}
+
+
+StrategyNode Strategy::getTag() {
+	return imp->zetag;
+}
+
+Strategy Strategy::getFather() {
+	if (hasFather()) return Strategy(imp->father);
+	return Dummy();
+}
+
+bool Strategy::hasFather() {
+	if (imp->father != NULL) {
+		for (int i=0;i< imp->father->nodes.size();i++) {
+			if ((imp->father->nodes[i].imp)  == imp)
+				return true;
+		}
+	}
+	return false;
+}
+
+Strategy Strategy::getChild(int i) {
+	if (i<0 || i>=degree() ) {cout<<"Child "<<i<<" does not exist"<<endl;abort();}
+	return imp->nodes[i];
+}
+
+Strategy Strategy::getSubStrategy(vector<int> position) {
+	if (position.empty()) return *this;
+	int deg = degree();
+	if (deg == 0) {
+		cout<<"Did not find substrategy"<<endl;
+		return Strategy::Dummy();
+	}
+	for (int i=0;i<deg;i++) {
+		Strategy child=getChild(i);
+		bool ok=true;
+		if (child.values().size() == 0) {
+			ok = false;
+		}
+		for (int j=0;(j<child.values().size()) && ok;j++) {
+			if (child.value(j) != position[j]) ok=false;
+		}
+		if (ok) {
+			position.erase(position.begin(),position.begin() + (child.values().size()));
+			return child.getSubStrategy(position);
+		}
+	}
+	cout<<"Did not find substrategy"<<endl;
+	return Strategy::Dummy();
+}
+
+void Strategy::attach(Strategy child) {
+	if (child.isDummy()) {
+		int todosToAdd = 0;
+
+		for (int i=0;i<child.degree();i++) {
+			this->attach(child.getChild(i));
+		}
+	}
+	else {
+		imp->nodes.push_back(child);
+		todosUpdate(child.imp->todos);
+		(child.imp)->father = this->imp;
+	}
+}
+
+void Strategy::detach(Strategy son) {
+	
+	vector<Strategy>::iterator it = imp->nodes.begin();
+	while (it != (imp->nodes.end()) && ( (*it).id() != son.id())) {
+	it++;}
+	if ( it != imp->nodes.end()) {
+		todosUpdate(0-((*it).imp->todos));
+		(*it).imp->father=NULL;
+		imp->nodes.erase(it);
+	}
+}
+
+
+void Strategy::detach(unsigned int i) {
+	if (imp->nodes.size() < i) return;
+	
+	vector<Strategy>::iterator it = imp->nodes.begin()+i;
+	todosUpdate(0-((*it).imp->todos));
+	(*it).imp->father=NULL;
+	imp->nodes.erase(it);
+}
+
+Strategy Strategy::STrue() {
+	Strategy ret(StrategyNode::STrue());
+	return ret; 
+}
+
+Strategy Strategy::SFalse() {
+	Strategy ret(StrategyNode::SFalse());
+	return ret;
+}
+
+Strategy Strategy::Dummy() {
+	Strategy ret(StrategyNode::Dummy());
+	return ret;
+}
+
+Strategy Strategy::Stodo() {
+	Strategy ret(StrategyNode::Todo());
+	ret.imp->todos=1;
+	return ret;
+}
+
+vector<int> Strategy::getPosition() {
+	vector<int> ret;
+	Strategy asc = *this;
+	while (!asc.isDummy()) {
+//		cout<<"GetPosition adding "<<asc.values().size()<<" elements to a vector of size "<<ret.size()<<endl;
+		vector<int> ret2;
+		ret2.reserve(ret.size() + asc.values().size() +1);
+		for (int i=0;i<asc.values().size();i++) {
+			ret2.push_back(asc.values()[i]);
+		}
+		for (int i=0;i<ret.size();i++) {
+			ret2.push_back(ret[i]);
+		}
+		ret=ret2;
+		asc = asc.getFather();
+	}
+	return ret;
+}
+
+int Strategy::checkIntegrity() {
+	int ret=0;
+	for (unsigned int i=0;i < (this->degree());i++) {
+		if ( (((imp->nodes[i]).imp)->father) != imp) {
+			ret++;
+			cout<< (((imp->nodes[i]).imp)->father) << " should be " << imp <<endl;
+		}
+		ret += (getChild(i).checkIntegrity());
+	}
+	return ret;
+}
+		
+

data/ext/libgecode3/vendor/gecode-3.7.3/contribs/qecode/Strategy.hh

@@ -0,0 +1,112 @@
+/****   , [ bobocheTree.hh ], 
+ Copyright (c) 2008 Universite d'Orleans - Jeremie Vautard 
+ 
+ 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 __BOBOCHE_TREE__
+#define __BOBOCHE_TREE__
+#include <vector>
+#include <iostream>
+#include <string>
+#include "StrategyNode.hh"
+#include "qecode.hh"
+
+using namespace std;
+class Strategy;
+
+class StrategyImp {
+	friend class Strategy;
+private:
+	unsigned int pointers; // number of Strategy objects pointing to this
+	StrategyNode zetag; // Node information
+	vector<Strategy> nodes; // children of this node
+	unsigned int todos; // number of todo nodes recursively present in the children
+	StrategyImp* father;
+	void todosUpdate(int i);
+	StrategyImp();
+	
+public:
+	StrategyImp(StrategyNode tag);
+	~StrategyImp();    
+};
+
+/** \brief Strategy of a QCSP+ problem
+ *
+ * This class represents a solution of a QCSP+. Basically it consists in the tree-representation of the winning strategy.
+ * 3 spacial cases exists : the trivially true strategy, the trivially false strategy (used for the UNSAT answer), 
+ * and the "Dummy" node, used to link together each tree of a strategy which first player is universal (such a strategy is not a tree but a forest) 
+ */
+class QECODE_VTABLE_EXPORT Strategy {
+	friend class StrategyImp;
+private:
+	StrategyImp* imp;
+	void todosUpdate(int i) {imp->todosUpdate(i);}
+	Strategy(StrategyImp* imp);
+public:
+	QECODE_EXPORT Strategy(); ///< default constructor
+	QECODE_EXPORT Strategy(StrategyNode tag); ///< builds a strategy on a given strategy node (deprecated)
+	
+	/* \brief builds a one node (sub)strategy
+	 *
+	 * this method builds a one-node strategy that will typically be attached as child of another strategy. A strategy node embeds informations about quantification, 
+	 * scope and values of variables that must be provided
+	 * @param qt quantifier of the scope this node represents
+	 * @param VMin index of the first variable of the scope this node represents
+	 * @param VMax index of the last variable of the scope this node represents
+	 * @param values values taken by the variables between VMin and VMax in this part of the strategy
+	 */
+	QECODE_EXPORT Strategy(bool qt,int VMin, int VMax, int scope,vector<int> values); 
+	QECODE_EXPORT Strategy(const Strategy& tree); ///< copy constructor
+	QECODE_EXPORT Strategy& operator = (const Strategy& rvalue); 
+	QECODE_EXPORT ~Strategy();
+	QECODE_EXPORT StrategyNode getTag();///< DEPRECATED returns the StrategyNode object corresponding to the root of this strategy
+	QECODE_EXPORT forceinline unsigned int degree() {return imp->nodes.size();}///< returns this strategy's number of children
+	QECODE_EXPORT Strategy getChild(int i); ///< returns the i-th child of this strategy
+	QECODE_EXPORT Strategy getFather();
+	QECODE_EXPORT bool hasFather();
+	QECODE_EXPORT Strategy getSubStrategy(vector<int> position); ///< returns the substrategy at given position, dummy if does not exists
+	QECODE_EXPORT void attach(Strategy child);///< attach the strategy given in parameter as a child of the current strategy
+	QECODE_EXPORT void detach(unsigned int i); ///< detach the i-th child of this strategy (provided it exists)
+	QECODE_EXPORT void detach(Strategy son);
+	QECODE_EXPORT forceinline bool isFalse() {return imp->zetag.isFalse();} ///< returns wether this strategy represents the UNSAT answer
+	QECODE_EXPORT forceinline bool isTrue() {return imp->zetag.isTrue();} ///< returns wether this strategy is trivially true
+	QECODE_EXPORT forceinline bool isComplete() {return ((imp->todos) == 0);} ///< returns wether this is a complete sub-strategy (without todo nodes)
+	QECODE_EXPORT forceinline bool isDummy() {return imp->zetag.isDummy();} ///< returns wether this strategy is a set of 
+	QECODE_EXPORT forceinline bool isTodo() {return imp->zetag.isTodo();} ///< return wether this strategy is a "ToDo" marker or not
+	
+	QECODE_EXPORT static Strategy STrue(); ///< returns the trivially true strategy
+	QECODE_EXPORT static Strategy SFalse(); ///< returns the trivially false strategy
+	QECODE_EXPORT static Strategy Dummy(); ///< returns a "dummy" node
+	QECODE_EXPORT static Strategy Stodo(); ///< returns a "todo" node
+	QECODE_EXPORT forceinline bool quantifier() {return imp->zetag.quantifier;} ///< returns the quantifier of the root (true for universal, false for existential)
+	QECODE_EXPORT forceinline int VMin() {return imp->zetag.Vmin;} ///< returns the index of the first variable of the scope of the root
+	QECODE_EXPORT forceinline int VMax() {return imp->zetag.Vmax;} ///< returns the index of the last variable of the scope of the root
+	QECODE_EXPORT forceinline int scope() {return imp->zetag.scope;} ///< returns the scope of the root
+	QECODE_EXPORT forceinline vector<int> values() {return imp->zetag.valeurs;} ///< returns the values taken by the variables of the scope of the root in this (sub)strategy
+	QECODE_EXPORT forceinline int value(int var) {return imp->zetag.valeurs[var];}
+	QECODE_EXPORT forceinline void* id() {return imp;} ///< Return an identifier for this strategy (this identifier is shared among multiples instances of this strategy)
+	QECODE_EXPORT vector<int> getPosition();
+	QECODE_EXPORT forceinline int nbTodos() {return imp->todos;}
+	
+	QECODE_EXPORT int checkIntegrity();
+};
+
+
+#endif

data/ext/libgecode3/vendor/gecode-3.7.3/contribs/qecode/StrategyNode.cc

@@ -0,0 +1,59 @@
+/****   , [ StrategyNode.cc ], 
+Copyright (c) 2008 Universite d'Orleans - Jeremie Vautard 
+
+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 "StrategyNode.hh"
+
+StrategyNode::StrategyNode() {
+    type=0;
+    quantifier=true;
+    Vmin=-1;
+    Vmax=-1;
+    scope=-1;
+}
+
+StrategyNode::StrategyNode(int typ,bool qt,int min, int max, int sco) {
+    type=typ;
+    quantifier=qt;
+    Vmin=min;
+    Vmax=max;
+    scope=sco;
+}
+
+/*
+StrategyNode::StrategyNode(const StrategyNode& st) {
+    cout<<"Strategynode copy constructor"<<endl;
+    type=st.type;
+    quantifier=st.quantifier;
+    Vmin=st.Vmin;
+    Vmax=st.Vmax;
+    if (type == 2) {
+        valeurs=new int[Vmax-Vmin];
+        for (int i=0;i<Vmax-Vmin;i++)
+            valeurs[i]=st.valeurs[i];
+    }
+}
+*/
+
+StrategyNode::~StrategyNode() {
+
+}
+

data/ext/libgecode3/vendor/gecode-3.7.3/contribs/qecode/StrategyNode.hh

@@ -0,0 +1,49 @@
+/****   , [ StrategyNode.hh ], 
+Copyright (c) 2008 Universite d'Orleans - Jeremie Vautard 
+
+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 __QECODE_STRATEGY_NODE__
+#define __QECODE_STRATEGY_NODE__
+ #include "qecode.hh"
+#include <vector>
+using namespace std;
+class QECODE_VTABLE_EXPORT StrategyNode {
+public:
+    int type; // 0 = dummy, 1 = empty, 2 = normal, 3 = Todo.
+    bool quantifier;
+    int Vmin;
+    int Vmax;
+    int scope;
+    vector<int> valeurs;
+    
+    QECODE_EXPORT StrategyNode();
+    QECODE_EXPORT StrategyNode(int type,bool qt,int Vmin, int Vmax, int scope);
+    QECODE_EXPORT ~StrategyNode();
+    QECODE_EXPORT static StrategyNode STrue() { return StrategyNode(1,true,-1,-1,-1);}
+    QECODE_EXPORT static StrategyNode SFalse() { return StrategyNode(1,false,-1,-1,-1);}
+    QECODE_EXPORT static StrategyNode Dummy() { return StrategyNode(0,true,-1,-1,-1);}
+  	QECODE_EXPORT static StrategyNode Todo() { return StrategyNode(3,false,-1,-1,-1);}
+    QECODE_EXPORT forceinline bool isFalse() { return ( (type==1) && (quantifier == false) );}
+    QECODE_EXPORT forceinline bool isTrue() { return ( (type==1) && (quantifier == true) );}
+    QECODE_EXPORT forceinline bool isDummy() { return (type==0);}
+	QECODE_EXPORT forceinline bool isTodo() { return (type==3);}
+};
+#endif
+