tri11paragon
/
blt-gp
mirror of https://github.com/tri11paragon/blt-gp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

generators!

thread
Brett 2024-06-24 21:56:51 -04:00
parent 8a9ecb3484
commit 6b86f83d61
8 changed files with 201 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -1,5 +1,5 @@
cmake_minimum_required(VERSION 3.25)
project(blt-gp VERSION 0.0.29)
project(blt-gp VERSION 0.0.30)
option(ENABLE_ADDRSAN "Enable the address sanitizer" OFF)
option(ENABLE_UBSAN "Enable the ub sanitizer" OFF)

2
examples/gp_test_2.cpp
View File

@ -31,7 +31,7 @@ blt::gp::operation_t lit([]() {
return dist(program.get_random());
});
int main_old()
int main()
{
type_system.register_type<float>();
type_system.register_type<bool>();

2
examples/main.cpp
View File

@ -326,7 +326,7 @@ namespace blt::gp::detail
blt::gp::stack_allocator alloc;
int main()
int main_old()
{
constexpr blt::size_t MAX_ALIGNMENT = 8;
test();

4
include/blt/gp/fwdecl.h
View File

@ -29,6 +29,10 @@ namespace blt::gp
class type_system;
class tree_t;
class population_t;
class tree_generator_t;
class grow_generator_t;

30
include/blt/gp/generators.h
View File

@ -44,6 +44,36 @@ namespace blt::gp
tree_t generate(gp_program& program, blt::size_t min_depth, blt::size_t max_depth) final;
};
class population_initializer_t
{
public:
virtual population_t generate(gp_program& program, blt::size_t size, blt::size_t min_depth, blt::size_t max_depth) = 0;
};
class grow_initializer_t
{
public:
population_t generate(gp_program& program, blt::size_t size, blt::size_t min_depth, blt::size_t max_depth) final;
};
class full_initializer_t
{
public:
population_t generate(gp_program& program, blt::size_t size, blt::size_t min_depth, blt::size_t max_depth) final;
};
class half_half_initializer_t
{
public:
population_t generate(gp_program& program, blt::size_t size, blt::size_t min_depth, blt::size_t max_depth) final;
};
class ramped_half_initializer_t
{
public:
population_t generate(gp_program& program, blt::size_t size, blt::size_t min_depth, blt::size_t max_depth) final;
};
}
#endif //BLT_GP_GENERATORS_H

63
include/blt/gp/program.h
View File

@ -46,18 +46,34 @@ namespace blt::gp
static constexpr blt::size_t STATIC_T = 0x1;
static constexpr blt::size_t TERMINAL_T = 0x2;
struct argc_t
{
blt::size_t argc = 0;
blt::size_t argc_context = 0;
};
template<typename Context = detail::empty_t>
class gp_operations
{
friend class gp_program;
friend class blt::gp::detail::operator_storage_test;
public:
explicit gp_operations(type_system& system): system(system)
{}
template<typename T>
void add_non_context_argument(blt::gp::operator_id operator_id)
{
if constexpr (!std::is_same_v<Context, detail::remove_cv_ref<T>>)
{
argument_types[operator_id].push_back(system.get_type<T>());
}
}
template<typename Return, typename... Args>
void add_operator(const operation_t<Return(Args...)>& op, bool is_static = false)
gp_operations& add_operator(const operation_t<Return(Args...)>& op, bool is_static = false)
{
auto return_type_id = system.get_type<Return>().id();
auto operator_id = blt::gp::operator_id(operators.size());
@ -65,10 +81,24 @@ namespace blt::gp
auto& operator_list = op.get_argc() == 0 ? terminals : non_terminals;
operator_list[return_type_id].push_back(operator_id);
(argument_types[operator_id].push_back(system.get_type<Args>()), ...);
if constexpr (sizeof...(Args) > 0)
{
(add_non_context_argument<Args>(), ...);
}
argc_t argc;
argc.argc_context = argc.argc = sizeof...(Args);
((std::is_same_v<detail::remove_cv_ref<Args>, Context> ? argc.argc -= 1 : (blt::size_t) nullptr), ...);
BLT_ASSERT(argc.argc_context - argc.argc <= 1 && "Cannot pass multiple context as arguments!");
operator_argc[operator_id] = argc;
operators.push_back(op.template make_callable<Context>());
if (is_static)
static_types.insert(operator_id);
return *this;
}
private:
@ -79,6 +109,7 @@ namespace blt::gp
blt::expanding_buffer<std::vector<operator_id>> non_terminals;
// indexed from OPERATOR ID (operator number)
blt::expanding_buffer<std::vector<type>> argument_types;
blt::expanding_buffer<argc_t> operator_argc;
blt::hashset_t<operator_id> static_types;
std::vector<detail::callable_t> operators;
};
@ -105,6 +136,22 @@ namespace blt::gp
return engine;
}
[[nodiscard]] inline bool choice()
{
static std::uniform_int_distribution dist(0, 1);
return dist(engine);
}
/**
* @param cutoff precent in floating point form chance of the event happening.
* @return
*/
[[nodiscard]] inline bool choice(double cutoff)
{
static std::uniform_real_distribution dist(0.0, 1.0);
return dist(engine) < cutoff;
}
[[nodiscard]] inline type_system& get_typesystem()
{
return system;
@ -137,6 +184,16 @@ namespace blt::gp
return non_terminals[id];
}
inline argc_t get_argc(operator_id id)
{
return operator_argc[id];
}
inline detail::callable_t& get_operation(operator_id id)
{
return operators[id];
}
inline bool is_static(operator_id id)
{
return static_types.contains(static_cast<blt::size_t>(id));
@ -149,6 +206,7 @@ namespace blt::gp
non_terminals = std::move(op.non_terminals);
argument_types = std::move(op.argument_types);
static_types = std::move(op.static_types);
operator_argc = std::move(op.operator_argc);
operators = std::move(op.operators);
}
@ -162,6 +220,7 @@ namespace blt::gp
blt::expanding_buffer<std::vector<operator_id>> non_terminals;
// indexed from OPERATOR ID (operator number)
blt::expanding_buffer<std::vector<type>> argument_types;
blt::expanding_buffer<argc_t> operator_argc;
blt::hashset_t<operator_id> static_types;
std::vector<detail::callable_t> operators;
};

42
include/blt/gp/tree.h
View File

@ -22,13 +22,27 @@
#include <blt/gp/typesystem.h>
#include <blt/gp/stack.h>
#include <blt/gp/fwdecl.h>
#include <blt/std/types.h>
namespace blt::gp
{
struct op_container_t
{
blt::gp::operator_id op_id;
blt::u16 depth;
};
class tree_t
{
public:
[[nodiscard]] inline std::vector<blt::gp::operator_id>& get_operations()
[[nodiscard]] inline std::vector<op_container_t>& get_operations()
{
valid = false;
return operations;
}
[[nodiscard]] inline const std::vector<op_container_t>& get_operations() const
{
return operations;
}
@ -37,10 +51,34 @@ namespace blt::gp
{
return values;
}
void setDepth(blt::size_t d)
{
depth = d;
valid = true;
}
blt::size_t getDepth()
{
if (valid)
return depth;
valid = true;
return 0;
}
private:
std::vector<blt::gp::operator_id> operations;
bool valid = false;
std::vector<op_container_t> operations;
blt::gp::stack_allocator values;
blt::size_t depth;
};
class population_t
{
public:
private:
std::vector<tree_t> individuals;
};
}

75
src/generators.cpp
View File

@ -28,7 +28,7 @@ namespace blt::gp
blt::size_t depth;
};
static inline std::stack<stack> get_base_generator(gp_program& program)
inline std::stack<stack> get_initial_stack(gp_program& program)
{
std::stack<stack> tree_generator;
@ -40,36 +40,87 @@ namespace blt::gp
base_type = system.select_type(program.get_random());
} while (program.get_type_non_terminals(base_type.id()).empty());
tree_generator.push(stack{program.select_non_terminal(base_type.id()), 0});
tree_generator.push(stack{program.select_non_terminal(base_type.id()), 1});
return tree_generator;
}
template<typename Func>
tree_t create_tree(Func, gp_program& program, blt::size_t, blt::size_t)
inline tree_t create_tree(Func&& perChild, gp_program& program)
{
std::stack<stack> tree_generator = get_base_generator(program);
std::stack<stack> tree_generator = get_initial_stack(program);
blt::size_t max_depth = 0;
tree_t tree;
while (!tree_generator.empty())
{
auto top = tree_generator.top();
tree_generator.pop();
tree.get_operations().push_back({top.id, static_cast<blt::u16>(top.depth)});
max_depth = std::max(max_depth, top.depth);
if (program.is_static(top.id))
{
program.get_operation(top.id)(nullptr, tree.get_values());
continue;
}
for (const auto& child : program.get_argument_types(top.id))
{
std::forward<Func>(perChild)(program, tree_generator, child, top.depth + 1);
}
}
tree.setDepth(max_depth);
return tree;
}
tree_t grow_generator_t::generate(gp_program& program, blt::size_t min_depth, blt::size_t max_depth)
{
return create_tree([]() {
}, program, min_depth, max_depth);
return create_tree([min_depth, max_depth](gp_program& program, std::stack<stack>& tree_generator, const type& type, blt::size_t new_depth) {
if (new_depth >= max_depth)
{
tree_generator.push({program.select_terminal(type.id()), new_depth});
return;
}
if (program.choice() || new_depth < min_depth)
tree_generator.push({program.select_non_terminal(type.id()), new_depth});
else
tree_generator.push({program.select_terminal(type.id()), new_depth});
}, program);
}
tree_t full_generator_t::generate(gp_program& program, blt::size_t min_depth, blt::size_t max_depth)
tree_t full_generator_t::generate(gp_program& program, blt::size_t, blt::size_t max_depth)
{
return create_tree([]() {
}, program, min_depth, max_depth);
return create_tree([max_depth](gp_program& program, std::stack<stack>& tree_generator, const type& type, blt::size_t new_depth) {
if (new_depth >= max_depth)
{
tree_generator.push({program.select_terminal(type.id()), new_depth});
return;
}
tree_generator.push({program.select_non_terminal(type.id()), new_depth});
}, program);
}
population_t grow_initializer_t::generate(gp_program& program, blt::size_t size, blt::size_t min_depth, blt::size_t max_depth)
{
return population_t();
}
population_t full_initializer_t::generate(gp_program& program, blt::size_t size, blt::size_t min_depth, blt::size_t max_depth)
{
return population_t();
}
population_t half_half_initializer_t::generate(gp_program& program, blt::size_t size, blt::size_t min_depth, blt::size_t max_depth)
{
return population_t();
}
population_t ramped_half_initializer_t::generate(gp_program& program, blt::size_t size, blt::size_t min_depth, blt::size_t max_depth)
{
return population_t();
}
}