Nettoyage
git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@1823 331e1502-861f-0410-8da2-ba01fb791d7f
This commit is contained in:
parent
ccd7ca05a5
commit
f7490eeadd
42 changed files with 444 additions and 1385 deletions
|
|
@ -1,147 +0,0 @@
|
|||
/*
|
||||
* <make_ls_moeo.h>
|
||||
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
|
||||
* (C) OPAC Team, LIFL, 2002-2007
|
||||
*
|
||||
* Arnaud Liefooghe
|
||||
*
|
||||
* 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 MAKE_LS_MOEO_H_
|
||||
#define MAKE_LS_MOEO_H_
|
||||
|
||||
#include <eoContinue.h>
|
||||
#include <eoEvalFunc.h>
|
||||
#include <eoGenOp.h>
|
||||
#include <utils/eoParser.h>
|
||||
#include <utils/eoState.h>
|
||||
#include <algo/moeoIBMOLS.h>
|
||||
#include <algo/moeoIteratedIBMOLS.h>
|
||||
#include <algo/moeoLS.h>
|
||||
#include <archive/moeoArchive.h>
|
||||
#include <fitness/moeoBinaryIndicatorBasedFitnessAssignment.h>
|
||||
#include <fitness/moeoExpBinaryIndicatorBasedFitnessAssignment.h>
|
||||
#include <metric/moeoNormalizedSolutionVsSolutionBinaryMetric.h>
|
||||
#include <move/moeoMoveIncrEval.h>
|
||||
|
||||
/**
|
||||
* This functions allows to build a moeoLS from the parser
|
||||
* @param _parser the parser
|
||||
* @param _state to store allocated objects
|
||||
* @param _eval the funtions evaluator
|
||||
* @param _moveIncrEval the incremental evaluation
|
||||
* @param _continue the stopping crietria
|
||||
* @param _op the variation operators
|
||||
* @param _opInit the initilization operator
|
||||
* @param _moveInit the move initializer
|
||||
* @param _nextMove the move incrementor
|
||||
* @param _archive the archive of non-dominated solutions
|
||||
*/
|
||||
template < class MOEOT, class Move >
|
||||
moeoLS < MOEOT, eoPop<MOEOT> & > & do_make_ls_moeo (
|
||||
eoParser & _parser,
|
||||
eoState & _state,
|
||||
eoEvalFunc < MOEOT > & _eval,
|
||||
moeoMoveIncrEval < Move > & _moveIncrEval,
|
||||
eoContinue < MOEOT > & _continue,
|
||||
eoMonOp < MOEOT > & _op,
|
||||
eoMonOp < MOEOT > & _opInit,
|
||||
moMoveInit < Move > & _moveInit,
|
||||
moNextMove < Move > & _nextMove,
|
||||
moeoArchive < MOEOT > & _archive
|
||||
)
|
||||
{
|
||||
/* the objective vector type */
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
/* the fitness assignment strategy */
|
||||
std::string & fitnessParam = _parser.getORcreateParam(std::string("IndicatorBased"), "fitness",
|
||||
"Fitness assignment strategy parameter: IndicatorBased...", 'F',
|
||||
"Evolution Engine").value();
|
||||
std::string & indicatorParam = _parser.getORcreateParam(std::string("Epsilon"), "indicator",
|
||||
"Binary indicator to use with the IndicatorBased assignment: Epsilon, Hypervolume", 'i',
|
||||
"Evolution Engine").value();
|
||||
double rho = _parser.getORcreateParam(1.1, "rho", "reference point for the hypervolume indicator",
|
||||
'r', "Evolution Engine").value();
|
||||
double kappa = _parser.getORcreateParam(0.05, "kappa", "Scaling factor kappa for IndicatorBased",
|
||||
'k', "Evolution Engine").value();
|
||||
moeoBinaryIndicatorBasedFitnessAssignment < MOEOT > * fitnessAssignment;
|
||||
if (fitnessParam == std::string("IndicatorBased"))
|
||||
{
|
||||
// metric
|
||||
moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > *metric;
|
||||
if (indicatorParam == std::string("Epsilon"))
|
||||
{
|
||||
metric = new moeoAdditiveEpsilonBinaryMetric < ObjectiveVector >;
|
||||
}
|
||||
else if (indicatorParam == std::string("Hypervolume"))
|
||||
{
|
||||
metric = new moeoHypervolumeBinaryMetric < ObjectiveVector > (rho);
|
||||
}
|
||||
else
|
||||
{
|
||||
std::string stmp = std::string("Invalid binary quality indicator: ") + indicatorParam;
|
||||
throw std::runtime_error(stmp.c_str());
|
||||
}
|
||||
fitnessAssignment = new moeoExpBinaryIndicatorBasedFitnessAssignment < MOEOT> (*metric, kappa);
|
||||
}
|
||||
else
|
||||
{
|
||||
std::string stmp = std::string("Invalid fitness assignment strategy: ") + fitnessParam;
|
||||
throw std::runtime_error(stmp.c_str());
|
||||
}
|
||||
_state.storeFunctor(fitnessAssignment);
|
||||
// number of iterations
|
||||
unsigned int n = _parser.getORcreateParam(1, "n", "Number of iterations for population Initialization", 'n', "Evolution Engine").value();
|
||||
// LS
|
||||
std::string & lsParam = _parser.getORcreateParam(std::string("I-IBMOLS"), "ls",
|
||||
"Local Search: IBMOLS, I-IBMOLS (Iterated-IBMOLS)...", 'L',
|
||||
"Evolution Engine").value();
|
||||
moeoLS < MOEOT, eoPop<MOEOT> & > * ls;
|
||||
if (lsParam == std::string("IBMOLS"))
|
||||
{
|
||||
ls = new moeoIBMOLS < MOEOT, Move > (_moveInit, _nextMove, _eval, _moveIncrEval, *fitnessAssignment, _continue);
|
||||
;
|
||||
}
|
||||
else if (lsParam == std::string("I-IBMOLS"))
|
||||
{
|
||||
ls = new moeoIteratedIBMOLS < MOEOT, Move > (_moveInit, _nextMove, _eval, _moveIncrEval, *fitnessAssignment, _continue, _op, _opInit, n);
|
||||
}
|
||||
else
|
||||
{
|
||||
std::string stmp = std::string("Invalid fitness assignment strategy: ") + fitnessParam;
|
||||
throw std::runtime_error(stmp.c_str());
|
||||
}
|
||||
_state.storeFunctor(ls);
|
||||
// that's it !
|
||||
return *ls;
|
||||
}
|
||||
|
||||
#endif /*MAKE_LS_MOEO_H_*/
|
||||
|
|
@ -41,7 +41,7 @@
|
|||
|
||||
#include <eoPop.h>
|
||||
#include <eoEvalFunc.h>
|
||||
#include <fitness/moeoSingleObjectivization.h>
|
||||
#include <scalarStuffs/fitness/moeoSingleObjectivization.h>
|
||||
|
||||
/*
|
||||
* Fitness assignment scheme which use weight foreach objectives
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@
|
|||
#define MOEOCONSTRAINTFITNESSASSIGNMENT_H_
|
||||
|
||||
#include <eoPop.h>
|
||||
#include <fitness/moeoSingleObjectivization.h>
|
||||
#include <scalarStuffs/fitness/moeoSingleObjectivization.h>
|
||||
#include <utils/moeoObjectiveVectorNormalizer.h>
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -41,6 +41,7 @@
|
|||
|
||||
#include <comparator/moeoParetoObjectiveVectorComparator.h>
|
||||
#include <metric/moeoMetric.h>
|
||||
#include <metric/moeoVecVsVecEpsilonBinaryMetric.h>
|
||||
|
||||
/**
|
||||
* moeoVecVsVecAdditiveEpsilonBinaryMetric is the implementation of moeoVecVsVecEpsilonBinaryMetric whose calculate an additive epsilon indicator
|
||||
|
|
|
|||
|
|
@ -42,55 +42,44 @@
|
|||
#include <eo>
|
||||
|
||||
#include <algo/moeoAlgo.h>
|
||||
#include <algo/moeoASEEA.h>
|
||||
#include <algo/moeoEA.h>
|
||||
#include <algo/moeoEasyEA.h>
|
||||
#include <algo/moeoIBEA.h>
|
||||
#include <algo/moeoMOGA.h>
|
||||
#include <algo/moeoNSGA.h>
|
||||
#include <algo/moeoNSGAII.h>
|
||||
#include <algo/moeoPopAlgo.h>
|
||||
#include <algo/moeoSEEA.h>
|
||||
#include <algo/moeoASEEA.h>
|
||||
#include <algo/moeoSPEA2.h>
|
||||
#include <algo/moeoHC.h>
|
||||
#include <algo/moeoTS.h>
|
||||
#include <algo/moeoVNS.h>
|
||||
#include <algo/moeoSA.h>
|
||||
#include <algo/moeoILS.h>
|
||||
#include <algo/moeoVFAS.h>
|
||||
#include <algo/moeoPopLS.h>
|
||||
#include <algo/moeoUnifiedDominanceBasedLS.h>
|
||||
#include <algo/moeoPLS1.h>
|
||||
#include <algo/moeoPLS2.h>
|
||||
#include <algo/moeoPopAlgo.h>
|
||||
#include <algo/moeoPopLS.h>
|
||||
#include <algo/moeoSEEA.h>
|
||||
#include <algo/moeoSPEA2.h>
|
||||
#include <algo/moeoUnifiedDominanceBasedLS.h>
|
||||
|
||||
#include <archive/moeoArchive.h>
|
||||
#include <archive/moeoArchiveIndex.h>
|
||||
#include <archive/moeoBoundedArchive.h>
|
||||
#include <archive/moeoEpsilonHyperboxArchive.h>
|
||||
#include <archive/moeoFitDivBoundedArchive.h>
|
||||
#include <archive/moeoFixedSizeArchive.h>
|
||||
#include <archive/moeoIndexedArchive.h>
|
||||
#include <archive/moeoImprOnlyBoundedArchive.h>
|
||||
#include <archive/moeoSPEA2Archive.h>
|
||||
#include <archive/moeoUnboundedArchive.h>
|
||||
#include <archive/moeoImprOnlyBoundedArchive.h>
|
||||
#include <archive/moeoFitDivBoundedArchive.h>
|
||||
#include <archive/moeoEpsilonHyperboxArchive.h>
|
||||
#include <archive/moeoQuadTree.h>
|
||||
#include <archive/moeoQuickUnboundedArchiveIndex.h>
|
||||
|
||||
|
||||
#include <comparator/moeoAggregativeComparator.h>
|
||||
#include <comparator/moeoComparator.h>
|
||||
#include <comparator/moeoDiversityThenFitnessComparator.h>
|
||||
#include <comparator/moeoEpsilonObjectiveVectorComparator.h>
|
||||
#include <comparator/moeoFitnessComparator.h>
|
||||
#include <comparator/moeoFitnessThenDiversityComparator.h>
|
||||
#include <comparator/moeoGDominanceObjectiveVectorComparator.h>
|
||||
#include <comparator/moeoObjectiveVectorComparator.h>
|
||||
#include <comparator/moeoObjectiveObjectiveVectorComparator.h>
|
||||
#include <comparator/moeoObjectiveVectorComparator.h>
|
||||
#include <comparator/moeoOneObjectiveComparator.h>
|
||||
#include <comparator/moeoParetoObjectiveVectorComparator.h>
|
||||
#include <comparator/moeoPtrComparator.h>
|
||||
#include <comparator/moeoStrictObjectiveVectorComparator.h>
|
||||
#include <comparator/moeoWeakObjectiveVectorComparator.h>
|
||||
#include <comparator/moeoFitnessComparator.h>
|
||||
|
||||
#include <core/MOEO.h>
|
||||
#include <core/moeoBitVector.h>
|
||||
|
|
@ -104,14 +93,10 @@
|
|||
|
||||
#include <distance/moeoDistance.h>
|
||||
#include <distance/moeoDistanceMatrix.h>
|
||||
#include <distance/moeoObjSpaceDistance.h>
|
||||
#include <distance/moeoEuclideanDistance.h>
|
||||
#include <distance/moeoManhattanDistance.h>
|
||||
#include <distance/moeoNormalizedDistance.h>
|
||||
#include <distance/moeoAchievementScalarizingFunctionDistance.h>
|
||||
#include <distance/moeoAugmentedAchievementScalarizingFunctionDistance.h>
|
||||
#include <distance/moeoAugmentedWeightedChebychevDistance.h>
|
||||
#include <distance/moeoWeightedChebychevDistance.h>
|
||||
#include <distance/moeoObjSpaceDistance.h>
|
||||
|
||||
#include <diversity/moeoCrowdingDiversityAssignment.h>
|
||||
#include <diversity/moeoDiversityAssignment.h>
|
||||
|
|
@ -121,17 +106,14 @@
|
|||
#include <diversity/moeoNearestNeighborDiversityAssignment.h>
|
||||
#include <diversity/moeoSharingDiversityAssignment.h>
|
||||
|
||||
|
||||
#include <explorer/moeoHCMoveLoopExpl.h>
|
||||
#include <explorer/moeoTSMoveLoopExpl.h>
|
||||
#include <explorer/moeoPopNeighborhoodExplorer.h>
|
||||
#include <explorer/moeoExhaustiveNeighborhoodExplorer.h>
|
||||
#include <explorer/moeoFirstImprovingNeighborhoodExplorer.h>
|
||||
#include <explorer/moeoSimpleSubNeighborhoodExplorer.h>
|
||||
#include <explorer/moeoNoDesimprovingNeighborhoodExplorer.h>
|
||||
#include <explorer/moeoPopNeighborhoodExplorer.h>
|
||||
#include <explorer/moeoSimpleSubNeighborhoodExplorer.h>
|
||||
#include <explorer/moeoSubNeighborhoodExplorer.h>
|
||||
|
||||
#include <fitness/moeoAchievementFitnessAssignment.h>
|
||||
|
||||
#include <fitness/moeoAggregationFitnessAssignment.h>
|
||||
#include <fitness/moeoBinaryIndicatorBasedFitnessAssignment.h>
|
||||
#include <fitness/moeoConstraintFitnessAssignment.h>
|
||||
|
|
@ -145,47 +127,80 @@
|
|||
#include <fitness/moeoExpBinaryIndicatorBasedFitnessAssignment.h>
|
||||
#include <fitness/moeoFitnessAssignment.h>
|
||||
#include <fitness/moeoIndicatorBasedFitnessAssignment.h>
|
||||
#include <fitness/moeoReferencePointIndicatorBasedFitnessAssignment.h>
|
||||
#include <fitness/moeoScalarFitnessAssignment.h>
|
||||
#include <fitness/moeoSingleObjectivization.h>
|
||||
#include <fitness/moeoUnaryIndicatorBasedFitnessAssignment.h>
|
||||
#include <fitness/moeoAchievementScalarizingFunctionMetricFitnessAssignment.h>
|
||||
#include <fitness/moeoAugmentedAchievementScalarizingFunctionMetricFitnessAssignment.h>
|
||||
#include <fitness/moeoWeightedChebychevMetricFitnessAssignment.h>
|
||||
#include <fitness/moeoAugmentedWeightedChebychevMetricFitnessAssignment.h>
|
||||
#include <fitness/moeoIncrEvalSingleObjectivizer.h>
|
||||
|
||||
#include <hybridization/moeoDMLSGenUpdater.h>
|
||||
#include <hybridization/moeoDMLSMonOp.h>
|
||||
|
||||
#include <metric/moeoAdditiveEpsilonBinaryMetric.h>
|
||||
#include <metric/moeoContributionMetric.h>
|
||||
#include <metric/moeoDistanceMetric.h>
|
||||
#include <metric/moeoEntropyMetric.h>
|
||||
#include <metric/moeoHypervolumeBinaryMetric.h>
|
||||
#include <metric/moeoHyperVolumeDifferenceMetric.h>
|
||||
#include <metric/moeoHyperVolumeMetric.h>
|
||||
#include <metric/moeoMetric.h>
|
||||
#include <metric/moeoNormalizedSolutionVsSolutionBinaryMetric.h>
|
||||
#include <metric/moeoVecVsVecEpsilonBinaryMetric.h>
|
||||
#include <metric/moeoVecVsVecAdditiveEpsilonBinaryMetric.h>
|
||||
#include <metric/moeoVecVsVecEpsilonBinaryMetric.h>
|
||||
#include <metric/moeoVecVsVecMultiplicativeEpsilonBinaryMetric.h>
|
||||
#include <metric/moeoDistanceMetric.h>
|
||||
|
||||
#include <replacement/moeoElitistReplacement.h>
|
||||
#include <replacement/moeoEnvironmentalReplacement.h>
|
||||
#include <replacement/moeoGenerationalReplacement.h>
|
||||
#include <replacement/moeoReplacement.h>
|
||||
|
||||
#include <scalarStuffs/algo/moeoHC.h>
|
||||
#include <scalarStuffs/algo/moeoILS.h>
|
||||
#include <scalarStuffs/algo/moeoSA.h>
|
||||
#include <scalarStuffs/algo/moeoSolAlgo.h>
|
||||
#include <scalarStuffs/algo/moeoTS.h>
|
||||
#include <scalarStuffs/algo/moeoVFAS.h>
|
||||
#include <scalarStuffs/algo/moeoVNS.h>
|
||||
#include <scalarStuffs/archive/moeoArchiveIndex.h>
|
||||
#include <scalarStuffs/archive/moeoIndexedArchive.h>
|
||||
#include <scalarStuffs/archive/moeoQuadTree.h>
|
||||
#include <scalarStuffs/archive/moeoQuadTreeArchive.h>
|
||||
#include <scalarStuffs/archive/moeoQuickUnboundedArchiveIndex.h>
|
||||
#include <scalarStuffs/distance/moeoAchievementScalarizingFunctionDistance.h>
|
||||
#include <scalarStuffs/distance/moeoAugmentedAchievementScalarizingFunctionDistance.h>
|
||||
#include <scalarStuffs/distance/moeoAugmentedWeightedChebychevDistance.h>
|
||||
#include <scalarStuffs/distance/moeoWeightedChebychevDistance.h>
|
||||
#include <scalarStuffs/explorer/moeoHCMoveLoopExpl.h>
|
||||
#include <scalarStuffs/explorer/moeoTSMoveLoopExpl.h>
|
||||
#include <scalarStuffs/fitness/moeoAchievementFitnessAssignment.h>
|
||||
#include <scalarStuffs/fitness/moeoAchievementScalarizingFunctionMetricFitnessAssignment.h>
|
||||
#include <scalarStuffs/fitness/moeoAugmentedAchievementScalarizingFunctionMetricFitnessAssignment.h>
|
||||
#include <scalarStuffs/fitness/moeoAugmentedWeightedChebychevMetricFitnessAssignment.h>
|
||||
#include <scalarStuffs/fitness/moeoIncrEvalSingleObjectivizer.h>
|
||||
#include <scalarStuffs/fitness/moeoMetricFitnessAssignment.h>
|
||||
#include <scalarStuffs/fitness/moeoSingleObjectivization.h>
|
||||
#include <scalarStuffs/fitness/moeoWeightedChebychevMetricFitnessAssignment.h>
|
||||
#include <scalarStuffs/weighting/moeoAnytimeWeightStrategy.h>
|
||||
#include <scalarStuffs/weighting/moeoAugmentedQexploreWeightStrategy.h>
|
||||
#include <scalarStuffs/weighting/moeoDichoWeightStrategy.h>
|
||||
#include <scalarStuffs/weighting/moeoDummyRefPointStrategy.h>
|
||||
#include <scalarStuffs/weighting/moeoDummyWeightStrategy.h>
|
||||
#include <scalarStuffs/weighting/moeoFixedTimeBothDirectionWeightStrategy.h>
|
||||
#include <scalarStuffs/weighting/moeoFixedTimeOneDirectionWeightStrategy.h>
|
||||
#include <scalarStuffs/weighting/moeoQexploreWeightStrategy.h>
|
||||
#include <scalarStuffs/weighting/moeoRandWeightStrategy.h>
|
||||
#include <scalarStuffs/weighting/moeoVariableRefPointStrategy.h>
|
||||
#include <scalarStuffs/weighting/moeoVariableWeightStrategy.h>
|
||||
|
||||
#include <selection/moeoDetArchiveSelect.h>
|
||||
#include <selection/moeoDetTournamentSelect.h>
|
||||
#include <selection/moeoExhaustiveUnvisitedSelect.h>
|
||||
#include <selection/moeoNumberUnvisitedSelect.h>
|
||||
#include <selection/moeoRandomSelect.h>
|
||||
#include <selection/moeoRouletteSelect.h>
|
||||
#include <selection/moeoSelectFromPopAndArch.h>
|
||||
#include <selection/moeoSelectOne.h>
|
||||
#include <selection/moeoSelectors.h>
|
||||
#include <selection/moeoStochTournamentSelect.h>
|
||||
#include <selection/moeoDetArchiveSelect.h>
|
||||
#include <selection/moeoUnvisitedSelect.h>
|
||||
#include <selection/moeoExhaustiveUnvisitedSelect.h>
|
||||
#include <selection/moeoNumberUnvisitedSelect.h>
|
||||
|
||||
#include <utils/moeoArchiveObjectiveVectorSavingUpdater.h>
|
||||
#include <utils/moeoArchiveUpdater.h>
|
||||
|
|
@ -194,19 +209,7 @@
|
|||
#include <utils/moeoBinaryMetricSavingUpdater.h>
|
||||
#include <utils/moeoConvertPopToObjectiveVectors.h>
|
||||
#include <utils/moeoDominanceMatrix.h>
|
||||
#include <utils/moeoObjectiveVectorNormalizer.h>
|
||||
#include <utils/moeoObjVecStat.h>
|
||||
#include <utils/moeoAnytimeWeightStrategy.h>
|
||||
#include <utils/moeoDummyRefPointStrategy.h>
|
||||
#include <utils/moeoDummyWeightStrategy.h>
|
||||
#include <utils/moeoRandWeightStrategy.h>
|
||||
#include <utils/moeoVariableWeightStrategy.h>
|
||||
#include <utils/moeoVariableRefPointStrategy.h>
|
||||
#include <utils/moeoQexploreWeightStrategy.h>
|
||||
#include <utils/moeoAugmentedQexploreWeightStrategy.h>
|
||||
#include <utils/moeoFixedTimeOneDirectionWeightStrategy.h>
|
||||
#include <utils/moeoFixedTimeBothDirectionWeightStrategy.h>
|
||||
#include <utils/moeoDichoWeightStrategy.h>
|
||||
|
||||
|
||||
|
||||
#endif /*MOEO_*/
|
||||
|
|
|
|||
99
trunk/paradiseo-moeo/src/scalarStuffs/algo/moeoHC.h
Normal file
99
trunk/paradiseo-moeo/src/scalarStuffs/algo/moeoHC.h
Normal file
|
|
@ -0,0 +1,99 @@
|
|||
/*
|
||||
<moeoHC.h>
|
||||
Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2008
|
||||
(C) OPAC Team, LIFL, 2002-2008
|
||||
|
||||
Sébastien Cahon, Jean-Charles Boisson (Jean-Charles.Boisson@lifl.fr)
|
||||
François Legillon
|
||||
|
||||
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 __moeoHC_h
|
||||
#define __moeoHC_h
|
||||
#include <scalarStuffs/explorer/moeoHCMoveLoopExpl.h>
|
||||
#include <scalarStuffs/fitness/moeoSingleObjectivization.h>
|
||||
#include <scalarStuffs/fitness/moeoIncrEvalSingleObjectivizer.h>
|
||||
#include <scalarStuffs/algo/moeoSolAlgo.h>
|
||||
#include <moHC.h>
|
||||
//! Hill Climbing (HC)
|
||||
/*!
|
||||
Class which describes the algorithm for a hill climbing.
|
||||
Adapts the moHC for a multi-objective problem using a moeoSingleObjectivization.
|
||||
M is for Move
|
||||
*/
|
||||
template <class M>
|
||||
class moeoHC : public moeoSolAlgo < typename M::EOType >
|
||||
{
|
||||
|
||||
public:
|
||||
typedef typename M::EOType MOEOT;
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
typedef typename MOEOT::Fitness Fitness;
|
||||
|
||||
//! Full constructor.
|
||||
/*!
|
||||
All the boxes are given in order the HC to use a moHCMoveLoopExpl.
|
||||
|
||||
\param _move_initializer a move initialiser.
|
||||
\param _next_move_generator a neighborhood explorer.
|
||||
\param _incremental_evaluation a (generally) efficient evaluation function.
|
||||
\param _move_selection a move selector.
|
||||
\param _singler a singleObjectivizer to translate objectiveVectors into fitness
|
||||
*/
|
||||
moeoHC (moMoveInit < M > & _move_initializer, moNextMove < M > & _next_move_generator,
|
||||
moMoveIncrEval < M,ObjectiveVector > & _incremental_evaluation, moMoveSelect < M > & _move_selection, moeoSingleObjectivization < MOEOT > & _singler) :
|
||||
incrEval((new moeoIncrEvalSingleObjectivizer<MOEOT,M>(_singler,_incremental_evaluation))),
|
||||
moveLoop(new moeoHCMoveLoopExpl<M>(_move_initializer,_next_move_generator,*(incrEval),_move_selection)),
|
||||
algo(*(moveLoop), (_singler))
|
||||
{}
|
||||
//! Function which launches the HC
|
||||
/*!
|
||||
The HC has to improve a current solution.
|
||||
As the moSA and the mo TS, it can be used for HYBRIDATION in an evolutionnary algorithm.
|
||||
|
||||
\param _solution a current solution to improve.
|
||||
\return true.
|
||||
*/
|
||||
|
||||
bool operator()(MOEOT &_solution){
|
||||
if (_solution.invalidObjectiveVector()) {
|
||||
(*incrEval)(_solution);
|
||||
}else{
|
||||
}
|
||||
return algo(_solution);
|
||||
}
|
||||
|
||||
private:
|
||||
moeoIncrEvalSingleObjectivizer<MOEOT,M> *incrEval;
|
||||
moeoHCMoveLoopExpl<M> *moveLoop;
|
||||
//! the actual algo
|
||||
moHC<M> algo;
|
||||
|
||||
};
|
||||
#endif
|
||||
156
trunk/paradiseo-moeo/src/scalarStuffs/algo/moeoILS.h
Normal file
156
trunk/paradiseo-moeo/src/scalarStuffs/algo/moeoILS.h
Normal file
|
|
@ -0,0 +1,156 @@
|
|||
/*
|
||||
<moeoILS.h>
|
||||
Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2008
|
||||
(C) OPAC Team, LIFL, 2002-2008
|
||||
|
||||
Sébastien Cahon, Jean-Charles Boisson (Jean-Charles.Boisson@lifl.fr)
|
||||
François Legillon
|
||||
|
||||
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 _moeoILS_h
|
||||
#define _moeoILS_h
|
||||
|
||||
#include <moComparator.h>
|
||||
#include <moILS.h>
|
||||
|
||||
|
||||
#include <scalarStuffs/algo/moeoHC.h>
|
||||
#include <scalarStuffs/algo/moeoTS.h>
|
||||
#include <scalarStuffs/algo/moeoSA.h>
|
||||
#include <eoEvalFunc.h>
|
||||
#include <scalarStuffs/algo/moeoSolAlgo.h>
|
||||
#include <moHCMoveLoopExpl.h>
|
||||
#include <scalarStuffs/fitness/moeoSingleObjectivization.h>
|
||||
#include <scalarStuffs/explorer/moeoHCMoveLoopExpl.h>
|
||||
|
||||
//! Iterated Local Search (ILS)
|
||||
/*!
|
||||
Class which describes the algorithm for a iterated local search.
|
||||
Adapts the moILS for a multi-objective problem using a moeoSingleObjectivization.
|
||||
M is for Move
|
||||
*/
|
||||
|
||||
template < class M >
|
||||
class moeoILS:public moeoSolAlgo < typename M::EOType >
|
||||
{
|
||||
|
||||
public:
|
||||
typedef typename M::EOType MOEOT;
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
typedef typename MOEOT::Fitness Fitness;
|
||||
//! Generic constructor
|
||||
/*!
|
||||
Generic constructor using a moAlgo
|
||||
|
||||
\param _algorithm The solution based heuristic to use.
|
||||
\param _continue The stopping criterion.
|
||||
\param _acceptance_criterion The acceptance criterion.
|
||||
\param _perturbation The pertubation generator.
|
||||
\param _full_evaluation The evaluation function.
|
||||
*/
|
||||
moeoILS (moeoSolAlgo<MOEOT> & _algorithm, moSolContinue <MOEOT> & _continue, moComparator<MOEOT> & _acceptance_criterion,
|
||||
eoMonOp<MOEOT> & _perturbation, moeoSingleObjectivization<MOEOT> & _full_evaluation):
|
||||
algo(_algorithm,_continue,_acceptance_criterion,_perturbation,_full_evaluation)
|
||||
{}
|
||||
//! Constructor for using a moHC
|
||||
/*!
|
||||
\param _move_initializer The move initialisation (for the moHC).
|
||||
\param _next_move_generator The move generator (for the moHC).
|
||||
\param _incremental_evaluation The partial evaluation function (for the moHC).
|
||||
\param _singler a singleObjectivizer to translate objectiveVectors into fitness
|
||||
\param _move_selection The move selection strategy (for the moHC).
|
||||
\param _continue The stopping criterion.
|
||||
\param _acceptance_criterion The acceptance criterion.
|
||||
\param _perturbation The pertubation generator.
|
||||
*/
|
||||
moeoILS (moMoveInit < M > & _move_initializer, moNextMove < M > & _next_move_generator,
|
||||
moMoveIncrEval < M,ObjectiveVector > & _incremental_evaluation, moeoSingleObjectivization<MOEOT> &_singler,moMoveSelect < M > & _move_selection,
|
||||
moSolContinue <MOEOT> & _continue, moComparator<MOEOT> & _acceptance_criterion,
|
||||
eoMonOp<MOEOT> & _perturbation):
|
||||
subAlgo(new moeoHC<M>(_move_initializer,_next_move_generator,_incremental_evaluation,_move_selection,_singler)),
|
||||
algo(*subAlgo,_continue,_acceptance_criterion,_perturbation,_singler)
|
||||
{}
|
||||
//! Constructor for using a moTS for the moAlgo
|
||||
/*!
|
||||
\param _move_initializer The move initialisation (for the moTS).
|
||||
\param _next_move_generator The move generator (for the moTS).
|
||||
\param _incremental_evaluation The partial evaluation function (for the moTS).
|
||||
\param _singler a singleObjectivizer to translate objectiveVectors into fitness
|
||||
\param _tabu_list The tabu list (for the moTS !!!!).
|
||||
\param _aspiration_criterion The aspiration criterion (for the moTS).
|
||||
\param _moTS_continue The stopping criterion (for the moTS).
|
||||
\param _continue The stopping criterion.
|
||||
\param _acceptance_criterion The acceptance criterion.
|
||||
\param _perturbation The pertubation generator.
|
||||
*/
|
||||
|
||||
moeoILS (moMoveInit <M> & _move_initializer, moNextMove <M> & _next_move_generator,moMoveIncrEval <M,ObjectiveVector> & _incremental_evaluation, moeoSingleObjectivization<MOEOT> &_singler, moTabuList <M> & _tabu_list,moAspirCrit <M> & _aspiration_criterion, moSolContinue <MOEOT> & _moTS_continue,moSolContinue <MOEOT> & _continue, moComparator<MOEOT> & _acceptance_criterion, eoMonOp<MOEOT> & _perturbation):
|
||||
subAlgo(new moeoTS<M>(_move_initializer,_next_move_generator,_incremental_evaluation,_tabu_list,_aspiration_criterion,_moTS_continue,_singler)),
|
||||
algo((*subAlgo),_continue,_acceptance_criterion,_perturbation,_singler)
|
||||
{}
|
||||
//! Constructor for using a moSA for the moAlgo
|
||||
/*!
|
||||
\param _random_move_generator The random move generator (for the moSA).
|
||||
\param _incremental_evaluation The partial evaluation function (for the moSA).
|
||||
\param _singler a singleObjectivizer to translate objectiveVectors into fitness
|
||||
\param _moSA_continue The stopping criterion (for the moSA).
|
||||
\param _initial_temperature The initial temperature (for the moSA).
|
||||
\param _cooling_schedule The cooling schedule (for the moSA).
|
||||
\param _continue The stopping criterion.
|
||||
\param _acceptance_criterion The acceptance criterion.
|
||||
\param _perturbation The pertubation generator.
|
||||
*/
|
||||
moeoILS (moRandMove<M> & _random_move_generator, moMoveIncrEval <M,ObjectiveVector> & _incremental_evaluation,moeoSingleObjectivization<MOEOT> &_singler, moSolContinue <MOEOT> & _moSA_continue,double _initial_temperature, moCoolingSchedule & _cooling_schedule, moSolContinue <MOEOT> & _continue,moComparator<MOEOT> & _acceptance_criterion, eoMonOp<MOEOT> & _perturbation):
|
||||
subAlgo(new moeoSA<M>(_random_move_generator, _incremental_evaluation, _moSA_continue, _initial_temperature,_cooling_schedule, _singler)),
|
||||
algo(*subAlgo,_continue, _acceptance_criterion, _perturbation, _singler)
|
||||
{}
|
||||
|
||||
|
||||
|
||||
//! Function which launches the ILS
|
||||
/*!
|
||||
The ILS has to improve a current solution.
|
||||
|
||||
\param _solution a current solution to improve.
|
||||
\return true.
|
||||
*/
|
||||
bool operator()(MOEOT &_solution){
|
||||
// std::cout<<"moeoILS"<<std::endl;
|
||||
return algo(_solution);
|
||||
}
|
||||
|
||||
private:
|
||||
moeoSolAlgo<MOEOT> *subAlgo;
|
||||
//! the actual algo
|
||||
moILS<M> algo;
|
||||
|
||||
|
||||
};
|
||||
#endif
|
||||
85
trunk/paradiseo-moeo/src/scalarStuffs/algo/moeoSA.h
Normal file
85
trunk/paradiseo-moeo/src/scalarStuffs/algo/moeoSA.h
Normal file
|
|
@ -0,0 +1,85 @@
|
|||
/*
|
||||
<moeoSA.h>
|
||||
Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2008
|
||||
(C) OPAC Team, LIFL, 2002-2008
|
||||
|
||||
Sébastien Cahon, Jean-Charles Boisson (Jean-Charles.Boisson@lifl.fr)
|
||||
François Legillon
|
||||
|
||||
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 __moeoSA_h
|
||||
#define __moeoSA_h
|
||||
|
||||
#include <eoEvalFunc.h>
|
||||
#include <scalarStuffs/algo/moeoSolAlgo.h>
|
||||
#include <moTSMoveLoopExpl.h>
|
||||
#include <scalarStuffs/fitness/moeoSingleObjectivization.h>
|
||||
#include <scalarStuffs/explorer/moeoTSMoveLoopExpl.h>
|
||||
#include <moSA.h>
|
||||
//! Simulated annealing (SA)
|
||||
/*!
|
||||
Generic algorithm that describes a Simulated Annealing algorithm.
|
||||
Adapts the moSA for a multi-objective problem using a moeoSingleObjectivization.
|
||||
M is for Move
|
||||
*/
|
||||
|
||||
template < class M >
|
||||
class moeoSA:public moeoSolAlgo < typename M::EOType >
|
||||
{
|
||||
|
||||
public:
|
||||
|
||||
typedef typename M::EOType MOEOT;
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
typedef typename MOEOT::Fitness Fitness;
|
||||
moeoSA (moRandMove < M > & _random_move_generator, moMoveIncrEval < M,ObjectiveVector > & _incremental_evaluation,
|
||||
moSolContinue < MOEOT > & _continue, double _initial_temperature, moCoolingSchedule & _cooling_schedule,
|
||||
moeoSingleObjectivization<MOEOT> &_singler):
|
||||
incrEval(_singler,_incremental_evaluation),
|
||||
algo(_random_move_generator,incrEval,_continue,_initial_temperature,_cooling_schedule, _singler)
|
||||
{}
|
||||
/*!
|
||||
Algorithm of the SA
|
||||
As a moHC, it can be used for HYBRIDATION in an evolutionary algorithm.
|
||||
|
||||
\param _solution a solution to improve.
|
||||
\return TRUE.
|
||||
*/
|
||||
bool operator()(MOEOT &_solution){
|
||||
return algo(_solution);
|
||||
}
|
||||
|
||||
private:
|
||||
moeoIncrEvalSingleObjectivizer<MOEOT,M> incrEval;
|
||||
//! the actual algo
|
||||
moSA<M> algo;
|
||||
|
||||
};
|
||||
#endif
|
||||
55
trunk/paradiseo-moeo/src/scalarStuffs/algo/moeoSolAlgo.h
Executable file
55
trunk/paradiseo-moeo/src/scalarStuffs/algo/moeoSolAlgo.h
Executable file
|
|
@ -0,0 +1,55 @@
|
|||
/*
|
||||
* <moeoSolAlgo.h>
|
||||
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
|
||||
* (C) OPAC Team, LIFL, 2002-2007
|
||||
*
|
||||
* Arnaud Liefooghe
|
||||
* Jérémie Humeau
|
||||
* François Legillon
|
||||
*
|
||||
* 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 MOEOSOLALGO_H_
|
||||
#define MOEOSOLALGO_H_
|
||||
|
||||
#include <eoAlgo.h>
|
||||
#include <algo/moeoAlgo.h>
|
||||
#include <moAlgo.h>
|
||||
|
||||
/**
|
||||
* Abstract class for Solution based multi-objective evolutionary algorithms.
|
||||
*/
|
||||
template < class MOEOT >
|
||||
class moeoSolAlgo : public moAlgo<MOEOT>, public moeoAlgo
|
||||
{
|
||||
};
|
||||
|
||||
#endif /*MOEOSOLALGO_H_*/
|
||||
102
trunk/paradiseo-moeo/src/scalarStuffs/algo/moeoTS.h
Normal file
102
trunk/paradiseo-moeo/src/scalarStuffs/algo/moeoTS.h
Normal file
|
|
@ -0,0 +1,102 @@
|
|||
/*
|
||||
<moeoTS.h>
|
||||
Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2008
|
||||
(C) OPAC Team, LIFL, 2002-2008
|
||||
|
||||
Sébastien Cahon, Jean-Charles Boisson (Jean-Charles.Boisson@lifl.fr)
|
||||
François Legillon
|
||||
|
||||
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 __moeoTS_h
|
||||
#define __moeoTS_h
|
||||
|
||||
#include <moTS.h>
|
||||
#include <eoEvalFunc.h>
|
||||
#include <scalarStuffs/algo/moeoSolAlgo.h>
|
||||
#include <scalarStuffs/fitness/moeoSingleObjectivization.h>
|
||||
#include <scalarStuffs/explorer/moeoTSMoveLoopExpl.h>
|
||||
//! Tabu Search (TS)
|
||||
/*!
|
||||
Generic algorithm that describes a tabu search.
|
||||
Adapts the moTS for a multi-objective problem using a moeoSingleObjectivization.
|
||||
M is for Move
|
||||
*/
|
||||
|
||||
template < class M >
|
||||
class moeoTS:public moeoSolAlgo < typename M::EOType >
|
||||
{
|
||||
|
||||
public:
|
||||
typedef typename M::EOType MOEOT;
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
typedef typename MOEOT::Fitness Fitness;
|
||||
|
||||
//! Full constructor.
|
||||
/*!
|
||||
All the boxes are given in order the TS to use a moTSMoveLoopExpl.
|
||||
|
||||
\param _move_initializer a move initialiser.
|
||||
\param _next_move_generator a neighborhood explorer.
|
||||
\param _incremental_evaluation a (generally) efficient evaluation function.
|
||||
\param _tabu_list The tabu list.
|
||||
\param _aspiration_criterion An aspiration criterion.
|
||||
\param _continue The stopping criterion.
|
||||
\param _singler a singleObjectivizer to translate objectiveVectors into fitness
|
||||
*/
|
||||
moeoTS (moMoveInit < M > & _move_initializer, moNextMove < M > & _next_move_generator,
|
||||
moMoveIncrEval < M, typename MOEOT::ObjectiveVector > & _incremental_evaluation, moTabuList < M > & _tabu_list,
|
||||
moAspirCrit < M > & _aspiration_criterion, moSolContinue < MOEOT > & _continue,
|
||||
moeoSingleObjectivization<MOEOT> &_singler):
|
||||
incrEval(_singler,_incremental_evaluation),
|
||||
moveLoop(_move_initializer,_next_move_generator,incrEval,_tabu_list,_aspiration_criterion),
|
||||
algo(moveLoop,_continue,_singler)
|
||||
{}
|
||||
|
||||
//! Function which launchs the Tabu Search
|
||||
/*!
|
||||
Algorithm of the tabu search.
|
||||
As a moSA or a moHC, it can be used for HYBRIDATION in an evolutionary algorithm.
|
||||
For security a lock (pthread_mutex_t) is closed during the algorithm.
|
||||
|
||||
\param _solution a solution to improve.
|
||||
\return TRUE.
|
||||
*/
|
||||
bool operator()(MOEOT &_solution){
|
||||
return algo(_solution);
|
||||
}
|
||||
|
||||
private:
|
||||
moeoIncrEvalSingleObjectivizer<MOEOT,M> incrEval;
|
||||
moeoTSMoveLoopExpl<M> moveLoop;
|
||||
//! the actual algo
|
||||
moTS<M> algo;
|
||||
|
||||
};
|
||||
#endif
|
||||
160
trunk/paradiseo-moeo/src/scalarStuffs/algo/moeoVFAS.h
Normal file
160
trunk/paradiseo-moeo/src/scalarStuffs/algo/moeoVFAS.h
Normal file
|
|
@ -0,0 +1,160 @@
|
|||
/*
|
||||
<moeoVFAS.h>
|
||||
Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2008
|
||||
(C) OPAC Team, LIFL, 2002-2008
|
||||
|
||||
Sébastien Cahon, Jean-Charles Boisson (Jean-Charles.Boisson@lifl.fr)
|
||||
François Legillon
|
||||
|
||||
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 _moeoVFAS_h
|
||||
#define _moeoVFAS_h
|
||||
|
||||
#include <moComparator.h>
|
||||
|
||||
#include <eoEvalFunc.h>
|
||||
#include <scalarStuffs/algo/moeoSolAlgo.h>
|
||||
#include <scalarStuffs/fitness/moeoSingleObjectivization.h>
|
||||
#include <fitness/moeoAggregationFitnessAssignment.h>
|
||||
#include <scalarStuffs/explorer/moeoHCMoveLoopExpl.h>
|
||||
#include <scalarStuffs/weighting/moeoVariableWeightStrategy.h>
|
||||
#include <scalarStuffs/weighting/moeoVariableRefPointStrategy.h>
|
||||
#include <scalarStuffs/weighting/moeoDummyWeightStrategy.h>
|
||||
#include <scalarStuffs/weighting/moeoDummyRefPointStrategy.h>
|
||||
//! Variable fitness assignment search (vfas)
|
||||
/*!
|
||||
Search using multiple fitness assignment to search solution to a multi objective problem
|
||||
*/
|
||||
|
||||
template < class M >
|
||||
class moeoVFAS:public moeoPopAlgo < typename M::EOType >
|
||||
{
|
||||
|
||||
public:
|
||||
typedef typename M::EOType MOEOT;
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
typedef typename MOEOT::Fitness Fitness;
|
||||
/**
|
||||
* constructor using a moAlgo and a vector of weight
|
||||
* take a base vector of weight, and modify it to relaunch the algo with a diferent fitness
|
||||
* use a selectOne to determine which moeot should be the base for the algo launch
|
||||
* use a eoPop to keep result from each iteration
|
||||
* @param _algorithm The solution based heuristic to use. It should at least use the fitness value at some point.
|
||||
* @param _continue The stopping criterion.
|
||||
* @param _select a selector to choose on which moeot we use the algorithm
|
||||
* @param _weights a vector containing the base weights, which will be changed at each iteration.
|
||||
* @param _eval The evaluation function.
|
||||
* @param _wstrat the strategy to change weights (should be constructed with the same weights as the fitness)
|
||||
*/
|
||||
moeoVFAS (moeoSolAlgo<MOEOT> & _algorithm, eoContinue <MOEOT> & _continue,moeoSelectOne<MOEOT> &_select,
|
||||
std::vector<double> &_weights, eoEvalFunc< MOEOT > &_eval , moeoVariableWeightStrategy<MOEOT> &_wstrat ):
|
||||
algo(_algorithm),cont(_continue), select(_select), weights(_weights),eval(_eval),refPoint(defaultRefPoint), wstrat(_wstrat), rstrat(defaultRstrat)
|
||||
{}
|
||||
|
||||
/**
|
||||
* constructor using a moAlgo an ObjectiveVector and a vector of weight
|
||||
* take a base vector of weight, and modify it to relaunch the algo with a diferent fitness
|
||||
* use a selectOne to determine which moeot should be the base for the algo launch
|
||||
* use a eoPop to keep result from each iteration
|
||||
* @param _algorithm The solution based heuristic to use. It should at least use the fitness value at some point.
|
||||
* @param _continue The stopping criterion.
|
||||
* @param _select a selector to choose on which moeot we use the algorithm
|
||||
* @param _weights a vector containing the base weights, which will be changed at each iteration.
|
||||
* @param _refPoint a reference point changed at each iteration
|
||||
* @param _eval The evaluation function.
|
||||
* @param _wstrat the strategy to change weights (should be constructed with the same weights as the fitness)
|
||||
* @param _rstrat the strategy to change the reference point
|
||||
*/
|
||||
moeoVFAS (moeoSolAlgo<MOEOT> & _algorithm, eoContinue <MOEOT> & _continue,moeoSelectOne<MOEOT> &_select,
|
||||
std::vector<double> &_weights, ObjectiveVector &_refPoint, eoEvalFunc< MOEOT > &_eval , moeoVariableWeightStrategy<MOEOT> &_wstrat , moeoVariableRefPointStrategy<MOEOT>& _rstrat):
|
||||
algo(_algorithm),cont(_continue), select(_select), weights(_weights),eval(_eval),refPoint(_refPoint),wstrat(_wstrat), rstrat(_rstrat)
|
||||
{}
|
||||
|
||||
/**
|
||||
* constructor without the weights
|
||||
* @param _algorithm The solution based heuristic to use. It should at least use the fitness value at some point.
|
||||
* @param _continue The stopping criterion.
|
||||
* @param _select a selector to choose on which moeot we use the algorithm
|
||||
* @param _eval The evaluation function.
|
||||
* @param _wstrat the strategy to change weights (should be constructed with the same weights as the fitness)
|
||||
*/
|
||||
moeoVFAS (moeoSolAlgo<MOEOT> & _algorithm, eoContinue <MOEOT> & _continue,moeoSelectOne<MOEOT> &_select,
|
||||
eoEvalFunc< MOEOT > &_eval, moeoVariableWeightStrategy<MOEOT> &_wstrat):
|
||||
algo(_algorithm),cont(_continue), select(_select), weights(defaultWeights), eval(_eval), refPoint(defaultRefPoint), wstrat(defaultWstrat), rstrat(defaultRstrat)
|
||||
{
|
||||
weights.resize(MOEOT::ObjectiveVector::nObjectives(),1.0/MOEOT::ObjectiveVector::nObjectives());
|
||||
}
|
||||
/**
|
||||
* launch the algorithm
|
||||
* @param _pop the initial population on which algo will be launched
|
||||
**/
|
||||
virtual void operator()(eoPop<MOEOT> &_pop){
|
||||
uniform_generator<double> rngGen(0.0,1.0);
|
||||
for (unsigned int i=0;i<_pop.size();i++){
|
||||
if (_pop[i].invalidObjectiveVector())
|
||||
eval(_pop[i]);
|
||||
}
|
||||
moeoObjectiveVectorNormalizer<MOEOT> norm(_pop);
|
||||
moeoAggregationFitnessAssignment<MOEOT> fitness(weights,eval);
|
||||
bool res=false;
|
||||
fitness(_pop);
|
||||
MOEOT moeot(select(_pop));
|
||||
wstrat(weights,moeot);
|
||||
rstrat(refPoint,moeot);
|
||||
|
||||
do {
|
||||
norm.update_by_pop(_pop);
|
||||
fitness(_pop);
|
||||
moeot=(select(_pop));
|
||||
res=algo(moeot)||res;
|
||||
_pop.push_back(moeot);
|
||||
std::cout<<moeot.objectiveVector()<<std::endl;
|
||||
wstrat(weights,moeot);
|
||||
rstrat(refPoint,moeot);
|
||||
}while(cont(_pop));
|
||||
}
|
||||
|
||||
private:
|
||||
moeoSolAlgo<MOEOT> &algo;
|
||||
eoContinue<MOEOT> &cont;
|
||||
moeoSelectOne<MOEOT> &select;
|
||||
std::vector<double> &weights;
|
||||
std::vector<double> defaultWeights;
|
||||
eoEvalFunc<MOEOT> &eval;
|
||||
ObjectiveVector &refPoint;
|
||||
ObjectiveVector defaultRefPoint;
|
||||
moeoVariableWeightStrategy<MOEOT> &wstrat;
|
||||
moeoVariableRefPointStrategy<MOEOT> &rstrat;
|
||||
moeoDummyRefPointStrategy<MOEOT> defaultRstrat;
|
||||
moeoDummyWeightStrategy<MOEOT> defaultWstrat;
|
||||
|
||||
|
||||
};
|
||||
#endif
|
||||
86
trunk/paradiseo-moeo/src/scalarStuffs/algo/moeoVNS.h
Normal file
86
trunk/paradiseo-moeo/src/scalarStuffs/algo/moeoVNS.h
Normal file
|
|
@ -0,0 +1,86 @@
|
|||
/*
|
||||
<moeoVNS.h>
|
||||
Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2008
|
||||
(C) OPAC Team, LIFL, 2002-2008
|
||||
|
||||
Sébastien Cahon, Jean-Charles Boisson (Jean-Charles.Boisson@lifl.fr)
|
||||
François Legillon
|
||||
|
||||
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 _moeoVNS_h
|
||||
#define _moeoVNS_h
|
||||
|
||||
#include <moAlgo.h>
|
||||
#include <eoEvalFunc.h>
|
||||
#include <scalarStuffs/algo/moeoSolAlgo.h>
|
||||
#include <moHCMoveLoopExpl.h>
|
||||
#include <scalarStuffs/fitness/moeoSingleObjectivization.h>
|
||||
#include <scalarStuffs/explorer/moeoHCMoveLoopExpl.h>
|
||||
//! Variable Neighbors Search (VNS)
|
||||
/*!
|
||||
Class which describes the algorithm for a Variable Neighbors Search.
|
||||
Adapts the moVNS for a multi-objective problem using a moeoSingleObjectivization.
|
||||
M is for Move
|
||||
*/
|
||||
|
||||
template < class MOEOT >
|
||||
class moeoVNS:public moeoSolAlgo < MOEOT >
|
||||
{
|
||||
|
||||
public:
|
||||
// typedef typename M::EOType MOEOT;
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
typedef typename MOEOT::Fitness Fitness;
|
||||
//! Generic constructor
|
||||
/*!
|
||||
Generic constructor using a moExpl
|
||||
|
||||
\param _explorer Vector of Neighborhoods.
|
||||
\param _full_evaluation The singleObjectivization containing a full eval.
|
||||
*/
|
||||
moeoVNS(moExpl< MOEOT> & _explorer, moeoSingleObjectivization < MOEOT> & _full_evaluation): algo(_explorer,_full_evaluation) {}
|
||||
|
||||
//! Function which launches the VNS
|
||||
/*!
|
||||
The VNS has to improve a current solution.
|
||||
|
||||
\param _solution a current solution to improve.
|
||||
\return true.
|
||||
*/
|
||||
bool operator()(MOEOT &_solution){
|
||||
return algo(_solution);
|
||||
}
|
||||
|
||||
private:
|
||||
//! the actual algo
|
||||
moVNS<MOEOT> algo;
|
||||
|
||||
};
|
||||
#endif
|
||||
83
trunk/paradiseo-moeo/src/scalarStuffs/archive/moeoArchiveIndex.h
Executable file
83
trunk/paradiseo-moeo/src/scalarStuffs/archive/moeoArchiveIndex.h
Executable file
|
|
@ -0,0 +1,83 @@
|
|||
#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/scalarStuffs/archive/moeoIndexedArchive.h
Executable file
110
trunk/paradiseo-moeo/src/scalarStuffs/archive/moeoIndexedArchive.h
Executable file
|
|
@ -0,0 +1,110 @@
|
|||
#ifndef MOEOINDEXEDARCHIVE_H_
|
||||
#define MOEOINDEXEDARCHIVE_H_
|
||||
|
||||
#include <eoPop.h>
|
||||
#include <archive/moeoArchive.h>
|
||||
#include <scalarStuffs/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/scalarStuffs/archive/moeoQuadTree.h
Executable file
527
trunk/paradiseo-moeo/src/scalarStuffs/archive/moeoQuadTree.h
Executable file
|
|
@ -0,0 +1,527 @@
|
|||
/*
|
||||
* <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 <scalarStuffs/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_*/
|
||||
|
|
@ -0,0 +1,103 @@
|
|||
/*
|
||||
* <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;
|
||||
|
||||
|
||||
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/scalarStuffs/archive/moeoQuickUnboundedArchiveIndex.h
Executable file
235
trunk/paradiseo-moeo/src/scalarStuffs/archive/moeoQuickUnboundedArchiveIndex.h
Executable file
|
|
@ -0,0 +1,235 @@
|
|||
#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_*/
|
||||
|
|
@ -0,0 +1,109 @@
|
|||
/*
|
||||
* <moeoAchievementScalarizingFunctionDistance.h>
|
||||
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
|
||||
* (C) OPAC Team, LIFL, 2002-2007
|
||||
*
|
||||
* Jeremie Humeau
|
||||
* Arnaud Liefooghe
|
||||
* François Legillon
|
||||
*
|
||||
* 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 MOEOASFADIST_H_
|
||||
#define MOEOASFADIST_H_
|
||||
|
||||
#include <utils/moeoObjectiveVectorNormalizer.h>
|
||||
|
||||
/**
|
||||
Achievment scalarizing function aproach to calculate a distance
|
||||
*/
|
||||
template < class MOEOT>
|
||||
class moeoAchievementScalarizingFunctionDistance : public moeoObjSpaceDistance< MOEOT >
|
||||
{
|
||||
public:
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
typedef typename MOEOT::Fitness Fitness;
|
||||
|
||||
/**
|
||||
constructor with a normalizer
|
||||
@param _rho
|
||||
@param _weight the weight to apply to each dimension
|
||||
@param _normalizer the normalizer
|
||||
*/
|
||||
moeoAchievementScalarizingFunctionDistance(unsigned int _rho, const ObjectiveVector& _weight, moeoObjectiveVectorNormalizer<MOEOT>& _normalizer): normalizer(_normalizer), weight(_weight), rho(_rho){}
|
||||
|
||||
/**
|
||||
constructor without a normalizer
|
||||
@param _rho
|
||||
@param _weight the weight to apply to each dimension
|
||||
*/
|
||||
moeoAchievementScalarizingFunctionDistance(unsigned int _rho, const ObjectiveVector& _weight): normalizer(defaultNormalizer), weight(_weight), rho(_rho){}
|
||||
|
||||
/**
|
||||
fonction which calculate the distance
|
||||
@param _obj the point to evaluate
|
||||
@param _reference the reference to calculate the distance from
|
||||
@return the fitness conrresponding to the distance
|
||||
*/
|
||||
const Fitness operator()(const ObjectiveVector& _reference, const ObjectiveVector& _obj){
|
||||
unsigned int dim=_obj.size();
|
||||
ObjectiveVector tmp1(_reference);
|
||||
ObjectiveVector tmp2(_obj);
|
||||
Fitness max=iteration(tmp2,tmp1,0,_obj.minimizing(0));
|
||||
Fitness res=max;
|
||||
for (unsigned i=0;i<dim;i++){
|
||||
res=iteration(_obj,_reference,i,_obj.minimizing(i));
|
||||
if (max<res)
|
||||
max=res;
|
||||
}
|
||||
return max;
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
moeoObjectiveVectorNormalizer<MOEOT> defaultNormalizer;
|
||||
moeoObjectiveVectorNormalizer<MOEOT> &normalizer;
|
||||
const ObjectiveVector &weight;
|
||||
double rho;
|
||||
|
||||
Fitness iteration(const ObjectiveVector &obj, const ObjectiveVector& reference, int dim, bool mini){
|
||||
ObjectiveVector obj_norm=normalizer(obj);
|
||||
ObjectiveVector ref_norm=normalizer(reference);
|
||||
Fitness res;
|
||||
if (mini){
|
||||
res=(obj_norm[dim]-ref_norm[dim]);
|
||||
}else{
|
||||
res=(ref_norm[dim]-obj_norm[dim]);
|
||||
}
|
||||
res=weight[dim]*res;
|
||||
return res;
|
||||
}
|
||||
};
|
||||
#endif
|
||||
|
|
@ -0,0 +1,111 @@
|
|||
/*
|
||||
* <moeoAugmentedAchievmentScalarizingFunctionDistance.h>
|
||||
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
|
||||
* (C) OPAC Team, LIFL, 2002-2007
|
||||
*
|
||||
* Jeremie Humeau
|
||||
* Arnaud Liefooghe
|
||||
* Legillon François
|
||||
*
|
||||
* 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 MOEOASFAORDIST_H_
|
||||
#define MOEOASFAORDIST_H_
|
||||
|
||||
|
||||
#include <eo>
|
||||
#include <moeo>
|
||||
#include <cmath>
|
||||
|
||||
/**
|
||||
Order representing Achievment scalarizing function aproach to calculate a metric
|
||||
*/
|
||||
template < class MOEOT>
|
||||
class moeoAugmentedAchievementScalarizingFunctionDistance : public moeoObjSpaceDistance< MOEOT >
|
||||
{
|
||||
public:
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
typedef typename MOEOT::Fitness Fitness;
|
||||
/**
|
||||
constructor with a normalizer
|
||||
@param _rho
|
||||
@param _weight the weight to apply to each dimansion
|
||||
@param _normalizer the normalizer
|
||||
*/
|
||||
moeoAugmentedAchievementScalarizingFunctionDistance(unsigned int _rho,const ObjectiveVector &_weight,moeoObjectiveVectorNormalizer<MOEOT> &_normalizer): normalizer(_normalizer),weight(_weight),rho(_rho)
|
||||
{}
|
||||
/**
|
||||
constructor without a normalizer
|
||||
@param _rho
|
||||
@param _weight the weight to apply to each dimansion
|
||||
*/
|
||||
moeoAugmentedAchievementScalarizingFunctionDistance(unsigned int _rho,const ObjectiveVector &_weight): normalizer(defaultNormalizer),weight(_weight),rho(_rho)
|
||||
{}
|
||||
|
||||
|
||||
/**
|
||||
fonction which apply the metric to calculate a fitness
|
||||
@param _reference the reference point to calculate the distance
|
||||
@param _obj the point to evaluate
|
||||
@return the fitness conrresponding to the distance
|
||||
*/
|
||||
const Fitness operator()(const ObjectiveVector &_reference,const ObjectiveVector &_obj){
|
||||
unsigned int dim=_obj.size();
|
||||
Fitness res=0;
|
||||
Fitness max=iteration(_obj,_reference,0,_obj.minimizing(0));
|
||||
for (unsigned i=0;i<dim;i++){
|
||||
Fitness tmp=iteration(_obj,_reference,i,_obj.minimizing(i));
|
||||
if (max<tmp)
|
||||
max=tmp;
|
||||
res+=tmp;
|
||||
}
|
||||
return res+rho*max;
|
||||
}
|
||||
|
||||
private:
|
||||
moeoObjectiveVectorNormalizer<MOEOT> defaultNormalizer;
|
||||
moeoObjectiveVectorNormalizer<MOEOT> &normalizer;
|
||||
const ObjectiveVector &weight;
|
||||
double rho;
|
||||
Fitness iteration(const ObjectiveVector &obj,const ObjectiveVector &reference,int dim,bool mini){
|
||||
ObjectiveVector obj_norm=normalizer(obj);
|
||||
ObjectiveVector ref_norm=normalizer(reference);
|
||||
Fitness res;
|
||||
if (mini){
|
||||
res=obj_norm[dim]-ref_norm[dim];
|
||||
}else{
|
||||
|
||||
res=ref_norm[dim]-obj_norm[dim];
|
||||
}
|
||||
res=weight[dim]*res;
|
||||
return res;
|
||||
}
|
||||
};
|
||||
#endif
|
||||
|
|
@ -0,0 +1,102 @@
|
|||
/*
|
||||
* <moeoAugmentedWeightedChebychevDistance.h>
|
||||
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
|
||||
* (C) OPAC Team, LIFL, 2002-2007
|
||||
*
|
||||
* François Legillon
|
||||
* Jeremie Humeau
|
||||
* Arnaud Liefooghe
|
||||
*
|
||||
* 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 MOEOCHEBYCHEVORDIST_H_
|
||||
#define MOEOCHEBYCHEVORDIST_H_
|
||||
|
||||
#include <distance/moeoObjSpaceDistance.h>
|
||||
|
||||
/**
|
||||
order representing chebychev distance
|
||||
*/
|
||||
template < class MOEOT>
|
||||
class moeoAugmentedWeightedChebychevDistance : public moeoObjSpaceDistance < MOEOT >
|
||||
{
|
||||
public:
|
||||
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
|
||||
typedef typename MOEOT::Fitness Fitness;
|
||||
|
||||
/**
|
||||
constructor with a normalizer
|
||||
@param _rho
|
||||
@param _weight the weight to apply to each dimension
|
||||
@param _normalizer the normalizer
|
||||
*/
|
||||
moeoAugmentedWeightedChebychevDistance(unsigned int _rho, const ObjectiveVector& _weight, moeoObjectiveVectorNormalizer<MOEOT>& _normalizer): normalizer(_normalizer), weight(_weight), rho(_rho){}
|
||||
|
||||
/**
|
||||
constructor with a dummy normalizer
|
||||
@param _rho
|
||||
@param _weight the weight to apply to each dimension
|
||||
*/
|
||||
moeoAugmentedWeightedChebychevDistance(unsigned int _rho, const ObjectiveVector& _weight): normalizer(defaultNormalizer), weight(_weight), rho(_rho){}
|
||||
|
||||
/**
|
||||
fonction which calculate a fitness
|
||||
@param _reference the reference to calculate the distance from
|
||||
@param _obj the point to evaluate
|
||||
@return the fitness conrresponding to the distance
|
||||
*/
|
||||
const Fitness operator()(const ObjectiveVector& _reference, const ObjectiveVector& _obj){
|
||||
unsigned int dim=_obj.size();
|
||||
Fitness res=iteration(_obj,_reference,0);
|
||||
Fitness max=res*weight[0];
|
||||
for (unsigned i=1;i<dim;i++){
|
||||
Fitness tmp=iteration(_obj,_reference,i);
|
||||
if (tmp*weight[i]>max)
|
||||
max=tmp*weight[i];
|
||||
res+=tmp;
|
||||
}
|
||||
res=res*rho+max;
|
||||
return res;
|
||||
}
|
||||
|
||||
private:
|
||||
moeoObjectiveVectorNormalizer<MOEOT> &normalizer;
|
||||
moeoObjectiveVectorNormalizer<MOEOT> defaultNormalizer;
|
||||
const ObjectiveVector &weight;
|
||||
double rho;
|
||||
|
||||
Fitness iteration(const ObjectiveVector &obj,const ObjectiveVector &reference,int dim){
|
||||
ObjectiveVector obj_norm=normalizer(obj);
|
||||
ObjectiveVector ref_norm=normalizer(reference);
|
||||
Fitness res=abs(obj_norm[dim]-ref_norm[dim]);
|
||||
return res;
|
||||
}
|
||||
};
|
||||
#endif
|
||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue