nojhan/paradiseo
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Nettoyage

Browse source 
git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@1823 331e1502-861f-0410-8da2-ba01fb791d7f
This commit is contained in:
jhumeau 2010-05-26 15:18:59 +00:00
commit f7490eeadd
51 changed files with 444 additions and 1385 deletions
Download patch file Download diff file Expand all files Collapse all files

83
trunk/paradiseo-moeo/src/archive/moeoArchiveIndex.h
View file

@ -1,83 +0,0 @@
#ifndef MOEOARCHIVEINDEX_H_
#define MOEOARCHIVEINDEX_H_
#include <eoPop.h>
#include <archive/moeoArchive.h>
/**
* Inteface for Archive Indexes
*/
template < class MOEOT >
class moeoArchiveIndex
{
public:
//type of MOEOT Objective vector
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
/**type for a modification that will have to be applied to the archive
* each item concern one ObjectiveVector, designated by itemObjective
**/
struct modif{
public:
//Objective vector of the concerned item
ObjectiveVector itemObjective;
//oldIdx is the index of the item in the vector before the modification (in the archive itself, not in the index)
int oldIdx;
//newIdx is the new index of the item in the vector after the modification (in the archive itself, not in the index)
//-1 if deletion has to occur
int newIdx;
/**
* ctor for a deletion
* @param _obj the objectiveVector of the concerned entry
* @param _oldIdx the current index of the concerned entry in the vector (before deletion)
*/
modif(ObjectiveVector& _obj, int _oldIdx):itemObjective(_obj),oldIdx(_oldIdx),newIdx(-1){}
/**
* ctor for a move
* @param _obj the objectiveVector of the concerned entry
* @param _oldIdx the current index of the concerned entry in the vector (before moving)
* @param _newIdx the index of the concerned entry in the vector after moving
**/
modif(ObjectiveVector& _obj, int _oldIdx,int _newIdx):itemObjective(_obj),oldIdx(_oldIdx),newIdx(_newIdx){}
};
/**
* principal method for the index, add a moeot to the index
* @param _moeot the MOEOT we try to insert
* @param _insert should we really insert the moeot, or just check if we have to
* @return a pair, the first is a boolean indicating if the insertion can occur, the second a vector of modification
**/
virtual std::pair<bool,std::vector<modif> > operator()(const MOEOT& _moeot, bool _insert=true)=0;
/*
* method for adding a population of moeot to the the index
* @param _pop the population of MOEOT we try to insert
* @param _insert should we really insert the moeot, or just check if we have to
* @return a pair, the first is how many moeot can be inserted, the second a vector of modification that would have to occur to insert
*/
// virtual std::pair<bool,std::vector<modif> > operator()(const eoPop<MOEOT>& _pop, bool _insert=true)=0;
/**
* when updates will be necessary to keep indexes of archive and index synced, the archive will launch this method
* @param _update the update to do, see modif documentation
* @return false if no problem occured
*/
virtual bool update( modif& _update)=0;
/**
* creates a modif that move the item ObjectiveVector placed at idx oldIdx in the archive to newIdx, or delete it if newIdx=-1
* @param _obj the objectiveVector we want to move
* @param _oldIdx the index of the item we want to move in the vector
* @param _newIdx the new index for the item, -1 if we want it deleted
**/
static modif make_modif(ObjectiveVector &_obj,int _oldIdx,int _newIdx=-1){
modif res(_obj,_oldIdx,_newIdx);
return res;
}
};
#endif /*MOEOARCHIVEINDEX_H_*/

110
trunk/paradiseo-moeo/src/archive/moeoIndexedArchive.h
View file

@ -1,110 +0,0 @@
#ifndef MOEOINDEXEDARCHIVE_H_
#define MOEOINDEXEDARCHIVE_H_
#include <eoPop.h>
#include <archive/moeoArchive.h>
#include <archive/moeoArchiveIndex.h>
/**
* Archive used for 2 dimension vectors which remove pareto dominated values
* Use an moeoArchiveIndex
*/
template < class MOEOT >
class moeoIndexedArchive : public moeoArchive < MOEOT >
{
public:
using eoPop < MOEOT > :: size;
using eoPop < MOEOT > :: operator[];
using eoPop < MOEOT > :: pop_back;
/**
* The type of an objective vector for a solution
*/
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
/**
* Default ctor.
* The moeoObjectiveVectorComparator used to compare solutions is based on Pareto dominance
*/
moeoIndexedArchive(moeoArchiveIndex<MOEOT>& _index) : index(_index) {}
/**
* Updates the archive with a given individual _moeo
* @param _moeo the given individual
*/
bool operator()(const MOEOT & _moeo){
std::pair<bool,std::vector<typename moeoArchiveIndex<MOEOT>::modif> > res=index(_moeo);
if (!(res.first)){
return false;
}
else{
for (unsigned int i=0;i<res.second.size();i++){
apply_modif(res.second[i]);
}
push_back(_moeo);
return true;
}
}
/**
* Updates the archive with a given population _pop
* @param _pop the given population
*/
bool operator()(const eoPop < MOEOT > & _pop)
{
bool res=false;
for (unsigned int i=0;i<_pop.size();i++){
res=operator()(_pop[i])||res;
}
return res;
}
protected:
/**
* apply a modification
* @param _modif the modification to apply
**/
void apply_modif(typename moeoArchiveIndex<MOEOT>::modif &_modif){
if (_modif.newIdx==-1){
int oldIdx=size()-1;
(*this)[_modif.oldIdx]=(*this)[size()-1];
ObjectiveVector obj=(*this)[_modif.oldIdx].objectiveVector();
typename moeoArchiveIndex<MOEOT>::modif upd(obj,oldIdx,_modif.oldIdx);
index.update(upd);
pop_back();
}
}
//not used yet...
void apply_modif(std::vector<typename moeoArchiveIndex<MOEOT>::modif> &_modifs){
unsigned int num_to_delete=0;
for (unsigned int i=0;i<_modifs.size();i++){
if (_modifs[i].newIdx==-1){
num_to_delete++;
int oldIdx=size()-1;
(*this)[_modifs[i].oldIdx]=(*this)[size()-1];
ObjectiveVector obj=(*this)[_modifs[i].oldIdx].objectiveVector();
typename moeoArchiveIndex<MOEOT>::modif upd(obj,oldIdx,_modifs[i].oldIdx);
index.update(upd);
}
}
for (unsigned int i=0;i<num_to_delete;i++)
pop_back();
}
private:
moeoArchiveIndex<MOEOT> &index;
};
#endif /*MOEOINDEXEDARCHIVE_H_*/

527
trunk/paradiseo-moeo/src/archive/moeoQuadTree.h
View file

@ -1,527 +0,0 @@
/*
* <moeoQuadTree.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
*
* Arnaud Liefooghe
* Jérémie Humeau
*
* This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use,
* modify and/ or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info".
*
* As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited liability.
*
* In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
* The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms.
*
* ParadisEO WebSite : http://paradiseo.gforge.inria.fr
* Contact: paradiseo-help@lists.gforge.inria.fr
*
*/
//-----------------------------------------------------------------------------
#ifndef MOEOQUADTREE_H_
#define MOEOQUADTREE_H_
#include <comparator/moeoParetoObjectiveVectorComparator.h>
#include <archive/moeoArchiveIndex.h>
template < class ObjectiveVector >
class QuadTreeNode{
public:
QuadTreeNode(ObjectiveVector& _objVec):objVec(_objVec),subTree(){}
QuadTreeNode(const QuadTreeNode& _source):objVec(_source.objVec),subTree(_source.subTree){}
QuadTreeNode& operator=(const QuadTreeNode& _src){
(*this).objVec=_src.objVec;
(*this).subTree=subTree;
(*this).inserted=_src.is_inserted();
if(inserted) (*this).index=_src.get_index();
return *this;
}
ObjectiveVector& getVec(){
return objVec;
}
/**
* @param _kSuccesor the k_successor of _child regarding this Node
* @param _child the child to link at the index _kSuccessor
* @return true if _child is inserted, false if there is already a child for this index
*/
bool setChild(unsigned int _kSuccesor, QuadTreeNode<ObjectiveVector>* _child){
bool res = false;
if((*this).subTree[_kSuccesor] == NULL){
res=true;
(*this).subTree[_kSuccesor]= _child;
}
return res;
}
std::map<unsigned int, QuadTreeNode<ObjectiveVector>*>& getSubTree(){
return (*this).subTree;
}
void set_index(int idx){
inserted=true;
index=idx;
}
unsigned int get_index(){
if (!inserted) std::cerr<<"moeoQuadTree getting index of a non-inserted node"<<std::endl;
return index;
}
bool is_inserted(){
return inserted;
}
private:
ObjectiveVector objVec;
std::map<unsigned int, QuadTreeNode<ObjectiveVector>*> subTree;
unsigned int index;
bool inserted;
};
template < class MOEOT >
class moeoQuadTree : public moeoArchiveIndex<MOEOT> {
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
typedef typename std::map<unsigned int, QuadTreeNode<ObjectiveVector>*>::iterator QuadTreeIterator;
typedef typename moeoArchiveIndex<MOEOT>::modif modif;
public:
moeoQuadTree():root(NULL),current_size(0){
bound=pow(2,ObjectiveVector::nObjectives())-1;
comparator=new moeoParetoObjectiveVectorComparator<ObjectiveVector>();
}
~moeoQuadTree(){
delete(comparator);
}
/**
* insert a _moeot in the index if it can be inserted
* @param @_moeot the individual ton insert
* @param _insert not used, should be changed...
*/
std::pair<bool,std::vector<modif> > operator()(const MOEOT& _moeot, bool _insert=true){
std::pair<bool,std::vector<modif> > res;
insert(_moeot.objectiveVector(),res);
if (res.first){
current_size=current_size+1-res.second.size();
}
return res;
};
/**
* apply the modif
* @param _update the modif to apply (move only)
* @return false if no problem occured
**/
bool update( modif& _update){
QuadTreeNode<ObjectiveVector>* node=find_node(_update.itemObjective,getRoot());
if (node==NULL) return true;
node->set_index(_update.newIdx);
return false;
}
/**
* @paramm _obj the Objective Vector to insert into the tree.
* @return true if it is inserted
*/
void insert(ObjectiveVector _obj, std::pair<bool, std::vector<modif> > &res){
//create a new node
QuadTreeNode<ObjectiveVector>* tmp = new QuadTreeNode<ObjectiveVector>(_obj);
//if the tree is empty, we have a new root!
if(isEmpty()){
root=tmp;
tmp->set_index(0);
res.first=true;
}
//else try to insert the new node in the tree
else{
res.first = insert_aux(tmp, root, NULL, 0, res.second);
if(res.first) tmp->set_index(size()-1);
}
}
/**
* @param _newnode the node to insert
* @param _tmproot the temporary root
* @param _parent the parent of _tmproot
* @param _succ the index of _parent where the _tmproot is linked
* @return true if the _newnode is inserted
*/
bool insert_aux(QuadTreeNode<ObjectiveVector>* _newnode, QuadTreeNode<ObjectiveVector>* _tmproot, QuadTreeNode<ObjectiveVector>* _parent, unsigned int _succ, std::vector<modif> &modifs){
bool res=false;
bool dominated=false;
unsigned int succ=k_succ(_newnode->getVec(), _tmproot->getVec());
if(succ==bound){
//_newnode is dominated by _tmproot
delete(_newnode);
}
else if(succ==0){
//_newnode dominates _tmproot
replace(_newnode, _tmproot, _parent, _succ, modifs);
res=true;
}
else{
//dominance test1 (test if _newnode is dominated by the childs of _tmproot)
if(!(_tmproot->getSubTree().empty())){
QuadTreeIterator it=_tmproot->getSubTree().begin();
while(!dominated && (it != _tmproot->getSubTree().end())){
if((*it).second != NULL){
if( ((*it).first < succ) && (((succ ^ bound) & ((*it).first ^ bound)) == (succ ^ bound)) ){
dominated = test1(_newnode, (*it).second);
}
}
it++;
}
}
if(dominated){
//_newnode is dominated by a node of the subtree
delete(_newnode);
}
else{
//dominance test2 (test if _newnode dominates the childs of _tmproot)
QuadTreeIterator it=_tmproot->getSubTree().begin();
while(it != _tmproot->getSubTree().end()){
if((*it).second != NULL){
if( (succ < (*it).first) && ((succ & (*it).first) == succ)){
test2(_newnode, (*it).second, _tmproot, (*it).first, modifs);
}
}
it++;
}
//insertion
if(_tmproot->setChild(succ, _newnode)){
//the child is inserted
res=true;
}
else{
//else if the child is not inserted, insert it in the subtree
res=insert_aux(_newnode, _tmproot->getSubTree()[succ], _tmproot, succ , modifs);
}
}
}
return res;
}
/*
* @param _objVec1
* @param _objVec2
* @return the k-successor of _objVec1 with respect to _objVec2
*/
unsigned int k_succ(const ObjectiveVector& _objVec1, const ObjectiveVector& _objVec2){
unsigned int res=0;
if(!(*comparator)(_objVec2, _objVec1)){
for(unsigned int i=0; i < ObjectiveVector::nObjectives(); i++){
if( (ObjectiveVector::minimizing(i) && ((_objVec1[i] - _objVec2[i]) >= (-1.0 * 1e-6 ))) ||
(ObjectiveVector::maximizing(i) && ((_objVec1[i] - _objVec2[i]) <= 1e-6 ))){
res+=pow(2,ObjectiveVector::nObjectives()-i-1);
}
}
}
return res;
}
/*
* replace the root by a new one
* @param _newnode thee new root
* @param _tmproot the old root
* @param _parent the parent of _tmproot
* @param _succ the index of _parent where the _tmproot is linked
*/
void replace(QuadTreeNode<ObjectiveVector>* _newnode, QuadTreeNode<ObjectiveVector>* _tmproot, QuadTreeNode<ObjectiveVector>* _parent, unsigned int _succ, std::vector<modif> & res){
if(!(_tmproot->getSubTree().empty())){
//reconsider each son of the old root
QuadTreeIterator it;
for(it=(_tmproot->getSubTree()).begin(); it != (_tmproot->getSubTree()).end(); it++){
if((*it).second!=NULL){
reconsider(_newnode, (*it).second, res);
}
}
}
//replace the old root by the new one
if(_parent==NULL){
root=_newnode;
}
else{
_parent->getSubTree()[_succ]=_newnode;
}
//kill the old root
modif new_modif(_tmproot->getVec(),_tmproot->get_index());
res.push_back(new_modif);
delete(_tmproot);
}
/**
* @param _newroot the new root
* @param _child a node to reconsider regarding tthe _newroot
*/
void reconsider(QuadTreeNode<ObjectiveVector>* _newroot, QuadTreeNode<ObjectiveVector>* _child, std::vector<modif> & res){
unsigned int succ;
//reconsider all child of _child
if(!(_child->getSubTree().empty())){
QuadTreeIterator it;
for(it=(_child->getSubTree()).begin(); it != (_child->getSubTree()).end(); it++){
if((*it).second != NULL){
QuadTreeNode<ObjectiveVector>* tmp=(*it).second;
_child->getSubTree()[(*it).first]=NULL;
reconsider(_newroot, tmp, res );
}
}
}
succ=k_succ(_child->getVec(),_newroot->getVec());
//if _child is dominated by the newroot, delete it
if(succ==bound){
modif new_modif(_child->getVec(),_child->get_index());
res.push_back(new_modif);
delete(_child);
}
//else reinsert it in the tree rooted at _newroot
else if(_newroot->getSubTree()[succ] != NULL){
reinsert(_newroot->getSubTree()[succ],_child);
}
else{
_newroot->setChild(succ, _child);
}
}
/**
* reinsert _node2 into _node1
* @param _node1 first node
* @param _node2 second node
*/
void reinsert(QuadTreeNode<ObjectiveVector>* _node1, QuadTreeNode<ObjectiveVector>* _node2){
//first resinsert all child of the second node into node1
if(_node1 != _node2){
unsigned int succ;
if(!(_node2->getSubTree().empty())){
QuadTreeIterator it;
for(it=(_node2->getSubTree()).begin(); it != (_node2->getSubTree()).end(); it++){
if((*it).second != NULL){
QuadTreeNode<ObjectiveVector>* tmp=(*it).second;
_node2->getSubTree()[(*it).first]=NULL;
reinsert(_node1, tmp);
}
}
}
//insert node2 into node1
succ=k_succ(_node2->getVec(),_node1->getVec());
if(_node1->getSubTree()[succ] != NULL){
reinsert(_node1->getSubTree()[succ],_node2);
}
else{
_node1->setChild(succ, _node2);
}
}
}
/**
* remove a node
* @param _node the node to remove
* @param _parent its parent
* @param _succ the index of _parent where the _node is linked
*/
void remove(QuadTreeNode<ObjectiveVector>* _node, QuadTreeNode<ObjectiveVector>* _parent, unsigned int _succ, std::vector<modif> & res){
unsigned int k=1;
QuadTreeNode<ObjectiveVector>* tmp=NULL;
_parent->getSubTree()[_succ]=NULL;
while((k < (bound -1)) && _node->getSubTree()[k]==NULL){
k++;
}
if(_node->getSubTree()[k]!=NULL){
tmp =_node->getSubTree()[k];
_parent->setChild(_succ, tmp);
}
k++;
while(k < (bound -1)){
if(_node->getSubTree()[k]!=NULL){
reinsert(tmp ,_node->getSubTree()[k]);
}
k++;
}
modif new_modif(_node->getVec(),_node->get_index());
res.push_back(new_modif);
delete(_node);
}
/**
* test if _node1 is dominated by _node2 (and recursivly by its childs)
* @param _node1 first node
* @param _node2 second node
*/
bool test1(QuadTreeNode<ObjectiveVector>* _node1, QuadTreeNode<ObjectiveVector>* _node2){
bool res = false;
unsigned int succ;
succ=k_succ(_node1->getVec(), _node2->getVec());
if(succ==bound){
res=true;
}
else{
QuadTreeIterator it=_node2->getSubTree().begin();
while(!res && (it != _node2->getSubTree().end())){
if((*it).second!=NULL){
if( ((succ ^ bound) & ((*it).first ^ bound)) == (succ^bound)){
res = res || test1(_node1, (*it).second);
}
}
it++;
}
}
return res;
}
/**
* test if _node1 dominates _node2 (and recursivly its childs)
* @param _node1 first node
* @param _node2 second node
*/
void test2(QuadTreeNode<ObjectiveVector>* _node1, QuadTreeNode<ObjectiveVector>* _node2, QuadTreeNode<ObjectiveVector>* _parent, unsigned int _succ, std::vector<modif> & res){
unsigned int succ;
succ=k_succ(_node1->getVec(), _node2->getVec());
if(succ==0){
remove(_node2, _parent, _succ, res);
if(_parent->getSubTree()[_succ]!=NULL)
test2(_node1, _parent->getSubTree()[_succ], _parent, _succ, res);
}
else{
QuadTreeIterator it=_node2->getSubTree().begin();
while(it != _node2->getSubTree().end()){
if((*it).second!=NULL){
if( (succ & (*it).first) == succ){
test2(_node1, (*it).second, _node2, (*it).first, res);
}
}
it++;
}
}
}
//************* A REVOIR ************
void printTree(){
QuadTreeIterator it;
if(!isEmpty()){
std::cout << "root: " << root->getVec() << " -> ";
if(!(root->getSubTree().empty())){
for(it=(root->getSubTree()).begin(); it != (root->getSubTree()).end(); it++){
if((*it).second!=NULL)
std::cout << (*it).second->getVec() << " ; ";
}
std::cout << std::endl;
for(it=(root->getSubTree()).begin(); it != (root->getSubTree()).end(); it++){
if((*it).second!=NULL){
printChild((*it).second, (*it).first);
std::cout << std::endl;
}
}
}
}
}
void printChild(QuadTreeNode<ObjectiveVector>* _child, unsigned int _key){
QuadTreeIterator it;
std::cout << "[" << _key << " : " << _child->getVec() << "] -> ";
if(!(_child->getSubTree().empty())){
for(it=(_child->getSubTree()).begin(); it != (_child->getSubTree()).end(); it++){
if((*it).second!=NULL)
std::cout << (*it).second->getVec() << " ; ";
}
std::cout << std::endl;
for(it=(_child->getSubTree()).begin(); it != (_child->getSubTree()).end(); it++){
if((*it).second!=NULL){
printChild((*it).second, (*it).first);
std::cout << std::endl;
}
}
}
}
//***********************************
/**
* @return if the tree is empty or not
*/
bool isEmpty(){
return root==NULL;
}
/**
* @return a pointer on the root of the tree
*/
QuadTreeNode<ObjectiveVector>* getRoot(){
return root;
}
/**
* the number of individual currently indexed
* @return the tree size
*/
unsigned int size(){
return current_size;
}
private:
/**
* to find a node from his objectiveVector
* @param _obj the objective to find
* @param current the node in which we are looking (to be able to recurse)
* @return the node with obj as objectiveVector, or null if it's not found
*/
QuadTreeNode<ObjectiveVector>* find_node(ObjectiveVector &_obj, QuadTreeNode<ObjectiveVector>* current){
if (current->getVec()==_obj) return current;
else{
int succ=k_succ(current->getVec(),_obj);
if(current->getSubTree()[succ]!=NULL)
return find_node(_obj,current->getSubTree()[succ]);
else{
return NULL;
}
}
}
//pointer on the root of the tree
QuadTreeNode<ObjectiveVector>* root;
//size max of an index
unsigned int bound;
//Pareto comparator
moeoParetoObjectiveVectorComparator<ObjectiveVector>* comparator;
//current tree size
int current_size;
};
#endif /*MOEOQUADTREE_H_*/

109
trunk/paradiseo-moeo/src/archive/moeoQuadTreeArchive.h
View file

@ -1,109 +0,0 @@
/*
* <moeoQuadTreeArchive.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Lille-Nord Europe, 2006-2008
* (C) OPAC Team, LIFL, 2002-2008
*
* Arnaud Liefooghe
* Jeremie Humeau
*
* This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use,
* modify and/ or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info".
*
* As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited liability.
*
* In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
* The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms.
*
* ParadisEO WebSite : http://paradiseo.gforge.inria.fr
* Contact: paradiseo-help@lists.gforge.inria.fr
*
*/
//-----------------------------------------------------------------------------
// moeoEpsilonHyperboxArchive.h
//-----------------------------------------------------------------------------
#ifndef MOEOQUADTREEARCHIVE_H_
#define MOEOQUADTREEARCHIVE_H_
#include <eoPop.h>
/**
* This class represents an epsilon hyperbox archive.
*/
template < class MOEOT >
class moeoQuadTreeArchive : public moeoArchive < MOEOT >
{
public:
using moeoArchive < MOEOT > :: size;
using moeoArchive < MOEOT > :: resize;
using moeoArchive < MOEOT > :: operator[];
using moeoArchive < MOEOT > :: back;
using moeoArchive < MOEOT > :: pop_back;
using moeoArchive < MOEOT > :: push_back;
using moeoArchive < MOEOT > :: begin;
using moeoArchive < MOEOT > :: end;
using moeoArchive < MOEOT > :: replace;
/**
* The type of an objective vector for a solution
*/
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
/**
* Ctor where you can choose your own moeoObjectiveVectorComparator
* @param _comparator the functor used to compare objective vectors
* @param _epsilon the vector contains epsilon values for each objective
* @param _replace boolean which determine if a solution with the same objectiveVector than another one, can replace it or not
*/
moeoQuadTreeArchive() : moeoArchive < MOEOT >(){}
/**
* Updates the archive with a given individual _moeo
* @param _moeo the given individual
* @return if the _moeo is added to the archive
*/
bool operator()(const MOEOT & _moeo){
return false;
}
/**
* Updates the archive with a given population _pop
* @param _pop the given population
* @return if at least one _pop[i] is added to the archive
*/
bool operator()(const eoPop < MOEOT > & _pop){
bool res, tmp = false;
for(unsigned int i=0; i<_pop.size(); i++){
tmp = (*this)(_pop[i]);
res = res || tmp;
}
return res;
}
};
#endif /*MOEOQUADTREEARCHIVE_H_*/

235
trunk/paradiseo-moeo/src/archive/moeoQuickUnboundedArchiveIndex.h
View file

@ -1,235 +0,0 @@
#ifndef MOEOQUICKUNBOUNDEDARCHIVEINDEX_H_
#define MOEOQUICKUNBOUNDEDARCHIVEINDEX_H_
#include <eoPop.h>
#include <archive/moeoArchive.h>
#include <comparator/moeoObjectiveVectorComparator.h>
#include <comparator/moeoParetoObjectiveVectorComparator.h>
#include <algorithm>
#include <iostream>
/**
* Archive used for 2 dimension vectors which remove pareto dominated values
* the index is ordered following the first objective
*/
template < class MOEOT >
class moeoQuickUnboundedArchiveIndex : public moeoArchiveIndex < MOEOT >
{
public:
/**
* The type of an objective vector for a solution
*/
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
typedef typename moeoArchiveIndex<MOEOT>::modif modif;
// typedef typename moeoArchiveIndex < MOEOT> :: s_update s_update;
/**
* Default ctor. Pareto !!!!
* The moeoObjectiveVectorComparator used to compare solutions is based on Pareto dominance
*/
moeoQuickUnboundedArchiveIndex() : index() {}
/**
* Ctor
* @param _comparator the moeoObjectiveVectorComparator used to compare solutions
*/
//moeoQuickUnboundedArchive(moeoObjectiveVectorComparator < ObjectiveVector > & _comparator) : moeoArchive < MOEOT >(_comparator),index() {}
/**struct for an entry of the index
* obj is the objective vector of the vector[indice]
*/
struct entree{
entree(ObjectiveVector _obj, int _indice):obj(_obj),indice(_indice){}
bool operator == (const entree a){
return obj==a.obj;
}
ObjectiveVector obj;
int indice;
};
/**
* equivalent to "number one element should be on top of number two element" in the list by looking to the first obj
*/
struct CompareByFirst
: std::binary_function< bool, entree, entree > {
bool operator ()(
const entree& elem1,
const entree& elem2
) const {
if (ObjectiveVector::minimizing(0)){
return elem1.obj[0] > elem2.obj[0];
}
else{
return elem1.obj[0] < elem2.obj[0];
}
}
}cbf;
/**
* equivalent to "number one element should be on top of number two element" in the list by looking to the 2nd obj
*/
struct CompareByLast
: std::binary_function< bool, entree, entree > {
bool operator ()(
const entree& elem1,
const entree& elem2
) const {
if (ObjectiveVector::minimizing(1)){
return elem1.obj[1] < elem2.obj[1];
}
else{
return elem1.obj[1] > elem2.obj[1];
}
}
}cbl;
struct CompareByLast2
: std::binary_function< bool, MOEOT, MOEOT > {
bool operator ()(
const MOEOT& elem1,
const MOEOT& elem2
) const {
if (ObjectiveVector::minimizing(1)){
return elem1.objectiveVector()[1] < elem2.objectiveVector()[1];
}
else{
return elem1.objectiveVector()[1] > elem2.objectiveVector()[1];
}
}
}cbl2;
/**
* type for the index
*/
typedef typename std::set<entree,CompareByLast> MOEOTIndex;
/**
* iterator from the index
*/
typedef typename std::set<entree,CompareByLast>::iterator MOEOTIndexIte;
/**
* iterator for gcc stop being annoying
*/
typedef typename std::set<MOEOT>::iterator set_ite;
/**
updates the index following a modif
@param _update the modification to apply
@return false
*/
bool update(modif& _update){
entree oldEnt(_update.itemObjective,_update.oldIdx);
entree newEnt(_update.itemObjective,_update.newIdx);
index.erase(oldEnt);
index.insert(newEnt);
return false;
}
/*
std::pair<bool,std::vector<modif> > operator()(const eoPop<MOEOT>& _pop, bool _insert=true){
std::cout<<"OH, HI, je fais quelque chose"<<std::endl;
std::pair < bool, std::vector<modif> > res;
res.first=false;
std::vector <modif> tmp;
for (unsigned int i=0;i<_pop.size();i++){
std::cout<<"once va être créé"<<std::endl;
std::pair<bool,std::vector<modif> > once=operator()(_pop[i],_insert);
if (once.first){
std::cout<<"once vrai taille "<<once.second.size()<<std::endl;
std::copy(once.second.begin(),once.second.end(),res.second.end());
res.first=true;
}
}
return res;
};
*/
virtual std::pair<bool,std::vector<modif> > operator()(const MOEOT& _moeo, bool _insert=true){
return insert(_moeo,_insert);
}
/**
* inserts a _moeo in the index
* @param _moeo the MOEOT to insert
* @param _insert if _insert is false we only ask the index, and dont modify it
* @return a pair composed by a boolean indicating if the moeot can be inserted, and a list of modif to do so
*/
virtual std::pair<bool,std::vector<modif> > insert(const MOEOT& _moeo, bool _insert=true){
// std::cout<<"entree dans l'algo avec "<<_moeo.objectiveVector()<<std::endl;
MOEOTIndexIte it,it2,it4;
std::pair<bool,std::vector<modif> > res;
std::vector<entree> to_er;
res.first=false;
if (index.empty()){
std::cout<<"empty donc ok"<<std::endl;
if (_insert)
index.insert(entree(_moeo.objectiveVector(),index.size()));
res.first=true;
return res;
}
it=index.lower_bound(entree(_moeo.objectiveVector(),-1));
if (it==index.end()) {
it--;
if (!comparator(_moeo.objectiveVector(),(*it).obj)){
std::cout<<"fin et ok"<<std::endl;
if (_insert)
index.insert(entree(_moeo.objectiveVector(),index.size()));
res.first=true;
}else {
std::cout<<"fin et ko"<<std::endl;
}
return res;
}
if ((_moeo.objectiveVector()==(*it).obj) or (comparator(_moeo.objectiveVector(),(*it).obj))){
std::cout<<"middle ko bas"<<std::endl;
return res;
}
if (it!=index.begin()){
it2=it;
it2--;
if (comparator(_moeo.objectiveVector(),(*it2).obj)){
std::cout<<"middle ko haut"<<std::endl;
return res;
}
}
it2=it;
while (it2!=index.end() && comparator((*it2).obj,_moeo.objectiveVector())){
it2++;
}
for (it4=it;it4!=it2;it4++){
std::cout<<"ajout d'un truc à del"<<std::endl;
ObjectiveVector cpy=(*it4).obj;
int cpy_idx=(*it4).indice;
modif new_modif(cpy,cpy_idx);
res.second.push_back(new_modif);
to_er.push_back(*it4);
}
if (_insert){
for (unsigned int i=0;i<to_er.size();i++){
index.erase(to_er[i]);
}
index.insert(entree(_moeo.objectiveVector(),index.size()));
}
res.first=true;
std::cout<<"sortie avec insertion"<<std::endl;
return res;
}
protected:
private:
MOEOTIndex index;
moeoParetoObjectiveVectorComparator<ObjectiveVector> comparator;
};
#endif /*MOEOQUICKUNBOUNDEDARCHIVE_H_*/