tri11paragon
/
Femboy_GP
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

i love your patches

main
Brett 2024-03-14 15:13:30 -04:00
parent ee917ea787
commit 0bec99b734
6 changed files with 99 additions and 13 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(lilfbtf5 VERSION 0.1.24)
project(lilfbtf5 VERSION 0.1.25)
option(ENABLE_ADDRSAN "Enable the address sanitizer" OFF)
option(ENABLE_UBSAN "Enable the ub sanitizer" OFF)

1
include/lilfbtf/random.h
View File

@ -34,6 +34,7 @@ namespace fb
void reset();
bool choice();
bool chance(double chance = 0.5);
float random_float(float min = 0, float max = 1);
double random_double(double min = 0, double max = 1);

17
include/lilfbtf/tree.h
View File

@ -25,6 +25,7 @@
#include "blt/std/allocator.h"
#include "type.h"
#include <lilfbtf/fwddecl.h>
#include <lilfbtf/random.h>
namespace fb
{
@ -62,7 +63,7 @@ namespace fb
/**
* @return the function id of this function container
*/
[[nodiscard]] inline type_id getFunction() const
[[nodiscard]] inline function_id getFunction() const
{ return function; }
inline void call(blt::span<detail::node_t*> args)
@ -113,14 +114,16 @@ namespace fb
class tree_t
{
private:
blt::bump_allocator<blt::BLT_2MB_SIZE, false>& alloc;
blt::bump_allocator<blt::BLT_2MB_SIZE, false> alloc;
type_engine_t& types;
detail::node_t* root;
public:
tree_t(blt::bump_allocator<blt::BLT_2MB_SIZE, false>& alloc, type_engine_t& types);
detail::node_t* root = nullptr;
static tree_t make_tree(blt::bump_allocator<blt::BLT_2MB_SIZE, false>& alloc, type_engine_t& types, blt::size_t min_height,
blt::size_t max_height);
inline blt::bump_allocator<blt::BLT_2MB_SIZE, false>& get_allocator()
{ return alloc; }
public:
explicit tree_t(type_engine_t& types);
static tree_t make_tree(type_engine_t& types, random& engine, blt::size_t min_height, blt::size_t max_height);
};
}

7
include/lilfbtf/type.h
View File

@ -153,6 +153,9 @@ namespace fb
[[nodiscard]] inline arg_c_t get_function_argc(function_name name) const
{ return get_function_argc(get_function_id(name)); }
[[nodiscard]] inline const std::vector<type_id>& get_function_allowed_arguments(function_id id) const
{ return function_inputs[id]; }
type_engine_t& associate_input(function_name func_name, const std::vector<std::string>& types);
[[nodiscard]] inline const func_t_call_t& get_function(function_id id) const
@ -167,11 +170,15 @@ namespace fb
[[nodiscard]] inline const func_t_init_t& get_function_initializer(function_name name) const
{ return get_function_initializer(get_function_id(name)); }
// output type -> list of functions that output that type and take arguments themselves
inline std::vector<function_id>& get_terminals(type_id type)
{ return terminals[type]; }
inline std::vector<function_id>& get_non_terminals(type_id type)
{ return non_terminals[type]; }
[[nodiscard]] inline const std::vector<std::pair<type_id, function_id>>& get_all_non_terminals() const
{ return all_non_terminals; }
};
}

5
src/random.cpp
View File

@ -58,4 +58,9 @@ namespace fb
std::uniform_int_distribution<blt::i32> dist(min, max);
return dist(engine);
}
bool random::chance(double chance)
{
return random_double() <= chance;
}
}

80
src/tree.cpp
View File

@ -15,6 +15,7 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include <lilfbtf/tree.h>
#include <stack>
namespace fb
{
@ -23,15 +24,84 @@ namespace fb
argc_(argc), type(output_type), function(function_type), func(func)
{}
tree_t::tree_t(blt::bump_allocator<blt::BLT_2MB_SIZE, false>& alloc, type_engine_t& types): alloc(alloc), types(types)
tree_t::tree_t(type_engine_t& types): alloc(), types(types)
{}
tree_t tree_t::make_tree(blt::bump_allocator<blt::BLT_2MB_SIZE, false>& alloc, type_engine_t& types, blt::size_t min_height,
blt::size_t max_height)
tree_t tree_t::make_tree(type_engine_t& types, random& engine,
blt::size_t min_height, blt::size_t max_height)
{
tree_t tree(alloc, types);
using detail::node_t;
tree_t tree(types);
{
auto& non_terminals = types.get_all_non_terminals();
auto selection = non_terminals[engine.random_long(0, non_terminals.size() - 1)];
func_t func(types.get_function_argc(selection.second), types.get_function(selection.second), selection.first, selection.second);
tree.root = tree.alloc.template emplace<node_t>(func, tree.alloc);
}
std::stack<std::pair<node_t*, blt::size_t>> stack;
stack.emplace(tree.root, 0);
while (!stack.empty())
{
auto top = stack.top();
auto* node = top.first;
auto depth = top.second;
stack.pop();
const auto& allowed_types = types.get_function_allowed_arguments(node->type.getFunction());
// we need to make sure there is at least one non-terminal generation, until we hit the min height
bool has_one_non_terminal = false;
for (blt::size_t i = 0; i < node->type.argc(); i++)
{
type_id type_category = allowed_types[i];
const auto& terminals = types.get_terminals(type_category);
const auto& non_terminals = types.get_non_terminals(type_category);
if (depth < max_height)
stack.emplace(node->children[i], depth + 1);
if (depth < min_height && !has_one_non_terminal)
{
function_id selection = non_terminals[engine.random_long(0, non_terminals.size() - 1)];
func_t func(types.get_function_argc(selection), types.get_function(selection), type_category, selection);
node->children[i] = tree.alloc.template emplace<node_t>(func, tree.alloc);
has_one_non_terminal = true;
continue;
}
if (depth >= max_height)
{
function_id selection = terminals[engine.random_long(0, terminals.size() - 1)];
func_t func(types.get_function_argc(selection), types.get_function(selection), type_category, selection);
node->children[i] = tree.alloc.template emplace<node_t>(func, tree.alloc);
continue;
}
if (engine.choice())
{
// use full() method
function_id selection = non_terminals[engine.random_long(0, non_terminals.size() - 1)];
func_t func(types.get_function_argc(selection), types.get_function(selection), type_category, selection);
node->children[i] = tree.alloc.template emplace<node_t>(func, tree.alloc);
} else
{
// use grow() method, meaning select choice again
if (engine.choice())
{
// use non-terminals
function_id selection = non_terminals[engine.random_long(0, non_terminals.size() - 1)];
func_t func(types.get_function_argc(selection), types.get_function(selection), type_category, selection);
node->children[i] = tree.alloc.template emplace<node_t>(func, tree.alloc);
} else
{
// use terminals
function_id selection = terminals[engine.random_long(0, terminals.size() - 1)];
func_t func(types.get_function_argc(selection), types.get_function(selection), type_category, selection);
node->children[i] = tree.alloc.template emplace<node_t>(func, tree.alloc);
}
}
}
}
return tree;
}