gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.2.0/contribs/qecode/Implicative.hh

@@ -0,0 +1,164 @@
+/****   , [ Implicative.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_IMPLICATIVEOPT__
+#define __QECODE_IMPLICATIVEOPT__
+
+#include "myspace.hh"
+#include "vartype.hh"
+#include "OptVar.hh"
+#include <vector>
+
+
+using namespace std;
+class QECODE_VTABLE_EXPORT Implicative {
+    friend class valueHeuristic;
+    friend class QSolverOpt;
+private:
+    struct Opts {
+        vector<OptVar*> vars; // Several Optvars in universal scopes, one in existential ones
+        int opt_type;        // Used in existential scopes : 0 for ANY, 1 for MIN, 2 for MAX.
+    };
+    
+    int n;
+    int nbSpaces;
+    void** v;
+    VarType* type_of_v;
+    
+    bool* Quantifiers;
+    MySpace** rules;
+    MySpace* goal;
+    Opts* optim;
+    int* nbVarBySpace;
+    int* whichSpaceOwns;
+    bool* varInitialised;
+    
+    int currentDeclareSpace;
+    
+public:
+    QECODE_EXPORT int nv() {return n;}
+    
+    /** \brief  Default constructor for a restricted-quantified space
+        *
+        *  This is the first step for building a QCSP+/QCOP+ problem. The prefix is defined here.
+        *  @param ns The number of scopes in the prefix.
+        *  @param quant Array of booleans which contains the quantifier of every scope (true for universal, false for existential).
+        *  @param nv Array of integer which contains the number of variables by scope.
+        */    
+    QECODE_EXPORT Implicative(int ns, bool* quant,int* nv);
+    QECODE_EXPORT ~Implicative();
+    
+    /** \brief Defines an integer variable in the quantified space
+        *
+        *  Defines an integer variable in the quantifies space using a fully declared domain.
+        *  @param var Number of the variable to be  defined.
+        *  @param dom The initial domain of the variable.
+        */    
+    QECODE_EXPORT void QIntVar(int var,int min,int max);
+    
+    /** \brief Defines an integer variable in the quantified space
+        *
+        *  Defines an integer variable in the quantifies space using a fully declared domain.
+        *  @param var Number of the variable to be  defined.
+        *  @param dom The initial domain of the variable.
+        */
+    QECODE_EXPORT void QIntVar(int var,IntSet dom);
+    
+    /** \brief Defines a boolean variable in the quantified space
+        *
+        *  Defines a boolean variable with a full initial domain in the quantified space.
+        *  @param var Number of the variable to be defined.
+        */
+    QECODE_EXPORT void QBoolVar(int var);
+    
+    /** \brief Returns the current declarating space
+        *
+        *  Return the space we are currently declarating constraints in. nextScope() is used to set the nextspace as the current one.
+        */    
+    QECODE_EXPORT MySpace* space();
+    
+    /** \brief Returns an integer variable from the space we are currently declaring
+        *
+        *  Returns an integer variable from the cpace we are currently declaring. Will abort if the variable is not integer.
+        *  @param n The number of the variable to return.
+        */
+    QECODE_EXPORT IntVar var(int n);
+
+    /** \brief Returns a boolean variable from the space we are currently declaring
+        *
+        * Returns a boolean variable from the space we are currently declaring. Will abort if the variable is not boolean.
+        *  @param n The number of the variable to return.
+        */
+    QECODE_EXPORT BoolVar bvar(int n);
+
+    /** \brief Switch to the next space for constraint declaration
+        *
+        *   Switches to the next space for constraint declaration. var, bvar and space methods will now refer to the next rule space (or to the goal space if the current space was the last rule one).
+        *  Returns the new space number, or -1 if it was called while there was no next space to declare constraints in.
+        */
+    QECODE_EXPORT int nextScope();
+
+    /** \brief Finalizes the object construction
+        *
+        * Finalizes the restricted-quantified space construction. Must be invoked once all the variable and all the constraints have been declared, and before the search is performed on this space.
+        * calling this method is not mandatory, although it is recommanded to besure that the problem have been well built.
+        * For the existential scopes on which an optimization condition have not been defined yet, this method will post a "Any" optimization condition (i.e. do not optimize).
+        */
+    QECODE_EXPORT void makeStructure();
+
+    /** \brief returns an aggregate of the problem
+        *
+        * Creates an aggregate at a given universal scope. This aggregate is an optimization variable that an existential scope can use for optimizing.
+        * @param scope the scope where this aggregate will be defined. Must be an unversal scope
+        * @param opt The optimization variable we want to aggregate. There must not be any universal scope between an agregate and thisoptimization variable.
+        * @param agg The aggregator function that will be used for this aggregate.
+        */
+    QECODE_EXPORT OptVar* getAggregate(int scope, OptVar* opt, Aggregator* agg);
+
+    /** returns an existential optimization variable
+        *
+        * Creates an optimization variable that will have the value of an existential variable defined in the problem. 
+        * @param var the number of the existential variable that must be considered
+        */
+    QECODE_EXPORT OptVar* getExistential(int var);
+    
+    /** set an optimization condition on an existential scope
+        *
+        * set an optimization condition on a given existential scope of the problem. An optimizaiton condition is composed of an optimization variable (aggregate or existential variable), and of an
+        * optimization type. 
+        * @param scope the scope on which the optimization condition is posted. Must be existential.
+        * @param optType the optimization type of the condision we post. 0 is for ANY, 1 is for MIN, 2 is for MAX.
+        * @param var the optimization variable to be minimized/maximized
+        */
+    QECODE_EXPORT void optimize(int scope, int optType, OptVar* var);
+//    QECODE_EXPORT void print();
+    
+    QECODE_EXPORT bool qt_of_var(int v); ///< returns uantifier of variable 'v'
+    QECODE_EXPORT bool quantification(int scope) {return Quantifiers[scope];} ///< returns quantifier of scope 'scope'
+    QECODE_EXPORT int spaces(); ///< returns the number of scopes of the problem
+    QECODE_EXPORT int nbVarInScope(int scope) {return nbVarBySpace[scope];}///< returns the number of variables present in scope 'scope'
+    QECODE_EXPORT MySpace* getSpace(int scope);///< returns a copy of the Gecode::Space corresponding to the 'scope'-th restricted quantifier of the problem
+    QECODE_EXPORT MySpace* getGoal();
+    QECODE_EXPORT int getOptType(int scope); ///< returns theoptimization type of the 'scope'-th scope of the problem
+    QECODE_EXPORT OptVar* getOptVar(int scope);///< returns the optimization variable of the 'scope'-th scope of the problem
+};
+    
+#endif

data/ext/gecode-2.2.0/contribs/qecode/Makefile.in.in

@@ -0,0 +1,163 @@
+# Qecode Makefile
+# Largely inspired from the map makefile by Gregoire Dooms
+#
+# Jeremie Vautard, Universite d'Orleans
+
+#
+gecode_top_srcdir = ../../$(top_srcdir)
+gecode_top_builddir = ../..
+
+qecode_top_srcdir = $(gecode_top_srcdir)/contribs/qecode
+qecode_top_builddir = .
+
+KERNELDLL := $(KERNELDLL:%=../../%)
+INTDLL := $(INTDLL:%=../../%)
+MMDLL := $(MMDLL:%=../../%)
+SEARCHDLL := $(SEARCHDLL:%=../../%)
+SUPPORTDLL := $(SUPPORTDLL:%=../../%)
+SUPPORTOBJ := $(SUPPORTOBJ:%=../../%)
+
+
+ifeq "$(LIBPREFIX)" "$(LINKPREFIX)"
+LINKSET:=../../$(LINKSET)
+LINKSUPPORT:=../../$(LINKSUPPORT)
+LINKKERNEL:=../../$(LINKKERNEL)
+LINKINT:=../../$(LINKINT)
+LINKMM:=../../$(LINKMM)
+LINKSEARCH:=../../$(LINKSEARCH)
+LINKALL := $(LINKMM) $(LINKSET) $(LINKINT) $(LINKSEARCH) $(LINKKERNEL)
+else
+EXTRALINKFLAGS := -L../..
+endif
+
+#
+# QECODE COMPONENTS
+#
+
+QECODESRC0 = Implicative.cc myspace.cc OptVar.cc qsolver.cc Strategy.cc StrategyNode.cc
+QECODEHDR0 = 
+
+
+QECODESRC	= $(QECODESRC0)
+QECODEHDR	= qecode.hh $(QECODEHDR0)
+QECODEOBJ	= $(QECODESRC:%.cc=%$(OBJSUFFIX))
+QECODEFLAGS	= \
+	-I$(gecode_top_srcdir) -I$(gecode_top_builddir) \
+	-I$(qecode_top_srcdir) -I$(qecode_top_builddir) \
+	-L$(gecode_top_builddir) -L$(qecode_top_builddir)
+QECODEDLL	= $(LIBPREFIX)@QECODE@$(DLLSUFFIX)
+QECODESTATICLIB	= $(LIBPREFIX)@QECODE@$(STATICLIBSUFFIX)
+QECODELIB	= $(LIBPREFIX)@QECODE@$(LIBSUFFIX)
+LINKQECODE	= $(LINKPREFIX)@QECODE@$(LINKSUFFIX)
+
+LINKALL := $(LINKALL) $(LINKQECODE)
+
+ALLLIB :=  $(ALLLIB) $(QECODELIB) 
+
+
+ifeq "@BUILDDLL@" "yes"
+DLLTARGETS = $(QECODEDLL)
+else
+DLTARGETS= 
+endif
+
+ifeq "@BUILDSTATIC@" "yes"
+STATICTARGETS = \
+	$(QECODESTATICLIB)
+else
+STATICTARGETS=
+endif
+
+LIBTARGETS= $(DLLTARGETS) $(STATICTARGETS)
+
+
+all : $(LIBTARGETS) 
+
+#
+# Object targets
+#
+
+%$(OBJSUFFIX): $(qecode_top_srcdir)/%.cc
+	$(CXX) $(CXXFLAGS)  $(QECODEFLAGS) \
+	@COMPILEOBJ@$@ @CXXIN@ $<
+%$(SBJSUFFIX): $(qecode_top_srcdir)/%.cc
+	$(CXX) $(CXXFLAGS)   $(QECODEFLAGS) \
+	@COMPILESBJ@$@ @CXXIN@ $<
+
+
+
+
+#
+# DLL Targets
+#
+
+ifeq "$(DLLSUFFIX)" "$(LIBSUFFIX)"
+#linux
+$(QECODEDLL): $(QECODEOBJ) $(KERNELDLL) $(INTDLL) $(SEARCHDLL) $(SUPPORTDLL) $(MMDLL)
+	$(CXX) $(DLLFLAGS) $(QECODEOBJ)  $(QECODEFLAGS) \
+		@DLLPATH@ $(LINKKERNEL) $(LINKSEARCH) $(LINKINT) $(LINKMM) $(LINKSUPPORT) \
+		@LINKOUTPUT@$(QECODEDLL)
+	$(CREATELINK) $@ $(@:%$(DLLSUFFIX)=%$(SOLINKSUFFIX))
+	$(CREATELINK) $@ $(@:%$(DLLSUFFIX)=%$(SOSUFFIX))
+else
+#win
+$(QECODEDLL) $(QECODELIB): $(QECODEOBJ) $(KERNELDLL) $(INTDLL) $(SEARCHDLL) $(SUPPORTDLL) $(MMDLL)
+	$(CXX) $(DLLFLAGS) $(QECODEOBJ)  $(QECODEFLAGS)\
+		@DLLPATH@ $(LINKKERNEL) $(LINKSEARCH) $(LINKINT) $(LINKMM) $(LINKSUPPORT)  \
+		@LINKOUTPUT@$(QECODEDLL)
+endif
+
+
+#
+# Static libraries
+#
+
+$(QECODESTATICLIB): $(QECODEOBJ)
+	$(AR) $(ARFLAGS) $@ $(QECODEOBJ)
+	$(RANLIB) $@
+
+# 
+# EXE targets
+#
+#
+
+
+#for linux: ?
+CXXFLAGS := $(CXXFLAGS) $(QECODEFLAGS) 
+
+#
+# Autoconf
+#
+
+$(qecode_top_srcdir)/configure: $(qecode_top_srcdir)/configure.ac 
+	(cd $(qecode_top_srcdir) && autoconf)
+config.status: $(qecode_top_srcdir)/configure
+	../../config.status --recheck
+	./config.status --recheck
+# use the sustitutions from gecode to generate the Makefile.in
+Makefile.in: $(qecode_top_srcdir)/Makefile.in.in ../../config.status 
+	../../config.status \
+	  --file Makefile.in:$(qecode_top_srcdir)/Makefile.in.in
+
+# use the sustitutions from configure to generate the Makefile
+Makefile: Makefile.in ./config.status 
+	./config.status --file ./Makefile:./Makefile.in
+
+
+.PHONY: clean veryclean distclean
+clean:
+	$(RMF) $(QECODEOBJ) $(QECODESBJ)
+
+veryclean: clean
+	$(RMF) $(LIBTARGETS)
+	$(RMF) $(LIBTARGETS:%$(DLLSUFFIX)=%.exp) $(LIBTARGETS:%$(DLLSUFFIX)=%.lib)
+	$(RMF) $(LIBTARGETS:%$(DLLSUFFIX)=%.ilk) $(LIBTARGETS:%$(DLLSUFFIX)=%.pdb)
+	$(RMF) $(QECODEDLL)
+
+distclean: veryclean
+	$(RMF) config.log config.status
+
+.PHONY: doc
+doc: $(QECODEHDR) $(QECODESRC) 
+	mkdir -p doc/html
+	doxygen doxygen.conf

data/ext/gecode-2.2.0/contribs/qecode/OptVar.cc

@@ -0,0 +1,82 @@
+/****   , [ OptVar.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 "OptVar.hh"
+
+ExistOptVar::ExistOptVar(int var,int scope) {
+    varId = var;
+    scopeId=scope;
+}
+
+int ExistOptVar::getVal(Strategy s) {
+//    cout<<"getval on existoptvar "<<varId<<" at scope "<<scopeId<<endl;
+    if (s.isTrue()) {cout<<"EOV "<<varId<<" scope "<<scopeId<<" try to get opt value on TRUE"<<endl;abort();}
+    if (s.isFalse()) {cout<<"EOV "<<varId<<" scope "<<scopeId<<"Try to get opt value on FALSE"<<endl;abort();} // (sub)Strategy must neither be false
+    if (s.isDummy()) {cout<<"EOV "<<varId<<" scope "<<scopeId<<"Try to get opt value on Dummy"<<endl;abort();} // nor begin with a universal scope
+    if (s.scope() > scopeId) {cout<<"EOV "<<varId<<" scope "<<scopeId<<"Try to get opt value on  asubstrategy not containing opt variable"<<endl;abort();} // nor begin at a scope after the one we want ^^
+    
+    if (s.scope() == scopeId) return s.value(varId-s.VMin());
+    // s.getTag() < scope
+    Strategy nextScope = s.getChild(0);
+    
+    return getVal(nextScope);
+}
+
+int ExistOptVar::getScope() {return scopeId;}
+
+UnivOptVar::UnivOptVar(int scope,OptVar* zevar, Aggregator* agg) {
+    var=zevar;
+    fct=agg;
+    scopeId=scope;
+}
+
+int UnivOptVar::getVal(Strategy s) {
+//    cout<<"getVal sur univoptvar "<<scopeId<<endl;
+    vector<int> values; values.clear();
+    if (s.isFalse()) {cout<<"UOV Try to get opt value on FALSE"<<endl;abort();}
+    if (s.isTrue()) return fct->eval(values); 
+    if (s.isDummy()) {
+        for (int i=0;i<s.degree();i++) {
+            values.push_back(var->getVal(s.getChild(i)));
+        }
+        return fct->eval(values);
+    }
+
+    if (s.scope() == (scopeId-1)) {
+        for (int i=0;i<s.degree();i++) {
+            values.push_back(var->getVal(s.getChild(i)));
+        }
+        return fct->eval(values);
+    }
+    
+    if (s.scope() < (scopeId-1) ) {
+        if (s.quantifier()) {cout<<"UOV universal scope too soon"<<endl;abort();} // universal quantifier too soon
+        return getVal(s.getChild(0));
+    }
+    // s.scope() > scope-1 -> too far away
+    cout<<"UOV try to get aggregate on a substrategy not containing required scope"<<endl;
+    abort();
+    return 0; // dummy return to avoid a compiler complain...
+}    
+        
+
+int UnivOptVar::getScope() {return scopeId;}

data/ext/gecode-2.2.0/contribs/qecode/OptVar.hh

@@ -0,0 +1,123 @@
+/****   , [ OptVar.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_OPTVAR__
+#define __QECODE_OPTVAR__
+
+#include "Strategy.hh"
+#include <vector>
+
+/** \brief Abstract class for an Aggregator
+*   
+*   An aggregator is defined as a function Multiset_of_int -> int. From an implementation
+*   point of view, this multiset is a vector of int.
+*/
+class QECODE_VTABLE_EXPORT Aggregator {
+public:
+    virtual int eval(vector<int> values)=0;
+    virtual ~Aggregator() {}
+};
+
+/** \brief Sum aggregator
+*
+* This aggregator computes the sum of all elements of the multiset
+*/
+class QECODE_VTABLE_EXPORT AggregatorSum : public Aggregator{
+public:
+    QECODE_EXPORT virtual int eval(vector<int> values) {
+        int cpt=0;
+        for (int i=0;i<values.size();i++) 
+            cpt += values[i];
+        return cpt;
+    }
+    virtual ~AggregatorSum() {}
+};
+
+/** \brief Mean aggregator
+*
+* This aggregator computes the mean of all elements of the multiset
+*/
+class QECODE_VTABLE_EXPORT AggregatorMean : public Aggregator{
+public:
+    QECODE_EXPORT virtual int eval(vector<int> values) {
+        int size=values.size();
+        if (size == 0) return 0;
+        int cpt=0;
+        for (int i=0;i<size; i++)
+            cpt += values[i];
+        cpt = cpt / size;
+        return cpt;
+    }
+    virtual ~AggregatorMean() {}
+};
+
+/** \brief Abstract class for an optimization variable
+*
+* This class defines the interface of an optimization variable, which can be either an existential variable, of the result of an aggregator function
+*/
+class QECODE_VTABLE_EXPORT OptVar {
+public:
+    QECODE_EXPORT virtual int getVal(Strategy s)=0; ///< returns value of this optimization variable in the substrategy s
+    QECODE_EXPORT virtual int getScope()=0; ///< returns the scope where this optimization variable belong
+    virtual ~OptVar() {}
+};
+
+/** \brief Existential optimization variable
+*
+* This class defines an existential optimization variable. This variabe is just an other point of view for an existential variable of the problem.
+*/
+class QECODE_VTABLE_EXPORT ExistOptVar : public OptVar {
+private:
+    int varId;
+    int scopeId;
+public:
+    QECODE_EXPORT ExistOptVar(int var,int scope);
+    QECODE_EXPORT virtual int getVal(Strategy s);
+    QECODE_EXPORT virtual int getScope();
+    virtual ~ExistOptVar() {}
+};
+
+/** \brief Universal optimization variable (aggregator result)
+*
+* This class defines a universal optimization variable. Such a variable represents the result of an aggregator on the set of values that an inner
+* optimization variable takes in every sub-strategy of the current scope. 
+*/
+class QECODE_VTABLE_EXPORT UnivOptVar : public OptVar {
+private:
+    int scopeId;
+    OptVar* var;
+    Aggregator* fct;
+public:
+        /** \brief constructor for an universal optimization variable
+        *
+        * Builds a universal optimzation variable at a given (universal) scope, that will represent the result of the agg aggregator on the set of all values 
+        * taken by the optimization variable zevar in each substrategy below the current point.
+        * @param scope the scope where this optimization variable belong
+        * @param zevar the inner optimization variable that will be aggregated
+        * @param agg the aggregator function to be used
+        */
+    QECODE_EXPORT UnivOptVar(int scope,OptVar* zevar,Aggregator* agg);
+    QECODE_EXPORT virtual int getVal(Strategy s);
+    QECODE_EXPORT virtual int getScope();
+    virtual ~UnivOptVar() {delete fct;}
+};
+    
+#endif