Jip J. Dekker
981be2067e
git-subtree-dir: software/gecode_on_replay git-subtree-split: 8051d92b9c89e49cccfbd1c201371580d7703ab4
113 lines
6.1 KiB
C++
113 lines
6.1 KiB
C++
/**** , [ 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
|