void EA<T>::replace()
{
switch (replacement) {
case GENERATIONAL:
for (unsigned int i = 0; i < offspring.size(); i++) {
if (offspring[i]) {
population.push_back(offspring[i]);
}
else {
population.push_back(selected[i]);
}
}
break;
case STEADY_STATE:
for (unsigned int i = 0; i < offspring.size(); i += 2) {
if (offspring[i] && offspring[i + 1]) {
offspring[i]->setFitness(fitnessFunction(offspring[i]));
offspring[i + 1]->setFitness(fitnessFunction(offspring[i + 1]));
std::vector<Chromosome<T>*> replacing_order;
replacing_order.push_back(selected[i]);
replacing_order.push_back(selected[i + 1]);
replacing_order.push_back(offspring[i]);
replacing_order.push_back(offspring[i + 1]);
std::sort(replacing_order.begin(), replacing_order.end(), ChromosomeComp<T>);
population.push_back(replacing_order.back());
replacing_order.pop_back();
population.push_back(replacing_order.back());
replacing_order.clear();
}
else {
population.push_back(selected[i]);
population.push_back(selected[i + 1]);
}
}
break;
case ELITISM:
for (unsigned int i = 0; i < selected.size(); i++) {
population.push_back(selected[i]);
}
std::sort(population.begin(), population.end(), ChromosomeCompInv<T>);
for (unsigned int i = 0; i < offspring.size(); i++) {
if (offspring[i]) {
population.pop_back();
}
}
for (unsigned int i = 0; i < offspring.size(); i++) {
if (offspring[i]) {
population.push_back(offspring[i]);
}
}
break;
}
}
void CandidateSolution::RandomizeGenome(double lowerBound, double upperBound)
{
for (int i = 0; i < PROBLEM_DIMENSION; ++i)
{
m_genome[i] = randomGene(lowerBound, upperBound);
}
m_fitness = fitnessFunction(m_genome);
}
void EA<T>::evaluate()
{
for (unsigned int i = 0; i < population.size(); i++) {
if (!population[i]->isEvaluated()){
population[i]->setFitness(fitnessFunction(population[i]));
}
}
}
CandidateSolution::CandidateSolution(double * genome)
{
m_genome = new double[PROBLEM_DIMENSION];
m_type = candidateSolution;
for (int i = 0; i < PROBLEM_DIMENSION; ++i)
{
m_genome[i] = genome[i];
}
m_fitness = fitnessFunction(m_genome);
}
void EA<T>::evaluateOne(unsigned int i){
population[i]->setFitness(fitnessFunction(population[i]));
}
DecompositionPtr TreeDecomposer::decompose(const Instance& instance) const
{
std::unique_ptr<htd::LibraryInstance> htd(htd::createManagementInstance(htd::Id::FIRST));
// Which algorithm to use?
if(optEliminationOrdering.getValue() == "min-degree")
htd->orderingAlgorithmFactory().setConstructionTemplate(new htd::MinDegreeOrderingAlgorithm(htd.get()));
else {
assert(optEliminationOrdering.getValue() == "min-fill");
htd->orderingAlgorithmFactory().setConstructionTemplate(new htd::MinFillOrderingAlgorithm(htd.get()));
}
Hypergraph graph = buildNamedHypergraph(*htd, instance);
std::unique_ptr<htd::TreeDecompositionOptimizationOperation> operation(new htd::TreeDecompositionOptimizationOperation(htd.get()));
operation->setManagementInstance(htd.get());
// Add transformation to path decomposition
if(optPathDecomposition.isUsed())
operation->addManipulationOperation(new htd::JoinNodeReplacementOperation(htd.get()));
// Add empty leaves
if(optNoEmptyLeaves.isUsed() == false)
operation->addManipulationOperation(new htd::AddEmptyLeavesOperation(htd.get()));
// Add empty root
if(optNoEmptyRoot.isUsed() == false)
operation->addManipulationOperation(new htd::AddEmptyRootOperation(htd.get()));
// Normalize
if(optNormalization.getValue() == "semi")
operation->addManipulationOperation(new htd::SemiNormalizationOperation(htd.get()));
else if(optNormalization.getValue() == "weak")
operation->addManipulationOperation(new htd::WeakNormalizationOperation(htd.get()));
else if(optNormalization.getValue() == "normalized")
operation->addManipulationOperation(new htd::NormalizationOperation(htd.get()));
if(optPostJoin.isUsed())
operation->addManipulationOperation(new htd::AddIdenticalJoinNodeParentOperation(htd.get()));
// Set up fitness function to find a "good" TD
FitnessCriterion fitnessCriterion;
if(optFitnessCriterion.getValue() == "join-bag-avg")
fitnessCriterion = FitnessCriterion::AVERAGE_JOIN_NODE_BAG_SIZE;
else if(optFitnessCriterion.getValue() == "join-bag-median")
fitnessCriterion = FitnessCriterion::MEDIAN_JOIN_NODE_BAG_SIZE;
else if(optFitnessCriterion.getValue() == "num-joins")
fitnessCriterion = FitnessCriterion::NUM_JOIN_NODES;
else {
assert(optFitnessCriterion.getValue() == "width");
fitnessCriterion = FitnessCriterion::WIDTH;
}
FitnessFunction fitnessFunction(fitnessCriterion);
std::unique_ptr<htd::ITreeDecompositionAlgorithm> baseAlgorithm(htd->treeDecompositionAlgorithmFactory().createInstance());
baseAlgorithm->addManipulationOperation(operation.release());
htd::IterativeImprovementTreeDecompositionAlgorithm algorithm(htd.get(), baseAlgorithm.release(), fitnessFunction);
int iterationCount = DEFAULT_ITERATION_COUNT;
if(optIterationCount.isUsed())
iterationCount = util::strToInt(optIterationCount.getValue(), "Invalid iteration count");
algorithm.setIterationCount(iterationCount);
algorithm.setNonImprovementLimit(-1);
// Compute decomposition
std::unique_ptr<htd::ITreeDecomposition> decomposition{algorithm.computeDecomposition(graph.internalGraph())};
// Transform htd's tree decomposition into our format
DecompositionPtr result = transformTd(*decomposition, graph, app);
return result;
}
