diff --git a/trunk/paradiseo-peo/tutorial/Lesson8/make/make_checkpoint_moeo.h b/trunk/paradiseo-peo/tutorial/Lesson8/make/make_checkpoint_moeo.h new file mode 100644 index 000000000..02685e311 --- /dev/null +++ b/trunk/paradiseo-peo/tutorial/Lesson8/make/make_checkpoint_moeo.h @@ -0,0 +1,201 @@ +/* +* +* 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_CHECKPOINT_MOEO_H_ +#define MAKE_CHECKPOINT_MOEO_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +bool testDirRes(std::string _dirName, bool _erase); + +/** + * This functions allows to build an eoCheckPoint for multi-objective optimization from the parser (partly taken from make_checkpoint_pareto.h) + * @param _parser the parser + * @param _state to store allocated objects + * @param _eval the funtions evaluator + * @param _continue the stopping crietria + * @param _pop the population + * @param _archive the archive of non-dominated solutions + */ +template < class MOEOT > +eoCheckPoint < MOEOT > & do_make_checkpoint_moeo (eoParser & _parser, eoState & _state, eoPopEvalFunc < MOEOT > & _eval, eoContinue < MOEOT > & _continue, eoPop < MOEOT > & _pop, moeoArchive < MOEOT > & _archive) +{ + eoCheckPoint < MOEOT > & checkpoint = _state.storeFunctor(new eoCheckPoint < MOEOT > (_continue)); + /* the objective vector type */ + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + + /////////////////// + // Counters + ////////////////// + // is nb Eval to be used as counter? + //bool useEval = _parser.getORcreateParam(true, "useEval", "Use nb of eval. as counter (vs nb of gen.)", '\0', "Output").value(); + // Create anyway a generation-counter parameter + eoValueParam *generationCounter = new eoValueParam(0, "Gen."); + // Create an incrementor (sub-class of eoUpdater). + eoIncrementor & increment = _state.storeFunctor( new eoIncrementor(generationCounter->value()) ); + // Add it to the checkpoint + checkpoint.add(increment); + // dir for DISK output + std::string & dirName = _parser.getORcreateParam(std::string("Res"), "resDir", "Directory to store DISK outputs", '\0', "Output").value(); + // shoudl we empty it if exists + eoValueParam& eraseParam = _parser.getORcreateParam(true, "eraseDir", "erase files in dirName if any", '\0', "Output"); + bool dirOK = false; // not tested yet + + // Dump of the whole population + //----------------------------- + bool printPop = _parser.getORcreateParam(false, "printPop", "Print sorted pop. every gen.", '\0', "Output").value(); + eoSortedPopStat * popStat; + if ( printPop ) // we do want pop dump + { + popStat = & _state.storeFunctor(new eoSortedPopStat); + checkpoint.add(*popStat); + } + + ////////////////////////////////// + // State savers + ////////////////////////////// + // feed the state to state savers + // save state every N generation + eoValueParam& saveFrequencyParam = _parser.createParam((unsigned int)(0), "saveFrequency", "Save every F generation (0 = only final state, absent = never)", '\0', "Persistence" ); + if (_parser.isItThere(saveFrequencyParam)) + { + // first make sure dirName is OK + if (! dirOK ) + dirOK = testDirRes(dirName, eraseParam.value()); // TRUE + unsigned int freq = (saveFrequencyParam.value()>0 ? saveFrequencyParam.value() : UINT_MAX ); +#ifdef _MSVC + std::string stmp = dirName + "\generations"; +#else + std::string stmp = dirName + "/generations"; +#endif + eoCountedStateSaver *stateSaver1 = new eoCountedStateSaver(freq, _state, stmp); + _state.storeFunctor(stateSaver1); + checkpoint.add(*stateSaver1); + } + // save state every T seconds + eoValueParam& saveTimeIntervalParam = _parser.getORcreateParam((unsigned int)(0), "saveTimeInterval", "Save every T seconds (0 or absent = never)", '\0',"Persistence" ); + if (_parser.isItThere(saveTimeIntervalParam) && saveTimeIntervalParam.value()>0) + { + // first make sure dirName is OK + if (! dirOK ) + dirOK = testDirRes(dirName, eraseParam.value()); // TRUE +#ifdef _MSVC + std::string stmp = dirName + "\time"; +#else + std::string stmp = dirName + "/time"; +#endif + eoTimedStateSaver *stateSaver2 = new eoTimedStateSaver(saveTimeIntervalParam.value(), _state, stmp); + _state.storeFunctor(stateSaver2); + checkpoint.add(*stateSaver2); + } + + /////////////////// + // Archive + ////////////////// + // update the archive every generation + bool updateArch = _parser.getORcreateParam(true, "updateArch", "Update the archive at each gen.", '\0', "Evolution Engine").value(); + if (updateArch) + { + moeoArchiveUpdater < MOEOT > * updater = new moeoArchiveUpdater < MOEOT > (_archive, _pop); + _state.storeFunctor(updater); + checkpoint.add(*updater); + } + // store the objective vectors contained in the archive every generation + bool storeArch = _parser.getORcreateParam(false, "storeArch", "Store the archive's objective vectors at each gen.", '\0', "Output").value(); + if (storeArch) + { + if (! dirOK ) + dirOK = testDirRes(dirName, eraseParam.value()); // TRUE +#ifdef _MSVC + std::string stmp = dirName + "\arch"; +#else + std::string stmp = dirName + "/arch"; +#endif + moeoArchiveObjectiveVectorSavingUpdater < MOEOT > * save_updater = new moeoArchiveObjectiveVectorSavingUpdater < MOEOT > (_archive, stmp); + _state.storeFunctor(save_updater); + checkpoint.add(*save_updater); + } + // store the contribution of the non-dominated solutions + bool cont = _parser.getORcreateParam(false, "contribution", "Store the contribution of the archive at each gen.", '\0', "Output").value(); + if (cont) + { + if (! dirOK ) + dirOK = testDirRes(dirName, eraseParam.value()); // TRUE +#ifdef _MSVC + std::string stmp = dirName + "\contribution"; +#else + std::string stmp = dirName + "/contribution"; +#endif + moeoContributionMetric < ObjectiveVector > * contribution = new moeoContributionMetric < ObjectiveVector >; + moeoBinaryMetricSavingUpdater < MOEOT > * contribution_updater = new moeoBinaryMetricSavingUpdater < MOEOT > (*contribution, _archive, stmp); + _state.storeFunctor(contribution_updater); + checkpoint.add(*contribution_updater); + } + // store the entropy of the non-dominated solutions + bool ent = _parser.getORcreateParam(false, "entropy", "Store the entropy of the archive at each gen.", '\0', "Output").value(); + if (ent) + { + if (! dirOK ) + dirOK = testDirRes(dirName, eraseParam.value()); // TRUE +#ifdef _MSVC + std::string stmp = dirName + "\entropy"; +#else + std::string stmp = dirName + "/entropy"; +#endif + moeoEntropyMetric < ObjectiveVector > * entropy = new moeoEntropyMetric < ObjectiveVector >; + moeoBinaryMetricSavingUpdater < MOEOT > * entropy_updater = new moeoBinaryMetricSavingUpdater < MOEOT > (*entropy, _archive, stmp); + _state.storeFunctor(entropy_updater); + checkpoint.add(*entropy_updater); + } + + // and that's it for the (control and) output + return checkpoint; +} + +#endif /*MAKE_CHECKPOINT_MOEO_H_*/ diff --git a/trunk/paradiseo-peo/tutorial/Lesson8/make/make_continue_moeo.h b/trunk/paradiseo-peo/tutorial/Lesson8/make/make_continue_moeo.h new file mode 100644 index 000000000..00461e745 --- /dev/null +++ b/trunk/paradiseo-peo/tutorial/Lesson8/make/make_continue_moeo.h @@ -0,0 +1,130 @@ +/* +* +* 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_CONTINUE_MOEO_H_ +#define MAKE_CONTINUE_MOEO_H_ +#include +#include +#include +#include +#include +#ifndef _MSC_VER +#include +#endif +#include +#include + + +/** + * Helper function + * @param _combined the eoCombinedContinue object + * @param _cont the eoContinue to add + */ +template +eoCombinedContinue * make_combinedContinue(eoCombinedContinue *_combined, eoContinue *_cont) +{ + if (_combined) // already exists + _combined->add(*_cont); + else + _combined = new eoCombinedContinue(*_cont); + return _combined; +} + + +/** + * This functions allows to build a eoContinue for multi-objective optimization from the parser (partly taken from make_continue_pareto.h) + * @param _parser the parser + * @param _state to store allocated objects + * @param _eval the funtions evaluator + */ +template +eoContinue & do_make_continue_moeo(eoParser& _parser, eoState& _state, eoPopEvalFunc & _eval) +{ + // the combined continue - to be filled + eoCombinedContinue *continuator = NULL; + // First the eoGenContinue - need a default value so you can run blind + // but we also need to be able to avoid it <--> 0 + eoValueParam& maxGenParam = _parser.createParam((unsigned int)(100), "maxGen", "Maximum number of generations (0 = none)",'G',"Stopping criterion"); + if (maxGenParam.value()) // positive: -> define and store + { + eoGenContinue *genCont = new eoGenContinue(maxGenParam.value()); + _state.storeFunctor(genCont); + // and "add" to combined + continuator = make_combinedContinue(continuator, genCont); + } + // maxEval + eoValueParam& maxEvalParam = _parser.getORcreateParam((unsigned long)(0), "maxEval", "Maximum number of evaluations (0 = none)", 'E', "Stopping criterion"); + /* if (maxEvalParam.value()) + { + eoEvalContinue *evalCont = new eoEvalContinue(_eval, maxEvalParam.value()); + _state.storeFunctor(evalCont); + // and "add" to combined + continuator = make_combinedContinue(continuator, evalCont); + }*/ + // maxTime + eoValueParam& maxTimeParam = _parser.getORcreateParam((unsigned long)(0), "maxTime", "Maximum running time in seconds (0 = none)", 'T', "Stopping criterion"); + if (maxTimeParam.value()) // positive: -> define and store + { + eoTimeContinue *timeCont = new eoTimeContinue(maxTimeParam.value()); + _state.storeFunctor(timeCont); + // and "add" to combined + continuator = make_combinedContinue(continuator, timeCont); + } + // CtrlC +#ifndef _MSC_VER + // the CtrlC interception (Linux only I'm afraid) + eoCtrlCContinue *ctrlCCont; + eoValueParam& ctrlCParam = _parser.createParam(true, "CtrlC", "Terminate current generation upon Ctrl C",'C', "Stopping criterion"); + if (_parser.isItThere(ctrlCParam)) + { + ctrlCCont = new eoCtrlCContinue; + // store + _state.storeFunctor(ctrlCCont); + // add to combinedContinue + continuator = make_combinedContinue(continuator, ctrlCCont); + } +#endif + // now check that there is at least one! + if (!continuator) + throw std::runtime_error("You MUST provide a stopping criterion"); + // OK, it's there: store in the eoState + _state.storeFunctor(continuator); + // and return + return *continuator; +} + +#endif /*MAKE_CONTINUE_MOEO_H_*/ diff --git a/trunk/paradiseo-peo/tutorial/Lesson8/make/make_ea_moeo.h b/trunk/paradiseo-peo/tutorial/Lesson8/make/make_ea_moeo.h new file mode 100644 index 000000000..f0eaa47bb --- /dev/null +++ b/trunk/paradiseo-peo/tutorial/Lesson8/make/make_ea_moeo.h @@ -0,0 +1,297 @@ +/* +* +* 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_EA_MOEO_H_ +#define MAKE_EA_MOEO_H_ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +/** + * This functions allows to build a moeoEA from the parser + * @param _parser the parser + * @param _state to store allocated objects + * @param _eval the funtions evaluator + * @param _continue the stopping crietria + * @param _op the variation operators + * @param _archive the archive of non-dominated solutions + */ +template < class MOEOT > +moeoEA < MOEOT > & do_make_ea_moeo(eoParser & _parser, eoState & _state, eoPopEvalFunc < MOEOT > & _eval, eoContinue < MOEOT > & _continue, eoGenOp < MOEOT > & _op, moeoArchive < MOEOT > & _archive) +{ + + /* the objective vector type */ + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + + + /* the fitness assignment strategy */ + std::string & fitnessParam = _parser.createParam(std::string("FastNonDominatedSorting"), "fitness", + "Fitness assignment scheme: Dummy, FastNonDominatedSorting or IndicatorBased", 'F', + "Evolution Engine").value(); + std::string & indicatorParam = _parser.createParam(std::string("Epsilon"), "indicator", + "Binary indicator for IndicatorBased: Epsilon, Hypervolume", 'i', + "Evolution Engine").value(); + double rho = _parser.createParam(1.1, "rho", "reference point for the hypervolume indicator", 'r', + "Evolution Engine").value(); + double kappa = _parser.createParam(0.05, "kappa", "Scaling factor kappa for IndicatorBased", 'k', + "Evolution Engine").value(); + moeoFitnessAssignment < MOEOT > * fitnessAssignment; + if (fitnessParam == std::string("Dummy")) + { + fitnessAssignment = new moeoDummyFitnessAssignment < MOEOT> (); + } + else if (fitnessParam == std::string("FastNonDominatedSorting")) + { + fitnessAssignment = new moeoFastNonDominatedSortingFitnessAssignment < MOEOT> (); + } + else 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); + + + /* the diversity assignment strategy */ + eoValueParam & diversityParam = _parser.createParam(eoParamParamType("Dummy"), "diversity", + "Diversity assignment scheme: Dummy, Sharing(nicheSize) or Crowding", 'D', "Evolution Engine"); + eoParamParamType & diversityParamValue = diversityParam.value(); + moeoDiversityAssignment < MOEOT > * diversityAssignment; + if (diversityParamValue.first == std::string("Dummy")) + { + diversityAssignment = new moeoDummyDiversityAssignment < MOEOT> (); + } + else if (diversityParamValue.first == std::string("Sharing")) + { + double nicheSize; + if (!diversityParamValue.second.size()) // no parameter added + { + std::cerr << "WARNING, no niche size given for Sharing, using 0.5" << std::endl; + nicheSize = 0.5; + diversityParamValue.second.push_back(std::string("0.5")); + } + else + { + nicheSize = atoi(diversityParamValue.second[0].c_str()); + } + diversityAssignment = new moeoFrontByFrontSharingDiversityAssignment < MOEOT> (nicheSize); + } + else if (diversityParamValue.first == std::string("Crowding")) + { + diversityAssignment = new moeoFrontByFrontCrowdingDiversityAssignment < MOEOT> (); + } + else + { + std::string stmp = std::string("Invalid diversity assignment strategy: ") + diversityParamValue.first; + throw std::runtime_error(stmp.c_str()); + } + _state.storeFunctor(diversityAssignment); + + + /* the comparator strategy */ + std::string & comparatorParam = _parser.createParam(std::string("FitnessThenDiversity"), "comparator", + "Comparator scheme: FitnessThenDiversity, DiversityThenFitness or Aggregative", 'C', "Evolution Engine").value(); + moeoComparator < MOEOT > * comparator; + if (comparatorParam == std::string("FitnessThenDiversity")) + { + comparator = new moeoFitnessThenDiversityComparator < MOEOT> (); + } + else if (comparatorParam == std::string("DiversityThenFitness")) + { + comparator = new moeoDiversityThenFitnessComparator < MOEOT> (); + } + else if (comparatorParam == std::string("Aggregative")) + { + comparator = new moeoAggregativeComparator < MOEOT> (); + } + else + { + std::string stmp = std::string("Invalid comparator strategy: ") + comparatorParam; + throw std::runtime_error(stmp.c_str()); + } + _state.storeFunctor(comparator); + + + /* the selection strategy */ + eoValueParam < eoParamParamType > & selectionParam = _parser.createParam(eoParamParamType("DetTour(2)"), "selection", + "Selection scheme: DetTour(T), StochTour(t) or Random", 'S', "Evolution Engine"); + eoParamParamType & ppSelect = selectionParam.value(); + moeoSelectOne < MOEOT > * select; + if (ppSelect.first == std::string("DetTour")) + { + unsigned int tSize; + if (!ppSelect.second.size()) // no parameter added + { + std::cerr << "WARNING, no parameter passed to DetTour, using 2" << std::endl; + tSize = 2; + // put back 2 in parameter for consistency (and status file) + ppSelect.second.push_back(std::string("2")); + } + else // parameter passed by user as DetTour(T) + { + tSize = atoi(ppSelect.second[0].c_str()); + } + select = new moeoDetTournamentSelect < MOEOT > (*comparator, tSize); + } + else if (ppSelect.first == std::string("StochTour")) + { + double tRate; + if (!ppSelect.second.size()) // no parameter added + { + std::cerr << "WARNING, no parameter passed to StochTour, using 1" << std::endl; + tRate = 1; + // put back 1 in parameter for consistency (and status file) + ppSelect.second.push_back(std::string("1")); + } + else // parameter passed by user as StochTour(T) + { + tRate = atof(ppSelect.second[0].c_str()); + } + select = new moeoStochTournamentSelect < MOEOT > (*comparator, tRate); + } + /* + else if (ppSelect.first == string("Roulette")) + { + // TO DO ! + // ... + } + */ + else if (ppSelect.first == std::string("Random")) + { + select = new moeoRandomSelect (); + } + else + { + std::string stmp = std::string("Invalid selection strategy: ") + ppSelect.first; + throw std::runtime_error(stmp.c_str()); + } + _state.storeFunctor(select); + + + /* the replacement strategy */ + std::string & replacementParam = _parser.createParam(std::string("Elitist"), "replacement", + "Replacement scheme: Elitist, Environmental or Generational", 'R', "Evolution Engine").value(); + moeoReplacement < MOEOT > * replace; + if (replacementParam == std::string("Elitist")) + { + replace = new moeoElitistReplacement < MOEOT> (*fitnessAssignment, *diversityAssignment, *comparator); + } + else if (replacementParam == std::string("Environmental")) + { + replace = new moeoEnvironmentalReplacement < MOEOT> (*fitnessAssignment, *diversityAssignment, *comparator); + } + else if (replacementParam == std::string("Generational")) + { + replace = new moeoGenerationalReplacement < MOEOT> (); + } + else + { + std::string stmp = std::string("Invalid replacement strategy: ") + replacementParam; + throw std::runtime_error(stmp.c_str()); + } + _state.storeFunctor(replace); + + + /* the number of offspring */ + eoValueParam < eoHowMany > & offspringRateParam = _parser.createParam(eoHowMany(1.0), "nbOffspring", + "Number of offspring (percentage or absolute)", 'O', "Evolution Engine"); + + + // the general breeder + eoGeneralBreeder < MOEOT > * breed = new eoGeneralBreeder < MOEOT > (*select, _op, offspringRateParam.value()); + _state.storeFunctor(breed); + // the eoEasyEA + moeoEA < MOEOT > * algo = new moeoEasyEA < MOEOT > (_continue, _eval, *breed, *replace, *fitnessAssignment, *diversityAssignment); + _state.storeFunctor(algo); + return *algo; + +} + +#endif /*MAKE_EA_MOEO_H_*/ diff --git a/trunk/paradiseo-peo/tutorial/Lesson8/make/make_library.h b/trunk/paradiseo-peo/tutorial/Lesson8/make/make_library.h new file mode 100644 index 000000000..781db653c --- /dev/null +++ b/trunk/paradiseo-peo/tutorial/Lesson8/make/make_library.h @@ -0,0 +1,8 @@ +#include +#include +#include +#include +#include +#include +#include +#include diff --git a/trunk/paradiseo-peo/tutorial/Lesson8/make/make_para_eval.h b/trunk/paradiseo-peo/tutorial/Lesson8/make/make_para_eval.h new file mode 100644 index 000000000..b243e8fdb --- /dev/null +++ b/trunk/paradiseo-peo/tutorial/Lesson8/make/make_para_eval.h @@ -0,0 +1,25 @@ +#include +#include +#include + +peoMoeoPopEval & do_make_para_eval(eoParser& _parser, eoState& _state) +{ + std::string benchmarkFileName = _parser.getORcreateParam(std::string(), "BenchmarkFile", "Benchmark file name (benchmarks are available at www.lifl.fr/~liefooga/benchmarks)", 'B',"Representation", true).value(); + if (benchmarkFileName == "") + { + std::string stmp = "*** Missing name of the benchmark file\n"; + stmp += " Type '-B=the_benchmark_file_name' or '--BenchmarkFile=the_benchmark_file_name'\n"; + stmp += " Benchmarks files are available at www.lifl.fr/~liefooga/benchmarks"; + throw std::runtime_error(stmp.c_str()); + } + FlowShopBenchmarkParser fParser(benchmarkFileName); + unsigned int M = fParser.getM(); + unsigned int N = fParser.getN(); + std::vector< std::vector > p = fParser.getP(); + std::vector d = fParser.getD(); + + FlowShopEval* plainEval = new FlowShopEval(M, N, p, d); + peoMoeoPopEval* eval = new peoMoeoPopEval (* plainEval); + _state.storeFunctor(eval); + return *eval; +}