gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.1.1/contribs/qecode/qsolver.cc

@@ -1,168 +0,0 @@
-/*****************************************************************[qsolver.cc]
-Copyright (c) 2007, Universite d'Orleans - Jeremie Vautard, Marco Benedetti,
-Arnaud Lallouet.
-
-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 "qsolver.hh"
-#include "implicative.hh"
-
-
-QSolver::QSolver(QSpace* qs, VariableHeuristic* ev, valueHeuristic* ve) {
-    debug=false;
-    eval=ev;
-    valEval = ve;
-    sp=qs;
-    n=sp->nv();
-    bh=new BranchingHeuristic(sp,eval);
-    sp->indicateBranchingHeuristic(bh);
-    nbRanges = new int;
-}
-
-
-bool QSolver::solve(unsigned long int& nodes, unsigned long int& propsteps) {
-    int ret = sp->status(0,propsteps);
-    return rSolve(sp,nodes,propsteps,0);
-}
-
-
-bool QSolver::rSolve(QSpace* qs, unsigned long int& nodes, unsigned long int& propsteps, int curvar) {
-    unsigned int rien=0;
-    nodes++;
-    
-//    if (debug) cout<<"Solver : Rsolve appelé..."<<endl;
-    
-    // Step 0 : we ask to the branching heuristic /////////////////////////////////
-    // for the next variable to branch on. ////////////////////////////////////////
-    int branchon = bh->nextVar(qs);                                              //
-    ///////////////////////////////////////////////////////////////////////////////
-    
-    // Step 1 : if there is no more variables to branch on, we ask for the ////////
-    // final status of the QCSP, and return its result. ///////////////////////////
-    if (branchon == n) {                                                         //
-        int ret=qs->status(curvar,propsteps);
-        int fret=qs->finalStatus(propsteps);                                     //
-        
-#ifdef QDEBUG        
-        cout<<"Solver : finalstatus appelé, résultat = "<<fret<<endl;
-        qs->print();
-#endif
-        qs->backtrack();                                                         //
-        bh->backtrack(qs);                                                       //
-#ifdef QDEBUG        
-        cout<<"Solver : backtracking"<<endl;                          //
-#endif
-        return (fret==1)?true:false;                                             //
-    }                                                                            //
-    ///////////////////////////////////////////////////////////////////////////////
-    
-    // Step 2 : if we must branch on a variable, first we check the status of  ////
-    // the problem (it could be given at this moment) /////////////////////////////
-    int ret = qs->status(curvar,propsteps);                                      //
-#ifdef QDEBUG        
-    cout<<"Solver : status appelé, résultat = "<<ret<<endl;
-    qs->print();
-#endif
-    if (ret==1) { // If the answer is TRUE...                                    //
-        qs->backtrack();                                                         //
-        bh->backtrack(qs);                                                       //
-#ifdef QDEBUG        
-        cout<<"Solver : backtracking"<<endl;
-#endif
-        return true;                                                             //
-    }                                                                            //
-                                                                                 //
-    if (ret==0) { // If the answer is FALSE...                                   //
-        qs->backtrack();                                                         //
-        bh->backtrack(qs);                                                       //
-#ifdef QDEBUG        
-        cout<<"Solver : backtracking"<<endl;
-#endif
-        return false;                                                            //
-    }                                                                            //
-    ///////////////////////////////////////////////////////////////////////////////
-    
-    
-    // Step 3 : the answer is "Don't know yet". We branch on the given variable. //
-    int** tab = valEval->subSet(static_cast<Implicative*>(qs),branchon,nbRanges);//
-    QSpace* subspace;                                                            //
-    subspace=qs->clone();                                                        //
-    switch (qs->type_of_v[branchon]) {                                           //
-        case VTYPE_INT :                                                         //
-            subspace->assign_int(branchon,tab,*nbRanges);                        //
-            break;                                                               //
-        case VTYPE_BOOL :                                                        //
-            subspace->assign_bool(branchon,tab,*nbRanges);                       //
-            break;
-    }
-#ifdef QDEBUG        
-    cout<<"Solver : first branch : v"<<branchon<<" = "<<the_set<<endl;
-#endif
-    if ( rSolve(subspace,nodes, propsteps,branchon) ^ qs->quantification(branchon)) {
-        delete subspace;                                                         //
-        qs->backtrack();                                                         //
-        bh->backtrack(qs);                                                       //
-#ifdef QDEBUG        
-        cout<<"Solver : Backtrack"<<endl;
-#endif
-        delete [] tab[0];
-        delete [] tab[1];
-        delete [] tab;
-        return (!qs->quantification(branchon));                                  //
-    }                                                                            //
-    delete subspace;                                                             //
-    subspace=qs->clone();                                                        //
-    switch (subspace->type_of_v[branchon]) {
-        case VTYPE_INT : 
-            subspace->remove_int(branchon,tab,*nbRanges);
-            break;
-        case VTYPE_BOOL : 
-            subspace->remove_bool(branchon,tab,*nbRanges);
-            break;
-    }
-
-#ifdef QDEBUG        
-    cout<<"Solver : second branch : v"<<branchon<<" != "<<the_set<<endl;
-#endif
-    if ( rSolve(subspace,nodes, propsteps, branchon) ^ qs->quantification(branchon)) {
-        delete subspace;                                                         //
-        qs->backtrack();                                                         //
-        bh->backtrack(qs);                                                       //
-#ifdef QDEBUG        
-        cout<<"Solver : Backtrack"<<endl;
-#endif
-        delete [] tab[0];
-        delete [] tab[1];
-        delete [] tab;
-        return (!qs->quantification(branchon));                                  //
-    }                                                                            //
-    delete subspace;                                                             //
-    qs->backtrack();                                                             //
-    bh->backtrack(qs);                                                           //
-#ifdef QDEBUG        
-    cout<<"Solver : Backtrack"<<endl;
-#endif
-    delete [] tab[0];
-    delete [] tab[1];
-    delete [] tab;
-    return (qs->quantification(branchon));                                       //
-  /////////////////////////////////////////////////////////////////////////////////
-}
-

data/ext/gecode-2.1.1/contribs/qecode/qsolver.hh

@@ -1,73 +0,0 @@
-/*****************************************************************[qsolver.hh]
-Copyright (c) 2007, Universite d'Orleans - Jeremie Vautard, Marco Benedetti,
-Arnaud Lallouet.
-
-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_QSOLVER__
-#define __QECODE_QSOLVER__
-
-#include "qecode.hh"
-#include <iostream>
-#include <cstdlib>
-#include "gecode/minimodel.hh"
-
-#include "qecore.hh"
-#include "valueHeuristic.hh"
-
-using namespace Gecode;
-using namespace std;
-using namespace Gecode::Int;
-
-
-/** \brief Depth-first search engine for quantified spaces.
-* A quite naive depth-first search engine for quantified spaces. The answer of such an engine is true or false. The complete winning strategy, if existing, is not given. 
-*/
-class QECODE_VTABLE_EXPORT QSolver {
-    
-private : 
-    bool debug;
-    int n;
-    QSpace* sp;
-    int* nbRanges;
-    BranchingHeuristic* bh;
-    VariableHeuristic* eval;
-    valueHeuristic* valEval;
-    bool rSolve(QSpace* qs,unsigned long int& nodes, unsigned long int& propsteps, int curvar);
-public :
-        
-        /** \brief  Constructor for a quantified space solver.
-        * Builds, providing a quantified space and a score for this space, a solver for this space.
-        *  @param sp The quantified space to be solved.
-        *  @param ev The score attribuer ("evaluator") that will be used by the branching heuristic.
-        */
-        QECODE_EXPORT QSolver(QSpace* sp, VariableHeuristic* ev,valueHeuristic* ve);
-    
-    
-    /** \brief  Solves the quantified space.
-        * Solves the quantifies dpace, returning its solution. The parameters are used to provide statistics.
-        *  @param nodes The integer referenced will be increased by the number of nodes of the search tree explored.
-        *  @param propsteps The integer references will be increased by the total number of propagation steps (in the Gecode sense) performed during search.
-        */
-    QECODE_EXPORT bool solve(unsigned long int& nodes, unsigned long int& propsteps);
-};
-
-
-#endif

data/ext/gecode-2.1.1/contribs/qecode/valueHeuristic.hh

@@ -1,91 +0,0 @@
-/*********************************************************[valueheuristic.hh]
-Copyright (c) 2007, Universite d'Orleans - Jeremie Vautard, Marco Benedetti,
-Arnaud Lallouet.
-
-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 VALUEHEUR
-#define VALUEHEUR
-#include "qecode.hh"
-#include "implicative.hh"
-using namespace Gecode;
-using namespace Gecode::Int;
-using namespace std;
-
-
-class QECODE_VTABLE_EXPORT valueHeuristic {
-    friend class Implicative;
-protected :
-    int whichSpaceOwns(Implicative* imp,int var) {
-        return imp->whichSpaceOwns[var];
-    }
-    
-    int nbSpaces(Implicative* imp) {
-        return imp->nbSpaces;
-    }
-    
-    IntVar* getIntVar(Implicative* imp,int scope,int var) {
-        if (imp->type_of_v[var] != VTYPE_INT) {cout<< "valueHeuristic getIntVar : Variable "<<var<<" is not int"<<endl; abort();}
-        if (scope<imp->nbSpaces) {
-            if (imp->ruleDefined[scope]) 
-                return (static_cast<IntVar*>(imp->rules[scope]->v[var]));
-            else 
-                return NULL;
-        }
-        else {
-            if (imp->goalDefined) 
-                return (static_cast<IntVar*>(imp->goal->v[var]));
-            else 
-                return NULL;
-        }
-    }
-    
-    bool scopeDefined(Implicative* imp,int scope) {
-        if (scope == imp->nbSpaces) return imp->goalDefined;
-        else return imp->ruleDefined[scope];
-    }
-
-    BoolVar* getBoolVar(Implicative* imp,int scope,int var) {
-        if (imp->type_of_v[var] != VTYPE_INT) {cout<< "valueHeuristic getBoolVar : Variable "<<var<<" is not bool"<<endl; abort();}
-        if (scope<imp->nbSpaces) {
-            if (imp->ruleDefined[scope]) 
-                return (static_cast<BoolVar*>(imp->rules[scope]->v[var]));
-            else 
-                return NULL;
-        }
-        else {
-            if (imp->goalDefined) 
-                return (static_cast<BoolVar*>(imp->goal->v[var]));
-            else 
-                return NULL;
-        }
-    }
-
-public :
-    virtual int** subSet(Implicative* home,int var,int* nbRanges)=0;
-    virtual ~valueHeuristic() {}
-};
-
-
-
-
-
-#endif

data/ext/gecode-2.1.1/contribs/qecode/warner.cc

@@ -1,101 +0,0 @@
-/*****************************************************************[warner.cc]
-Copyright (c) 2007, Universite d'Orleans - Jeremie Vautard, Marco Benedetti,
-Arnaud Lallouet.
-
-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 "warner.hh"
-
-void Warner::warn(int w) {
-  if (bh != NULL) 
-    bh->vartouched(w,sp);
-}
-
-
-void Warner::setBH(BranchingHeuristic* b) {
-  bh=b;
-}
-
-
-IntWarningProp::IntWarningProp(Space* home, int v, IntView vv, Warner* f, bool fd) : UnaryPropagator<IntView,PC_INT_DOM>(home,vv) {
-  var=v;
-  toWarn=f;
-}
-
-IntWarningProp::IntWarningProp(Space* home, bool share, IntWarningProp& p) : UnaryPropagator<IntView,PC_INT_DOM>(home,share,p) {
-  var=p.var;
-  toWarn=p.toWarn;
-}
-
-IntWarningProp::~IntWarningProp(void) {}
-
-PropCost IntWarningProp::cost(void) const {return PC_CRAZY_HI;}
-
-ExecStatus IntWarningProp::propagate(Space * home,ModEventDelta med) {
-  toWarn->warn(var);
-  return ES_NOFIX;
-}
-
-Actor* IntWarningProp::copy(Space* home,bool share) {return new (home) IntWarningProp(home,share,*this);}
-
-ExecStatus IntWarningProp::warning(Space* home, int v, IntView vv, Warner* f) {
-  (void) new (home) IntWarningProp(home,v,vv,f);
-  return ES_OK;
-}
-
-void IntWarningProp::IntWarning(Space* home, int v, IntVar iv, Warner* f) {
-  IntView vv(iv);  
-  GECODE_ES_FAIL(home,warning(home,v,vv,f));
-}
-
-//////////////////////////////////////////////
-
-BoolWarningProp::BoolWarningProp(Space* home, int v, BoolView vv, Warner* f, bool fd) : UnaryPropagator<BoolView,PC_INT_DOM>(home,vv) {
-    var=v;
-    toWarn=f;
-}
-
-BoolWarningProp::BoolWarningProp(Space* home, bool share, BoolWarningProp& p) : UnaryPropagator<BoolView,PC_INT_DOM>(home,share,p) {
-    var=p.var;
-    toWarn=p.toWarn;
-}
-
-BoolWarningProp::~BoolWarningProp(void) {}
-
-PropCost BoolWarningProp::cost(void) const {return PC_CRAZY_HI;}
-
-ExecStatus BoolWarningProp::propagate(Space * home,ModEventDelta med) {
-    toWarn->warn(var);
-    return ES_NOFIX;
-}
-
-Actor* BoolWarningProp::copy(Space* home,bool share) {return new (home) BoolWarningProp(home,share,*this);}
-
-ExecStatus BoolWarningProp::warning(Space* home, int v, BoolView vv, Warner* f) {
-    (void) new (home) BoolWarningProp(home,v,vv,f);
-    return ES_OK;
-}
-
-void BoolWarningProp::BoolWarning(Space* home, int v, BoolVar iv, Warner* f) {
-    BoolView vv(iv);  
-    GECODE_ES_FAIL(home,warning(home,v,vv,f));
-}
-
-
-

data/ext/gecode-2.1.1/contribs/qecode/warner.hh

@@ -1,83 +0,0 @@
-/*****************************************************************[warner.hh]
-Copyright (c) 2007, Universite d'Orleans - Jeremie Vautard, Marco Benedetti,
-Arnaud Lallouet.
-
-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_WARNER__
-#define __QECODE_WARNER__
-
-#include "qecode.hh"
-#include <iostream>
-#include <cstdlib>
-#include "gecode/minimodel.hh"
-#include "qecore.hh"
-
-
-using namespace Gecode;
-using namespace Gecode::Int;
-
-class QECODE_VTABLE_EXPORT Warner {
-private : 
-  BranchingHeuristic* bh;
-  QSpace* sp;
-public : 
-  QECODE_EXPORT Warner(QSpace* qs) {bh=NULL;sp=qs;}
-  QECODE_EXPORT void update(QSpace* qs) {sp=qs;}
-  QECODE_EXPORT void setBH(BranchingHeuristic* b);
-  QECODE_EXPORT void warn(int w);
-};
-
-
-class QECODE_VTABLE_EXPORT IntWarningProp : public UnaryPropagator<IntView,PC_INT_DOM> {
-
-private : 
-  int var;
-  Warner* toWarn;
-
-public : 
-  QECODE_EXPORT IntWarningProp (Space* home, int v, IntView vv, Warner* f, bool fd=false);
-  QECODE_EXPORT IntWarningProp (Space* home,bool share, IntWarningProp& p);
-  QECODE_EXPORT ~IntWarningProp (void);
-  QECODE_EXPORT virtual PropCost cost(void) const;
-  QECODE_EXPORT virtual ExecStatus propagate(Space * home,ModEventDelta med);
-  QECODE_EXPORT virtual Actor* copy(Space* home,bool share);
-  QECODE_EXPORT static ExecStatus warning(Space* home, int v, IntView vv, Warner* f);
-  QECODE_EXPORT static void IntWarning(Space* home, int v, IntVar iv, Warner* f);
-};
-
-class QECODE_VTABLE_EXPORT BoolWarningProp : public UnaryPropagator<BoolView,PC_INT_DOM> {
-    
-private : 
-    int var;
-    Warner* toWarn;
-    
-public : 
-    QECODE_EXPORT BoolWarningProp (Space* home, int v, BoolView vv, Warner* f, bool fd=false);
-    QECODE_EXPORT BoolWarningProp (Space* home,bool share, BoolWarningProp& p);
-    QECODE_EXPORT ~BoolWarningProp (void);
-    QECODE_EXPORT virtual PropCost cost(void) const;
-    QECODE_EXPORT virtual ExecStatus propagate(Space * home,ModEventDelta med);
-    QECODE_EXPORT virtual Actor* copy(Space* home,bool share);
-    QECODE_EXPORT static ExecStatus warning(Space* home, int v, BoolView vv, Warner* f);
-    QECODE_EXPORT static void BoolWarning(Space* home, int v, BoolVar iv, Warner* f);
-};
-
-
-#endif