Begin working on adding drop function, add tests for many symbolic regression configs + performance

.gitignore

@@ -8,4 +8,3 @@ massif.*
 callgrind.*
 *.out.*
 heaptrack.*
-Rice_Cammeo_Osmancik.arff

CMakeLists.txt

@@ -27,29 +27,7 @@ macro(compile_options target_name)
     sanitizers(${target_name})
 endmacro()
 
-macro(blt_add_project name source type)
-
-    project(${name}-${type})
-
-    add_executable(${name}-${type} ${source})
-
-    target_link_libraries(${name}-${type} PRIVATE BLT blt-gp Threads::Threads)
-
-    compile_options(${name}-${type})
-    target_compile_definitions(${name}-${type} PRIVATE BLT_DEBUG_LEVEL=${DEBUG_LEVEL})
-
-    if (${TRACK_ALLOCATIONS})
-        target_compile_definitions(${name}-${type} PRIVATE BLT_TRACK_ALLOCATIONS=1)
-    endif ()
-
-    add_test(NAME ${name} COMMAND ${name}-${type})
-
-    set_property(TEST ${name} PROPERTY FAIL_REGULAR_EXPRESSION "FAIL;ERROR;FATAL;exception")
-
-    project(blt-gp)
-endmacro()
-
-project(blt-gp VERSION 0.2.2)
+project(blt-gp VERSION 0.3.0)
 
 include(CTest)
 
@@ -94,6 +72,28 @@ if (${TRACK_ALLOCATIONS})
     target_compile_definitions(blt-gp PRIVATE BLT_TRACK_ALLOCATIONS=1)
 endif ()
 
+macro(blt_add_project name source type)
+
+    project(${name}-${type})
+
+    add_executable(${name}-${type} ${source})
+
+    target_link_libraries(${name}-${type} PRIVATE BLT blt-gp Threads::Threads)
+
+    compile_options(${name}-${type})
+    target_compile_definitions(${name}-${type} PRIVATE BLT_DEBUG_LEVEL=${DEBUG_LEVEL})
+
+    if (${TRACK_ALLOCATIONS})
+        target_compile_definitions(${name}-${type} PRIVATE BLT_TRACK_ALLOCATIONS=1)
+    endif ()
+
+    add_test(NAME ${name}-${type} COMMAND ${name}-${type})
+
+    set_property(TEST ${name}-${type} PROPERTY FAIL_REGULAR_EXPRESSION "FAIL;ERROR;FATAL;exception")
+
+    project(blt-gp)
+endmacro()
+
 if (${BUILD_EXAMPLES})
 
     blt_add_project(blt-symbolic-regression examples/src/symbolic_regression.cpp example)
@@ -103,16 +103,18 @@ endif ()
 
 if (${BUILD_GP_TESTS})
 
-    blt_add_project(blt-stack tests/stack_tests.cpp test)
-    blt_add_project(blt-eval tests/evaluation_tests.cpp test)
-    blt_add_project(blt-order tests/order_tests.cpp test)
+    blt_add_project(blt-stack tests/old/stack_tests.cpp test)
+    blt_add_project(blt-eval tests/old/evaluation_tests.cpp test)
+    blt_add_project(blt-order tests/old/order_tests.cpp test)
     #blt_add_project(blt-destructor tests/destructor_test.cpp test)
-    blt_add_project(blt-gp1 tests/gp_test_1.cpp test)
-    blt_add_project(blt-gp2 tests/gp_test_2.cpp test)
-    blt_add_project(blt-gp3 tests/gp_test_3.cpp test)
-    blt_add_project(blt-gp4 tests/gp_test_4.cpp test)
-    blt_add_project(blt-gp5 tests/gp_test_5.cpp test)
-    blt_add_project(blt-gp6 tests/gp_test_6.cpp test)
-    blt_add_project(blt-gp7 tests/gp_test_7.cpp test)
+    blt_add_project(blt-gp1 tests/old/gp_test_1.cpp test)
+    blt_add_project(blt-gp2 tests/old/gp_test_2.cpp test)
+    blt_add_project(blt-gp3 tests/old/gp_test_3.cpp test)
+    blt_add_project(blt-gp4 tests/old/gp_test_4.cpp test)
+    blt_add_project(blt-gp5 tests/old/gp_test_5.cpp test)
+    blt_add_project(blt-gp6 tests/old/gp_test_6.cpp test)
+    blt_add_project(blt-gp7 tests/old/gp_test_7.cpp test)
+
+    blt_add_project(blt-symbolic-regression tests/symbolic_regression_test.cpp test)
 
 endif ()

README.md

@@ -43,3 +43,6 @@ const auto fitness_function = [](blt::gp::tree_t& current_tree, blt::gp::fitness
 ```
 
 ## Performance
+
+## Bibliography
+Rice (Cammeo and Osmancik) [Dataset]. (2019). UCI Machine Learning Repository. https://doi.org/10.24432/C5MW4Z.

examples/examples_base.h

@@ -0,0 +1,64 @@
+#pragma once
+/*
+ *  Copyright (C) 2024  Brett Terpstra
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef BLT_GP_EXAMPLESEXAMPLES_BASE_H
+#define BLT_GP_EXAMPLESEXAMPLES_BASE_H
+
+#include <blt/gp/program.h>
+
+namespace blt::gp::example
+{
+    class example_base_t
+    {
+    public:
+        template<typename SEED>
+        example_base_t(SEED&& seed, const prog_config_t& config): program{std::forward<SEED>(seed), config}
+        {
+        }
+
+        example_base_t& set_crossover_selection(selection_t& sel)
+        {
+            crossover_sel = &sel;
+            return *this;
+        }
+
+        example_base_t& set_mutation_selection(selection_t& sel)
+        {
+            mutation_sel = &sel;
+            return *this;
+        }
+
+        example_base_t& set_reproduction_selection(selection_t& sel)
+        {
+            reproduction_sel = &sel;
+            return *this;
+        }
+
+        gp_program& get_program() { return program; }
+        const gp_program& get_program() const { return program; }
+
+    protected:
+        gp_program program;
+        selection_t* crossover_sel = nullptr;
+        selection_t* mutation_sel = nullptr;
+        selection_t* reproduction_sel = nullptr;
+        std::function<bool(const tree_t&, fitness_t&, size_t)> fitness_function_ref;
+    };
+}
+
+#endif //BLT_GP_EXAMPLESEXAMPLES_BASE_H

examples/rice_classification.h

@@ -0,0 +1,180 @@
+#pragma once
+/*
+ *  Copyright (C) 2024  Brett Terpstra
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef BLT_GP_EXAMPLES_RICE_CLASSIFICATION_H
+#define BLT_GP_EXAMPLES_RICE_CLASSIFICATION_H
+
+#include "examples_base.h"
+
+namespace blt::gp::example
+{
+    class rice_classification_t : public example_base_t
+    {
+    private:
+        enum class rice_type_t
+        {
+            Cammeo,
+            Osmancik
+        };
+
+        struct rice_record
+        {
+            float area;
+            float perimeter;
+            float major_axis_length;
+            float minor_axis_length;
+            float eccentricity;
+            float convex_area;
+            float extent;
+            rice_type_t type;
+        };
+
+        bool fitness_function(const tree_t& current_tree, fitness_t& fitness, size_t) const;
+
+    public:
+        template <typename SEED>
+        rice_classification_t(SEED&& seed, const prog_config_t& config): example_base_t{std::forward<SEED>(seed), config}
+        {
+            BLT_INFO("Starting BLT-GP Rice Classification Example");
+            fitness_function_ref = [this](const tree_t& t, fitness_t& f, const size_t i)
+            {
+                return fitness_function(t, f, i);
+            };
+        }
+
+        void make_operators();
+
+        void load_rice_data(std::string_view rice_file_path);
+
+        [[nodiscard]] confusion_matrix_t test_individual(const individual_t& individual) const;
+
+        void execute(const std::string_view rice_file_path)
+        {
+            load_rice_data(rice_file_path);
+            make_operators();
+            generate_initial_population();
+            run_generation_loop();
+            evaluate_individuals();
+            print_best();
+            print_average();
+        }
+
+        void run_generation_loop()
+        {
+            BLT_DEBUG("Begin Generation Loop");
+            while (!program.should_terminate())
+            {
+                BLT_TRACE("------------{Begin Generation %ld}------------", program.get_current_generation());
+                BLT_TRACE("Creating next generation");
+                program.create_next_generation();
+                BLT_TRACE("Move to next generation");
+                program.next_generation();
+                BLT_TRACE("Evaluate Fitness");
+                program.evaluate_fitness();
+                auto& stats = program.get_population_stats();
+                BLT_TRACE("Avg Fit: %lf, Best Fit: %lf, Worst Fit: %lf, Overall Fit: %lf",
+                          stats.average_fitness.load(std::memory_order_relaxed), stats.best_fitness.load(std::memory_order_relaxed),
+                          stats.worst_fitness.load(std::memory_order_relaxed), stats.overall_fitness.load(std::memory_order_relaxed));
+                BLT_TRACE("----------------------------------------------");
+                std::cout << std::endl;
+            }
+        }
+
+        void evaluate_individuals()
+        {
+            results.clear();
+            for (auto& i : program.get_current_pop().get_individuals())
+                results.emplace_back(test_individual(i), &i);
+            std::sort(results.begin(), results.end(), [](const auto& a, const auto& b)
+            {
+                return a.first > b.first;
+            });
+        }
+
+        void generate_initial_population()
+        {
+            BLT_DEBUG("Generate Initial Population");
+            static auto sel = select_tournament_t{};
+            if (crossover_sel == nullptr)
+                crossover_sel = &sel;
+            if (mutation_sel == nullptr)
+                mutation_sel = &sel;
+            if (reproduction_sel == nullptr)
+                reproduction_sel = &sel;
+            program.generate_population(program.get_typesystem().get_type<float>().id(), fitness_function_ref, *crossover_sel, *mutation_sel,
+                                        *reproduction_sel);
+        }
+
+        void print_best(const size_t amount = 3)
+        {
+            BLT_INFO("Best results:");
+            for (size_t index = 0; index < amount; index++)
+            {
+                const auto& record = results[index].first;
+                const auto& i = *results[index].second;
+
+                BLT_INFO("Hits %ld, Total Cases %ld, Percent Hit: %lf", record.get_hits(), record.get_total(), record.get_percent_hit());
+                std::cout << record.pretty_print() << std::endl;
+                BLT_DEBUG("Fitness: %lf, stand: %lf, raw: %lf", i.fitness.adjusted_fitness, i.fitness.standardized_fitness, i.fitness.raw_fitness);
+                i.tree.print(program, std::cout);
+
+                std::cout << "\n";
+            }
+        }
+
+        void print_worst(const size_t amount = 3) const
+        {
+            BLT_INFO("Worst Results:");
+            for (size_t index = 0; index < amount; index++)
+            {
+                const auto& record = results[results.size() - 1 - index].first;
+                const auto& i = *results[results.size() - 1 - index].second;
+
+                BLT_INFO("Hits %ld, Total Cases %ld, Percent Hit: %lf", record.get_hits(), record.get_total(), record.get_percent_hit());
+                std::cout << record.pretty_print() << std::endl;
+                BLT_DEBUG("Fitness: %lf, stand: %lf, raw: %lf", i.fitness.adjusted_fitness, i.fitness.standardized_fitness, i.fitness.raw_fitness);
+
+                std::cout << "\n";
+            }
+        }
+
+        void print_average()
+        {
+            BLT_INFO("Average Results");
+            confusion_matrix_t avg{};
+            avg.set_name_a("cammeo");
+            avg.set_name_b("osmancik");
+            for (const auto& [matrix, _] : results)
+                avg += matrix;
+            avg /= results.size();
+            BLT_INFO("Hits %ld, Total Cases %ld, Percent Hit: %lf", avg.get_hits(), avg.get_total(), avg.get_percent_hit());
+            std::cout << avg.pretty_print() << std::endl;
+            std::cout << "\n";
+        }
+
+        auto& get_results() { return results; }
+        const auto& get_results() const { return results; }
+
+    private:
+        std::vector<rice_record> training_cases;
+        std::vector<rice_record> testing_cases;
+        std::vector<std::pair<confusion_matrix_t, individual_t*>> results;
+    };
+}
+
+#endif //BLT_GP_EXAMPLES_RICE_CLASSIFICATION_H

examples/src/rice_classification.cpp

@@ -25,329 +25,200 @@
 #include <blt/format/format.h>
 #include <blt/parse/argparse.h>
 #include <iostream>
-#include "operations_common.h"
+#include <filesystem>
+#include "../rice_classification.h"
 #include "blt/fs/loader.h"
 
 static const auto SEED_FUNC = [] { return std::random_device()(); };
 
-enum class rice_type_t
-{
-    Cammeo,
-    Osmancik
-};
-
-struct rice_record
-{
-    float area;
-    float perimeter;
-    float major_axis_length;
-    float minor_axis_length;
-    float eccentricity;
-    float convex_area;
-    float extent;
-    rice_type_t type;
-};
-
-std::vector<rice_record> training_cases;
-std::vector<rice_record> testing_cases;
-
 blt::gp::prog_config_t config = blt::gp::prog_config_t()
-        .set_initial_min_tree_size(2)
-        .set_initial_max_tree_size(6)
-        .set_elite_count(2)
-        .set_crossover_chance(0.9)
-        .set_mutation_chance(0.1)
-        .set_reproduction_chance(0)
-        .set_max_generations(50)
-        .set_pop_size(5000)
-        .set_thread_count(0);
-
-blt::gp::gp_program program{SEED_FUNC, config};
-
-auto lit = blt::gp::operation_t([]() {
-    return program.get_random().get_float(-32000.0f, 32000.0f);
-}, "lit").set_ephemeral();
-
-blt::gp::operation_t op_area([](const rice_record& rice_data) {
-    return rice_data.area;
-}, "area");
-
-blt::gp::operation_t op_perimeter([](const rice_record& rice_data) {
-    return rice_data.perimeter;
-}, "perimeter");
-
-blt::gp::operation_t op_major_axis_length([](const rice_record& rice_data) {
-    return rice_data.major_axis_length;
-}, "major_axis_length");
-
-blt::gp::operation_t op_minor_axis_length([](const rice_record& rice_data) {
-    return rice_data.minor_axis_length;
-}, "minor_axis_length");
-
-blt::gp::operation_t op_eccentricity([](const rice_record& rice_data) {
-    return rice_data.eccentricity;
-}, "eccentricity");
-
-blt::gp::operation_t op_convex_area([](const rice_record& rice_data) {
-    return rice_data.convex_area;
-}, "convex_area");
-
-blt::gp::operation_t op_extent([](const rice_record& rice_data) {
-    return rice_data.extent;
-}, "extent");
-
-constexpr auto fitness_function = [](blt::gp::tree_t& current_tree, blt::gp::fitness_t& fitness, blt::size_t) {
-    for (auto& training_case : training_cases)
-    {
-        auto v = current_tree.get_evaluation_value<float>(training_case);
-        switch (training_case.type)
-        {
-            case rice_type_t::Cammeo:
-                if (v >= 0)
-                    fitness.hits++;
-                break;
-            case rice_type_t::Osmancik:
-                if (v < 0)
-                    fitness.hits++;
-                break;
-        }
-    }
-    fitness.raw_fitness = static_cast<double>(fitness.hits);
-    fitness.standardized_fitness = fitness.raw_fitness;
-    fitness.adjusted_fitness = 1.0 - (1.0 / (1.0 + fitness.standardized_fitness));
-    return static_cast<blt::size_t>(fitness.hits) == training_cases.size();
-};
-
-void load_rice_data(std::string_view rice_file_path)
-{
-    auto rice_file_data = blt::fs::getLinesFromFile(rice_file_path);
-    size_t index = 0;
-    while (!blt::string::contains(rice_file_data[index++], "@DATA"))
-    {}
-    std::vector<rice_record> c;
-    std::vector<rice_record> o;
-    for (std::string_view v : blt::itr_offset(rice_file_data, index))
-    {
-        auto data = blt::string::split(v, ',');
-        rice_record r{std::stof(data[0]), std::stof(data[1]), std::stof(data[2]), std::stof(data[3]), std::stof(data[4]), std::stof(data[5]),
-                      std::stof(data[6]), blt::string::contains(data[7], "Cammeo") ? rice_type_t::Cammeo : rice_type_t::Osmancik};
-        switch (r.type)
-        {
-            case rice_type_t::Cammeo:
-                c.push_back(r);
-                break;
-            case rice_type_t::Osmancik:
-                o.push_back(r);
-                break;
-        }
-    }
-    
-    blt::size_t total_records = c.size() + o.size();
-    blt::size_t training_size = std::min(total_records / 3, 1000ul);
-    for (blt::size_t i = 0; i < training_size; i++)
-    {
-        auto& random = program.get_random();
-        auto& vec = random.choice() ? c : o;
-        auto pos = random.get_i64(0, static_cast<blt::i64>(vec.size()));
-        training_cases.push_back(vec[pos]);
-        vec.erase(vec.begin() + pos);
-    }
-    testing_cases.insert(testing_cases.end(), c.begin(), c.end());
-    testing_cases.insert(testing_cases.end(), o.begin(), o.end());
-    std::shuffle(testing_cases.begin(), testing_cases.end(), program.get_random());
-    BLT_INFO("Created training set of size %ld, testing set is of size %ld", training_size, testing_cases.size());
-}
-
-struct test_results_t
-{
-    blt::size_t cc = 0;
-    blt::size_t co = 0;
-    blt::size_t oo = 0;
-    blt::size_t oc = 0;
-    blt::size_t hits = 0;
-    blt::size_t size = 0;
-    double percent_hit = 0;
-    
-    test_results_t& operator+=(const test_results_t& a)
-    {
-        cc += a.cc;
-        co += a.co;
-        oo += a.oo;
-        oc += a.oc;
-        hits += a.hits;
-        size += a.size;
-        percent_hit += a.percent_hit;
-        return *this;
-    }
-    
-    test_results_t& operator/=(blt::size_t s)
-    {
-        cc /= s;
-        co /= s;
-        oo /= s;
-        oc /= s;
-        hits /= s;
-        size /= s;
-        percent_hit /= static_cast<double>(s);
-        return *this;
-    }
-    
-    friend bool operator<(const test_results_t& a, const test_results_t& b)
-    {
-        return a.hits < b.hits;
-    }
-    
-    friend bool operator>(const test_results_t& a, const test_results_t& b)
-    {
-        return a.hits > b.hits;
-    }
-};
-
-test_results_t test_individual(blt::gp::individual_t& i)
-{
-    test_results_t results;
-    
-    for (auto& testing_case : testing_cases)
-    {
-        auto result = i.tree.get_evaluation_value<float>(testing_case);
-        switch (testing_case.type)
-        {
-            case rice_type_t::Cammeo:
-                if (result >= 0)
-                    results.cc++; // cammeo cammeo
-                else
-                    results.co++; // cammeo osmancik
-                break;
-            case rice_type_t::Osmancik:
-                if (result < 0)
-                    results.oo++; // osmancik osmancik
-                else
-                    results.oc++; // osmancik cammeo
-                break;
-        }
-    }
-    
-    results.hits = results.cc + results.oo;
-    results.size = testing_cases.size();
-    results.percent_hit = static_cast<double>(results.hits) / static_cast<double>(results.size) * 100;
-    
-    return results;
-}
+                                .set_initial_min_tree_size(2)
+                                .set_initial_max_tree_size(6)
+                                .set_elite_count(2)
+                                .set_crossover_chance(0.9)
+                                .set_mutation_chance(0.1)
+                                .set_reproduction_chance(0)
+                                .set_max_generations(50)
+                                .set_pop_size(500)
+                                .set_thread_count(0);
 
 int main(int argc, const char** argv)
 {
     blt::arg_parse parser;
-    parser.addArgument(blt::arg_builder{"-f", "--file"}.setHelp("File for rice data. Should be in .arff format.").setRequired().build());
-    
+    parser.addArgument(blt::arg_builder{"file"}
+                       .setHelp("File for rice data. Should be in .arff format.").setDefault("../datasets/Rice_Cammeo_Osmancik.arff").build());
+
     auto args = parser.parse_args(argc, argv);
-    
+
     if (!args.contains("file"))
     {
         BLT_WARN("Please provide path to file with -f or --file");
         return 1;
     }
-    
-    auto rice_file_path = args.get<std::string>("file");
-    
-    BLT_INFO("Starting BLT-GP Rice Classification Example");
-    BLT_START_INTERVAL("Rice Classification", "Main");
-    BLT_DEBUG("Setup Fitness cases");
-    load_rice_data(rice_file_path);
-    
-    BLT_DEBUG("Setup Types and Operators");
-    
-    blt::gp::operator_builder<rice_record> builder{};
-    program.set_operations(builder.build(add, sub, mul, pro_div, op_exp, op_log, lit, op_area, op_perimeter, op_major_axis_length,
-                                         op_minor_axis_length, op_eccentricity, op_convex_area, op_extent));
-    
-    BLT_DEBUG("Generate Initial Population");
-    auto sel = blt::gp::select_tournament_t{};
-    program.generate_population(program.get_typesystem().get_type<float>().id(), fitness_function, sel, sel, sel);
-    
-    BLT_DEBUG("Begin Generation Loop");
-    while (!program.should_terminate())
-    {
-        BLT_TRACE("------------{Begin Generation %ld}------------", program.get_current_generation());
-        BLT_TRACE("Creating next generation");
-        BLT_START_INTERVAL("Rice Classification", "Gen");
-        program.create_next_generation();
-        BLT_END_INTERVAL("Rice Classification", "Gen");
-        BLT_TRACE("Move to next generation");
-        BLT_START_INTERVAL("Rice Classification", "Fitness");
-        program.next_generation();
-        BLT_TRACE("Evaluate Fitness");
-        program.evaluate_fitness();
-        BLT_END_INTERVAL("Rice Classification", "Fitness");
-        auto& stats = program.get_population_stats();
-        BLT_TRACE("Stats:");
-        BLT_TRACE("Average fitness: %lf", stats.average_fitness.load());
-        BLT_TRACE("Best fitness: %lf", stats.best_fitness.load());
-        BLT_TRACE("Worst fitness: %lf", stats.worst_fitness.load());
-        BLT_TRACE("Overall fitness: %lf", stats.overall_fitness.load());
-        BLT_TRACE("----------------------------------------------");
-        std::cout << std::endl;
-    }
-    
-    BLT_END_INTERVAL("Rice Classification", "Main");
-    
-    std::vector<std::pair<test_results_t, blt::gp::individual_t*>> results;
-    for (auto& i : program.get_current_pop().get_individuals())
-        results.emplace_back(test_individual(i), &i);
-    std::sort(results.begin(), results.end(), [](const auto& a, const auto& b) {
-        return a.first > b.first;
-    });
-    
-    BLT_INFO("Best results:");
-    for (blt::size_t index = 0; index < 3; index++)
-    {
-        const auto& record = results[index].first;
-        const auto& i = *results[index].second;
-        
-        BLT_INFO("Hits %ld, Total Cases %ld, Percent Hit: %lf", record.hits, record.size, record.percent_hit);
-        BLT_DEBUG("Cammeo Cammeo: %ld", record.cc);
-        BLT_DEBUG("Cammeo Osmancik: %ld", record.co);
-        BLT_DEBUG("Osmancik Osmancik: %ld", record.oo);
-        BLT_DEBUG("Osmancik Cammeo: %ld", record.oc);
-        BLT_DEBUG("Fitness: %lf, stand: %lf, raw: %lf", i.fitness.adjusted_fitness, i.fitness.standardized_fitness, i.fitness.raw_fitness);
-        i.tree.print(program, std::cout);
-        
-        std::cout << "\n";
-    }
-    
-    BLT_INFO("Worst Results:");
-    for (blt::size_t index = 0; index < 3; index++)
-    {
-        const auto& record = results[results.size() - 1 - index].first;
-        const auto& i = *results[results.size() - 1 - index].second;
-        
-        BLT_INFO("Hits %ld, Total Cases %ld, Percent Hit: %lf", record.hits, record.size, record.percent_hit);
-        BLT_DEBUG("Cammeo Cammeo: %ld", record.cc);
-        BLT_DEBUG("Cammeo Osmancik: %ld", record.co);
-        BLT_DEBUG("Osmancik Osmancik: %ld", record.oo);
-        BLT_DEBUG("Osmancik Cammeo: %ld", record.oc);
-        BLT_DEBUG("Fitness: %lf, stand: %lf, raw: %lf", i.fitness.adjusted_fitness, i.fitness.standardized_fitness, i.fitness.raw_fitness);
-        
-        std::cout << "\n";
-    }
-    
-    BLT_INFO("Average Results");
-    test_results_t avg{};
-    for (const auto& v : results)
-        avg += v.first;
-    avg /= results.size();
-    BLT_INFO("Hits %ld, Total Cases %ld, Percent Hit: %lf", avg.hits, avg.size, avg.percent_hit);
-    BLT_DEBUG("Cammeo Cammeo: %ld", avg.cc);
-    BLT_DEBUG("Cammeo Osmancik: %ld", avg.co);
-    BLT_DEBUG("Osmancik Osmancik: %ld", avg.oo);
-    BLT_DEBUG("Osmancik Cammeo: %ld", avg.oc);
-    std::cout << "\n";
-    
-    BLT_PRINT_PROFILE("Rice Classification", blt::PRINT_CYCLES | blt::PRINT_THREAD | blt::PRINT_WALL);
 
-#ifdef BLT_TRACK_ALLOCATIONS
-    BLT_TRACE("Total Allocations: %ld times with a total of %s", blt::gp::tracker.getAllocations(),
-              blt::byte_convert_t(blt::gp::tracker.getAllocatedBytes()).convert_to_nearest_type().to_pretty_string().c_str());
-#endif
-    
+    auto rice_file_path = args.get<std::string>("file");
+
+    blt::gp::example::rice_classification_t rice_classification{SEED_FUNC, config};
+
+    rice_classification.execute(rice_file_path);
+
     return 0;
-}
+}
+
+void blt::gp::example::rice_classification_t::make_operators()
+{
+    BLT_DEBUG("Setup Types and Operators");
+    static operation_t add{[](const float a, const float b) { return a + b; }, "add"};
+    static operation_t sub([](const float a, const float b) { return a - b; }, "sub");
+    static operation_t mul([](const float a, const float b) { return a * b; }, "mul");
+    static operation_t pro_div([](const float a, const float b) { return b == 0.0f ? 0.0f : a / b; }, "div");
+    static operation_t op_exp([](const float a) { return std::exp(a); }, "exp");
+    static operation_t op_log([](const float a) { return a == 0.0f ? 0.0f : std::log(a); }, "log");
+    static auto lit = operation_t([this]()
+    {
+        return program.get_random().get_float(-32000.0f, 32000.0f);
+    }, "lit").set_ephemeral();
+
+    static operation_t op_area([](const rice_record& rice_data)
+    {
+        return rice_data.area;
+    }, "area");
+
+    static operation_t op_perimeter([](const rice_record& rice_data)
+    {
+        return rice_data.perimeter;
+    }, "perimeter");
+
+    static operation_t op_major_axis_length([](const rice_record& rice_data)
+    {
+        return rice_data.major_axis_length;
+    }, "major_axis_length");
+
+    static operation_t op_minor_axis_length([](const rice_record& rice_data)
+    {
+        return rice_data.minor_axis_length;
+    }, "minor_axis_length");
+
+    static operation_t op_eccentricity([](const rice_record& rice_data)
+    {
+        return rice_data.eccentricity;
+    }, "eccentricity");
+
+    static operation_t op_convex_area([](const rice_record& rice_data)
+    {
+        return rice_data.convex_area;
+    }, "convex_area");
+
+    static operation_t op_extent([](const rice_record& rice_data)
+    {
+        return rice_data.extent;
+    }, "extent");
+
+    operator_builder<rice_record> builder{};
+    builder.build(add, sub, mul, pro_div, op_exp, op_log, lit, op_area, op_perimeter, op_major_axis_length,
+                  op_minor_axis_length, op_eccentricity, op_convex_area, op_extent);
+    program.set_operations(builder.grab());
+}
+
+bool blt::gp::example::rice_classification_t::fitness_function(const tree_t& current_tree, fitness_t& fitness, size_t) const
+{
+    for (auto& training_case : training_cases)
+    {
+        BLT_GP_UPDATE_CONTEXT(training_case);
+        const auto v = current_tree.get_evaluation_value<float>(training_case);
+        switch (training_case.type)
+        {
+        case rice_type_t::Cammeo:
+            if (v >= 0)
+                fitness.hits++;
+            break;
+        case rice_type_t::Osmancik:
+            if (v < 0)
+                fitness.hits++;
+            break;
+        }
+    }
+    fitness.raw_fitness = static_cast<double>(fitness.hits);
+    fitness.standardized_fitness = fitness.raw_fitness;
+    // fitness.adjusted_fitness = 1.0 - (1.0 / (1.0 + fitness.standardized_fitness));
+    fitness.adjusted_fitness = fitness.standardized_fitness / static_cast<double>(training_cases.size());
+    return static_cast<size_t>(fitness.hits) == training_cases.size();
+}
+
+void blt::gp::example::rice_classification_t::load_rice_data(const std::string_view rice_file_path)
+{
+    if (!std::filesystem::exists(rice_file_path))
+    {
+        BLT_WARN("Rice file not found!");
+        std::exit(0);
+    }
+    BLT_DEBUG("Setup Fitness cases");
+    auto rice_file_data = fs::getLinesFromFile(rice_file_path);
+    size_t index = 0;
+    while (!string::contains(rice_file_data[index++], "@DATA"))
+    {
+    }
+    std::vector<rice_record> c;
+    std::vector<rice_record> o;
+    for (const std::string_view v : iterate(rice_file_data).skip(index))
+    {
+        auto data = string::split(v, ',');
+        rice_record r{
+            std::stof(data[0]), std::stof(data[1]), std::stof(data[2]), std::stof(data[3]), std::stof(data[4]), std::stof(data[5]),
+            std::stof(data[6]), string::contains(data[7], "Cammeo") ? rice_type_t::Cammeo : rice_type_t::Osmancik
+        };
+        switch (r.type)
+        {
+        case rice_type_t::Cammeo:
+            c.push_back(r);
+            break;
+        case rice_type_t::Osmancik:
+            o.push_back(r);
+            break;
+        }
+    }
+
+    const size_t total_records = c.size() + o.size();
+    const size_t testing_size = total_records / 3;
+    for (size_t i = 0; i < testing_size; i++)
+    {
+        auto& random = program.get_random();
+        auto& vec = random.choice() ? c : o;
+        const auto pos = random.get_i64(0, static_cast<i64>(vec.size()));
+        testing_cases.push_back(vec[pos]);
+        vec.erase(vec.begin() + pos);
+    }
+    training_cases.insert(training_cases.end(), c.begin(), c.end());
+    training_cases.insert(training_cases.end(), o.begin(), o.end());
+    std::shuffle(training_cases.begin(), training_cases.end(), program.get_random());
+    BLT_INFO("Created testing set of size %ld, training set is of size %ld", testing_cases.size(), training_cases.size());
+}
+
+blt::gp::confusion_matrix_t blt::gp::example::rice_classification_t::test_individual(const individual_t& individual) const
+{
+    confusion_matrix_t confusion_matrix;
+    confusion_matrix.set_name_a("cammeo");
+    confusion_matrix.set_name_b("osmancik");
+
+    for (auto& testing_case : testing_cases)
+    {
+        const auto result = individual.tree.get_evaluation_value<float>(testing_case);
+        switch (testing_case.type)
+        {
+        case rice_type_t::Cammeo:
+            if (result >= 0)
+                confusion_matrix.is_A_predicted_A(); // cammeo cammeo
+            else
+                confusion_matrix.is_A_predicted_B(); // cammeo osmancik
+            break;
+        case rice_type_t::Osmancik:
+            if (result < 0)
+                confusion_matrix.is_B_predicted_B(); // osmancik osmancik
+            else
+                confusion_matrix.is_B_predicted_A(); // osmancik cammeo
+            break;
+        }
+    }
+
+    return confusion_matrix;
+}

examples/src/symbolic_regression.cpp

@@ -17,25 +17,48 @@
  */
 #include "../symbolic_regression.h"
 
-static const unsigned long SEED = std::random_device()();
+// you can either use a straight numeric seed, or provide a function which produces a u64 output which will initialize the thread local random number generators.
+static const auto SEED_FUNC = [] { return std::random_device()(); };
 
-blt::gp::prog_config_t config = blt::gp::prog_config_t()
-        .set_initial_min_tree_size(2)
-        .set_initial_max_tree_size(6)
-        .set_elite_count(2)
-        .set_crossover_chance(0.9)
-        .set_mutation_chance(0.0)
-        .set_reproduction_chance(0.25)
-        .set_max_generations(50)
-        .set_pop_size(500)
-        .set_thread_count(0);
+blt::gp::grow_generator_t grow_generator;
+blt::gp::full_generator_t full_generator;
+
+blt::gp::ramped_half_initializer_t ramped_half_initializer;
+blt::gp::full_initializer_t full_initializer;
 
 int main()
 {
-    blt::gp::example::symbolic_regression_t regression{config, SEED};
+    // config options can be chained together to form compound statements.
+    blt::gp::prog_config_t config = blt::gp::prog_config_t()
+            .set_initial_min_tree_size(2)
+            .set_initial_max_tree_size(6)
+            .set_elite_count(2)
+            .set_crossover_chance(0.9)
+            .set_mutation_chance(0.1)
+            .set_reproduction_chance(0.0)
+            .set_max_generations(50)
+            .set_pop_size(500)
+            .set_thread_count(16);
+
+    // example on how you can change the mutation config
+    blt::gp::mutation_t::config_t mut_config{};
+    mut_config.generator = grow_generator;
+    mut_config.replacement_min_depth = 2;
+    mut_config.replacement_max_depth = 6;
+
+    blt::gp::advanced_mutation_t mut_adv{mut_config};
+    blt::gp::mutation_t mut{mut_config};
+
+    // you can choose to set any type of system used by the GP. Mutation, Crossover, and Initializers
+    // (config options changed do not affect others, so you can programmatically change them at runtime)
+    config.set_initializer(ramped_half_initializer);
+    config.set_mutation(mut_adv);
+
+    // the config is copied into the gp_system so changing the config will not change the runtime of the program.
+    blt::gp::example::symbolic_regression_t regression{SEED_FUNC, config};
+
     regression.execute();
 
-    BLT_TRACE("%lf vs %lf", blt::gp::parent_fitness.load(std::memory_order_relaxed), blt::gp::child_fitness.load(std::memory_order_relaxed));
-    
     return 0;
-}
+}
+

examples/symbolic_regression.h

@@ -19,15 +19,14 @@
 #ifndef BLT_GP_EXAMPLE_SYMBOLIC_REGRESSION_H
 #define BLT_GP_EXAMPLE_SYMBOLIC_REGRESSION_H
 
-#include <blt/gp/program.h>
-#include <blt/gp/tree.h>
+#include "examples_base.h"
 #include <blt/std/logging.h>
 #include <blt/format/format.h>
 #include <iostream>
 
 namespace blt::gp::example
 {
-    class symbolic_regression_t
+    class symbolic_regression_t : public example_base_t
     {
     public:
         struct context
@@ -62,7 +61,8 @@ namespace blt::gp::example
         }
 
     public:
-        symbolic_regression_t(const prog_config_t& config, const size_t seed): program{seed, config}
+        template <typename SEED>
+        symbolic_regression_t(SEED seed, const prog_config_t& config): example_base_t{std::forward<SEED>(seed), config}
         {
             BLT_INFO("Starting BLT-GP Symbolic Regression Example");
             BLT_DEBUG("Setup Fitness cases");
@@ -74,15 +74,20 @@ namespace blt::gp::example
                 const auto y = example_function(x);
                 fitness_case = {x, y};
             }
+
+            fitness_function_ref = [this](const tree_t& t, fitness_t& f, const size_t i)
+            {
+                return fitness_function(t, f, i);
+            };
         }
 
-        template <typename Ctx>
-        auto make_operations(operator_builder<Ctx>& builder)
+        void setup_operations()
         {
+            BLT_DEBUG("Setup Types and Operators");
             static operation_t add{[](const float a, const float b) { return a + b; }, "add"};
             static operation_t sub([](const float a, const float b) { return a - b; }, "sub");
             static operation_t mul([](const float a, const float b) { return a * b; }, "mul");
-            static operation_t pro_div([](const float a, const float b) { return b == 0.0f ? 1.0f : a / b; }, "div");
+            static operation_t pro_div([](const float a, const float b) { return b == 0.0f ? 0.0f : a / b; }, "div");
             static operation_t op_sin([](const float a) { return std::sin(a); }, "sin");
             static operation_t op_cos([](const float a) { return std::cos(a); }, "cos");
             static operation_t op_exp([](const float a) { return std::exp(a); }, "exp");
@@ -97,26 +102,35 @@ namespace blt::gp::example
                 return context.x;
             }, "x");
 
-            return builder.build(add, sub, mul, pro_div, op_sin, op_cos, op_exp, op_log, lit, op_x);
+            operator_builder<context> builder{};
+            builder.build(add, sub, mul, pro_div, op_sin, op_cos, op_exp, op_log, lit, op_x);
+            program.set_operations(builder.grab());
         }
 
-        void execute()
+        void generate_initial_population()
         {
-            BLT_DEBUG("Setup Types and Operators");
-            operator_builder<context> builder{};
-            program.set_operations(make_operations(builder));
-
             BLT_DEBUG("Generate Initial Population");
-            auto sel = select_tournament_t{};
-            auto fitness = [this](const tree_t& c, fitness_t& f, const size_t i) { return fitness_function(c, f, i); };
-            program.generate_population(program.get_typesystem().get_type<float>().id(), fitness, sel, sel, sel);
+            static auto sel = select_tournament_t{};
+            if (crossover_sel == nullptr)
+                crossover_sel = &sel;
+            if (mutation_sel == nullptr)
+                mutation_sel = &sel;
+            if (reproduction_sel == nullptr)
+                reproduction_sel = &sel;
+            program.generate_population(program.get_typesystem().get_type<float>().id(), fitness_function_ref, *crossover_sel, *mutation_sel,
+                                        *reproduction_sel);
+        }
 
+        void run_generation_loop()
+        {
             BLT_DEBUG("Begin Generation Loop");
             while (!program.should_terminate())
             {
+#ifdef BLT_TRACK_ALLOCATIONS
                 auto cross = crossover_calls.start_measurement();
                 auto mut = mutation_calls.start_measurement();
                 auto repo = reproduction_calls.start_measurement();
+#endif
                 BLT_TRACE("------------{Begin Generation %ld}------------", program.get_current_generation());
                 BLT_TRACE("Creating next generation");
                 program.create_next_generation();
@@ -126,18 +140,23 @@ namespace blt::gp::example
                 program.evaluate_fitness();
                 const auto& stats = program.get_population_stats();
                 BLT_TRACE("Avg Fit: %lf, Best Fit: %lf, Worst Fit: %lf, Overall Fit: %lf",
-                    stats.average_fitness.load(std::memory_order_relaxed), stats.best_fitness.load(std::memory_order_relaxed),
-                    stats.worst_fitness.load(std::memory_order_relaxed), stats.overall_fitness.load(std::memory_order_relaxed));
+                          stats.average_fitness.load(std::memory_order_relaxed), stats.best_fitness.load(std::memory_order_relaxed),
+                          stats.worst_fitness.load(std::memory_order_relaxed), stats.overall_fitness.load(std::memory_order_relaxed));
+#ifdef BLT_TRACK_ALLOCATIONS
                 crossover_calls.stop_measurement(cross);
                 mutation_calls.stop_measurement(mut);
                 reproduction_calls.stop_measurement(repo);
                 const auto total = (cross.get_call_difference() * 2) + mut.get_call_difference() + repo.get_call_difference();
                 BLT_TRACE("Calls Crossover: %ld, Mutation %ld, Reproduction %ld; %ld", cross.get_call_difference(), mut.get_call_difference(), repo.get_call_difference(), total);
                 BLT_TRACE("Value Crossover: %ld, Mutation %ld, Reproduction %ld; %ld", cross.get_value_difference(), mut.get_value_difference(), repo.get_value_difference(), (cross.get_value_difference() * 2 + mut.get_value_difference() + repo.get_value_difference()) - total);
+#endif
                 BLT_TRACE("----------------------------------------------");
                 std::cout << std::endl;
             }
+        }
 
+        auto get_and_print_best()
+        {
             const auto best = program.get_best_individuals<3>();
 
             BLT_INFO("Best approximations:");
@@ -148,18 +167,35 @@ namespace blt::gp::example
                 i.tree.print(program, std::cout);
                 std::cout << "\n";
             }
+
+            return best;
+        }
+
+        void print_stats() const
+        {
+            // TODO: make stats helper
             const auto& stats = program.get_population_stats();
             BLT_INFO("Stats:");
             BLT_INFO("Average fitness: %lf", stats.average_fitness.load());
             BLT_INFO("Best fitness: %lf", stats.best_fitness.load());
             BLT_INFO("Worst fitness: %lf", stats.worst_fitness.load());
             BLT_INFO("Overall fitness: %lf", stats.overall_fitness.load());
-            // TODO: make stats helper
+        }
+
+        void execute()
+        {
+            setup_operations();
+
+            generate_initial_population();
+
+            run_generation_loop();
+
+            get_and_print_best();
+
+            print_stats();
         }
 
     private:
-        gp_program program;
-        mutation_t mut;
         std::array<context, 200> training_cases{};
     };
 }

include/blt/gp/allocator.h

@@ -20,12 +20,29 @@
 #define BLT_GP_ALLOCATOR_H
 
 #include <blt/std/types.h>
-#include <blt/gp/stats.h>
-#include <blt/gp/fwdecl.h>
+#include <blt/std/logging.h>
+#include <blt/gp/util/trackers.h>
 #include <cstdlib>
+#include <vector>
 
 namespace blt::gp
 {
+    namespace detail
+    {
+        static constexpr inline size_t MAX_ALIGNMENT = 8;
+
+#if BLT_DEBUG_LEVEL > 0
+        static void check_alignment(const size_t bytes, const std::string& message = "Invalid alignment")
+        {
+            if (bytes % MAX_ALIGNMENT != 0)
+            {
+                BLT_ABORT((message + ", expected multiple of " + std::to_string(detail::MAX_ALIGNMENT) + " got "
+                    + std::to_string(bytes)).c_str());
+            }
+        }
+#endif
+    }
+
 #ifdef BLT_TRACK_ALLOCATIONS
     inline allocation_tracker_t tracker;
 
@@ -47,11 +64,14 @@ namespace blt::gp
     public:
         void* allocate(blt::size_t bytes) // NOLINT
         {
-#ifdef BLT_TRACK_ALLOCATIONS
+#ifdef BLT_TRACK_ALLOCATIONSS
             tracker.allocate(bytes);
             //                std::cout << "Hey our aligned allocator allocated " << bytes << " bytes!\n";
 #endif
-            return std::aligned_alloc(8, bytes);
+#if (BLT_DEBUG_LEVEL > 0)
+            detail::check_alignment(bytes);
+#endif
+            return std::aligned_alloc(detail::MAX_ALIGNMENT, bytes);
         }
 
         void deallocate(void* ptr, blt::size_t bytes) // NOLINT
@@ -62,7 +82,7 @@ namespace blt::gp
             tracker.deallocate(bytes);
             //                std::cout << "[Hey our aligned allocator deallocated " << bytes << " bytes!]\n";
 #else
-                (void) bytes;
+            (void)bytes;
 #endif
             std::free(ptr);
         }
@@ -108,7 +128,7 @@ namespace blt::gp
             ::blt::gp::tracker.deallocate(n * sizeof(T));
             //                std::cout << "[Hey our tracked allocator deallocated " << (n * sizeof(T)) << " bytes!]\n";
 #else
-                (void) n;
+            (void)n;
 #endif
             std::free(p);
         }
@@ -142,6 +162,14 @@ namespace blt::gp
     {
         return &lhs != &rhs;
     }
+
+#ifdef BLT_TRACK_ALLOCATIONS
+    template<typename T>
+    using tracked_vector = std::vector<T, tracked_allocator_t<T>>;
+#else
+    template <typename T>
+    using tracked_vector = std::vector<T>;
+#endif
 }
 
 #endif //BLT_GP_ALLOCATOR_H

include/blt/gp/config.h

@@ -30,11 +30,12 @@ namespace blt::gp
 {
     struct prog_config_t
     {
-        blt::size_t population_size = 500;
-        blt::size_t max_generations = 50;
-        blt::size_t initial_min_tree_size = 3;
-        blt::size_t initial_max_tree_size = 10;
-        
+        size_t population_size = 500;
+        size_t max_generations = 50;
+        size_t initial_min_tree_size = 2;
+        size_t initial_max_tree_size = 6;
+        size_t max_tree_depth = 17;
+
         // percent chance that we will do crossover
         double crossover_chance = 0.8;
         // percent chance that we will do mutation
@@ -42,96 +43,96 @@ namespace blt::gp
         // percent chance we will do reproduction (copy individual)
         double reproduction_chance = 0.1;
         // everything else will just be selected
-        
-        blt::size_t elites = 0;
-        
+
+        size_t elites = 0;
+
         bool try_mutation_on_crossover_failure = true;
-        
+
         std::reference_wrapper<mutation_t> mutator;
         std::reference_wrapper<crossover_t> crossover;
         std::reference_wrapper<population_initializer_t> pop_initializer;
-        
+
         blt::size_t threads = std::thread::hardware_concurrency();
         // number of elements each thread should pull per execution. this is for granularity performance and can be optimized for better results!
         blt::size_t evaluation_size = 4;
-        
+
         // default config (ramped half-and-half init) or for buildering
         prog_config_t();
-        
+
         // default config with a user specified initializer
         prog_config_t(const std::reference_wrapper<population_initializer_t>& popInitializer); // NOLINT
-        
+
         prog_config_t(size_t populationSize, const std::reference_wrapper<population_initializer_t>& popInitializer);
-        
+
         prog_config_t(size_t populationSize); // NOLINT
-        
+
         prog_config_t& set_pop_size(blt::size_t pop)
         {
             population_size = pop;
             //evaluation_size = (population_size / threads) / 2;
             return *this;
         }
-        
+
         prog_config_t& set_initial_min_tree_size(blt::size_t size)
         {
             initial_min_tree_size = size;
             return *this;
         }
-        
+
         prog_config_t& set_initial_max_tree_size(blt::size_t size)
         {
             initial_max_tree_size = size;
             return *this;
         }
-        
+
         prog_config_t& set_crossover(crossover_t& ref)
         {
             crossover = {ref};
             return *this;
         }
-        
+
         prog_config_t& set_mutation(mutation_t& ref)
         {
             mutator = {ref};
             return *this;
         }
-        
+
         prog_config_t& set_initializer(population_initializer_t& ref)
         {
             pop_initializer = ref;
             return *this;
         }
-        
+
         prog_config_t& set_elite_count(blt::size_t new_elites)
         {
             elites = new_elites;
             return *this;
         }
-        
+
         prog_config_t& set_crossover_chance(double new_crossover_chance)
         {
             crossover_chance = new_crossover_chance;
             return *this;
         }
-        
+
         prog_config_t& set_mutation_chance(double new_mutation_chance)
         {
             mutation_chance = new_mutation_chance;
             return *this;
         }
-        
+
         prog_config_t& set_max_generations(blt::size_t new_max_generations)
         {
             max_generations = new_max_generations;
             return *this;
         }
-        
+
         prog_config_t& set_try_mutation_on_crossover_failure(bool new_try_mutation_on_crossover_failure)
         {
             try_mutation_on_crossover_failure = new_try_mutation_on_crossover_failure;
             return *this;
         }
-        
+
         prog_config_t& set_thread_count(blt::size_t t)
         {
             if (t == 0)
@@ -140,13 +141,19 @@ namespace blt::gp
             //evaluation_size = (population_size / threads) / 2;
             return *this;
         }
-        
+
         prog_config_t& set_evaluation_size(blt::size_t s)
         {
             evaluation_size = s;
             return *this;
         }
-        
+
+        prog_config_t& set_max_tree_depth(const size_t depth)
+        {
+            max_tree_depth = depth;
+            return *this;
+        }
+
         prog_config_t& set_reproduction_chance(double chance)
         {
             reproduction_chance = chance;

include/blt/gp/fwdecl.h

@@ -22,12 +22,12 @@
 #include <functional>
 #include <blt/std/logging.h>
 #include <blt/std/types.h>
-#include <blt/gp/stats.h>
 #include <ostream>
 #include <cstdlib>
 #include <mutex>
 #include <atomic>
 #include <blt/std/mmap.h>
+#include <blt/gp/util/trackers.h>
 #include <blt/gp/allocator.h>
 
 namespace blt::gp
@@ -65,18 +65,6 @@ namespace blt::gp
     template<typename T>
     class tracked_allocator_t;
 
-#ifdef BLT_TRACK_ALLOCATIONS
-    template<typename T>
-    using tracked_vector = std::vector<T, tracked_allocator_t<T>>;
-#else
-    template<typename T>
-    using tracked_vector = std::vector<T>;
-#endif
-
-//    using operation_vector_t = tracked_vector<op_container_t>;
-//    using individual_vector_t = tracked_vector<individual_t, tracked_allocator_t<individual_t>>;
-//    using tree_vector_t = tracked_vector<tree_t>;
-    
     namespace detail
     {
         class operator_storage_test;
@@ -97,6 +85,18 @@ namespace blt::gp
         using const_op_iter_t = tracked_vector<op_container_t>::const_iterator;
         using op_iter_t = tracked_vector<op_container_t>::iterator;
     }
+
+#if BLT_DEBUG_LEVEL > 0
+
+    namespace detail::debug
+    {
+        inline void* context_ptr;
+    }
+
+#define BLT_GP_UPDATE_CONTEXT(context) blt::gp::detail::debug::context_ptr = const_cast<void*>(static_cast<const void*>(&context))
+#else
+    #define BLT_GP_UPDATE_CONTEXT(context)
+#endif
     
 }
 

include/blt/gp/program.h

@@ -140,16 +140,16 @@ namespace blt::gp
                 blt::size_t total_so_far = 0;
                 blt::size_t op_pos = 0;
 
-                for (const auto& operation : blt::reverse_iterate(ops.begin(), ops.end()))
+                for (const auto& operation : iterate(ops).rev())
                 {
                     op_pos++;
-                    if (operation.is_value)
+                    if (operation.is_value())
                     {
-                        total_so_far += stack_allocator::aligned_size(operation.type_size);
-                        results.values.copy_from(vals.from(total_so_far), stack_allocator::aligned_size(operation.type_size));
+                        total_so_far += operation.type_size();
+                        results.values.copy_from(vals.from(total_so_far), operation.type_size());
                         continue;
                     }
-                    call_jmp_table(operation.id, context, results.values, results.values, operators...);
+                    call_jmp_table(operation.id(), context, results.values, results.values, operators...);
                 }
 
                 return results;
@@ -157,19 +157,19 @@ namespace blt::gp
 
             blt::hashset_t<type_id> has_terminals;
 
-            for (const auto& v : blt::enumerate(storage.terminals))
+            for (const auto& [index, value] : blt::enumerate(storage.terminals))
             {
-                if (!v.second.empty())
-                    has_terminals.insert(v.first);
+                if (!value.empty())
+                    has_terminals.insert(index);
             }
 
-            for (const auto& op_r : blt::enumerate(storage.non_terminals))
+            for (const auto& [index, value] : blt::enumerate(storage.non_terminals))
             {
-                if (op_r.second.empty())
+                if (value.empty())
                     continue;
-                auto return_type = op_r.first;
+                auto return_type = index;
                 tracked_vector<std::pair<operator_id, blt::size_t>> ordered_terminals;
-                for (const auto& op : op_r.second)
+                for (const auto& op : value)
                 {
                     // count number of terminals
                     blt::size_t terminals = 0;
@@ -258,9 +258,9 @@ namespace blt::gp
             operator_metadata_t meta;
             if constexpr (sizeof...(Args) != 0)
             {
-                meta.arg_size_bytes = (stack_allocator::aligned_size(sizeof(Args)) + ...);
+                meta.arg_size_bytes = (stack_allocator::aligned_size<Args>() + ...);
             }
-            meta.return_size_bytes = sizeof(Return);
+            meta.return_size_bytes = stack_allocator::aligned_size<Return>();
             meta.argc = info.argc;
 
             storage.operator_metadata.push_back(meta);
@@ -370,6 +370,11 @@ namespace blt::gp
             create_threads();
         }
 
+        /**
+         *
+         * @param seed_func Function which provides a new random seed every time it is called.
+         * This will be used by each thread to initialize a new random number generator
+         */
         explicit gp_program(std::function<blt::u64()> seed_func): seed_func(std::move(seed_func))
         {
             create_threads();
@@ -485,6 +490,7 @@ namespace blt::gp
                             double sum_of_prob = 0;
                             for (const auto& [index, ind] : blt::enumerate(current_pop.get_individuals()))
                             {
+                                ind.fitness = {};
                                 if constexpr (std::is_same_v<LambdaReturn, bool> || std::is_convertible_v<LambdaReturn, bool>)
                                 {
                                     auto result = fitness_function(ind.tree, ind.fitness, index);
@@ -560,7 +566,7 @@ namespace blt::gp
                                 {
                                     auto& ind = current_pop.get_individuals()[i];
 
-
+                                    ind.fitness = {};
                                     if constexpr (std::is_same_v<LambdaReturn, bool> || std::is_convertible_v<LambdaReturn, bool>)
                                     {
                                         auto result = fitness_function(ind.tree, ind.fitness, i);
@@ -765,8 +771,8 @@ namespace blt::gp
             tracked_vector<std::pair<blt::size_t, double>> values;
             values.reserve(current_pop.get_individuals().size());
 
-            for (const auto& ind : blt::enumerate(current_pop.get_individuals()))
-                values.emplace_back(ind.first, ind.second.fitness.adjusted_fitness);
+            for (const auto& [index, value] : blt::enumerate(current_pop.get_individuals()))
+                values.emplace_back(index, value.fitness.adjusted_fitness);
 
             std::sort(values.begin(), values.end(), [](const auto& a, const auto& b)
             {

include/blt/gp/selection.h

@@ -20,6 +20,7 @@
 #define BLT_GP_SELECTION_H
 
 #include <blt/gp/fwdecl.h>
+#include <blt/gp/util/statistics.h>
 #include <blt/gp/tree.h>
 #include <blt/gp/config.h>
 #include <blt/gp/random.h>
@@ -42,6 +43,10 @@ namespace blt::gp
     {
         auto& [program, current_pop, current_stats, config, random] = args;
 
+        BLT_ASSERT_MSG(config.elites <= current_pop.get_individuals().size(), ("Not enough individuals in population (" +
+                           std::to_string(current_pop.get_individuals().size()) +
+                           ") for requested amount of elites (" + std::to_string(config.elites) + ")").c_str());
+
         if (config.elites > 0 && current_pop.get_individuals().size() >= config.elites)
         {
             static thread_local tracked_vector<std::pair<std::size_t, double>> values;
@@ -54,16 +59,16 @@ namespace blt::gp
             {
                 for (blt::size_t i = 0; i < config.elites; i++)
                 {
-                    if (ind.second.fitness.adjusted_fitness >= values[i].second)
+                    if (ind.value.fitness.adjusted_fitness >= values[i].second)
                     {
                         bool doesnt_contain = true;
                         for (blt::size_t j = 0; j < config.elites; j++)
                         {
-                            if (ind.first == values[j].first)
+                            if (ind.index == values[j].first)
                                 doesnt_contain = false;
                         }
                         if (doesnt_contain)
-                            values[i] = {ind.first, ind.second.fitness.adjusted_fitness};
+                            values[i] = {ind.index, ind.value.fitness.adjusted_fitness};
                         break;
                     }
                 }
@@ -101,43 +106,45 @@ namespace blt::gp
 
                 const tree_t* p1;
                 const tree_t* p2;
-                double parent_val = 0;
+                // double parent_val = 0;
                 do
                 {
                     p1 = &crossover_selection.select(program, current_pop);
                     p2 = &crossover_selection.select(program, current_pop);
 
-                    fitness_t fitness1;
-                    fitness_t fitness2;
-                    test_fitness_func(*p1, fitness1, 0);
-                    test_fitness_func(*p2, fitness2, 0);
-                    parent_val = fitness1.adjusted_fitness + fitness2.adjusted_fitness;
+                    // fitness_t fitness1;
+                    // fitness_t fitness2;
+                    // test_fitness_func(*p1, fitness1, 0);
+                    // test_fitness_func(*p2, fitness2, 0);
+                    // parent_val = fitness1.adjusted_fitness + fitness2.adjusted_fitness;
                     // BLT_TRACE("%ld> P1 Fit: %lf, P2 Fit: %lf", val, fitness1.adjusted_fitness, fitness2.adjusted_fitness);
 
                     c1.copy_fast(*p1);
                     c2->copy_fast(*p2);
 
+#ifdef BLT_TRACK_ALLOCATIONS
                     crossover_calls.value(1);
+#endif
                 }
                 while (!config.crossover.get().apply(program, *p1, *p2, c1, *c2));
-                fitness_t fitness1;
-                fitness_t fitness2;
-                test_fitness_func(c1, fitness1, 0);
-                test_fitness_func(*c2, fitness2, 0);
+                // fitness_t fitness1;
+                // fitness_t fitness2;
+                // test_fitness_func(c1, fitness1, 0);
+                // test_fitness_func(*c2, fitness2, 0);
 
-                const auto child_val = fitness1.adjusted_fitness + fitness2.adjusted_fitness;
+                // const auto child_val = fitness1.adjusted_fitness + fitness2.adjusted_fitness;
 
-                auto old_parent_val = parent_fitness.load(std::memory_order_relaxed);
-                while (!parent_fitness.compare_exchange_weak(old_parent_val, old_parent_val + parent_val, std::memory_order_relaxed,
-                                                             std::memory_order_relaxed))
-                {
-                }
+                // auto old_parent_val = parent_fitness.load(std::memory_order_relaxed);
+                // while (!parent_fitness.compare_exchange_weak(old_parent_val, old_parent_val + parent_val, std::memory_order_relaxed,
+                // std::memory_order_relaxed))
+                // {
+                // }
 
-                auto old_child_val = child_fitness.load(std::memory_order_relaxed);
-                while (!child_fitness.compare_exchange_weak(old_child_val, old_child_val + child_val, std::memory_order_relaxed,
-                                                             std::memory_order_relaxed))
-                {
-                }
+                // auto old_child_val = child_fitness.load(std::memory_order_relaxed);
+                // while (!child_fitness.compare_exchange_weak(old_child_val, old_child_val + child_val, std::memory_order_relaxed,
+                // std::memory_order_relaxed))
+                // {
+                // }
 
                 // BLT_TRACE("%ld> C1 Fit: %lf, C2 Fit: %lf", val, fitness1.adjusted_fitness, fitness2.adjusted_fitness);
 #ifdef BLT_TRACK_ALLOCATIONS
@@ -164,7 +171,9 @@ namespace blt::gp
                 {
                     p = &mutation_selection.select(program, current_pop);
                     c1.copy_fast(*p);
+#ifdef BLT_TRACK_ALLOCATIONS
                     mutation_calls.value(1);
+#endif
                 }
                 while (!config.mutator.get().apply(program, *p, c1));
 #ifdef BLT_TRACK_ALLOCATIONS

include/blt/gp/stack.h

@@ -27,7 +27,8 @@
 #include <blt/std/ranges.h>
 #include <blt/meta/meta.h>
 #include <blt/gp/fwdecl.h>
-#include <blt/gp/stats.h>
+#include <blt/gp/util/trackers.h>
+#include <blt/gp/allocator.h>
 #include <utility>
 #include <stdexcept>
 #include <cstdlib>
@@ -42,296 +43,325 @@ namespace blt::gp
     {
         BLT_META_MAKE_FUNCTION_CHECK(drop);
     }
-    
+
     class stack_allocator
     {
-            constexpr static blt::size_t PAGE_SIZE = 0x100;
-            constexpr static blt::size_t MAX_ALIGNMENT = 8;
-            template<typename T>
-            using NO_REF_T = std::remove_cv_t<std::remove_reference_t<T>>;
-            using Allocator = aligned_allocator;
-        public:
-            static Allocator& get_allocator();
-            
-            struct size_data_t
+        constexpr static blt::size_t PAGE_SIZE = 0x100;
+        template <typename T>
+        using NO_REF_T = std::remove_cv_t<std::remove_reference_t<T>>;
+        using Allocator = aligned_allocator;
+
+        // todo remove this once i fix all the broken references
+        struct detail
+        {
+            static constexpr size_t aligned_size(const size_t size) noexcept
             {
-                blt::size_t total_size_bytes = 0;
-                blt::size_t total_used_bytes = 0;
-                blt::size_t total_remaining_bytes = 0;
-                
-                friend std::ostream& operator<<(std::ostream& stream, const size_data_t& data)
-                {
-                    stream << "[";
-                    stream << data.total_used_bytes << " / " << data.total_size_bytes;
-                    stream << " ("
-                           << (data.total_size_bytes != 0 ? (static_cast<double>(data.total_used_bytes) / static_cast<double>(data.total_size_bytes) *
-                                                             100) : 0) << "%); space left: " << data.total_remaining_bytes << "]";
-                    return stream;
-                }
-            };
-            
-            template<typename T>
-            static inline constexpr blt::size_t aligned_size() noexcept
-            {
-                return aligned_size(sizeof(NO_REF_T<T>));
+                return (size + (gp::detail::MAX_ALIGNMENT - 1)) & ~(gp::detail::MAX_ALIGNMENT - 1);
             }
-            
-            static inline constexpr blt::size_t aligned_size(blt::size_t size) noexcept
+        };
+
+    public:
+        static Allocator& get_allocator();
+
+        struct size_data_t
+        {
+            blt::size_t total_size_bytes = 0;
+            blt::size_t total_used_bytes = 0;
+            blt::size_t total_remaining_bytes = 0;
+
+            friend std::ostream& operator<<(std::ostream& stream, const size_data_t& data)
             {
-                return (size + (MAX_ALIGNMENT - 1)) & ~(MAX_ALIGNMENT - 1);
+                stream << "[";
+                stream << data.total_used_bytes << " / " << data.total_size_bytes;
+                stream << " ("
+                    << (data.total_size_bytes != 0
+                            ? (static_cast<double>(data.total_used_bytes) / static_cast<double>(data.total_size_bytes) *
+                                100)
+                            : 0) << "%); space left: " << data.total_remaining_bytes << "]";
+                return stream;
             }
-            
-            stack_allocator() = default;
-            
-            stack_allocator(const stack_allocator& copy)
-            {
-                if (copy.data_ == nullptr || copy.bytes_stored == 0)
-                    return;
-                expand(copy.size_);
-                std::memcpy(data_, copy.data_, copy.bytes_stored);
-                bytes_stored = copy.bytes_stored;
-            }
-            
-            stack_allocator(stack_allocator&& move) noexcept:
-                    data_(std::exchange(move.data_, nullptr)), bytes_stored(std::exchange(move.bytes_stored, 0)), size_(std::exchange(move.size_, 0))
-            {}
-            
-            stack_allocator& operator=(const stack_allocator& copy) = delete;
-            
-            stack_allocator& operator=(stack_allocator&& move) noexcept
-            {
-                data_ = std::exchange(move.data_, data_);
-                size_ = std::exchange(move.size_, size_);
-                bytes_stored = std::exchange(move.bytes_stored, bytes_stored);
-                return *this;
-            }
-            
-            ~stack_allocator()
-            {
-                get_allocator().deallocate(data_, size_);
-            }
-            
-            void insert(const stack_allocator& stack)
-            {
-                if (stack.empty())
-                    return;
-                if (stack.bytes_stored + bytes_stored > size_)
-                    expand(stack.bytes_stored + size_);
-                std::memcpy(data_ + bytes_stored, stack.data_, stack.bytes_stored);
-                bytes_stored += stack.bytes_stored;
-            }
-            
-            void copy_from(const stack_allocator& stack, blt::size_t bytes)
-            {
-                if (bytes == 0)
-                    return;
-                if (bytes + bytes_stored > size_)
-                    expand(bytes + size_);
-                std::memcpy(data_ + bytes_stored, stack.data_ + (stack.bytes_stored - bytes), bytes);
-                bytes_stored += bytes;
-            }
-            
-            void copy_from(blt::u8* data, blt::size_t bytes)
-            {
-                if (bytes == 0 || data == nullptr)
-                    return;
-                if (bytes + bytes_stored > size_)
-                    expand(bytes + size_);
-                std::memcpy(data_ + bytes_stored, data, bytes);
-                bytes_stored += bytes;
-            }
-            
-            void copy_to(blt::u8* data, blt::size_t bytes)
-            {
-                if (bytes == 0 || data == nullptr)
-                    return;
-                std::memcpy(data, data_ + (bytes_stored - bytes), bytes);
-            }
-            
-            template<typename T, typename NO_REF = NO_REF_T<T>>
-            void push(const T& t)
-            {
-                static_assert(std::is_trivially_copyable_v<NO_REF> && "Type must be bitwise copyable!");
-                static_assert(alignof(NO_REF) <= MAX_ALIGNMENT && "Type alignment must not be greater than the max alignment!");
-                auto ptr = allocate_bytes_for_size(sizeof(NO_REF));
-                std::memcpy(ptr, &t, sizeof(NO_REF));
-            }
-            
-            template<typename T, typename NO_REF = NO_REF_T<T>>
-            T pop()
-            {
-                static_assert(std::is_trivially_copyable_v<NO_REF> && "Type must be bitwise copyable!");
-                static_assert(alignof(NO_REF) <= MAX_ALIGNMENT && "Type alignment must not be greater than the max alignment!");
-                constexpr auto size = aligned_size(sizeof(NO_REF));
+        };
+
+        template <typename T>
+        static constexpr size_t aligned_size() noexcept
+        {
+            const auto bytes = detail::aligned_size(sizeof(NO_REF_T<T>));
+            if constexpr (blt::gp::detail::has_func_drop_v<T>)
+                return bytes + aligned_size<size_t*>();
+            return bytes;
+        }
+
+        stack_allocator() = default;
+
+        stack_allocator(const stack_allocator& copy)
+        {
+            if (copy.data_ == nullptr || copy.bytes_stored == 0)
+                return;
+            expand(copy.size_);
+            std::memcpy(data_, copy.data_, copy.bytes_stored);
+            bytes_stored = copy.bytes_stored;
+        }
+
+        stack_allocator(stack_allocator&& move) noexcept:
+            data_(std::exchange(move.data_, nullptr)), bytes_stored(std::exchange(move.bytes_stored, 0)), size_(std::exchange(move.size_, 0))
+        {
+        }
+
+        stack_allocator& operator=(const stack_allocator& copy) = delete;
+
+        stack_allocator& operator=(stack_allocator&& move) noexcept
+        {
+            data_ = std::exchange(move.data_, data_);
+            size_ = std::exchange(move.size_, size_);
+            bytes_stored = std::exchange(move.bytes_stored, bytes_stored);
+            return *this;
+        }
+
+        ~stack_allocator()
+        {
+            get_allocator().deallocate(data_, size_);
+        }
+
+        void insert(const stack_allocator& stack)
+        {
+            if (stack.empty())
+                return;
+            if (stack.bytes_stored + bytes_stored > size_)
+                expand(stack.bytes_stored + size_);
+            std::memcpy(data_ + bytes_stored, stack.data_, stack.bytes_stored);
+            bytes_stored += stack.bytes_stored;
+        }
+
+        void copy_from(const stack_allocator& stack, blt::size_t bytes)
+        {
+            if (bytes == 0)
+                return;
+            if (bytes + bytes_stored > size_)
+                expand(bytes + size_);
+            std::memcpy(data_ + bytes_stored, stack.data_ + (stack.bytes_stored - bytes), bytes);
+            bytes_stored += bytes;
+        }
+
+        void copy_from(const u8* data, const size_t bytes)
+        {
+            if (bytes == 0 || data == nullptr)
+                return;
+            if (bytes + bytes_stored > size_)
+                expand(bytes + size_);
+            std::memcpy(data_ + bytes_stored, data, bytes);
+            bytes_stored += bytes;
+        }
+
+        void copy_to(u8* data, const size_t bytes) const
+        {
+            if (bytes == 0 || data == nullptr)
+                return;
+            std::memcpy(data, data_ + (bytes_stored - bytes), bytes);
+        }
+
+        template <typename T, typename NO_REF = NO_REF_T<T>>
+        void push(const T& t)
+        {
+            static_assert(std::is_trivially_copyable_v<NO_REF>, "Type must be bitwise copyable!");
+            static_assert(alignof(NO_REF) <= gp::detail::MAX_ALIGNMENT, "Type alignment must not be greater than the max alignment!");
+            const auto ptr = allocate_bytes_for_size(aligned_size<NO_REF>());
+            std::memcpy(ptr, &t, sizeof(NO_REF));
+        }
+
+        template <typename T, typename NO_REF = NO_REF_T<T>>
+        T pop()
+        {
+            static_assert(std::is_trivially_copyable_v<NO_REF>, "Type must be bitwise copyable!");
+            static_assert(alignof(NO_REF) <= gp::detail::MAX_ALIGNMENT, "Type alignment must not be greater than the max alignment!");
+            constexpr auto size = aligned_size<NO_REF>();
 #if BLT_DEBUG_LEVEL > 0
-                if (bytes_stored < size)
-                    BLT_ABORT("Not enough bytes left to pop!");
+            if (bytes_stored < size)
+                BLT_ABORT("Not enough bytes left to pop!");
 #endif
-                bytes_stored -= size;
-                return *reinterpret_cast<T*>(data_ + bytes_stored);
-            }
-            
-            [[nodiscard]] blt::u8* from(blt::size_t bytes) const
-            {
+            bytes_stored -= size;
+            return *reinterpret_cast<T*>(data_ + bytes_stored);
+        }
+
+        [[nodiscard]] u8* from(const size_t bytes) const
+        {
 #if BLT_DEBUG_LEVEL > 0
-                if (bytes_stored < bytes)
-                    BLT_ABORT(("Not enough bytes in stack to reference " + std::to_string(bytes) + " bytes requested but " + std::to_string(bytes) +
-                               " bytes stored!").c_str());
+            if (bytes_stored < bytes)
+                BLT_ABORT(("Not enough bytes in stack to reference " + std::to_string(bytes) + " bytes requested but " + std::to_string(bytes) +
+                " bytes stored!").c_str());
 #endif
-                return data_ + (bytes_stored - bytes);
-            }
-            
-            template<typename T, typename NO_REF = NO_REF_T<T>>
-            T& from(blt::size_t bytes)
-            {
-                static_assert(std::is_trivially_copyable_v<NO_REF> && "Type must be bitwise copyable!");
-                static_assert(alignof(NO_REF) <= MAX_ALIGNMENT && "Type alignment must not be greater than the max alignment!");
-                return *reinterpret_cast<NO_REF*>(from(aligned_size(sizeof(NO_REF)) + bytes));
-            }
-            
-            void pop_bytes(blt::size_t bytes)
-            {
+            return data_ + (bytes_stored - bytes);
+        }
+
+        template <typename T, typename NO_REF = NO_REF_T<T>>
+        T& from(const size_t bytes)
+        {
+            static_assert(std::is_trivially_copyable_v<NO_REF> && "Type must be bitwise copyable!");
+            static_assert(alignof(NO_REF) <= gp::detail::MAX_ALIGNMENT && "Type alignment must not be greater than the max alignment!");
+            return *reinterpret_cast<NO_REF*>(from(aligned_size<NO_REF>() + bytes));
+        }
+
+        void pop_bytes(const size_t bytes)
+        {
 #if BLT_DEBUG_LEVEL > 0
-                if (bytes_stored < bytes)
-                    BLT_ABORT(("Not enough bytes in stack to pop " + std::to_string(bytes) + " bytes requested but " + std::to_string(bytes) +
-                               " bytes stored!").c_str());
+            if (bytes_stored < bytes)
+                BLT_ABORT(("Not enough bytes in stack to pop " + std::to_string(bytes) + " bytes requested but " + std::to_string(bytes) +
+                " bytes stored!").c_str());
+            gp::detail::check_alignment(bytes);
 #endif
-                bytes_stored -= bytes;
-            }
-            
-            void transfer_bytes(stack_allocator& to, blt::size_t bytes)
-            {
+            bytes_stored -= bytes;
+        }
+
+        void transfer_bytes(stack_allocator& to, const size_t aligned_bytes)
+        {
 #if BLT_DEBUG_LEVEL > 0
-                if (bytes_stored < bytes)
-                    BLT_ABORT(("Not enough bytes in stack to transfer " + std::to_string(bytes) + " bytes requested but " + std::to_string(bytes) +
-                               " bytes stored!").c_str());
+            if (bytes_stored < aligned_bytes)
+                BLT_ABORT(("Not enough bytes in stack to transfer " + std::to_string(aligned_bytes) + " bytes requested but " + std::to_string(aligned_bytes) +
+                " bytes stored!").c_str());
+            gp::detail::check_alignment(aligned_bytes);
 #endif
-                auto alg = aligned_size(bytes);
-                to.copy_from(*this, alg);
-                pop_bytes(alg);
-            }
-            
-            template<typename... Args>
-            void call_destructors()
+            to.copy_from(*this, aligned_bytes);
+            pop_bytes(aligned_bytes);
+        }
+
+        template <typename... Args>
+        void call_destructors()
+        {
+            if constexpr (sizeof...(Args) > 0)
             {
-                if constexpr (sizeof...(Args) > 0)
-                {
-                    blt::size_t offset = (stack_allocator::aligned_size(sizeof(NO_REF_T<Args>)) + ...) -
-                                         stack_allocator::aligned_size(sizeof(NO_REF_T<typename blt::meta::arg_helper<Args...>::First>));
-                    ((call_drop<Args>(offset), offset -= stack_allocator::aligned_size(sizeof(NO_REF_T<Args>))), ...);
-                }
+                size_t offset = (aligned_size<NO_REF_T<Args>>() + ...) - aligned_size<NO_REF_T<typename meta::arg_helper<Args...>::First>>();
+                ((call_drop<Args>(offset), offset -= aligned_size<NO_REF_T<Args>>()), ...);
             }
-            
-            [[nodiscard]] bool empty() const noexcept
-            {
-                return bytes_stored == 0;
-            }
-            
-            [[nodiscard]] blt::ptrdiff_t remaining_bytes_in_block() const noexcept
-            {
-                return static_cast<blt::ptrdiff_t>(size_ - bytes_stored);
-            }
-            
-            [[nodiscard]] blt::ptrdiff_t bytes_in_head() const noexcept
-            {
-                return static_cast<blt::ptrdiff_t>(bytes_stored);
-            }
-            
-            [[nodiscard]] size_data_t size() const noexcept
-            {
-                size_data_t data;
-                
-                data.total_used_bytes = bytes_stored;
-                data.total_size_bytes = size_;
-                data.total_remaining_bytes = remaining_bytes_in_block();
-                
-                return data;
-            }
-            
-            void reserve(blt::size_t bytes)
-            {
-                if (bytes > size_)
-                    expand_raw(bytes);
-            }
-            
-            [[nodiscard]] blt::size_t stored() const
-            {
-                return bytes_stored;
-            }
-            
-            [[nodiscard]] blt::size_t internal_storage_size() const
-            {
-                return size_;
-            }
-            
-            void reset()
-            {
-                bytes_stored = 0;
-            }
-        
-        private:
-            void expand(blt::size_t bytes)
-            {
-                //bytes = to_nearest_page_size(bytes);
+        }
+
+        [[nodiscard]] bool empty() const noexcept
+        {
+            return bytes_stored == 0;
+        }
+
+        [[nodiscard]] ptrdiff_t remaining_bytes_in_block() const noexcept
+        {
+            return static_cast<ptrdiff_t>(size_ - bytes_stored);
+        }
+
+        [[nodiscard]] ptrdiff_t bytes_in_head() const noexcept
+        {
+            return static_cast<ptrdiff_t>(bytes_stored);
+        }
+
+        [[nodiscard]] size_data_t size() const noexcept
+        {
+            size_data_t data;
+
+            data.total_used_bytes = bytes_stored;
+            data.total_size_bytes = size_;
+            data.total_remaining_bytes = remaining_bytes_in_block();
+
+            return data;
+        }
+
+        void reserve(const size_t bytes)
+        {
+            if (bytes > size_)
                 expand_raw(bytes);
-            }
-            
-            void expand_raw(blt::size_t bytes)
+        }
+
+        [[nodiscard]] size_t stored() const
+        {
+            return bytes_stored;
+        }
+
+        [[nodiscard]] size_t internal_storage_size() const
+        {
+            return size_;
+        }
+
+        void reset()
+        {
+            bytes_stored = 0;
+        }
+
+    private:
+        void expand(const size_t bytes)
+        {
+            //bytes = to_nearest_page_size(bytes);
+            expand_raw(bytes);
+        }
+
+        void expand_raw(const size_t bytes)
+        {
+            // auto aligned = detail::aligned_size(bytes);
+            const auto new_data = static_cast<u8*>(get_allocator().allocate(bytes));
+            if (bytes_stored > 0)
+                std::memcpy(new_data, data_, bytes_stored);
+            get_allocator().deallocate(data_, size_);
+            data_ = new_data;
+            size_ = bytes;
+        }
+
+        static size_t to_nearest_page_size(const size_t bytes) noexcept
+        {
+            constexpr static size_t MASK = ~(PAGE_SIZE - 1);
+            return (bytes & MASK) + PAGE_SIZE;
+        }
+
+        [[nodiscard]] void* get_aligned_pointer(const size_t bytes) const noexcept
+        {
+            if (data_ == nullptr)
+                return nullptr;
+            size_t remaining_bytes = remaining_bytes_in_block();
+            auto* pointer = static_cast<void*>(data_ + bytes_stored);
+            return std::align(gp::detail::MAX_ALIGNMENT, bytes, pointer, remaining_bytes);
+        }
+
+        void* allocate_bytes_for_size(const size_t aligned_bytes)
+        {
+#if BLT_DEBUG_LEVEL > 0
+            gp::detail::check_alignment(aligned_bytes);
+#endif
+            auto aligned_ptr = get_aligned_pointer(aligned_bytes);
+            if (aligned_ptr == nullptr)
             {
-                auto new_data = static_cast<blt::u8*>(get_allocator().allocate(bytes));
-                if (bytes_stored > 0)
-                    std::memcpy(new_data, data_, bytes_stored);
-                get_allocator().deallocate(data_, size_);
-                data_ = new_data;
-                size_ = bytes;
+                expand(size_ + aligned_bytes);
+                aligned_ptr = get_aligned_pointer(aligned_bytes);
             }
-            
-            static size_t to_nearest_page_size(blt::size_t bytes) noexcept
+            if (aligned_ptr == nullptr)
+                throw std::bad_alloc();
+            bytes_stored += aligned_bytes;
+            return aligned_ptr;
+        }
+
+        template <typename T>
+        void call_drop(const size_t offset)
+        {
+            if constexpr (blt::gp::detail::has_func_drop_v<T>)
             {
-                constexpr static blt::size_t MASK = ~(PAGE_SIZE - 1);
-                return (bytes & MASK) + PAGE_SIZE;
+                from<NO_REF_T<T>>(offset).drop();
             }
-            
-            void* get_aligned_pointer(blt::size_t bytes) noexcept
-            {
-                if (data_ == nullptr)
-                    return nullptr;
-                blt::size_t remaining_bytes = remaining_bytes_in_block();
-                auto* pointer = static_cast<void*>(data_ + bytes_stored);
-                return std::align(MAX_ALIGNMENT, bytes, pointer, remaining_bytes);
-            }
-            
-            void* allocate_bytes_for_size(blt::size_t bytes)
-            {
-                auto used_bytes = aligned_size(bytes);
-                auto aligned_ptr = get_aligned_pointer(used_bytes);
-                if (aligned_ptr == nullptr)
-                {
-                    expand(size_ + used_bytes);
-                    aligned_ptr = get_aligned_pointer(used_bytes);
-                }
-                if (aligned_ptr == nullptr)
-                    throw std::bad_alloc();
-                bytes_stored += used_bytes;
-                return aligned_ptr;
-            }
-            
-            template<typename T>
-            inline void call_drop(blt::size_t offset)
-            {
-                if constexpr (detail::has_func_drop_v<T>)
-                {
-                    from<NO_REF_T<T >>(offset).drop();
-                }
-            }
-            
-            blt::u8* data_ = nullptr;
-            // place in the data_ array which has a free spot.
-            blt::size_t bytes_stored = 0;
-            blt::size_t size_ = 0;
+        }
+
+        u8* data_ = nullptr;
+        // place in the data_ array which has a free spot.
+        size_t bytes_stored = 0;
+        size_t size_ = 0;
+    };
+
+    template <size_t Size>
+    struct ref_counted_type
+    {
+        explicit ref_counted_type(size_t* ref_count): ref_count(ref_count)
+        {
+        }
+
+        size_t* ref_count = nullptr;
+        u8 storage[Size]{};
+
+        static size_t* access(const void* ptr)
+        {
+            ref_counted_type<1> type{nullptr};
+            std::memcpy(&type, ptr, sizeof(size_t*));
+            return type.ref_count;
+        }
     };
-    
-    
 }
 
 #endif //BLT_GP_STACK_H

include/blt/gp/transformers.h

@@ -60,27 +60,30 @@ namespace blt::gp
         public:
             struct point_info_t
             {
-                blt::ptrdiff_t point;
+                ptrdiff_t point;
                 operator_info_t& type_operator_info;
             };
             struct crossover_point_t
             {
-                blt::ptrdiff_t p1_crossover_point;
-                blt::ptrdiff_t p2_crossover_point;
+                ptrdiff_t p1_crossover_point;
+                ptrdiff_t p2_crossover_point;
             };
             struct config_t
             {
                 // number of times crossover will try to pick a valid point in the tree. this is purely based on the return type of the operators
-                blt::u16 max_crossover_tries = 5;
-                blt::f32 traverse_chance = 0.5;
-                blt::u32 min_tree_size = 5;
-                
-                // legacy settings:
-                
-                // if we fail to find a point in the tree, should we search forward from the last point to the end of the operators?
-                bool should_crossover_try_forward = false;
-                // avoid selecting terminals when doing crossover
-                bool avoid_terminals = false;
+                u32 max_crossover_tries = 5;
+                // if tree have fewer nodes than this number, they will not be considered for crossover
+                // should be at least 5 as crossover will not select the root node.
+                u32 min_tree_size = 5;
+                // used by the traverse version of get_crossover_point
+                // at each depth level, what chance do we have to exit with this as our point? or in other words what's the chance we continue traversing
+                // this is what this option configures.
+                f32 traverse_chance = 0.5;
+                // how often should we select terminals over functions. By default, we only allow selection of terminals 10% of the time
+                // this applies to both types of crossover point functions. Traversal will use the parent if it should not pick a terminal.
+                f32 terminal_chance = 0.1;
+                // use traversal to select point instead of random selection
+                bool traverse = false;
             };
             
             crossover_t() = default;
@@ -88,13 +91,11 @@ namespace blt::gp
             explicit crossover_t(const config_t& config): config(config)
             {}
             
-            std::optional<crossover_t::crossover_point_t> get_crossover_point(gp_program& program, const tree_t& c1, const tree_t& c2) const;
+            std::optional<crossover_point_t> get_crossover_point(gp_program& program, const tree_t& c1, const tree_t& c2) const;
             
-            std::optional<crossover_t::crossover_point_t> get_crossover_point_traverse(gp_program& program, const tree_t& c1, const tree_t& c2) const;
+            std::optional<crossover_point_t> get_crossover_point_traverse(gp_program& program, const tree_t& c1, const tree_t& c2) const;
             
-            std::optional<point_info_t> get_point_traverse(gp_program& program, const tree_t& t, std::optional<type_id> type) const;
-            
-            static std::optional<point_info_t> random_place_of_type(gp_program& program, const tree_t& t, type_id type);
+            std::optional<point_info_t> get_point_from_traverse_raw(gp_program& program, const tree_t& t, std::optional<type_id> type) const;
             
             /**
              * child1 and child2 are copies of the parents, the result of selecting a crossover point and performing standard subtree crossover.
@@ -138,7 +139,7 @@ namespace blt::gp
             virtual bool apply(gp_program& program, const tree_t& p, tree_t& c);
             
             // returns the point after the mutation
-            blt::size_t mutate_point(gp_program& program, tree_t& c, blt::size_t node);
+            blt::size_t mutate_point(gp_program& program, tree_t& c, blt::size_t node) const;
             
             virtual ~mutation_t() = default;
         

include/blt/gp/tree.h

@@ -34,13 +34,38 @@ namespace blt::gp
     
     struct op_container_t
     {
-        op_container_t(blt::size_t type_size, operator_id id, bool is_value):
-                type_size(type_size), id(id), is_value(is_value)
+        op_container_t(const size_t type_size, const operator_id id, const bool is_value):
+                m_type_size(type_size), m_id(id), m_is_value(is_value), m_has_drop(false)
         {}
-        
-        blt::size_t type_size;
-        operator_id id;
-        bool is_value;
+
+        op_container_t(const size_t type_size, const operator_id id, const bool is_value, const bool has_drop):
+                m_type_size(type_size), m_id(id), m_is_value(is_value), m_has_drop(has_drop)
+        {}
+
+        [[nodiscard]] auto type_size() const
+        {
+            return m_type_size;
+        }
+
+        [[nodiscard]] auto id() const
+        {
+            return m_id;
+        }
+
+        [[nodiscard]] auto is_value() const
+        {
+            return m_is_value;
+        }
+
+        [[nodiscard]] bool has_drop() const
+        {
+            return m_has_drop;
+        }
+    private:
+        size_t m_type_size;
+        operator_id m_id;
+        bool m_is_value;
+        bool m_has_drop;
     };
     
     class evaluation_context
@@ -74,13 +99,41 @@ namespace blt::gp
             {
                 if (this == &copy)
                     return;
-                values.reserve(copy.values.internal_storage_size());
+                values.reserve(copy.values.stored());
                 values.reset();
                 values.insert(copy.values);
-                
-                operations.clear();
+
                 operations.reserve(copy.operations.size());
-                operations.insert(operations.begin(), copy.operations.begin(), copy.operations.end());
+
+                auto copy_it = copy.operations.begin();
+                auto op_it = operations.begin();
+
+                for (; op_it != operations.end(); ++op_it)
+                {
+                    if (op_it->has_drop())
+                    {
+
+                    }
+                    if (copy_it == copy.operations.end())
+                        break;
+                    *op_it = *copy_it;
+                    if (copy_it->has_drop())
+                    {
+
+                    }
+                    ++copy_it;
+                }
+                const auto op_it_cpy = op_it;
+                for (;op_it != operations.end(); ++op_it)
+                {
+                    if (op_it->has_drop())
+                    {
+
+                    }
+                }
+                operations.erase(op_it_cpy, operations.end());
+                for (; copy_it != copy.operations.end(); ++copy_it)
+                    operations.emplace_back(*copy_it);
             }
             
             tree_t(tree_t&& move) = default;
@@ -106,7 +159,7 @@ namespace blt::gp
                 return operations;
             }
             
-            [[nodiscard]] inline blt::gp::stack_allocator& get_values()
+            [[nodiscard]] inline stack_allocator& get_values()
             {
                 return values;
             }
@@ -127,7 +180,7 @@ namespace blt::gp
                 return (*func)(*this, nullptr);
             }
             
-            blt::size_t get_depth(gp_program& program);
+            blt::size_t get_depth(gp_program& program) const;
             
             /**
              * Helper template for returning the result of the last evaluation
@@ -175,36 +228,36 @@ namespace blt::gp
             blt::ptrdiff_t find_parent(blt::gp::gp_program& program, blt::ptrdiff_t start) const;
             
             // valid for [begin, end)
-            static blt::size_t total_value_bytes(detail::const_op_iter_t begin, detail::const_op_iter_t end)
+            static size_t total_value_bytes(const detail::const_op_iter_t begin, const detail::const_op_iter_t end)
             {
-                blt::size_t total = 0;
-                for (auto it = begin; it != end; it++)
+                size_t total = 0;
+                for (auto it = begin; it != end; ++it)
                 {
-                    if (it->is_value)
-                        total += stack_allocator::aligned_size(it->type_size);
+                    if (it->is_value())
+                        total += it->type_size();
                 }
                 return total;
             }
             
-            [[nodiscard]] blt::size_t total_value_bytes(blt::size_t begin, blt::size_t end) const
+            [[nodiscard]] size_t total_value_bytes(const size_t begin, const size_t end) const
             {
                 return total_value_bytes(operations.begin() + static_cast<blt::ptrdiff_t>(begin),
                                          operations.begin() + static_cast<blt::ptrdiff_t>(end));
             }
             
-            [[nodiscard]] blt::size_t total_value_bytes(blt::size_t begin) const
+            [[nodiscard]] size_t total_value_bytes(const size_t begin) const
             {
                 return total_value_bytes(operations.begin() + static_cast<blt::ptrdiff_t>(begin), operations.end());
             }
             
-            [[nodiscard]] blt::size_t total_value_bytes() const
+            [[nodiscard]] size_t total_value_bytes() const
             {
                 return total_value_bytes(operations.begin(), operations.end());
             }
         
         private:
             tracked_vector<op_container_t> operations;
-            blt::gp::stack_allocator values;
+            stack_allocator values;
             detail::eval_func_t* func;
     };
     
@@ -213,7 +266,7 @@ namespace blt::gp
         double raw_fitness = 0;
         double standardized_fitness = 0;
         double adjusted_fitness = 0;
-        blt::i64 hits = 0;
+        i64 hits = 0;
     };
     
     struct individual_t
@@ -246,45 +299,6 @@ namespace blt::gp
         individual_t& operator=(individual_t&&) = default;
     };
     
-    struct population_stats
-    {
-        population_stats() = default;
-        
-        population_stats(const population_stats& copy):
-                overall_fitness(copy.overall_fitness.load()), average_fitness(copy.average_fitness.load()), best_fitness(copy.best_fitness.load()),
-                worst_fitness(copy.worst_fitness.load())
-        {
-            normalized_fitness.reserve(copy.normalized_fitness.size());
-            for (auto v : copy.normalized_fitness)
-                normalized_fitness.push_back(v);
-        }
-        
-        population_stats(population_stats&& move) noexcept:
-                overall_fitness(move.overall_fitness.load()), average_fitness(move.average_fitness.load()), best_fitness(move.best_fitness.load()),
-                worst_fitness(move.worst_fitness.load()), normalized_fitness(std::move(move.normalized_fitness))
-        {
-            move.overall_fitness = 0;
-            move.average_fitness = 0;
-            move.best_fitness = 0;
-            move.worst_fitness = 0;
-        }
-        
-        std::atomic<double> overall_fitness = 0;
-        std::atomic<double> average_fitness = 0;
-        std::atomic<double> best_fitness = 0;
-        std::atomic<double> worst_fitness = 1;
-        tracked_vector<double> normalized_fitness{};
-        
-        void clear()
-        {
-            overall_fitness = 0;
-            average_fitness = 0;
-            best_fitness = 0;
-            worst_fitness = 0;
-            normalized_fitness.clear();
-        }
-    };
-    
     class population_t
     {
         public:

include/blt/gp/typesystem.h

@@ -46,9 +46,9 @@ namespace blt::gp
             type() = default;
             
             template<typename T>
-            static type make_type(type_id id)
+            static type make_type(const type_id id)
             {
-                return type(sizeof(T), id, blt::type_string<T>());
+                return type(stack_allocator::aligned_size<T>(), id, blt::type_string<T>());
             }
             
             [[nodiscard]] inline blt::size_t size() const

include/blt/gp/util/statistics.h

@@ -0,0 +1,202 @@
+#pragma once
+/*
+ *  Copyright (C) 2024  Brett Terpstra
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef BLT_GP_UTIL_STATISTICS_H
+#define BLT_GP_UTIL_STATISTICS_H
+
+#include <blt/gp/util/trackers.h>
+#include <blt/gp/allocator.h>
+#include <blt/gp/fwdecl.h>
+
+namespace blt::gp
+{
+    struct confusion_matrix_t
+    {
+    public:
+        confusion_matrix_t() = default;
+
+        confusion_matrix_t& is_A_predicted_A()
+        {
+            ++is_A_pred_A;
+            return *this;
+        }
+
+        confusion_matrix_t& is_A_predicted_B()
+        {
+            ++is_A_pred_B;
+            return *this;
+        }
+
+        confusion_matrix_t& is_B_predicted_A()
+        {
+            ++is_B_pred_A;
+            return *this;
+        }
+
+        confusion_matrix_t& is_B_predicted_B()
+        {
+            ++is_B_pred_B;
+            return *this;
+        }
+
+        confusion_matrix_t& set_name_a(const std::string& name_a)
+        {
+            name_A = name_a;
+            return *this;
+        }
+
+        confusion_matrix_t& set_name_b(const std::string& name_b)
+        {
+            name_B = name_b;
+            return *this;
+        }
+
+        [[nodiscard]] u64 get_is_a_pred_a() const
+        {
+            return is_A_pred_A;
+        }
+
+        [[nodiscard]] u64 get_is_a_pred_b() const
+        {
+            return is_A_pred_B;
+        }
+
+        [[nodiscard]] u64 get_is_b_pred_b() const
+        {
+            return is_B_pred_B;
+        }
+
+        [[nodiscard]] u64 get_is_b_pred_a() const
+        {
+            return is_B_pred_A;
+        }
+
+        [[nodiscard]] u64 get_hits() const
+        {
+            return is_A_pred_A + is_B_pred_B;
+        }
+
+        [[nodiscard]] u64 get_misses() const
+        {
+            return is_B_pred_A + is_A_pred_B;
+        }
+
+        [[nodiscard]] u64 get_total() const
+        {
+            return get_hits() + get_misses();
+        }
+
+        [[nodiscard]] double get_percent_hit() const
+        {
+            return static_cast<double>(get_hits()) / static_cast<double>(get_total());
+        }
+
+        confusion_matrix_t& operator+=(const confusion_matrix_t& op)
+        {
+            is_A_pred_A += op.is_A_pred_A;
+            is_B_pred_A += op.is_B_pred_A;
+            is_A_pred_B += op.is_A_pred_B;
+            is_B_pred_B += op.is_B_pred_B;
+            return *this;
+        }
+
+        confusion_matrix_t& operator/=(const u64 val)
+        {
+            is_A_pred_A /= val;
+            is_B_pred_A /= val;
+            is_A_pred_B /= val;
+            is_B_pred_B /= val;
+            return *this;
+        }
+
+        friend confusion_matrix_t operator+(const confusion_matrix_t& op1, const confusion_matrix_t& op2)
+        {
+            confusion_matrix_t result = op1;
+            result += op2;
+            return result;
+        }
+
+        friend confusion_matrix_t operator/(const confusion_matrix_t& op1, const u64 val)
+        {
+            confusion_matrix_t result = op1;
+            result /= val;
+            return result;
+        }
+
+        friend bool operator<(const confusion_matrix_t& a, const confusion_matrix_t& b)
+        {
+            return a.get_percent_hit() < b.get_percent_hit();
+        }
+
+        friend bool operator>(const confusion_matrix_t& a, const confusion_matrix_t& b)
+        {
+            return a.get_percent_hit() > b.get_percent_hit();
+        }
+
+        [[nodiscard]] std::string pretty_print(const std::string& table_name = "Confusion Matrix") const;
+
+    private:
+        u64 is_A_pred_A = 0;
+        u64 is_A_pred_B = 0;
+        u64 is_B_pred_B = 0;
+        u64 is_B_pred_A = 0;
+        std::string name_A = "A";
+        std::string name_B = "B";
+    };
+
+    struct population_stats
+    {
+        population_stats() = default;
+
+        population_stats(const population_stats& copy):
+            overall_fitness(copy.overall_fitness.load()), average_fitness(copy.average_fitness.load()), best_fitness(copy.best_fitness.load()),
+            worst_fitness(copy.worst_fitness.load())
+        {
+            normalized_fitness.reserve(copy.normalized_fitness.size());
+            for (auto v : copy.normalized_fitness)
+                normalized_fitness.push_back(v);
+        }
+
+        population_stats(population_stats&& move) noexcept:
+            overall_fitness(move.overall_fitness.load()), average_fitness(move.average_fitness.load()), best_fitness(move.best_fitness.load()),
+            worst_fitness(move.worst_fitness.load()), normalized_fitness(std::move(move.normalized_fitness))
+        {
+            move.overall_fitness = 0;
+            move.average_fitness = 0;
+            move.best_fitness = 0;
+            move.worst_fitness = 0;
+        }
+
+        std::atomic<double> overall_fitness = 0;
+        std::atomic<double> average_fitness = 0;
+        std::atomic<double> best_fitness = 0;
+        std::atomic<double> worst_fitness = 1;
+        tracked_vector<double> normalized_fitness{};
+
+        void clear()
+        {
+            overall_fitness = 0;
+            average_fitness = 0;
+            best_fitness = 0;
+            worst_fitness = 0;
+            normalized_fitness.clear();
+        }
+    };
+}
+
+#endif //BLT_GP_UTIL_STATISTICS_H

lib/blt

@@ -1 +1 @@
-Subproject commit 0869509c6a5fd530efbd57469d2b99b89c22b769
+Subproject commit 8133553ed87f705c890c5becda710f72f3ddccb9

src/generators.cpp

@@ -60,7 +60,7 @@ namespace blt::gp
             tree_generator.pop();
             
             auto& info = args.program.get_operator_info(top.id);
-            
+
             tree.get_operations().emplace_back(
                     args.program.get_typesystem().get_type(info.return_type).size(),
                     top.id,

src/transformers.cpp

@@ -26,124 +26,129 @@
 
 namespace blt::gp
 {
-    
     grow_generator_t grow_generator;
-    
+
     inline tree_t& get_static_tree_tl(gp_program& program)
     {
-        static thread_local tree_t new_tree{program};
+        thread_local tree_t new_tree{program};
         new_tree.clear(program);
         return new_tree;
     }
-    
-    inline blt::size_t accumulate_type_sizes(detail::op_iter_t begin, detail::op_iter_t end)
+
+    inline size_t accumulate_type_sizes(detail::op_iter_t begin, detail::op_iter_t end)
     {
-        blt::size_t total = 0;
+        size_t total = 0;
         for (auto it = begin; it != end; ++it)
         {
-            if (it->is_value)
-                total += stack_allocator::aligned_size(it->type_size);
+            if (it->is_value())
+                total += it->type_size();
         }
         return total;
     }
-    
-    template<typename>
-    blt::u8* get_thread_pointer_for_size(blt::size_t bytes)
+
+    template <typename>
+    u8* get_thread_pointer_for_size(size_t bytes)
     {
-        static thread_local blt::expanding_buffer<blt::u8> buffer;
+        thread_local expanding_buffer<u8> buffer;
         if (bytes > buffer.size())
             buffer.resize(bytes);
         return buffer.data();
     }
-    
+
     mutation_t::config_t::config_t(): generator(grow_generator)
-    {}
-    
+    {
+    }
+
     bool crossover_t::apply(gp_program& program, const tree_t& p1, const tree_t& p2, tree_t& c1, tree_t& c2) // NOLINT
     {
         if (p1.get_operations().size() < config.min_tree_size || p2.get_operations().size() < config.min_tree_size)
             return false;
-        
+
         auto& c1_ops = c1.get_operations();
         auto& c2_ops = c2.get_operations();
-        
-        auto point = get_crossover_point(program, p1, p2);
-        
+
+        std::optional<crossover_point_t> point;
+
+        if (config.traverse)
+            point = get_crossover_point_traverse(program, p1, p2);
+        else
+            point = get_crossover_point(program, p1, p2);
+
         if (!point)
             return false;
-        
-        auto selection = program.get_random().get_u32(0, 2);
-        
+
+        const auto selection = program.get_random().get_u32(0, 2);
+
         // Used to make copies of operators. Statically stored for memory caching purposes.
         // Thread local as this function cannot have external modifications / will be called from multiple threads.
-        static thread_local tracked_vector<op_container_t> c1_operators;
-        static thread_local tracked_vector<op_container_t> c2_operators;
+        thread_local tracked_vector<op_container_t> c1_operators;
+        thread_local tracked_vector<op_container_t> c2_operators;
         c1_operators.clear();
         c2_operators.clear();
-        
+
         // TODO: more crossover!
         switch (selection)
         {
-            case 0:
-            case 1:
+        case 0:
+        case 1:
             {
                 // basic crossover
-                auto crossover_point_begin_itr = c1_ops.begin() + point->p1_crossover_point;
-                auto crossover_point_end_itr = c1_ops.begin() + c1.find_endpoint(program, point->p1_crossover_point);
-                
-                auto found_point_begin_itr = c2_ops.begin() + point->p2_crossover_point;
-                auto found_point_end_itr = c2_ops.begin() + c2.find_endpoint(program, point->p2_crossover_point);
-                
+                const auto crossover_point_begin_itr = c1_ops.begin() + point->p1_crossover_point;
+                const auto crossover_point_end_itr = c1_ops.begin() + c1.find_endpoint(program, point->p1_crossover_point);
+
+                const auto found_point_begin_itr = c2_ops.begin() + point->p2_crossover_point;
+                const auto found_point_end_itr = c2_ops.begin() + c2.find_endpoint(program, point->p2_crossover_point);
+
                 stack_allocator& c1_stack = c1.get_values();
                 stack_allocator& c2_stack = c2.get_values();
-                
-                for (const auto& op : blt::iterate(crossover_point_begin_itr, crossover_point_end_itr))
+
+                for (const auto& op : iterate(crossover_point_begin_itr, crossover_point_end_itr))
                     c1_operators.push_back(op);
-                for (const auto& op : blt::iterate(found_point_begin_itr, found_point_end_itr))
+                for (const auto& op : iterate(found_point_begin_itr, found_point_end_itr))
                     c2_operators.push_back(op);
-                
-                blt::size_t c1_stack_after_bytes = accumulate_type_sizes(crossover_point_end_itr, c1_ops.end());
-                blt::size_t c1_stack_for_bytes = accumulate_type_sizes(crossover_point_begin_itr, crossover_point_end_itr);
-                blt::size_t c2_stack_after_bytes = accumulate_type_sizes(found_point_end_itr, c2_ops.end());
-                blt::size_t c2_stack_for_bytes = accumulate_type_sizes(found_point_begin_itr, found_point_end_itr);
-                auto c1_total = static_cast<blt::ptrdiff_t>(c1_stack_after_bytes + c1_stack_for_bytes);
-                auto c2_total = static_cast<blt::ptrdiff_t>(c2_stack_after_bytes + c2_stack_for_bytes);
-                auto copy_ptr_c1 = get_thread_pointer_for_size<struct c1_t>(c1_total);
-                auto copy_ptr_c2 = get_thread_pointer_for_size<struct c2_t>(c2_total);
-                
+
+                const size_t c1_stack_after_bytes = accumulate_type_sizes(crossover_point_end_itr, c1_ops.end());
+                const size_t c1_stack_for_bytes = accumulate_type_sizes(crossover_point_begin_itr, crossover_point_end_itr);
+                const size_t c2_stack_after_bytes = accumulate_type_sizes(found_point_end_itr, c2_ops.end());
+                const size_t c2_stack_for_bytes = accumulate_type_sizes(found_point_begin_itr, found_point_end_itr);
+                const auto c1_total = static_cast<blt::ptrdiff_t>(c1_stack_after_bytes + c1_stack_for_bytes);
+                const auto c2_total = static_cast<blt::ptrdiff_t>(c2_stack_after_bytes + c2_stack_for_bytes);
+                const auto copy_ptr_c1 = get_thread_pointer_for_size<struct c1_t>(c1_total);
+                const auto copy_ptr_c2 = get_thread_pointer_for_size<struct c2_t>(c2_total);
+
                 c1_stack.reserve(c1_stack.bytes_in_head() - c1_stack_for_bytes + c2_stack_for_bytes);
                 c2_stack.reserve(c2_stack.bytes_in_head() - c2_stack_for_bytes + c1_stack_for_bytes);
-                
+
                 c1_stack.copy_to(copy_ptr_c1, c1_total);
                 c1_stack.pop_bytes(c1_total);
-                
+
                 c2_stack.copy_to(copy_ptr_c2, c2_total);
                 c2_stack.pop_bytes(c2_total);
-                
+
                 c2_stack.copy_from(copy_ptr_c1, c1_stack_for_bytes);
                 c2_stack.copy_from(copy_ptr_c2 + c2_stack_for_bytes, c2_stack_after_bytes);
-                
+
                 c1_stack.copy_from(copy_ptr_c2, c2_stack_for_bytes);
                 c1_stack.copy_from(copy_ptr_c1 + c1_stack_for_bytes, c1_stack_after_bytes);
-                
+
                 // now swap the operators
                 auto insert_point_c1 = crossover_point_begin_itr - 1;
                 auto insert_point_c2 = found_point_begin_itr - 1;
-                
+
                 // invalidates [begin, end()) so the insert points should be fine
                 c1_ops.erase(crossover_point_begin_itr, crossover_point_end_itr);
                 c2_ops.erase(found_point_begin_itr, found_point_end_itr);
-                
+
                 c1_ops.insert(++insert_point_c1, c2_operators.begin(), c2_operators.end());
                 c2_ops.insert(++insert_point_c2, c1_operators.begin(), c1_operators.end());
             }
-                break;
-                break;
-            default:
+            break;
+            break;
+        default:
 #if BLT_DEBUG_LEVEL > 0
                 BLT_ABORT("This place should be unreachable!");
 #else
-                BLT_UNREACHABLE;
+            BLT_UNREACHABLE;
 #endif
         }
 
@@ -152,14 +157,14 @@ namespace blt::gp
         blt::size_t c2_found_bytes = c2.get_values().size().total_used_bytes;
         blt::size_t c1_expected_bytes = std::accumulate(c1.get_operations().begin(), c1.get_operations().end(), 0ul,
                                                         [](const auto& v1, const auto& v2) {
-                                                            if (v2.is_value)
-                                                                return v1 + stack_allocator::aligned_size(v2.type_size);
+                                                            if (v2.is_value())
+                                                                return v1 + v2.type_size();
                                                             return v1;
                                                         });
         blt::size_t c2_expected_bytes = std::accumulate(c2.get_operations().begin(), c2.get_operations().end(), 0ul,
                                                         [](const auto& v1, const auto& v2) {
-                                                            if (v2.is_value)
-                                                                return v1 + stack_allocator::aligned_size(v2.type_size);
+                                                            if (v2.is_value())
+                                                                return v1 + v2.type_size();
                                                             return v1;
                                                         });
         if (c1_found_bytes != c1_expected_bytes || c2_found_bytes != c2_expected_bytes)
@@ -169,99 +174,83 @@ namespace blt::gp
             BLT_ABORT("Amount of bytes in stack doesn't match the number of bytes expected for the operations");
         }
 #endif
-        
+
+        c1.get_depth(program);
+
         return true;
     }
-    
+
     std::optional<crossover_t::crossover_point_t> crossover_t::get_crossover_point(gp_program& program, const tree_t& c1,
                                                                                    const tree_t& c2) const
     {
         auto& c1_ops = c1.get_operations();
         auto& c2_ops = c2.get_operations();
-        
-        blt::size_t crossover_point = program.get_random().get_size_t(1ul, c1_ops.size());
-        
-        while (config.avoid_terminals && program.get_operator_info(c1_ops[crossover_point].id).argc.is_terminal())
-            crossover_point = program.get_random().get_size_t(1ul, c1_ops.size());
-        
-        blt::size_t attempted_point = 0;
-        
-        const auto& crossover_point_type = program.get_operator_info(c1_ops[crossover_point].id);
-        operator_info_t* attempted_point_type = nullptr;
-        
+
+        size_t crossover_point = program.get_random().get_size_t(1ul, c1_ops.size());
+
+        const bool allow_terminal_selection = program.get_random().choice(config.terminal_chance);
+
         blt::size_t counter = 0;
-        do
+        while (!allow_terminal_selection && program.get_operator_info(c1_ops[crossover_point].id()).argc.is_terminal())
         {
             if (counter >= config.max_crossover_tries)
-            {
-                if (config.should_crossover_try_forward)
-                {
-                    bool found = false;
-                    for (auto i = attempted_point + 1; i < c2_ops.size(); i++)
-                    {
-                        auto* info = &program.get_operator_info(c2_ops[i].id);
-                        if (info->return_type == crossover_point_type.return_type)
-                        {
-                            if (config.avoid_terminals && info->argc.is_terminal())
-                                continue;
-                            attempted_point = i;
-                            attempted_point_type = info;
-                            found = true;
-                            break;
-                        }
-                    }
-                    if (!found)
-                        return {};
-                }
-                // should we try again over the whole tree? probably not.
                 return {};
-            } else
-            {
-                attempted_point = program.get_random().get_size_t(1ul, c2_ops.size());
-                attempted_point_type = &program.get_operator_info(c2_ops[attempted_point].id);
-                if (config.avoid_terminals && attempted_point_type->argc.is_terminal())
-                    continue;
-                if (crossover_point_type.return_type == attempted_point_type->return_type)
-                    break;
-                counter++;
-            }
-        } while (true);
-        
-        return crossover_point_t{static_cast<blt::ptrdiff_t>(crossover_point), static_cast<blt::ptrdiff_t>(attempted_point)};
+            crossover_point = program.get_random().get_size_t(1ul, c1_ops.size());
+            counter++;
+        }
+
+        size_t attempted_point = 0;
+
+        const auto& crossover_point_type = program.get_operator_info(c1_ops[crossover_point].id());
+        const operator_info_t* attempted_point_type = nullptr;
+
+        for (counter = 0; counter < config.max_crossover_tries; counter++)
+        {
+            attempted_point = program.get_random().get_size_t(1ul, c2_ops.size());
+            attempted_point_type = &program.get_operator_info(c2_ops[attempted_point].id());
+            if (!allow_terminal_selection && attempted_point_type->argc.is_terminal())
+                continue;
+            if (crossover_point_type.return_type == attempted_point_type->return_type)
+                return crossover_point_t{static_cast<blt::ptrdiff_t>(crossover_point), static_cast<blt::ptrdiff_t>(attempted_point)};
+        }
+        return {};
     }
-    
+
     std::optional<crossover_t::crossover_point_t> crossover_t::get_crossover_point_traverse(gp_program& program, const tree_t& c1,
                                                                                             const tree_t& c2) const
     {
-        auto c1_point_o = get_point_traverse_retry(program, c1, {});
+        const auto c1_point_o = get_point_traverse_retry(program, c1, {});
         if (!c1_point_o)
             return {};
-        auto c2_point_o = get_point_traverse_retry(program, c2, c1_point_o->type_operator_info.return_type);
+        const auto c2_point_o = get_point_traverse_retry(program, c2, c1_point_o->type_operator_info.return_type);
         if (!c2_point_o)
             return {};
-        
         return {{c1_point_o->point, c2_point_o->point}};
     }
-    
-    std::optional<crossover_t::point_info_t> crossover_t::random_place_of_type(gp_program& program, const tree_t& t, type_id type)
-    {
-        auto attempted_point = program.get_random().get_i64(1ul, t.get_operations().size());
-        auto& attempted_point_type = program.get_operator_info(t.get_operations()[attempted_point].id);
-        if (type == attempted_point_type.return_type)
-            return {{attempted_point, attempted_point_type}};
-        return {};
-    }
-    
-    std::optional<crossover_t::point_info_t> crossover_t::get_point_traverse(gp_program& program, const tree_t& t, std::optional<type_id> type) const
+
+    std::optional<crossover_t::point_info_t> crossover_t::get_point_from_traverse_raw(gp_program& program, const tree_t& t,
+                                                                                      std::optional<type_id> type) const
     {
         auto& random = program.get_random();
-        
-        blt::ptrdiff_t point = 0;
+
+        bool should_select_terminal = program.get_random().choice(config.terminal_chance);
+
+        ptrdiff_t parent = -1;
+        ptrdiff_t point = 0;
         while (true)
         {
-            auto& current_op_type = program.get_operator_info(t.get_operations()[point].id);
+            auto& current_op_type = program.get_operator_info(t.get_operations()[point].id());
             if (current_op_type.argc.is_terminal())
             {
+                if (!should_select_terminal)
+                {
+                    if (parent == -1)
+                        return {};
+                    auto& parent_type = program.get_operator_info(t.get_operations()[parent].id());
+                    if (type && *type != parent_type.return_type)
+                        return {};
+                    return {{parent, parent_type}};
+                }
                 if (type && *type != current_op_type.return_type)
                     return {};
                 return {{point, current_op_type}};
@@ -269,88 +258,89 @@ namespace blt::gp
             // traverse to a child
             if (random.choice(config.traverse_chance))
             {
-                auto args = current_op_type.argc.argc;
-                auto argument = random.get_size_t(0, args);
-                
+                const auto args = current_op_type.argc.argc;
+                const auto argument = random.get_size_t(0, args);
+
+                parent = point;
                 // move to the first child
                 point += 1;
                 // loop through all the children we wish to skip. The result will be the first node of the next child, becoming the new parent
-                for (blt::size_t i = 0; i < argument; i++)
+                for (size_t i = 0; i < argument; i++)
                     point = t.find_endpoint(program, point);
-                
+
                 continue;
             }
             if (!type || (type && *type == current_op_type.return_type))
                 return {{point, current_op_type}};
         }
     }
-    
+
     std::optional<crossover_t::point_info_t> crossover_t::get_point_traverse_retry(gp_program& program, const tree_t& t,
                                                                                    std::optional<type_id> type) const
     {
-        for (blt::size_t i = 0; i < config.max_crossover_tries; i++)
+        for (size_t i = 0; i < config.max_crossover_tries; i++)
         {
-            if (auto found = get_point_traverse(program, t, type))
+            if (auto found = get_point_from_traverse_raw(program, t, type))
                 return found;
         }
         return {};
     }
-    
+
     bool mutation_t::apply(gp_program& program, const tree_t&, tree_t& c)
     {
         mutate_point(program, c, program.get_random().get_size_t(0ul, c.get_operations().size()));
         return true;
     }
-    
-    blt::size_t mutation_t::mutate_point(gp_program& program, tree_t& c, blt::size_t node)
+
+    blt::size_t mutation_t::mutate_point(gp_program& program, tree_t& c, blt::size_t node) const
     {
         auto& ops_r = c.get_operations();
         auto& vals_r = c.get_values();
-        
+
         auto begin_point = static_cast<blt::ptrdiff_t>(node);
         auto end_point = c.find_endpoint(program, begin_point);
-        auto begin_operator_id = ops_r[begin_point].id;
+        auto begin_operator_id = ops_r[begin_point].id();
         const auto& type_info = program.get_operator_info(begin_operator_id);
-        
+
         auto begin_itr = ops_r.begin() + begin_point;
         auto end_itr = ops_r.begin() + end_point;
-        
+
         auto& new_tree = get_static_tree_tl(program);
         config.generator.get().generate(new_tree, {program, type_info.return_type, config.replacement_min_depth, config.replacement_max_depth});
-        
+
         auto& new_ops_r = new_tree.get_operations();
         auto& new_vals_r = new_tree.get_values();
-        
+
         blt::size_t total_bytes_after = accumulate_type_sizes(end_itr, ops_r.end());
         auto* stack_after_data = get_thread_pointer_for_size<struct mutation>(total_bytes_after);
-        
+
         // make a copy of any stack data after the mutation point / children.
         vals_r.copy_to(stack_after_data, total_bytes_after);
-        
+
         // remove the bytes of the data after the mutation point and the data for the children of the mutation node.
         vals_r.pop_bytes(static_cast<blt::ptrdiff_t>(total_bytes_after + accumulate_type_sizes(begin_itr, end_itr)));
-        
+
         // insert the new tree then move back the data from after the original mutation point.
         vals_r.insert(new_vals_r);
         vals_r.copy_from(stack_after_data, total_bytes_after);
-        
+
         auto before = begin_itr - 1;
         ops_r.erase(begin_itr, end_itr);
         ops_r.insert(++before, new_ops_r.begin(), new_ops_r.end());
-        
+
         // this will check to make sure that the tree is in a correct and executable state. it requires that the evaluation is context free!
 #if BLT_DEBUG_LEVEL >= 2
         //        BLT_ASSERT(new_vals_r.empty());
                 //BLT_ASSERT(stack_after.empty());
                 blt::size_t bytes_expected = 0;
                 auto bytes_size = vals_r.size().total_used_bytes;
-                
+
                 for (const auto& op : c.get_operations())
                 {
-                    if (op.is_value)
-                        bytes_expected += stack_allocator::aligned_size(op.type_size);
+                    if (op.is_value())
+                        bytes_expected += op.type_size();
                 }
-                
+
                 if (bytes_expected != bytes_size)
                 {
                     BLT_WARN_STREAM << "Stack state: " << vals_r.size() << "\n";
@@ -362,14 +352,14 @@ namespace blt::gp
                 auto copy = c;
                 try
                 {
-                    auto result = copy.evaluate(nullptr);
+                    const auto& result = copy.evaluate(*static_cast<char*>(detail::debug::context_ptr));
                     blt::black_box(result);
                 } catch (...)
                 {
                     std::cout << "This occurred at point " << begin_point << " ending at (old) " << end_point << "\n";
-                    std::cout << "our root type is " << ops_r[begin_point].id << " with size " << stack_allocator::aligned_size(ops_r[begin_point].type_size)
+                    std::cout << "our root type is " << ops_r[begin_point].id() << " with size " << ops_r[begin_point].type_size()
                               << "\n";
-                    std::cout << "now Named: " << (program.get_name(ops_r[begin_point].id) ? *program.get_name(ops_r[begin_point].id) : "Unnamed") << "\n";
+                    std::cout << "now Named: " << (program.get_name(ops_r[begin_point].id()) ? *program.get_name(ops_r[begin_point].id()) : "Unnamed") << "\n";
                     std::cout << "Was named: " << (program.get_name(begin_operator_id) ? *program.get_name(begin_operator_id) : "Unnamed") << "\n";
                     //std::cout << "Parent:" << std::endl;
                     //p.print(program, std::cout, false, true);
@@ -383,13 +373,13 @@ namespace blt::gp
 #endif
         return begin_point + new_ops_r.size();
     }
-    
+
     bool advanced_mutation_t::apply(gp_program& program, const tree_t& p, tree_t& c)
     {
-        (void) p;
+        (void)p;
         auto& ops = c.get_operations();
         auto& vals = c.get_values();
-        
+
         for (blt::size_t c_node = 0; c_node < ops.size(); c_node++)
         {
             double node_mutation_chance = per_node_mutation_chance / static_cast<double>(ops.size());
@@ -399,7 +389,7 @@ namespace blt::gp
 #if BLT_DEBUG_LEVEL >= 2
             tree_t c_copy = c;
 #endif
-            
+
             // select an operator to apply
             auto selected_point = static_cast<blt::i32>(mutation_operator::COPY);
             auto choice = program.get_random().get_double();
@@ -412,7 +402,8 @@ namespace blt::gp
                         selected_point = static_cast<blt::i32>(index);
                         break;
                     }
-                } else
+                }
+                else
                 {
                     if (choice > mutation_operator_chances[index - 1] && choice <= value)
                     {
@@ -421,29 +412,29 @@ namespace blt::gp
                     }
                 }
             }
-            
+
             switch (static_cast<mutation_operator>(selected_point))
             {
-                case mutation_operator::EXPRESSION:
-                    c_node += mutate_point(program, c, c_node);
-                    break;
-                case mutation_operator::ADJUST:
+            case mutation_operator::EXPRESSION:
+                c_node += mutate_point(program, c, c_node);
+                break;
+            case mutation_operator::ADJUST:
                 {
                     // this is going to be evil >:3
                     const auto& node = ops[c_node];
-                    if (!node.is_value)
+                    if (!node.is_value())
                     {
-                        auto& current_func_info = program.get_operator_info(ops[c_node].id);
+                        auto& current_func_info = program.get_operator_info(ops[c_node].id());
                         operator_id random_replacement = program.get_random().select(
-                                program.get_type_non_terminals(current_func_info.return_type.id));
+                            program.get_type_non_terminals(current_func_info.return_type.id));
                         auto& replacement_func_info = program.get_operator_info(random_replacement);
-                        
+
                         // cache memory used for offset data.
                         thread_local static tracked_vector<tree_t::child_t> children_data;
                         children_data.clear();
-                        
+
                         c.find_child_extends(program, children_data, c_node, current_func_info.argument_types.size());
-                        
+
                         for (const auto& [index, val] : blt::enumerate(replacement_func_info.argument_types))
                         {
                             // need to generate replacement.
@@ -453,23 +444,23 @@ namespace blt::gp
                                 auto& tree = get_static_tree_tl(program);
                                 config.generator.get().generate(tree,
                                                                 {program, val.id, config.replacement_min_depth, config.replacement_max_depth});
-                                
+
                                 auto& child = children_data[children_data.size() - 1 - index];
                                 blt::size_t total_bytes_for = c.total_value_bytes(child.start, child.end);
                                 blt::size_t total_bytes_after = c.total_value_bytes(child.end);
-                                
+
                                 auto after_ptr = get_thread_pointer_for_size<struct mutation_func>(total_bytes_after);
                                 vals.copy_to(after_ptr, total_bytes_after);
                                 vals.pop_bytes(static_cast<blt::ptrdiff_t>(total_bytes_after + total_bytes_for));
-                                
+
                                 blt::size_t total_child_bytes = tree.total_value_bytes();
-                                
+
                                 vals.copy_from(tree.get_values(), total_child_bytes);
                                 vals.copy_from(after_ptr, total_bytes_after);
-                                
+
                                 ops.erase(ops.begin() + child.start, ops.begin() + child.end);
                                 ops.insert(ops.begin() + child.start, tree.get_operations().begin(), tree.get_operations().end());
-                                
+
                                 // shift over everybody after.
                                 if (index > 0)
                                 {
@@ -479,10 +470,10 @@ namespace blt::gp
                                     {
                                         // remove the old tree size, then add the new tree size to get the correct positions.
                                         new_child.start =
-                                                new_child.start - (child.end - child.start) +
-                                                static_cast<blt::ptrdiff_t>(tree.get_operations().size());
+                                            new_child.start - (child.end - child.start) +
+                                            static_cast<blt::ptrdiff_t>(tree.get_operations().size());
                                         new_child.end =
-                                                new_child.end - (child.end - child.start) + static_cast<blt::ptrdiff_t>(tree.get_operations().size());
+                                            new_child.end - (child.end - child.start) + static_cast<blt::ptrdiff_t>(tree.get_operations().size());
                                     }
                                 }
                                 child.end = static_cast<blt::ptrdiff_t>(child.start + tree.get_operations().size());
@@ -492,8 +483,8 @@ namespace blt::gp
                                 blt::size_t expected_bytes = std::accumulate(ops.begin(),
                                                                              ops.end(), 0ul,
                                                                              [](const auto& v1, const auto& v2) {
-                                                                                 if (v2.is_value)
-                                                                                     return v1 + stack_allocator::aligned_size(v2.type_size);
+                                                                                 if (v2.is_value())
+                                                                                     return v1 + v2.type_size();
                                                                                  return v1;
                                                                              });
                                 if (found_bytes != expected_bytes)
@@ -504,7 +495,7 @@ namespace blt::gp
 #endif
                             }
                         }
-                        
+
                         if (current_func_info.argc.argc > replacement_func_info.argc.argc)
                         {
                             blt::size_t end_index = children_data[(current_func_info.argc.argc - replacement_func_info.argc.argc) - 1].end;
@@ -516,11 +507,13 @@ namespace blt::gp
                             vals.pop_bytes(static_cast<blt::ptrdiff_t>(total_bytes_after + total_bytes_for));
                             vals.copy_from(data, total_bytes_after);
                             ops.erase(ops.begin() + static_cast<blt::ptrdiff_t>(start_index), ops.begin() + static_cast<blt::ptrdiff_t>(end_index));
-                        } else if (current_func_info.argc.argc == replacement_func_info.argc.argc)
+                        }
+                        else if (current_func_info.argc.argc == replacement_func_info.argc.argc)
                         {
                             // exactly enough args
                             // return types should have been replaced if needed. this part should do nothing?
-                        } else
+                        }
+                        else
                         {
                             // not enough args
                             blt::size_t start_index = c_node + 1;
@@ -528,14 +521,16 @@ namespace blt::gp
                             auto* data = get_thread_pointer_for_size<struct mutation_func>(total_bytes_after);
                             vals.copy_to(data, total_bytes_after);
                             vals.pop_bytes(static_cast<blt::ptrdiff_t>(total_bytes_after));
-                            
+
                             for (blt::ptrdiff_t i = static_cast<blt::ptrdiff_t>(replacement_func_info.argc.argc) - 1;
                                  i >= current_func_info.argc.argc; i--)
                             {
                                 auto& tree = get_static_tree_tl(program);
                                 config.generator.get().generate(tree,
-                                                                {program, replacement_func_info.argument_types[i].id, config.replacement_min_depth,
-                                                                 config.replacement_max_depth});
+                                                                {
+                                                                    program, replacement_func_info.argument_types[i].id, config.replacement_min_depth,
+                                                                    config.replacement_max_depth
+                                                                });
                                 vals.insert(tree.get_values());
                                 ops.insert(ops.begin() + static_cast<blt::ptrdiff_t>(start_index), tree.get_operations().begin(),
                                            tree.get_operations().end());
@@ -544,11 +539,13 @@ namespace blt::gp
                             vals.copy_from(data, total_bytes_after);
                         }
                         // now finally update the type.
-                        ops[c_node] = {program.get_typesystem().get_type(replacement_func_info.return_type).size(), random_replacement,
-                                       program.is_operator_ephemeral(random_replacement)};
+                        ops[c_node] = {
+                            program.get_typesystem().get_type(replacement_func_info.return_type).size(), random_replacement,
+                            program.is_operator_ephemeral(random_replacement)
+                        };
                     }
 #if BLT_DEBUG_LEVEL >= 2
-                    if (!c.check(program, nullptr))
+                    if (!c.check(program, detail::debug::context_ptr))
                     {
                         std::cout << "Parent: " << std::endl;
                         c_copy.print(program, std::cout, false, true);
@@ -559,16 +556,16 @@ namespace blt::gp
                     }
 #endif
                 }
-                    break;
-                case mutation_operator::SUB_FUNC:
+                break;
+            case mutation_operator::SUB_FUNC:
                 {
-                    auto& current_func_info = program.get_operator_info(ops[c_node].id);
-                    
+                    auto& current_func_info = program.get_operator_info(ops[c_node].id());
+
                     // need to:
                     // mutate the current function.
                     // current function is moved to one of the arguments.
                     // other arguments are generated.
-                    
+
                     // get a replacement which returns the same type.
                     auto& non_terminals = program.get_type_non_terminals(current_func_info.return_type.id);
                     if (non_terminals.empty())
@@ -587,7 +584,8 @@ namespace blt::gp
                             }
                         }
                         random_replacement = program.get_random().select(program.get_type_non_terminals(current_func_info.return_type.id));
-                    } while (true);
+                    }
+                    while (true);
                 exit:
                     auto& replacement_func_info = program.get_operator_info(random_replacement);
                     auto new_argc = replacement_func_info.argc.argc;
@@ -596,19 +594,21 @@ namespace blt::gp
                     blt::size_t for_bytes = c.total_value_bytes(c_node, current_end);
                     blt::size_t after_bytes = c.total_value_bytes(current_end);
                     auto size = current_end - c_node;
-                    
+
                     auto combined_ptr = get_thread_pointer_for_size<struct SUB_FUNC_FOR>(for_bytes + after_bytes);
-                    
+
                     vals.copy_to(combined_ptr, for_bytes + after_bytes);
                     vals.pop_bytes(static_cast<blt::ptrdiff_t>(for_bytes + after_bytes));
-                    
+
                     blt::size_t start_index = c_node;
                     for (blt::ptrdiff_t i = new_argc - 1; i > static_cast<blt::ptrdiff_t>(arg_position); i--)
                     {
                         auto& tree = get_static_tree_tl(program);
                         config.generator.get().generate(tree,
-                                                        {program, replacement_func_info.argument_types[i].id, config.replacement_min_depth,
-                                                         config.replacement_max_depth});
+                                                        {
+                                                            program, replacement_func_info.argument_types[i].id, config.replacement_min_depth,
+                                                            config.replacement_max_depth
+                                                        });
                         blt::size_t total_bytes_for = tree.total_value_bytes();
                         vals.copy_from(tree.get_values(), total_bytes_for);
                         ops.insert(ops.begin() + static_cast<blt::ptrdiff_t>(start_index), tree.get_operations().begin(),
@@ -621,8 +621,10 @@ namespace blt::gp
                     {
                         auto& tree = get_static_tree_tl(program);
                         config.generator.get().generate(tree,
-                                                        {program, replacement_func_info.argument_types[i].id, config.replacement_min_depth,
-                                                         config.replacement_max_depth});
+                                                        {
+                                                            program, replacement_func_info.argument_types[i].id, config.replacement_min_depth,
+                                                            config.replacement_max_depth
+                                                        });
                         blt::size_t total_bytes_for = tree.total_value_bytes();
                         vals.copy_from(tree.get_values(), total_bytes_for);
                         ops.insert(ops.begin() + static_cast<blt::ptrdiff_t>(start_index), tree.get_operations().begin(),
@@ -630,13 +632,15 @@ namespace blt::gp
                         start_index += tree.get_operations().size();
                     }
                     vals.copy_from(combined_ptr + for_bytes, after_bytes);
-                    
+
                     ops.insert(ops.begin() + static_cast<blt::ptrdiff_t>(c_node),
-                               {program.get_typesystem().get_type(replacement_func_info.return_type).size(),
-                                random_replacement, program.is_operator_ephemeral(random_replacement)});
+                               {
+                                   program.get_typesystem().get_type(replacement_func_info.return_type).size(),
+                                   random_replacement, program.is_operator_ephemeral(random_replacement)
+                               });
 
 #if BLT_DEBUG_LEVEL >= 2
-                    if (!c.check(program, nullptr))
+                    if (!c.check(program, detail::debug::context_ptr))
                     {
                         std::cout << "Parent: " << std::endl;
                         p.print(program, std::cout, false, true);
@@ -649,10 +653,10 @@ namespace blt::gp
                     }
 #endif
                 }
-                    break;
-                case mutation_operator::JUMP_FUNC:
+                break;
+            case mutation_operator::JUMP_FUNC:
                 {
-                    auto& info = program.get_operator_info(ops[c_node].id);
+                    auto& info = program.get_operator_info(ops[c_node].id());
                     blt::size_t argument_index = -1ul;
                     for (const auto& [index, v] : blt::enumerate(info.argument_types))
                     {
@@ -664,21 +668,21 @@ namespace blt::gp
                     }
                     if (argument_index == -1ul)
                         continue;
-                    
+
                     static thread_local tracked_vector<tree_t::child_t> child_data;
                     child_data.clear();
-                    
+
                     c.find_child_extends(program, child_data, c_node, info.argument_types.size());
-                    
+
                     auto child_index = child_data.size() - 1 - argument_index;
                     auto child = child_data[child_index];
                     auto for_bytes = c.total_value_bytes(child.start, child.end);
                     auto after_bytes = c.total_value_bytes(child_data.back().end);
-                    
+
                     auto storage_ptr = get_thread_pointer_for_size<struct jump_func>(for_bytes + after_bytes);
                     vals.copy_to(storage_ptr + for_bytes, after_bytes);
                     vals.pop_bytes(static_cast<blt::ptrdiff_t>(after_bytes));
-                    
+
                     for (auto i = static_cast<blt::ptrdiff_t>(child_data.size() - 1); i > static_cast<blt::ptrdiff_t>(child_index); i--)
                     {
                         auto& cc = child_data[i];
@@ -699,7 +703,7 @@ namespace blt::gp
                     vals.copy_from(storage_ptr, for_bytes + after_bytes);
 
 #if BLT_DEBUG_LEVEL >= 2
-                    if (!c.check(program, nullptr))
+                    if (!c.check(program, detail::debug::context_ptr))
                     {
                         std::cout << "Parent: " << std::endl;
                         p.print(program, std::cout, false, true);
@@ -710,10 +714,10 @@ namespace blt::gp
                     }
 #endif
                 }
-                    break;
-                case mutation_operator::COPY:
+                break;
+            case mutation_operator::COPY:
                 {
-                    auto& info = program.get_operator_info(ops[c_node].id);
+                    auto& info = program.get_operator_info(ops[c_node].id());
                     blt::size_t pt = -1ul;
                     blt::size_t pf = -1ul;
                     for (const auto& [index, v] : blt::enumerate(info.argument_types))
@@ -735,25 +739,26 @@ namespace blt::gp
                     }
                     if (pt == -1ul || pf == -1ul)
                         continue;
-                    
+
                     blt::size_t from = 0;
                     blt::size_t to = 0;
-                    
+
                     if (program.get_random().choice())
                     {
                         from = pt;
                         to = pf;
-                    } else
+                    }
+                    else
                     {
                         from = pf;
                         to = pt;
                     }
-                    
+
                     static thread_local tracked_vector<tree_t::child_t> child_data;
                     child_data.clear();
-                    
+
                     c.find_child_extends(program, child_data, c_node, info.argument_types.size());
-                    
+
                     auto from_index = child_data.size() - 1 - from;
                     auto to_index = child_data.size() - 1 - to;
                     auto& from_child = child_data[from_index];
@@ -762,43 +767,43 @@ namespace blt::gp
                     blt::size_t after_from_bytes = c.total_value_bytes(from_child.end);
                     blt::size_t to_bytes = c.total_value_bytes(to_child.start, to_child.end);
                     blt::size_t after_to_bytes = c.total_value_bytes(to_child.end);
-                    
+
                     auto after_bytes = std::max(after_from_bytes, after_to_bytes);
-                    
+
                     auto from_ptr = get_thread_pointer_for_size<struct copy>(from_bytes);
                     auto after_ptr = get_thread_pointer_for_size<struct copy_after>(after_bytes);
-                    
+
                     vals.copy_to(after_ptr, after_from_bytes);
                     vals.pop_bytes(static_cast<blt::ptrdiff_t>(after_from_bytes));
                     vals.copy_to(from_ptr, from_bytes);
                     vals.copy_from(after_ptr, after_from_bytes);
-                    
+
                     vals.copy_to(after_ptr, after_to_bytes);
                     vals.pop_bytes(static_cast<blt::ptrdiff_t>(after_to_bytes + to_bytes));
-                    
+
                     vals.copy_from(from_ptr, from_bytes);
                     vals.copy_from(after_ptr, after_to_bytes);
-                    
+
                     static thread_local tracked_vector<op_container_t> op_copy;
                     op_copy.clear();
                     op_copy.insert(op_copy.begin(), ops.begin() + from_child.start, ops.begin() + from_child.end);
-                    
+
                     ops.erase(ops.begin() + to_child.start, ops.begin() + to_child.end);
                     ops.insert(ops.begin() + to_child.start, op_copy.begin(), op_copy.end());
                 }
-                    break;
-                case mutation_operator::END:
-                default:
+                break;
+            case mutation_operator::END:
+            default:
 #if BLT_DEBUG_LEVEL > 1
                     BLT_ABORT("You shouldn't be able to get here!");
 #else
-                    BLT_UNREACHABLE;
+                BLT_UNREACHABLE;
 #endif
             }
         }
 
 #if BLT_DEBUG_LEVEL >= 2
-        if (!c.check(program, nullptr))
+        if (!c.check(program, detail::debug::context_ptr))
         {
             std::cout << "Parent: " << std::endl;
             p.print(program, std::cout, false, true);
@@ -808,7 +813,7 @@ namespace blt::gp
             BLT_ABORT("Tree Check Failed.");
         }
 #endif
-        
+
         return true;
     }
-}
+}

src/tree.cpp

@@ -72,14 +72,14 @@ namespace blt::gp
             // reverse the order of the stack
             for (const auto& v : operations)
             {
-                if (v.is_value)
-                    copy.transfer_bytes(reversed, v.type_size);
+                if (v.is_value())
+                    copy.transfer_bytes(reversed, v.type_size());
             }
         }
         for (const auto& v : operations)
         {
-            auto info = program.get_operator_info(v.id);
-            auto name = program.get_name(v.id) ? program.get_name(v.id).value() : "NULL";
+            auto info = program.get_operator_info(v.id());
+            const auto name = program.get_name(v.id()) ? program.get_name(v.id()).value() : "NULL";
             auto return_type = get_return_type(program, info.return_type, include_types);
             if (info.argc.argc > 0)
             {
@@ -92,10 +92,10 @@ namespace blt::gp
                 if (print_literals)
                 {
                     create_indent(out, indent, pretty_print);
-                    if (program.is_operator_ephemeral(v.id))
+                    if (program.is_operator_ephemeral(v.id()))
                     {
-                        program.get_print_func(v.id)(out, reversed);
-                        reversed.pop_bytes(stack_allocator::aligned_size(v.type_size));
+                        program.get_print_func(v.id())(out, reversed);
+                        reversed.pop_bytes(v.type_size());
                     } else
                         out << name;
                     out << return_type << end_indent(pretty_print);
@@ -140,17 +140,20 @@ namespace blt::gp
         out << '\n';
     }
     
-    blt::size_t tree_t::get_depth(gp_program& program)
+    size_t tree_t::get_depth(gp_program& program) const
     {
-        blt::size_t depth = 0;
+        size_t depth = 0;
         
         auto operations_stack = operations;
-        tracked_vector<blt::size_t> values_process;
-        tracked_vector<blt::size_t> value_stack;
-        
+        thread_local tracked_vector<size_t> values_process;
+        thread_local tracked_vector<size_t> value_stack;
+
+        values_process.clear();
+        value_stack.clear();
+
         for (const auto& op : operations_stack)
         {
-            if (op.is_value)
+            if (op.is_value())
                 value_stack.push_back(1);
         }
         
@@ -159,7 +162,7 @@ namespace blt::gp
             auto operation = operations_stack.back();
             // keep the last value in the stack on the process stack stored in the eval context, this way it can be accessed easily.
             operations_stack.pop_back();
-            if (operation.is_value)
+            if (operation.is_value())
             {
                 auto d = value_stack.back();
                 depth = std::max(depth, d);
@@ -167,55 +170,55 @@ namespace blt::gp
                 value_stack.pop_back();
                 continue;
             }
-            blt::size_t local_depth = 0;
-            for (blt::size_t i = 0; i < program.get_operator_info(operation.id).argc.argc; i++)
+            size_t local_depth = 0;
+            for (size_t i = 0; i < program.get_operator_info(operation.id()).argc.argc; i++)
             {
                 local_depth = std::max(local_depth, values_process.back());
                 values_process.pop_back();
             }
             value_stack.push_back(local_depth + 1);
-            operations_stack.emplace_back(operation.type_size, operation.id, true);
+            operations_stack.emplace_back(operation.type_size(), operation.id(), true);
         }
         
         return depth;
     }
     
-    blt::ptrdiff_t tree_t::find_endpoint(gp_program& program, blt::ptrdiff_t index) const
+    ptrdiff_t tree_t::find_endpoint(gp_program& program, ptrdiff_t start) const
     {
-        blt::i64 children_left = 0;
+        i64 children_left = 0;
         
         do
         {
-            const auto& type = program.get_operator_info(operations[index].id);
+            const auto& type = program.get_operator_info(operations[start].id());
             // this is a child to someone
             if (children_left != 0)
                 children_left--;
             if (type.argc.argc > 0)
                 children_left += type.argc.argc;
-            index++;
+            start++;
         } while (children_left > 0);
         
-        return index;
+        return start;
     }
     
     // this function doesn't work!
-    blt::ptrdiff_t tree_t::find_parent(gp_program& program, blt::ptrdiff_t index) const
+    ptrdiff_t tree_t::find_parent(gp_program& program, ptrdiff_t start) const
     {
-        blt::i64 children_left = 0;
+        i64 children_left = 0;
         do
         {
-            if (index == 0)
+            if (start == 0)
                 return 0;
-            const auto& type = program.get_operator_info(operations[index].id);
+            const auto& type = program.get_operator_info(operations[start].id());
             if (type.argc.argc > 0)
                 children_left -= type.argc.argc;
             children_left++;
             if (children_left <= 0)
                 break;
-            --index;
+            --start;
         } while (true);
         
-        return index;
+        return start;
     }
     
     bool tree_t::check(gp_program& program, void* context) const
@@ -225,8 +228,8 @@ namespace blt::gp
         
         for (const auto& op : get_operations())
         {
-            if (op.is_value)
-                bytes_expected += stack_allocator::aligned_size(op.type_size);
+            if (op.is_value())
+                bytes_expected += op.type_size();
         }
         
         if (bytes_expected != bytes_size)
@@ -247,26 +250,26 @@ namespace blt::gp
         blt::size_t total_produced = 0;
         blt::size_t total_consumed = 0;
 
-        for (const auto& operation : blt::reverse_iterate(operations.begin(), operations.end()))
+        for (const auto& operation : iterate(operations).rev())
         {
-            if (operation.is_value)
+            if (operation.is_value())
             {
-                value_stack.transfer_bytes(values_process, operation.type_size);
-                total_produced += stack_allocator::aligned_size(operation.type_size);
+                value_stack.transfer_bytes(values_process, operation.type_size());
+                total_produced += operation.type_size();
                 continue;
             }
-            auto& info = program.get_operator_info(operation.id);
+            auto& info = program.get_operator_info(operation.id());
             for (auto& arg : info.argument_types)
-                total_consumed += stack_allocator::aligned_size(program.get_typesystem().get_type(arg).size());
-            program.get_operator_info(operation.id).func(context, values_process, values_process);
-            total_produced += stack_allocator::aligned_size(program.get_typesystem().get_type(info.return_type).size());
+                total_consumed += program.get_typesystem().get_type(arg).size();
+            program.get_operator_info(operation.id()).func(context, values_process, values_process);
+            total_produced += program.get_typesystem().get_type(info.return_type).size();
         }
         
-        auto v1 = results.values.bytes_in_head();
-        auto v2 = static_cast<blt::ptrdiff_t>(stack_allocator::aligned_size(operations.front().type_size));
+        const auto v1 = results.values.bytes_in_head();
+        const auto v2 = static_cast<ptrdiff_t>(operations.front().type_size());
         if (v1 != v2)
         {
-            auto vd = std::abs(v1 - v2);
+            const auto vd = std::abs(v1 - v2);
             BLT_ERROR("found %ld bytes expected %ld bytes, total difference: %ld", v1, v2, vd);
             BLT_ERROR("Total Produced %ld || Total Consumed %ld || Total Difference %ld", total_produced, total_consumed,
                       std::abs(static_cast<blt::ptrdiff_t>(total_produced) - static_cast<blt::ptrdiff_t>(total_consumed)));
@@ -275,7 +278,7 @@ namespace blt::gp
         return true;
     }
     
-    void tree_t::find_child_extends(gp_program& program, tracked_vector<child_t>& vec, blt::size_t parent_node, blt::size_t argc) const
+    void tree_t::find_child_extends(gp_program& program, tracked_vector<child_t>& vec, const size_t parent_node, const size_t argc) const
     {
         while (vec.size() < argc)
         {
@@ -284,8 +287,8 @@ namespace blt::gp
             if (current_point == 0)
             {
                 // first child.
-                prev = {static_cast<blt::ptrdiff_t>(parent_node + 1),
-                        find_endpoint(program, static_cast<blt::ptrdiff_t>(parent_node + 1))};
+                prev = {static_cast<ptrdiff_t>(parent_node + 1),
+                        find_endpoint(program, static_cast<ptrdiff_t>(parent_node + 1))};
                 vec.push_back(prev);
                 continue;
             } else

src/util/statistics.cpp

@@ -0,0 +1,50 @@
+/*
+ *  <Short Description>
+ *  Copyright (C) 2024  Brett Terpstra
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+#include <blt/gp/util/statistics.h>
+#include <blt/format/format.h>
+#include <numeric>
+
+namespace blt::gp {
+
+    std::string confusion_matrix_t::pretty_print(const std::string& table_name) const
+    {
+        string::TableFormatter formatter{table_name};
+        formatter.addColumn("Predicted " + name_A);
+        formatter.addColumn("Predicted " + name_B);
+        formatter.addColumn("Actual Class");
+
+        string::TableRow row;
+        row.rowValues.push_back(std::to_string(is_A_pred_A));
+        row.rowValues.push_back(std::to_string(is_A_pred_B));
+        row.rowValues.push_back(name_A);
+        formatter.addRow(row);
+
+        string::TableRow row2;
+        row2.rowValues.push_back(std::to_string(is_B_pred_A));
+        row2.rowValues.push_back(std::to_string(is_B_pred_B));
+        row2.rowValues.push_back(name_B);
+        formatter.addRow(row2);
+
+        auto tbl = formatter.createTable(true, true);
+        return std::accumulate(tbl.begin(), tbl.end(), std::string{}, [](const std::string& a, const std::string& b)
+        {
+            return a + "\n" + b;
+        });
+    }
+
+}

src/util/trackers.cpp

@@ -15,9 +15,10 @@
  *  You should have received a copy of the GNU General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-#include <blt/gp/stats.h>
+#include <blt/gp/util/trackers.h>
 #include <blt/std/logging.h>
 #include "blt/format/format.h"
+#include <numeric>
 
 namespace blt::gp
 {
@@ -27,4 +28,4 @@ namespace blt::gp
         BLT_TRACE("%s Allocations: %ld times with a total of %s", name.c_str(), getAllocationDifference(),
                   blt::byte_convert_t(getAllocatedByteDifference()).convert_to_nearest_type().to_pretty_string().c_str());
     }
-}
+}

tests/symbolic_regression_test.cpp

@@ -0,0 +1,164 @@
+/*
+ *  <Short Description>
+ *  Copyright (C) 2025  Brett Terpstra
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+#include "../examples/symbolic_regression.h"
+
+#include <fstream>
+#include <array>
+#include <blt/profiling/profiler_v2.h>
+
+static const auto SEED_FUNC = [] { return std::random_device()(); };
+
+std::array crossover_chances = {1.0, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 0.0};
+std::array mutation_chances = {0.0, 0.1, 0.2, 0.9, 1.0};
+std::array reproduction_chances = {0.0, 1.0, 0.1, 0.9};
+std::array elite_amounts = {0, 2, 10, 50};
+std::array population_sizes = {50, 500, 5000};
+
+blt::gp::prog_config_t best_config;
+double best_fitness = 0;
+
+void run(const blt::gp::prog_config_t& config)
+{
+    // the config is copied into the gp_system so changing the config will not change the runtime of the program.
+    blt::gp::example::symbolic_regression_t regression{SEED_FUNC, config};
+
+
+    BLT_START_INTERVAL("Symbolic Regression", "Setup Operations");
+    regression.setup_operations();
+    BLT_END_INTERVAL("Symbolic Regression", "Setup Operations");
+
+    BLT_START_INTERVAL("Symbolic Regression", "Generate Initial Population");
+    regression.generate_initial_population();
+    BLT_END_INTERVAL("Symbolic Regression", "Generate Initial Population");
+
+    BLT_START_INTERVAL("Symbolic Regression", "Total Generation Loop");
+    BLT_DEBUG("Begin Generation Loop");
+    auto& program = regression.get_program();
+    while (!program.should_terminate())
+    {
+#ifdef BLT_TRACK_ALLOCATIONS
+                auto cross = crossover_calls.start_measurement();
+                auto mut = mutation_calls.start_measurement();
+                auto repo = reproduction_calls.start_measurement();
+#endif
+        BLT_TRACE("------------{Begin Generation %ld}------------", program.get_current_generation());
+        BLT_TRACE("Creating next generation");
+        BLT_START_INTERVAL("Symbolic Regression", "Create Next Generation");
+        program.create_next_generation();
+        BLT_END_INTERVAL("Symbolic Regression", "Create Next Generation");
+        BLT_TRACE("Move to next generation");
+        BLT_START_INTERVAL("Symbolic Regress", "Move Next Generation");
+        program.next_generation();
+        BLT_END_INTERVAL("Symbolic Regress", "Move Next Generation");
+        BLT_TRACE("Evaluate Fitness");
+        BLT_START_INTERVAL("Symbolic Regress", "Evaluate Fitness");
+        program.evaluate_fitness();
+        BLT_END_INTERVAL("Symbolic Regress", "Evaluate Fitness");
+        BLT_START_INTERVAL("Symbolic Regress", "Fitness Print");
+        const auto& stats = program.get_population_stats();
+        BLT_TRACE("Avg Fit: %lf, Best Fit: %lf, Worst Fit: %lf, Overall Fit: %lf",
+                  stats.average_fitness.load(std::memory_order_relaxed), stats.best_fitness.load(std::memory_order_relaxed),
+                  stats.worst_fitness.load(std::memory_order_relaxed), stats.overall_fitness.load(std::memory_order_relaxed));
+        BLT_END_INTERVAL("Symbolic Regress", "Fitness Print");
+#ifdef BLT_TRACK_ALLOCATIONS
+                crossover_calls.stop_measurement(cross);
+                mutation_calls.stop_measurement(mut);
+                reproduction_calls.stop_measurement(repo);
+                const auto total = (cross.get_call_difference() * 2) + mut.get_call_difference() + repo.get_call_difference();
+                BLT_TRACE("Calls Crossover: %ld, Mutation %ld, Reproduction %ld; %ld", cross.get_call_difference(), mut.get_call_difference(), repo.get_call_difference(), total);
+                BLT_TRACE("Value Crossover: %ld, Mutation %ld, Reproduction %ld; %ld", cross.get_value_difference(), mut.get_value_difference(), repo.get_value_difference(), (cross.get_value_difference() * 2 + mut.get_value_difference() + repo.get_value_difference()) - total);
+#endif
+        BLT_TRACE("----------------------------------------------");
+        std::cout << std::endl;
+    }
+    BLT_END_INTERVAL("Symbolic Regression", "Total Generation Loop");
+
+    const auto best = program.get_best_individuals<1>();
+
+    if (best[0].get().fitness.adjusted_fitness > best_fitness)
+    {
+        best_fitness = best[0].get().fitness.adjusted_fitness;
+        best_config = config;
+    }
+}
+
+int main()
+{
+    std::stringstream results;
+    for (const auto crossover_chance : crossover_chances)
+    {
+        for (const auto mutation_chance : mutation_chances)
+        {
+            for (const auto reproduction_chance : reproduction_chances)
+            {
+                for (const auto elite_amount : elite_amounts)
+                {
+                    for (const auto population_sizes : population_sizes)
+                    {
+                        blt::gp::prog_config_t config = blt::gp::prog_config_t()
+                                                        .set_initial_min_tree_size(2)
+                                                        .set_initial_max_tree_size(6)
+                                                        .set_elite_count(elite_amount)
+                                                        .set_crossover_chance(crossover_chance)
+                                                        .set_mutation_chance(mutation_chance)
+                                                        .set_reproduction_chance(reproduction_chance)
+                                                        .set_max_generations(50)
+                                                        .set_pop_size(population_sizes)
+                                                        .set_thread_count(0);
+
+                        BLT_INFO_STREAM << "Run: Crossover (";
+                        BLT_INFO_STREAM << crossover_chance;
+                        BLT_INFO_STREAM << ") Mutation (";
+                        BLT_INFO_STREAM << mutation_chance;
+                        BLT_INFO_STREAM << ") Reproduction (";
+                        BLT_INFO_STREAM << reproduction_chance;
+                        BLT_INFO_STREAM << ") Elite (";
+                        BLT_INFO_STREAM << elite_amount;
+                        BLT_INFO_STREAM << ") Population Size (";
+                        BLT_INFO_STREAM << population_sizes;
+                        BLT_INFO_STREAM << ")" << "\n";
+                        run(config);
+
+                        results << "Run: Crossover (";
+                        results << crossover_chance;
+                        results << ") Mutation (";
+                        results << mutation_chance;
+                        results << ") Reproduction (";
+                        results << reproduction_chance;
+                        results << ") Elite (";
+                        results << elite_amount;
+                        results << ") Population Size (";
+                        results << population_sizes;
+                        results << ")" << std::endl;
+                        BLT_WRITE_PROFILE(results, "Symbolic Regression");
+                        results << std::endl;
+                    }
+                }
+            }
+        }
+    }
+    std::cout << results.str() << std::endl;
+
+    std::cout << "Best Configuration is: " << std::endl;
+    std::cout << "\tCrossover: " << best_config.crossover_chance << std::endl;
+    std::cout << "\tMutation: " << best_config.mutation_chance << std::endl;
+    std::cout << "\tReproduction: " << best_config.reproduction_chance << std::endl;
+    std::cout << "\tElites: " << best_config.elites << std::endl;
+    std::cout << "\tPopulation Size: " << best_config.population_size << std::endl;
+    std::cout << std::endl;
+}