void EvolutionaryAlgorithmTest::test_set_reserve_all_training_history(void)
{
message += "test_set_reserve_all_training_history\n";
EvolutionaryAlgorithm ea;
ea.set_reserve_all_training_history(true);
}
void TestEvolutionaryAlgorithm::test_resize_training_history(void)
{
message += "test_resize_training_history\n";
EvolutionaryAlgorithm ea;
ea.resize_training_history(1);
ea.resize_training_history(0);
}
void TestEvolutionaryAlgorithm::test_to_XML(void)
{
message += "test_to_XML\n";
EvolutionaryAlgorithm ea;
std::string object = ea.to_XML(true);
//std::cout << object << std::endl;
}
void TestEvolutionaryAlgorithm::test_set_standard_deviation_evaluation_goal(void)
{
message += "test_set_standard_deviation_evaluation_goal\n";
EvolutionaryAlgorithm ea;
ea.set_standard_deviation_evaluation_goal(1.0);
assert_true(ea.get_standard_deviation_evaluation_goal() == 1.0, LOG);
}
void EvolutionaryAlgorithmTest::test_set_recombination_size(void)
{
message += "test_set_recombination_size\n";
EvolutionaryAlgorithm ea;
ea.set_recombination_size(0.0);
assert_true(ea.get_recombination_size() == 0.0, LOG);
}
void EvolutionaryAlgorithmTest::test_get_fitness_assignment_method(void)
{
message += "test_get_fitness_assignment_method\n";
EvolutionaryAlgorithm ea;
ea.set_fitness_assignment_method(EvolutionaryAlgorithm::LinearRanking);
assert_true(ea.get_fitness_assignment_method() == EvolutionaryAlgorithm::LinearRanking, LOG);
}
void TestEvolutionaryAlgorithm::test_get_best_evaluation_history(void)
{
message += "test_get_best_evaluation_history\n";
EvolutionaryAlgorithm ea;
Vector<double> best_evaluation_history = ea.get_best_evaluation_history();
assert_true(best_evaluation_history.get_size() == 0, LOG);
}
void TestEvolutionaryAlgorithm::test_get_standard_deviation_norm_history(void)
{
message += "test_get_standard_deviation_norm_history\n";
EvolutionaryAlgorithm ea;
Vector<double> standard_deviation_norm_history = ea.get_standard_deviation_norm_history();
assert_true(standard_deviation_norm_history.get_size() == 0, LOG);
}
void TestEvolutionaryAlgorithm::test_get_population_history(void)
{
message += "test_get_population_history\n";
EvolutionaryAlgorithm ea;
Vector< Matrix<double> > population_history = ea.get_population_history();
assert_true(population_history.get_size() == 0, LOG);
}
void EvolutionaryAlgorithmTest::test_set_maximum_generations_number(void)
{
message += "test_set_maximum_generations_number\n";
EvolutionaryAlgorithm ea;
ea.set_maximum_generations_number(1);
assert_true(ea.get_maximum_generations_number() == 1, LOG);
}
void EvolutionaryAlgorithmTest::test_set_standard_deviation_performance_goal(void)
{
message += "test_set_standard_deviation_performance_goal\n";
EvolutionaryAlgorithm ea;
ea.set_standard_deviation_performance_goal(1.0);
assert_true(ea.get_standard_deviation_performance_goal() == 1.0, LOG);
}
void EvolutionaryAlgorithmTest::test_set_mutation_range(void)
{
message += "test_set_mutation_range\n";
EvolutionaryAlgorithm ea;
ea.set_mutation_range(0.0);
assert_true(ea.get_mutation_range() == 0.0, LOG);
}
void EvolutionaryAlgorithmTest::test_get_population_size(void)
{
message += "test_get_population_size\n";
EvolutionaryAlgorithm ea;
size_t population_size = ea.get_population_size();
assert_true(population_size == 0, LOG);
}
void EvolutionaryAlgorithmTest::test_set_selective_pressure(void)
{
message += "test_set_selective_pressure\n";
EvolutionaryAlgorithm ea;
ea.set_selective_pressure(1.0);
assert_true(ea.get_selective_pressure() == 1.0, LOG);
}
void EvolutionaryAlgorithmTest::test_get_selection_method(void)
{
message += "test_get_selection_method\n";
EvolutionaryAlgorithm ea;
ea.set_selection_method(EvolutionaryAlgorithm::RouletteWheel);
assert_true(ea.get_selection_method() == EvolutionaryAlgorithm::RouletteWheel, LOG);
}
void EvolutionaryAlgorithmTest::test_to_XML(void)
{
message += "test_to_XML\n";
EvolutionaryAlgorithm ea;
tinyxml2::XMLDocument* document = ea.to_XML();
assert_true(document != NULL, LOG);
delete document;
}
void TestEvolutionaryAlgorithm::test_set_evaluation(void)
{
message += "test_set_evaluation\n";
EvolutionaryAlgorithm ea;
Vector<double> evaluation;
ea.set_evaluation(evaluation);
assert_true(ea.get_evaluation() == 0.0, LOG);
}
void EvolutionaryAlgorithmTest::test_get_selective_pressure(void)
{
message += "test_get_selective_pressure\n";
EvolutionaryAlgorithm ea;
ea.set_fitness_assignment_method(EvolutionaryAlgorithm::LinearRanking);
ea.set_selective_pressure(1.0);
assert_true(ea.get_selective_pressure() == 1.0, LOG);
}
void EvolutionaryAlgorithmTest::test_set_selection(void)
{
message += "test_set_selection\n";
EvolutionaryAlgorithm ea;
Vector<double> selection;
ea.set_fitness(selection);
assert_true(ea.get_selection() == 0.0, LOG);
}
void EvolutionaryAlgorithmTest::test_set_fitness(void)
{
message += "test_set_fitness\n";
EvolutionaryAlgorithm ea;
Vector<double> fitness;
ea.set_fitness(fitness);
assert_true(ea.get_fitness() == 0.0, LOG);
}
void EvolutionaryAlgorithmTest::test_set_performance(void)
{
message += "test_set_performance\n";
EvolutionaryAlgorithm ea;
Vector<double> evaluation;
ea.set_performance(evaluation);
assert_true(ea.get_performance() == 0.0, LOG);
}
void TestEvolutionaryAlgorithm::test_get_reserve_best_evaluation_history(void)
{
message += "test_get_reserve_best_evaluation_history\n";
EvolutionaryAlgorithm ea;
ea.set_reserve_best_evaluation_history(true);
assert_true(ea.get_reserve_best_evaluation_history() == true, LOG);
ea.set_reserve_best_evaluation_history(false);
assert_true(ea.get_reserve_best_evaluation_history() == false, LOG);
}
void TestEvolutionaryAlgorithm::test_get_selection_method(void)
{
message += "test_get_selection_method\n";
EvolutionaryAlgorithm ea;
ea.set_selection_method(EvolutionaryAlgorithm::RouletteWheel);
assert_true(ea.get_selection_method() == EvolutionaryAlgorithm::RouletteWheel, LOG);
ea.set_selection_method(EvolutionaryAlgorithm::StochasticUniversalSampling);
assert_true(ea.get_selection_method() == EvolutionaryAlgorithm::StochasticUniversalSampling, LOG);
}
void TestEvolutionaryAlgorithm::test_get_mutation_method(void)
{
message += "test_get_mutation_method\n";
EvolutionaryAlgorithm ea;
ea.set_mutation_method(EvolutionaryAlgorithm::Normal);
assert_true(ea.get_mutation_method() == EvolutionaryAlgorithm::Normal, LOG);
ea.set_mutation_method(EvolutionaryAlgorithm::Uniform);
assert_true(ea.get_mutation_method() == EvolutionaryAlgorithm::Uniform, LOG);
}
void EvolutionaryAlgorithmTest::test_get_reserve_standard_deviation_norm_history(void)
{
message += "test_get_reserve_standard_deviation_norm_history\n";
EvolutionaryAlgorithm ea;
ea.set_reserve_standard_deviation_norm_history(true);
assert_true(ea.get_reserve_standard_deviation_norm_history() == true, LOG);
ea.set_reserve_standard_deviation_norm_history(false);
assert_true(ea.get_reserve_standard_deviation_norm_history() == false, LOG);
}
void EvolutionaryAlgorithmTest::test_get_recombination_method(void)
{
message += "test_get_recombination_method\n";
EvolutionaryAlgorithm ea;
ea.set_recombination_method(EvolutionaryAlgorithm::Line);
assert_true(ea.get_recombination_method() == EvolutionaryAlgorithm::Line, LOG);
ea.set_recombination_method(EvolutionaryAlgorithm::Intermediate);
assert_true(ea.get_recombination_method() == EvolutionaryAlgorithm::Intermediate, LOG);
}
void EvolutionaryAlgorithmTest::test_get_reserve_best_performance_history(void)
{
message += "test_get_reserve_best_performance_history\n";
EvolutionaryAlgorithm ea;
ea.set_reserve_best_performance_history(true);
assert_true(ea.get_reserve_best_performance_history() == true, LOG);
ea.set_reserve_best_performance_history(false);
assert_true(ea.get_reserve_best_performance_history() == false, LOG);
}
void TestEvolutionaryAlgorithm::test_load(void)
{
message += "test_load\n";
EvolutionaryAlgorithm ea;
ea.save("../Data/EvolutionaryAlgorithm.dat");
ea.load("../Data/EvolutionaryAlgorithm.dat");
MockObjectiveFunctional mof;
ea.set_objective_functional_pointer(&mof);
ea.save("../Data/EvolutionaryAlgorithm.dat");
ea.load("../Data/EvolutionaryAlgorithm.dat");
MultilayerPerceptron mlp(1);
mof.set_multilayer_perceptron_pointer(&mlp);
ea.save("../Data/EvolutionaryAlgorithm.dat");
ea.load("../Data/EvolutionaryAlgorithm.dat");
}
int main2()
{
// Start graphics thread
Graphics graphics;
graphics.startThread();
Sleep(1000);
// Arduino setup
EvolutionaryAlgorithm ea;
int counter = 0;
bool loop = true;
while (loop)
{
// Print population
std::vector<Individual> pop = ea.children;
std::cout << pop.size() << std::endl;
//Vecotr of scores
std::vector<double> score;
// For each population
for (unsigned i = 0; i < pop.size(); i++)
{
Individual ind = pop[i];
std::cout << "----" << "\n";
//Get stop position from camera
posMutex.lock();
Vec2 startPos = currentPosition;
posMutex.unlock();
graphics.setData(ind.genotype);
//Calculate score
double individualScore = (double)getVirtualScore2(ind.genotype);
std::cout << "Score: " << individualScore;
if (individualScore > 90.0)
{
loop = false;
graphics.saveAsImage("finished");
}
counter++;
graphics.saveAsImage(std::to_string(counter));
score.push_back(individualScore);
}
//Send score to algoritm
ea.evolutionaryLoop(score);
}
// Shutdown the software, wait for threads
std::cout << "Shutting down..." << std::endl;
cameraThreadRunning = false;
graphics.join();
return 0;
}
