i love your patches

CMakeLists.txt

@@ -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)

include/lilfbtf/random.h

@@ -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);

include/lilfbtf/tree.h

@@ -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;
+            detail::node_t* root = nullptr;
-        public:
-            tree_t(blt::bump_allocator<blt::BLT_2MB_SIZE, false>& alloc, type_engine_t& types);
             
-            static tree_t make_tree(blt::bump_allocator<blt::BLT_2MB_SIZE, false>& alloc, type_engine_t& types, blt::size_t min_height,
+            inline blt::bump_allocator<blt::BLT_2MB_SIZE, false>& get_allocator()
-                                    blt::size_t max_height);
+            { 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);
     };
 }
 

include/lilfbtf/type.h

@@ -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; }
     };
 }
 

src/random.cpp

@@ -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;
+    }
 }

src/tree.cpp

@@ -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,
+    tree_t tree_t::make_tree(type_engine_t& types, random& engine,
-                             blt::size_t max_height)
+                             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;
     }