/*! * \brief Construct a GA Generational evolver. * \param inEvalOp Evaluation operator. * \param inInitSize Number of bits in the GA bit strings. */ Beagle::MPI::GA::EvolverBitString::EvolverBitString(MPI::EvaluationOp::Handle inEvalOp, unsigned int inInitSize) : Beagle::MPI::Evolver(inEvalOp) { addOperator(inEvalOp); addOperator(new Beagle::GA::InitBitStrOp(inInitSize)); addOperator(new Beagle::GA::CrossoverOnePointBitStrOp); addOperator(new Beagle::GA::CrossoverTwoPointsBitStrOp); addOperator(new Beagle::GA::CrossoverUniformBitStrOp); addOperator(new Beagle::GA::MutationFlipBitStrOp); addBootStrapOp("IfThenElseOp"); IfThenElseOp::Handle lITE = castHandleT<IfThenElseOp>(getBootStrapSet().back()); lITE->setConditionTag("ms.restart.file"); lITE->setConditionValue(""); lITE->insertPositiveOp("GA-InitBitStrOp", getOperatorMap()); lITE->insertPositiveOp(inEvalOp->getName(), getOperatorMap()); lITE->insertPositiveOp("StatsCalcFitnessSimpleOp", getOperatorMap()); lITE->insertNegativeOp("MilestoneReadOp", getOperatorMap()); addBootStrapOp("TermMaxGenOp"); addBootStrapOp("MilestoneWriteOp"); addMainLoopOp("SelectTournamentOp"); addMainLoopOp("GA-CrossoverOnePointBitStrOp"); addMainLoopOp("GA-MutationFlipBitStrOp"); addMainLoopOp(inEvalOp->getName()); addMainLoopOp("MigrationRandomRingOp"); addMainLoopOp("StatsCalcFitnessSimpleOp"); addMainLoopOp("TermMaxGenOp"); addMainLoopOp("MilestoneWriteOp"); }
/*! * \brief Construct a GA Generational evolver. * \param inEvalOp Evaluation operator. * \param inInitSize Size of the GA bit strings. * \deprecated Use EvolverBitString(EvaluationOp::Handle,unsigned int) constructor instead. * \throw Beagle::RunTimeException If init size vector has more than one value. */ Beagle::MPI::GA::EvolverBitString::EvolverBitString(EvaluationOp::Handle inEvalOp, UIntArray inInitSize) : Beagle::MPI::Evolver(inEvalOp) { addOperator(inEvalOp); if(inInitSize.size()==0) addOperator(new Beagle::GA::InitBitStrOp(0)); else if(inInitSize.size()==1) addOperator(new Beagle::GA::InitBitStrOp(inInitSize[0])); else { std::ostringstream lOSS; lOSS << "Initialization of bit string individuals with more than one bit string "; lOSS << "is no more valid. You should use individuals made of one bit string, or "; lOSS << "define your own bit string initialization operator."; throw Beagle_RunTimeExceptionM(lOSS.str()); } addOperator(new Beagle::GA::CrossoverOnePointBitStrOp); addOperator(new Beagle::GA::CrossoverTwoPointsBitStrOp); addOperator(new Beagle::GA::CrossoverUniformBitStrOp); addOperator(new Beagle::GA::MutationFlipBitStrOp); addBootStrapOp("IfThenElseOp"); IfThenElseOp::Handle lITE = castHandleT<IfThenElseOp>(getBootStrapSet().back()); lITE->setConditionTag("ms.restart.file"); lITE->setConditionValue(""); lITE->insertPositiveOp("GA-InitBitStrOp", getOperatorMap()); lITE->insertPositiveOp(inEvalOp->getName(), getOperatorMap()); lITE->insertPositiveOp("StatsCalcFitnessSimpleOp", getOperatorMap()); lITE->insertNegativeOp("MilestoneReadOp", getOperatorMap()); addBootStrapOp("TermMaxGenOp"); addBootStrapOp("MilestoneWriteOp"); addMainLoopOp("SelectTournamentOp"); addMainLoopOp("GA-CrossoverOnePointBitStrOp"); addMainLoopOp("GA-MutationFlipBitStrOp"); addMainLoopOp(inEvalOp->getName()); addMainLoopOp("MigrationRandomRingOp"); addMainLoopOp("StatsCalcFitnessSimpleOp"); addMainLoopOp("TermMaxGenOp"); addMainLoopOp("MilestoneWriteOp"); }
/*! * \brief Configure master-slave cruncher evolutionary algorithm in evolver. * \param ioEvolver Evolver modified by setting the algorithm. * \param ioSystem Evolutionary system. * */ void Distrib::Master::AlgoSequential::configure(Evolver& ioEvolver, System& ioSystem) { Beagle_StackTraceBeginM(); // Get reference to the factory const Factory& lFactory = ioSystem.getFactory(); // Get name and allocator of used operators std::string lEvalOpName = "DBMS-DistribEvalOp"; Distrib::Master::DistribEvalOp::Alloc::Handle lEvalOpAlloc = castHandleT<Distrib::Master::DistribEvalOp::Alloc>(lFactory.getAllocator(lEvalOpName)); std::string lSelectOpName = lFactory.getConceptTypeName("SelectionOp"); SelectionOp::Alloc::Handle lSelectOpAlloc = castHandleT<SelectionOp::Alloc>(lFactory.getAllocator(lSelectOpName)); std::string lInitOpName = lFactory.getConceptTypeName("InitializationOp"); InitializationOp::Alloc::Handle lInitOpAlloc = castHandleT<InitializationOp::Alloc>(lFactory.getAllocator(lInitOpName)); std::string lCxOpName = lFactory.getConceptTypeName("CrossoverOp"); CrossoverOp::Alloc::Handle lCxOpAlloc = castHandleT<CrossoverOp::Alloc>(lFactory.getAllocator(lCxOpName)); std::string lMutOpName = lFactory.getConceptTypeName("MutationOp"); MutationOp::Alloc::Handle lMutOpAlloc = castHandleT<MutationOp::Alloc>(lFactory.getAllocator(lMutOpName)); std::string lMigOpName = lFactory.getConceptTypeName("MigrationOp"); MigrationOp::Alloc::Handle lMigOpAlloc = castHandleT<MigrationOp::Alloc>(lFactory.getAllocator(lMigOpName)); std::string lStatsCalcOpName = lFactory.getConceptTypeName("StatsCalculateOp"); StatsCalculateOp::Alloc::Handle lStatsCalcOpAlloc = castHandleT<StatsCalculateOp::Alloc>(lFactory.getAllocator(lStatsCalcOpName)); std::string lTermOpName = lFactory.getConceptTypeName("TerminationOp"); TerminationOp::Alloc::Handle lTermOpAlloc = castHandleT<TerminationOp::Alloc>(lFactory.getAllocator(lTermOpName)); std::string lITEOpName = "IfThenElseOp"; IfThenElseOp::Alloc::Handle lITEOpAlloc = castHandleT<IfThenElseOp::Alloc>(lFactory.getAllocator(lITEOpName)); std::string lMsWriteOpName = "DBMS-MilestoneWriteOp"; Distrib::Master::MilestoneWriteOp::Alloc::Handle lMsWriteOpAlloc = castHandleT<MilestoneWriteOp::Alloc>(lFactory.getAllocator(lMsWriteOpName)); std::string lBSBeginOpName = "DBMS-BootStrapBeginOp"; BootStrapBeginOp::Alloc::Handle lBSBeginOpAlloc = castHandleT<BootStrapBeginOp::Alloc>(lFactory.getAllocator(lBSBeginOpName)); std::string lBSEndOpName = "DBMS-BootStrapEndOp"; BootStrapEndOp::Alloc::Handle lBSEndOpAlloc = castHandleT<BootStrapEndOp::Alloc>(lFactory.getAllocator(lBSEndOpName)); std::string lMLBeginOpName = "DBMS-MainLoopBeginOp"; MainLoopBeginOp::Alloc::Handle lMLBeginOpAlloc = castHandleT<MainLoopBeginOp::Alloc>(lFactory.getAllocator(lMLBeginOpName)); std::string lMLEndOpName = "DBMS-MainLoopEndOp"; MainLoopEndOp::Alloc::Handle lMLEndOpAlloc = castHandleT<MainLoopEndOp::Alloc>(lFactory.getAllocator(lMLEndOpName)); // Clear bootstrap and mainloop sets ioEvolver.getBootStrapSet().clear(); ioEvolver.getMainLoopSet().clear(); // Set the boostrap operator set BootStrapBeginOp::Handle lBSBeginOpBS = castHandleT<BootStrapBeginOp>(lBSBeginOpAlloc->allocate()); lBSBeginOpBS->setName(lBSBeginOpName); ioEvolver.getBootStrapSet().push_back(lBSBeginOpBS); IfThenElseOp::Handle lITEOp = castHandleT<IfThenElseOp>(lITEOpAlloc->allocate()); lITEOp->setName(lITEOpName); ioEvolver.getBootStrapSet().push_back(lITEOp); lITEOp->setConditionTag("db.restart"); lITEOp->setConditionValue("1"); InitializationOp::Handle lInitOpBS = castHandleT<InitializationOp>(lInitOpAlloc->allocate()); lInitOpBS->setName(lInitOpName); lITEOp->insertNegativeOp(lInitOpBS); EvaluationOp::Handle lEvalOpBS = castHandleT<EvaluationOp>(lEvalOpAlloc->allocate()); lEvalOpBS->setName(lEvalOpName); lITEOp->insertNegativeOp(lEvalOpBS); MigrationOp::Handle lMigOpBS = castHandleT<MigrationOp>(lMigOpAlloc->allocate()); lMigOpBS->setName(lMigOpName); lITEOp->insertNegativeOp(lMigOpBS); StatsCalculateOp::Handle lStatsCalcOpBS = castHandleT<StatsCalculateOp>(lStatsCalcOpAlloc->allocate()); lStatsCalcOpBS->setName(lStatsCalcOpName); lITEOp->insertNegativeOp(lStatsCalcOpBS); TerminationOp::Handle lTermOpBS = castHandleT<TerminationOp>(lTermOpAlloc->allocate()); lTermOpBS->setName(lTermOpName); lITEOp->insertNegativeOp(lTermOpBS); MilestoneWriteOp::Handle lMsWriteOpBS = castHandleT<MilestoneWriteOp>(lMsWriteOpAlloc->allocate()); lMsWriteOpBS->setName(lMsWriteOpName); lITEOp->insertNegativeOp(lMsWriteOpBS); BootStrapEndOp::Handle lBSEndOpBS = castHandleT<BootStrapEndOp>(lBSEndOpAlloc->allocate()); lBSEndOpBS->setName(lBSEndOpName); ioEvolver.getBootStrapSet().push_back(lBSEndOpBS); // Set the mainloop operator set MainLoopBeginOp::Handle lMLBeginOpML = castHandleT<MainLoopBeginOp>(lMLBeginOpAlloc->allocate()); lMLBeginOpML->setName(lMLBeginOpName); ioEvolver.getMainLoopSet().push_back(lMLBeginOpML); SelectionOp::Handle lSelectOpML = castHandleT<SelectionOp>(lSelectOpAlloc->allocate()); lSelectOpML->setName(lSelectOpName); ioEvolver.getMainLoopSet().push_back(lSelectOpML); CrossoverOp::Handle lCxOpML = castHandleT<CrossoverOp>(lCxOpAlloc->allocate()); lCxOpML->setName(lCxOpName); ioEvolver.getMainLoopSet().push_back(lCxOpML); MutationOp::Handle lMutOpML = castHandleT<MutationOp>(lMutOpAlloc->allocate()); lMutOpML->setName(lMutOpName); ioEvolver.getMainLoopSet().push_back(lMutOpML); EvaluationOp::Handle lEvalOpML = castHandleT<EvaluationOp>(lEvalOpAlloc->allocate()); lEvalOpML->setName(lEvalOpName); ioEvolver.getMainLoopSet().push_back(lEvalOpML); MigrationOp::Handle lMigOpML = castHandleT<MigrationOp>(lMigOpAlloc->allocate()); lMigOpML->setName(lMigOpName); ioEvolver.getMainLoopSet().push_back(lMigOpML); StatsCalculateOp::Handle lStatsCalcOpML = castHandleT<StatsCalculateOp>(lStatsCalcOpAlloc->allocate()); lStatsCalcOpML->setName(lStatsCalcOpName); ioEvolver.getMainLoopSet().push_back(lStatsCalcOpML); TerminationOp::Handle lTermOpML = castHandleT<TerminationOp>(lTermOpAlloc->allocate()); lTermOpML->setName(lTermOpName); ioEvolver.getMainLoopSet().push_back(lTermOpML); MilestoneWriteOp::Handle lMsWriteOpML = castHandleT<MilestoneWriteOp>(lMsWriteOpAlloc->allocate()); lMsWriteOpML->setName(lMsWriteOpName); ioEvolver.getMainLoopSet().push_back(lMsWriteOpML); MainLoopEndOp::Handle lMLEndOpML = castHandleT<MainLoopEndOp>(lMLEndOpAlloc->allocate()); lMLEndOpML->setName(lMLEndOpName); ioEvolver.getMainLoopSet().push_back(lMLEndOpML); Beagle_StackTraceEndM(); }