#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 .
*/
#ifndef BLT_GP_TREE_H
#define BLT_GP_TREE_H
#include
#include
#include
#include
#include
#include
#include
#include
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
{
using iter_type = std::vector::const_iterator;
public:
explicit tree_t(gp_program& program);
struct child_t
{
blt::ptrdiff_t start;
// one past the end
blt::ptrdiff_t end;
};
[[nodiscard]] inline std::vector& get_operations()
{
return operations;
}
[[nodiscard]] inline const std::vector& 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;
}
evaluation_context evaluate(void* context) const
{
return (*func)(*this, context);
}
blt::size_t get_depth(gp_program& program);
/**
* Helper template for returning the result of the last evaluation
*/
template
T get_evaluation_value(evaluation_context& context)
{
return context.values.pop();
}
/**
* Helper template for returning the result of the last evaluation
*/
template
T& get_evaluation_ref(evaluation_context& context)
{
return context.values.from(0);
}
/**
* Helper template for returning the result of evaluation (this calls it)
*/
template
T get_evaluation_value(void* context)
{
auto results = evaluate(context);
return results.values.pop();
}
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, std::vector& vec, blt::size_t parent_node, blt::size_t argc) const;
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(iter_type begin, iter_type 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(begin),
operations.begin() + static_cast(end));
}
[[nodiscard]] blt::size_t total_value_bytes(blt::size_t begin) const
{
return total_value_bytes(operations.begin() + static_cast(begin), operations.end());
}
[[nodiscard]] blt::size_t total_value_bytes() const
{
return total_value_bytes(operations.begin(), operations.end());
}
private:
std::vector 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
{
tree_t tree;
fitness_t fitness;
individual() = default;
explicit individual(tree_t&& tree): tree(std::move(tree))
{}
explicit individual(const tree_t& tree): tree(tree)
{}
individual(const individual&) = default;
individual(individual&&) = default;
individual& operator=(const individual&) = delete;
individual& operator=(individual&&) = default;
};
struct population_stats
{
std::atomic overall_fitness = 0;
std::atomic average_fitness = 0;
std::atomic best_fitness = 0;
std::atomic worst_fitness = 1;
std::vector 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(std::vector& 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:
std::vector& ind;
blt::size_t pos;
};
std::vector& get_individuals()
{
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:
std::vector individuals;
};
}
#endif //BLT_GP_TREE_H