399 lines
13 KiB
C++
399 lines
13 KiB
C++
#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_TREE_H
|
|
#define BLT_GP_TREE_H
|
|
|
|
#include <blt/gp/typesystem.h>
|
|
#include <blt/gp/stack.h>
|
|
#include <blt/gp/fwdecl.h>
|
|
#include <blt/std/types.h>
|
|
|
|
#include <utility>
|
|
#include <stack>
|
|
#include <ostream>
|
|
#include <atomic>
|
|
|
|
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)
|
|
{}
|
|
|
|
blt::size_t type_size;
|
|
operator_id id;
|
|
bool is_value;
|
|
};
|
|
|
|
class evaluation_context
|
|
{
|
|
public:
|
|
explicit evaluation_context() = default;
|
|
|
|
blt::gp::stack_allocator values;
|
|
};
|
|
|
|
class tree_t
|
|
{
|
|
public:
|
|
explicit tree_t(gp_program& program);
|
|
|
|
tree_t(const tree_t& copy) = default;
|
|
|
|
tree_t& operator=(const tree_t& copy)
|
|
{
|
|
if (this == ©)
|
|
return *this;
|
|
copy_fast(copy);
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
* This function copies the data from the provided tree, will attempt to reserve and copy in one step.
|
|
* will avoid reallocation if enough space is already present.
|
|
*/
|
|
void copy_fast(const tree_t& copy)
|
|
{
|
|
if (this == ©)
|
|
return;
|
|
values.reserve(copy.values.internal_storage_size());
|
|
values.reset();
|
|
values.insert(copy.values);
|
|
|
|
operations.clear();
|
|
operations.reserve(copy.operations.size());
|
|
operations.insert(operations.begin(), copy.operations.begin(), copy.operations.end());
|
|
}
|
|
|
|
tree_t(tree_t&& move) = default;
|
|
|
|
tree_t& operator=(tree_t&& move) = default;
|
|
|
|
void clear(gp_program& program);
|
|
|
|
struct child_t
|
|
{
|
|
blt::ptrdiff_t start;
|
|
// one past the end
|
|
blt::ptrdiff_t end;
|
|
};
|
|
|
|
[[nodiscard]] inline tracked_vector<op_container_t>& get_operations()
|
|
{
|
|
return operations;
|
|
}
|
|
|
|
[[nodiscard]] inline const tracked_vector<op_container_t>& get_operations() const
|
|
{
|
|
return operations;
|
|
}
|
|
|
|
[[nodiscard]] inline blt::gp::stack_allocator& get_values()
|
|
{
|
|
return values;
|
|
}
|
|
|
|
[[nodiscard]] inline const blt::gp::stack_allocator& get_values() const
|
|
{
|
|
return values;
|
|
}
|
|
|
|
template<typename T, std::enable_if_t<!(std::is_pointer_v<T> || std::is_null_pointer_v<T>), bool> = true>
|
|
[[nodiscard]] evaluation_context& evaluate(const T& context) const
|
|
{
|
|
return (*func)(*this, const_cast<void*>(static_cast<const void*>(&context)));
|
|
}
|
|
|
|
[[nodiscard]] evaluation_context& evaluate() const
|
|
{
|
|
return (*func)(*this, nullptr);
|
|
}
|
|
|
|
blt::size_t get_depth(gp_program& program);
|
|
|
|
/**
|
|
* Helper template for returning the result of the last evaluation
|
|
*/
|
|
template<typename T>
|
|
T get_evaluation_value(evaluation_context& context)
|
|
{
|
|
return context.values.pop<T>();
|
|
}
|
|
|
|
/**
|
|
* Helper template for returning the result of the last evaluation
|
|
*/
|
|
template<typename T>
|
|
T& get_evaluation_ref(evaluation_context& context)
|
|
{
|
|
return context.values.from<T>(0);
|
|
}
|
|
|
|
/**
|
|
* Helper template for returning the result of evaluation (this calls it)
|
|
*/
|
|
template<typename T, typename Context>
|
|
T get_evaluation_value(const Context& context)
|
|
{
|
|
return evaluate(context).values.template pop<T>();
|
|
}
|
|
|
|
template<typename T>
|
|
T get_evaluation_value()
|
|
{
|
|
return evaluate().values.pop<T>();
|
|
}
|
|
|
|
void print(gp_program& program, std::ostream& output, bool print_literals = true, bool pretty_indent = false,
|
|
bool include_types = false) const;
|
|
|
|
bool check(gp_program& program, void* context) const;
|
|
|
|
void find_child_extends(gp_program& program, tracked_vector<child_t>& vec, blt::size_t parent_node, blt::size_t argc) const;
|
|
|
|
// places one past the end of the child. so it's [start, end)
|
|
blt::ptrdiff_t find_endpoint(blt::gp::gp_program& program, blt::ptrdiff_t start) const;
|
|
|
|
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)
|
|
{
|
|
blt::size_t total = 0;
|
|
for (auto it = begin; it != end; it++)
|
|
{
|
|
if (it->is_value)
|
|
total += stack_allocator::aligned_size(it->type_size);
|
|
}
|
|
return total;
|
|
}
|
|
|
|
[[nodiscard]] blt::size_t total_value_bytes(blt::size_t begin, blt::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
|
|
{
|
|
return total_value_bytes(operations.begin() + static_cast<blt::ptrdiff_t>(begin), operations.end());
|
|
}
|
|
|
|
[[nodiscard]] blt::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;
|
|
detail::eval_func_t* func;
|
|
};
|
|
|
|
struct fitness_t
|
|
{
|
|
double raw_fitness = 0;
|
|
double standardized_fitness = 0;
|
|
double adjusted_fitness = 0;
|
|
blt::i64 hits = 0;
|
|
};
|
|
|
|
struct individual_t
|
|
{
|
|
tree_t tree;
|
|
fitness_t fitness;
|
|
|
|
void copy_fast(const tree_t& copy)
|
|
{
|
|
// fast copy of the tree
|
|
tree.copy_fast(copy);
|
|
// reset fitness
|
|
fitness = {};
|
|
}
|
|
|
|
individual_t() = delete;
|
|
|
|
explicit individual_t(tree_t&& tree): tree(std::move(tree))
|
|
{}
|
|
|
|
explicit individual_t(const tree_t& tree): tree(tree)
|
|
{}
|
|
|
|
individual_t(const individual_t&) = default;
|
|
|
|
individual_t(individual_t&&) = default;
|
|
|
|
individual_t& operator=(const individual_t&) = delete;
|
|
|
|
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:
|
|
class population_tree_iterator
|
|
{
|
|
public:
|
|
population_tree_iterator(tracked_vector<individual_t>& ind, blt::size_t pos): ind(ind), pos(pos)
|
|
{}
|
|
|
|
auto begin()
|
|
{
|
|
return population_tree_iterator(ind, 0);
|
|
}
|
|
|
|
auto end()
|
|
{
|
|
return population_tree_iterator(ind, ind.size());
|
|
}
|
|
|
|
population_tree_iterator operator++(int)
|
|
{
|
|
auto prev = pos++;
|
|
return {ind, prev};
|
|
}
|
|
|
|
population_tree_iterator operator++()
|
|
{
|
|
return {ind, ++pos};
|
|
}
|
|
|
|
tree_t& operator*()
|
|
{
|
|
return ind[pos].tree;
|
|
}
|
|
|
|
tree_t& operator->()
|
|
{
|
|
return ind[pos].tree;
|
|
}
|
|
|
|
friend bool operator==(population_tree_iterator a, population_tree_iterator b)
|
|
{
|
|
return a.pos == b.pos;
|
|
}
|
|
|
|
friend bool operator!=(population_tree_iterator a, population_tree_iterator b)
|
|
{
|
|
return a.pos != b.pos;
|
|
}
|
|
|
|
private:
|
|
tracked_vector<individual_t>& ind;
|
|
blt::size_t pos;
|
|
};
|
|
|
|
tracked_vector<individual_t>& get_individuals()
|
|
{
|
|
return individuals;
|
|
}
|
|
|
|
[[nodiscard]] const tracked_vector<individual_t>& get_individuals() const
|
|
{
|
|
return individuals;
|
|
}
|
|
|
|
population_tree_iterator for_each_tree()
|
|
{
|
|
return population_tree_iterator{individuals, 0};
|
|
}
|
|
|
|
auto begin()
|
|
{
|
|
return individuals.begin();
|
|
}
|
|
|
|
auto end()
|
|
{
|
|
return individuals.end();
|
|
}
|
|
|
|
[[nodiscard]] auto begin() const
|
|
{
|
|
return individuals.begin();
|
|
}
|
|
|
|
[[nodiscard]] auto end() const
|
|
{
|
|
return individuals.end();
|
|
}
|
|
|
|
void clear()
|
|
{
|
|
individuals.clear();
|
|
}
|
|
|
|
population_t() = default;
|
|
|
|
population_t(const population_t&) = default;
|
|
|
|
population_t(population_t&&) = default;
|
|
|
|
population_t& operator=(const population_t&) = delete;
|
|
|
|
population_t& operator=(population_t&&) = default;
|
|
|
|
private:
|
|
tracked_vector<individual_t> individuals;
|
|
};
|
|
}
|
|
|
|
#endif //BLT_GP_TREE_H
|