start moving GA code to separate files

CMakeLists.txt

@@ -32,10 +32,10 @@ include_directories(${pythonic_include_directories})
 add_library(GA
         GA/GA.cpp
         GA/GA.h
-        GA/ga_util.cpp
-        GA/ga_util.h
+        GA/ga_base.cpp
+        GA/ga_base.h
         other_optimization/local_optimization.cpp
-        other_optimization/combi_optimizing.cpp other_optimization/combi_optimizing.h performance_testing/performance_distribution_maker.cpp performance_testing/performance_distribution_maker.h)
+        other_optimization/combi_optimizing.cpp other_optimization/combi_optimizing.h performance_testing/performance_distribution_maker.cpp performance_testing/performance_distribution_maker.h GA/operations/mutation.cpp GA/operations/mutation.h GA/operations/matting.cpp GA/operations/matting.h GA/operations/population_generation.cpp GA/operations/population_generation.h GA/operations/util.cpp GA/operations/util.h GA/operations/crossover.cpp GA/operations/crossover.h)
 
 # add_debug_release_library(GA D:/pythonic/cmake-build-debug/pythonic.lib D:/pythonic/cmake-build-release/pythonic.lib)
 

GA/GA.h

@@ -3,7 +3,11 @@
 #include <functional>
 #include <optional>
 
-#include "ga_util.h"
+#include "ga_base.h"
+
+#include "operations/matting.h"
+#include "operations/mutation.h"
+#include "operations/population_generation.h"
 
 constexpr bool DEBUG_GA = false;
 

GA/ga_util.cpp → GA/ga_base.cpp

@@ -1,4 +1,4 @@
-#include "ga_util.h"
+#include "ga_base.h"
 
 /*
 template<class distributor, class ... Args>
@@ -33,38 +33,6 @@ vector<double> uniform_distribute(const double from, const double to, const size
 
 namespace GA
 {
-	population generate_population(const std::vector<std::pair<double, double>>& ranges, const size_t amount)
-	{
-		size_t genome_size = ranges.size();
-		population res(amount);
-
-		std::vector<std::vector<double>> genome_randoms(genome_size);
-		for (int i = 0; i < genome_size; i++) {
-			genome_randoms[i] = uniform_distribute(ranges[i].first, ranges[i].second, amount);
-		}
-
-
-		for (size_t i = 0; i < amount; i++) {
-			res[i].reserve(genome_size);
-			for (size_t j = 0; j < genome_size; j++) {
-				res[i].emplace_back(genome_randoms[j][i]);
-			}
-		}
-
-		return res;
-	}
-
-	void mutate(genome& target_genome, const std::vector<double>& sigmas, const double target_gene_number, const normalizer& normaaa)
-	{
-		auto real_gene_number = static_cast<size_t>(cut(std::round(normaaa.generate(target_gene_number, target_gene_number / 2)), 0, target_genome.size()));
-		std::vector<size_t> mutate_indexes = uniform_int_distribute(0, target_genome.size() - 1, real_gene_number);
-		// vector<double> mutate_values = normal_distribute(0, sigma, real_gene_number);
-		// cout << mutate_indexes << " " << mutate_values << endl;
-		for (size_t index = 0; index < mutate_indexes.size(); index++) {
-			double this_mutate_value = normaaa.generate(0, sigmas[index]);
-			target_genome[mutate_indexes[index]] += this_mutate_value;
-		}
-	}
 
 
 	size_t get_matting_index(std::vector<double>& russian_roulette, const double value)
@@ -218,51 +186,7 @@ namespace GA
 		return { best_fitness, *g };
 	}
 
-	population make_new_generation(population& pop, const std::vector<double>& fitnesses, const normalizer& normaaaaa,
-		const double hyper_elite_fit_pow, const double usual_elite_fit_pow, const double parent_fit_pow, 
-		const size_t usual_elite_number, const size_t hyper_elite_number, const size_t best_genome_number, const genome& best_genome,
-		const matting_mode mode)
-	{
-		light_population souls;
-
-		souls.reserve(pop.size());
-		for (genome& val : pop) souls.push_back(&val);
 
-		light_population parents = select_matting_pool(souls, fitnesses, pop.size(), parent_fit_pow);
-		light_population usual_elite = select_matting_pool(souls, fitnesses, usual_elite_number, usual_elite_fit_pow);
-		light_population hyper_elite = select_matting_pool(souls, fitnesses, hyper_elite_number, hyper_elite_fit_pow);
-
-
-		size_t child_number = pop.size() - usual_elite_number - hyper_elite_number - best_genome_number;
-
-
-		// cout << "Parents: " << endl;
-		// for (auto parent : parents) cout << *parent << endl;
-
-		// cout << "Elite: " << endl;
-		// for (auto& p : elite) cout << *p << endl;
-
-
-		light_parents_t formed_pairs = distribute_pairs(parents, child_number);
-
-		// cout << "Best: " << 1 / find_best_genome(pop, fitnesses).first << " " << find_best_genome(pop, fitnesses).second << endl;
-
-		// cout << endl << "Pairs: " << endl;
-		// for (auto& p : formed_pairs) cout << *p.first << " " << *p.second << endl;
-
-		population res = perform_crossover(formed_pairs, normaaaaa, mode);
-
-		res.reserve(pop.size());
-
-		// cout << res << endl;
-
-		for (auto& elite_person : usual_elite) res.emplace_back(*elite_person);
-		for (auto& elite_person : hyper_elite) res.emplace_back(*elite_person);
-
-		for (size_t index = 0; index < best_genome_number; index++) res.emplace_back(best_genome);
-
-		return res;
-	}
 
 
 	genome mat_parents(const std::pair<genome*, genome*>& parents, const normalizer& normaaaaa, const matting_mode mode)
@@ -298,7 +222,6 @@ namespace GA
 				new_variance = exp(randval( log(variance / 2.), log(variance * 1.5) ));
 				this_gene = normaaaaa.generate(gene_mu, new_variance); // normal_distribute(gene_mu, new_variance, 1)[0];
 				break;
-				// TODO: use fast normal number generator!
 			case matting_mode::high_variance_genetic:
 			case matting_mode::low_variance_genetic:
 				bool high_mode = mode == matting_mode::high_variance_genetic;

GA/ga_base.h

@@ -0,0 +1,24 @@
+#pragma once
+#include <pythonic.h>
+#include <random>
+
+
+namespace GA {
+
+	using genome = std::vector<double>;
+
+	using population = std::vector<genome>;
+	using light_population = std::vector<genome*>;
+
+	using parents_t = std::vector<std::pair<genome, genome>>;
+	using light_parents_t = std::vector<std::pair<genome*, genome*>>;
+
+
+
+
+
+
+
+}
+
+void renew_random();

GA/operations/crossover.cpp

@@ -0,0 +1,11 @@
+//
+// Created by Vova on 18.09.2020.
+//
+
+#include "crossover.h"
+
+
+namespace GA
+{
+
+}

GA/operations/crossover.h

@@ -0,0 +1,17 @@
+//
+// Created by Vova on 18.09.2020.
+//
+
+#pragma once
+
+#include "../ga_base.h"
+
+namespace GA
+{
+	population perform_crossover_matting(parents_t& parents); // Deprecated
+	light_parents_t distribute_pairs(light_population& pop, size_t pair_amount, bool allow_gay_marriage = false);
+
+	genome mat_parents(const std::pair<genome*, genome*>& parents, const normalizer& normaaaaa, matting_mode mode = matting_mode::low_variance_genetic); // For test
+	population perform_crossover(parents_t& parents, const normalizer& normaaaaa,  matting_mode mode = matting_mode::low_variance_genetic); // Fancy
+	population perform_crossover(light_parents_t& parents, const normalizer& normaaaaa,  matting_mode mode = matting_mode::low_variance_genetic); // Fancy
+}

GA/operations/matting.cpp

@@ -0,0 +1,58 @@
+//
+// Created by Vova on 17.09.2020.
+//
+
+#include "matting.h"
+
+
+namespace GA
+{
+	population make_new_generation(population& pop, const std::vector<double>& fitnesses, const normalizer& normaaaaa,
+	                               const double hyper_elite_fit_pow, const double usual_elite_fit_pow, const double parent_fit_pow,
+	                               const size_t usual_elite_number, const size_t hyper_elite_number, const size_t best_genome_number, const genome& best_genome,
+	                               const matting_mode mode)
+	{
+		light_population souls;
+
+		souls.reserve(pop.size());
+		for (genome& val : pop) souls.push_back(&val);
+
+		light_population parents = select_matting_pool(souls, fitnesses, pop.size(), parent_fit_pow);
+		light_population usual_elite = select_matting_pool(souls, fitnesses, usual_elite_number, usual_elite_fit_pow);
+		light_population hyper_elite = select_matting_pool(souls, fitnesses, hyper_elite_number, hyper_elite_fit_pow);
+
+
+		size_t child_number = pop.size() - usual_elite_number - hyper_elite_number - best_genome_number;
+
+
+		// cout << "Parents: " << endl;
+		// for (auto parent : parents) cout << *parent << endl;
+
+		// cout << "Elite: " << endl;
+		// for (auto& p : elite) cout << *p << endl;
+
+
+		light_parents_t formed_pairs = distribute_pairs(parents, child_number);
+
+		// cout << "Best: " << 1 / find_best_genome(pop, fitnesses).first << " " << find_best_genome(pop, fitnesses).second << endl;
+
+		// cout << endl << "Pairs: " << endl;
+		// for (auto& p : formed_pairs) cout << *p.first << " " << *p.second << endl;
+
+		population res = perform_crossover(formed_pairs, normaaaaa, mode);
+
+		res.reserve(pop.size());
+
+		// cout << res << endl;
+
+		for (auto& elite_person : usual_elite) res.emplace_back(*elite_person);
+		for (auto& elite_person : hyper_elite) res.emplace_back(*elite_person);
+
+		for (size_t index = 0; index < best_genome_number; index++) res.emplace_back(best_genome);
+
+		return res;
+	}
+
+
+}
+

GA/operations/matting.h

@@ -0,0 +1,36 @@
+//
+// Created by Vova on 17.09.2020.
+//
+
+#pragma once
+
+#include "../ga_base.h"
+
+#include "crossover.h"
+
+
+namespace GA
+{
+	enum class matting_mode
+	{
+		uniform,
+
+		high_variance_normal,
+		middle_variance_normal,
+		low_variance_normal,
+
+		random_variance_normal,
+
+		high_variance_genetic,
+		low_variance_genetic
+	};
+
+	population make_new_generation(population& pop, const std::vector<double>& fitnesses, const normalizer& normaaaaa,
+	                               double hyper_elite_fit_pow, double usual_elite_fit_pow, double parent_fit_pow,
+	                               size_t usual_elite_number, size_t hyper_elite_number, size_t best_genome_number, const genome& best_genome,
+	                               matting_mode mode = matting_mode::low_variance_genetic);
+
+	population select_matting_pool(const population& genomes, const std::vector<double>& fitnesses, size_t amount, double fit_dependence);
+
+
+}

GA/operations/mutation.cpp

@@ -0,0 +1,24 @@
+//
+// Created by Vova on 17.09.2020.
+//
+
+#include "mutation.h"
+
+
+namespace GA
+{
+	void mutate(genome& target_genome, const std::vector<double>& sigmas, const double target_gene_number, const normalizer& normaaa)
+	{
+		auto real_gene_number = static_cast<size_t>(cut(std::round(normaaa.generate(target_gene_number, target_gene_number / 2)), 0, target_genome.size()));
+		std::vector<size_t> mutate_indexes = uniform_int_distribute(0, target_genome.size() - 1, real_gene_number);
+		// vector<double> mutate_values = normal_distribute(0, sigma, real_gene_number);
+		// cout << mutate_indexes << " " << mutate_values << endl;
+		for (size_t index = 0; index < mutate_indexes.size(); index++) {
+			double this_mutate_value = normaaa.generate(0, sigmas[index]);
+			target_genome[mutate_indexes[index]] += this_mutate_value;
+		}
+	}
+
+
+}
+

GA/operations/mutation.h

@@ -0,0 +1,13 @@
+//
+// Created by Vova on 17.09.2020.
+//
+
+#pragma once
+
+#include "../ga_base.h"
+
+namespace GA
+{
+	void mutate(genome& target_genome, const std::vector<double>& sigmas, double target_gene_number, const normalizer& normaaa);
+
+}