hyperdrone 0.1.0__py3-none-any.whl

hyperdrone/_vendor/rl-tools/include/rl_tools/persist/backends/tar/operations_posix.h

@@ -0,0 +1,63 @@
+
+#include "../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_PERSIST_BACKENDS_TAR_OPERATIONS_POSIX_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_PERSIST_BACKENDS_TAR_OPERATIONS_POSIX_H
+
+#include <stdio.h>
+#include "tar.h"
+#include "../../../utils/string/operations_generic.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::persist::backends::tar {
+    template <typename TI>
+    struct PosixFileData{
+        FILE *f;
+        TI size = 0;
+    };
+}
+namespace rl_tools{
+    namespace persist::backends::tar{
+        template <typename DEVICE, typename BD_TI, typename READ_OFFSET_TI, typename READ_SIZE_TI>
+        RL_TOOLS_FUNCTION_PLACEMENT bool seek(DEVICE& device, PosixFileData<BD_TI>& data_backend, const char* entry_name, READ_OFFSET_TI& entry_offset, READ_SIZE_TI& entry_size){
+            using TI = typename DEVICE::index_t;
+            if(!utils::assert_exit(device, fseek(data_backend.f, 0, SEEK_SET) == 0, "persist::backends::tar: Failed to seek to start of file")){return false;}
+            header h;
+            while(fread(&h, sizeof(header), 1, data_backend.f) == 1){
+                if(h.name[0] == '\0'){
+                    break;
+                }
+                if (!utils::assert_exit(device, utils::string::compare(h.magic, "ustar", 5), "Warning: Not a UStar format archive or header is corrupted.")){return false;};
+
+                entry_size = utils::string::parse_octal<TI>(h.size, 12);
+                if (utils::string::compare(h.name, entry_name, 100)){
+                    entry_offset = ftell(data_backend.f);
+                    return true;
+                }
+
+                size_t padding_size = (BLOCK_SIZE<TI> - (entry_size % BLOCK_SIZE<TI>)) % BLOCK_SIZE<TI>;
+                if(fseek(data_backend.f, entry_size + padding_size, SEEK_CUR) != 0){
+                    return false;
+                }
+            }
+            return false;
+        }
+        template <typename DEVICE, typename BD_TI>
+        RL_TOOLS_FUNCTION_PLACEMENT bool get(DEVICE& device, PosixFileData<BD_TI>& data_backend, const char* entry_name, char* output_data, typename DEVICE::index_t output_size, typename DEVICE::index_t& read_size){
+            using TI = typename DEVICE::index_t;
+            if(!utils::assert_exit(device, fseek(data_backend.f, 0, SEEK_SET) == 0, "persist::backends::tar: Failed to seek to start of file")){return false;}
+            TI entry_offset;
+            if (seek(device, data_backend, entry_name, entry_offset, read_size)){
+                if (!utils::assert_exit(device, read_size <= output_size, "persist::backends::tar: Output buffer is too small for the requested entry")){return false;};
+                if(fread(output_data, 1, read_size, data_backend.f) != read_size){
+                    return false;
+                }
+                return true;
+            }
+            return false;
+        }
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#include "operations_generic.h"
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/persist/backends/tar/tar.h

@@ -0,0 +1,74 @@
+#include "../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_PERSIST_BACKENDS_TAR_TAR_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_PERSIST_BACKENDS_TAR_TAR_H
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::persist::backends::tar {
+    template <typename TI>
+    static constexpr TI BLOCK_SIZE = 512;
+    // UStar tar header structure
+    struct header {
+        char name[100];
+        char mode[8];
+        char uid[8];
+        char gid[8];
+        char size[12];
+        char mtime[12];
+        char chksum[8];
+        char typeflag;
+        char linkname[100];
+        char magic[6];
+        char version[2];
+        char uname[32];
+        char gname[32];
+        char devmajor[8];
+        char devminor[8];
+        char prefix[155];
+        char padding[12];
+    };
+    static_assert(sizeof(header) == 512);
+    template <typename T_TI, typename T_WRITER>
+    struct WriterGroupSpecification{
+        using TI = T_TI;
+        using WRITER = T_WRITER;
+        static constexpr TI MAX_PATH_LENGTH = 100;
+        static constexpr TI META_SIZE = 2000;
+    };
+    template <typename T_SPEC>
+    struct WriterGroup{
+        using SPEC = T_SPEC;
+        using TI = typename SPEC::TI;
+        using WRITER = typename SPEC::WRITER;
+        char path[SPEC::MAX_PATH_LENGTH] = "";
+        WRITER* writer = nullptr;
+        char meta[SPEC::META_SIZE] = "";
+        TI meta_position = 0;
+        bool success = true;
+    };
+    template <typename TI>
+    struct BufferData{
+        const char* data = nullptr;
+        TI size = 0;
+    };
+    template <typename T_TI, typename T_DATA_BACKEND=BufferData<T_TI>>
+    struct ReaderGroupSpecification{
+        using TI = T_TI;
+        using DATA_BACKEND = T_DATA_BACKEND;
+        static constexpr TI MAX_PATH_LENGTH = 100;
+    };
+    template <typename T_SPEC>
+    struct ReaderGroup{
+        using SPEC = T_SPEC;
+        using TI = typename SPEC::TI;
+        char path[SPEC::MAX_PATH_LENGTH] = "";
+        typename SPEC::DATA_BACKEND data;
+        bool success = true;
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif
+
+
+
+

hyperdrone/_vendor/rl-tools/include/rl_tools/persist/code.h

@@ -0,0 +1,38 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_PERSIST_CODE_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_PERSIST_CODE_H
+
+#include <sstream>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::persist{
+    struct Code{
+        std::string header;
+        std::string body;
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template <typename DEVICE>
+    persist::Code embed_in_namespace(DEVICE&, persist::Code c, std::string name, typename DEVICE::index_t indent = 0){
+        using TI = typename DEVICE::index_t;
+        std::stringstream indent_ss;
+        for(TI i=0; i < indent; i++){
+            indent_ss << "    ";
+        }
+        std::string ind = indent_ss.str();
+        std::stringstream ss_header;
+        std::stringstream ss;
+        ss_header << c.header;
+        ss << ind << "namespace " << name << " {\n";
+        ss << c.body;
+        ss << ind << "}\n";
+        return {ss_header.str(), ss.str()};
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/random/operations_arm.h

@@ -0,0 +1,39 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_UTILS_RANDOM_OPERATIONS_ARM_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_UTILS_RANDOM_OPERATIONS_ARM_H
+
+
+#include "../utils/generic/typing.h"
+#include "operations_generic.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template <typename DEV_SPEC, typename SPEC>
+    void malloc(devices::ARM<DEV_SPEC>& device, devices::random::ARM::ENGINE<SPEC>& rng){}
+    template <typename DEV_SPEC, typename SPEC>
+    void free(devices::ARM<DEV_SPEC>& device, devices::random::ARM::ENGINE<SPEC>& rng){}
+    template <typename DEV_SPEC, typename SPEC>
+    void init(devices::ARM<DEV_SPEC>& device, devices::random::ARM::ENGINE<SPEC>& rng, typename devices::ARM<DEV_SPEC>::index_t seed = 1){
+        rng.state = 10000 + seed;
+    }
+    namespace random{
+        template<typename T, typename RNG>
+        T uniform_int_distribution(const devices::random::ARM& dev, T low, T high, RNG& rng){
+            return uniform_int_distribution(devices::random::Generic<devices::math::ARM>{}, low, high, rng);
+        }
+        template<typename T, typename RNG>
+        T uniform_real_distribution(const devices::random::ARM& dev, T low, T high, RNG& rng){
+            return uniform_real_distribution(devices::random::Generic<devices::math::ARM>{}, low, high, rng);
+        }
+        namespace normal_distribution{
+            template<typename T, typename RNG>
+            T sample(const devices::random::ARM& dev, T mean, T std, RNG& rng){
+                return sample(devices::random::Generic<devices::math::ARM>{}, mean, std, rng);
+            }
+        }
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/random/operations_cpu.h

@@ -0,0 +1,61 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_UTILS_RANDOM_OPERATIONS_CPU_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_UTILS_RANDOM_OPERATIONS_CPU_H
+
+
+#include "../utils/generic/typing.h"
+#include "operations_generic.h"
+
+#include <random>
+#include <limits>
+#include <sstream>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template <typename DEV_SPEC, typename SPEC>
+    void malloc(devices::CPU<DEV_SPEC>& device, devices::random::CPU::ENGINE<SPEC>& rng){}
+    template <typename DEV_SPEC, typename SPEC>
+    void free(devices::CPU<DEV_SPEC>& device, devices::random::CPU::ENGINE<SPEC>& rng){}
+    template <typename DEV_SPEC, typename SPEC>
+    void init(devices::CPU<DEV_SPEC>& device, devices::random::CPU::ENGINE<SPEC>& rng, typename devices::CPU<DEV_SPEC>::index_t seed = 1){
+        using ENGINE = devices::random::CPU::ENGINE<SPEC>;
+        rng.engine = typename ENGINE::TYPE(static_cast<typename ENGINE::TYPE::result_type>(seed+1));
+    };
+    namespace random{
+        template<typename T, typename SPEC>
+        T uniform_int_distribution(const devices::random::CPU& dev, T low, T high, devices::random::CPU::ENGINE<SPEC>& rng){
+            return std::uniform_int_distribution<T>(low, high)(rng.engine);
+        }
+
+        template<typename T, typename SPEC>
+        T uniform_real_distribution(const devices::random::CPU& dev, T low, T high, devices::random::CPU::ENGINE<SPEC>& rng){
+            static_assert(utils::typing::is_same_v<T, float> || utils::typing::is_same_v<T, double>);
+            return std::uniform_real_distribution<T>(low, high)(rng.engine);
+        }
+    //    template<typename T, typename RNG>
+    //    const std::normal_distribution<T> standard_normal_distribution(0, 1);
+        namespace normal_distribution{
+            template<typename T, typename SPEC>
+            T sample(const devices::random::CPU& dev, T mean, T std, devices::random::CPU::ENGINE<SPEC>& rng){
+                if(std == 0){
+                    return mean;
+                }
+                else{
+                    return (T)std::normal_distribution<float>(mean, std)(rng.engine);
+                }
+            }
+        }
+
+    }
+    template <typename DEV_SPEC, typename SPEC_1, typename SPEC_2, typename T = int>
+    T abs_diff(devices::CPU<DEV_SPEC>& device, devices::random::CPU::ENGINE<SPEC_1>& rng1, devices::random::CPU::ENGINE<SPEC_2>& rng2){
+        std::stringstream ss1, ss2;
+        ss1 << rng1.engine;
+        ss2 << rng2.engine;
+        return (ss1.str() == ss2.str()) ? 0 : 1;
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/random/operations_cuda.h

@@ -0,0 +1,164 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_UTILS_RANDOM_OPERATIONS_CUDA_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_UTILS_RANDOM_OPERATIONS_CUDA_H
+
+
+#include "../utils/generic/typing.h"
+#include "operations_generic.h"
+
+#include <curand_kernel.h>
+#include "../containers/matrix/matrix.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::random{
+    namespace cuda::kernels{
+        template <typename DEVICE, typename SPEC>
+        __global__
+        void init_rng_kernel(DEVICE device, devices::random::CUDA::ENGINE<SPEC> rng, typename DEVICE::index_t seed){
+            auto i = threadIdx.x + blockIdx.x * blockDim.x;
+            if(i < SPEC::NUM_RNGS){
+                curand_init(seed, i, 0, &get(rng.states, 0, i));
+            }
+        }
+    }
+
+    template<typename T, typename RNG>
+    RL_TOOLS_FUNCTION_PLACEMENT T uniform_real_distribution(const devices::random::CUDA& dev, T low, T high, RNG& rng){
+        // static_assert(utils::typing::is_same_v<T, float> || utils::typing::is_same_v<T, double>, "Only float and double are supported");
+        if constexpr(utils::typing::is_same_v<T, float>){
+            return curand_uniform(&rng) * (high - low) + low;
+        }
+        else{
+            if constexpr(utils::typing::is_same_v<T, double>){
+                return curand_uniform_double(&rng) * (high - low) + low;
+            }
+            else{
+                return (T)curand_uniform(&rng) * (high - low) + low;
+            }
+        }
+        return 0;
+    }
+    // Overload for ENGINE type (used from host code): extract first curandState
+    template<typename T, typename SPEC>
+    T uniform_real_distribution(const devices::random::CUDA& dev, T low, T high, devices::random::CUDA::ENGINE<SPEC>& rng){
+        auto& rng_state = get(rng.states, 0, 0);
+        return uniform_real_distribution(dev, low, high, rng_state);
+    }
+    template<typename T, typename RNG>
+    RL_TOOLS_FUNCTION_PLACEMENT T uniform_int_distribution(const devices::random::CUDA& dev, T low, T high, RNG& rng){
+        auto r = uniform_real_distribution(dev, (float)low, (float)high, rng);
+        return (T)r;
+    }
+    namespace normal_distribution{
+        template<typename T, typename RNG>
+        RL_TOOLS_FUNCTION_PLACEMENT T sample(const devices::random::CUDA& dev, T mean, T std, RNG& rng){
+            // static_assert(utils::typing::is_same_v<T, float> || utils::typing::is_same_v<T, double>);
+            if(std == (T)0){
+                return mean;
+            }
+            if constexpr(utils::typing::is_same_v<T, float>){
+                return curand_normal(&rng) * std + mean;
+            }
+            else{
+                if constexpr(utils::typing::is_same_v<T, double>){
+                    return curand_normal_double(&rng) * std + mean;
+                }
+                else{
+                    return ((T)curand_normal(&rng)) * std + mean;
+                }
+            }
+        }
+        // Overload for ENGINE type (used from host code): extract first curandState
+        template<typename T, typename SPEC>
+        T sample(const devices::random::CUDA& dev, T mean, T std, devices::random::CUDA::ENGINE<SPEC>& rng){
+            auto& rng_state = get(rng.states, 0, 0);
+            return sample(dev, mean, std, rng_state);
+        }
+    }
+    namespace normal_distribution{
+        template<typename T, typename SPEC>
+        T log_prob(const devices::random::CUDA& dev, T mean, T log_std, T value, devices::random::CUDA::ENGINE<SPEC>& rng){
+            // Just delegate to the generic implementation since log_prob doesn't need curand
+            auto& rng_state = get(rng.states, 0, 0);
+            return log_prob(dev, mean, log_std, value, rng_state);
+        }
+    }
+    // Fallback overloads for PortableState (generic XOR RNG, used for cross-device determinism)
+    template<typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT T uniform_real_distribution(const devices::random::CUDA& dev, T low, T high, devices::generic::random::PortableState& rng){
+        const devices::random::Generic<devices::math::CUDA>& generic_dev = dev;
+        return uniform_real_distribution(generic_dev, low, high, rng);
+    }
+    template<typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT T uniform_int_distribution(const devices::random::CUDA& dev, T low, T high, devices::generic::random::PortableState& rng){
+        const devices::random::Generic<devices::math::CUDA>& generic_dev = dev;
+        return uniform_int_distribution(generic_dev, low, high, rng);
+    }
+    namespace normal_distribution{
+        template<typename T>
+        RL_TOOLS_FUNCTION_PLACEMENT T sample(const devices::random::CUDA& dev, T mean, T std, devices::generic::random::PortableState& rng){
+            const devices::random::Generic<devices::math::CUDA>& generic_dev = dev;
+            return sample(generic_dev, mean, std, rng);
+        }
+    }
+    // Convenience overloads for ArrayENGINE: delegate to engine 0 (must be after PortableState overloads)
+    template<typename T, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT T uniform_real_distribution(const devices::random::CUDA& dev, T low, T high, devices::generic::random::ArrayENGINE<SPEC>& rng){
+        auto& rng_state = get(rng.states, 0, 0);
+        return uniform_real_distribution(dev, low, high, rng_state);
+    }
+    template<typename T, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT T uniform_int_distribution(const devices::random::CUDA& dev, T low, T high, devices::generic::random::ArrayENGINE<SPEC>& rng){
+        auto& rng_state = get(rng.states, 0, 0);
+        return uniform_int_distribution(dev, low, high, rng_state);
+    }
+    namespace normal_distribution{
+        template<typename T, typename SPEC>
+        RL_TOOLS_FUNCTION_PLACEMENT T sample(const devices::random::CUDA& dev, T mean, T std, devices::generic::random::ArrayENGINE<SPEC>& rng){
+            auto& rng_state = get(rng.states, 0, 0);
+            return sample(dev, mean, std, rng_state);
+        }
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools {
+    template <typename DEVICE, typename SPEC>
+    void malloc(DEVICE& device, devices::random::CUDA::ENGINE<SPEC>& rng){
+        malloc(device, rng.states);
+    }
+    template <typename DEVICE, typename SPEC>
+    void free(DEVICE& device, devices::random::CUDA::ENGINE<SPEC>& rng){
+        free(device, rng.states);
+    }
+    template <typename DEVICE>
+    RL_TOOLS_FUNCTION_PLACEMENT void malloc(DEVICE& device, curandState& rng){}
+    template <typename DEVICE>
+    RL_TOOLS_FUNCTION_PLACEMENT void free(DEVICE& device, curandState& rng){}
+    template <typename DEVICE>
+    RL_TOOLS_FUNCTION_PLACEMENT void init(DEVICE& device, curandState& rng, typename DEVICE::index_t seed = 1){
+        using TI = typename DEVICE::index_t;
+        TI id = threadIdx.x + blockIdx.x * blockDim.x;
+        curand_init(seed, id, 0, &rng);
+    };
+    template <typename DEV_SPEC, typename SPEC>
+    void init(devices::CUDA<DEV_SPEC>& device, devices::random::CUDA::ENGINE<SPEC>& rng, typename SPEC::TI seed = 1){
+        using DEVICE = devices::CUDA<DEV_SPEC>;
+        using TI = typename DEVICE::index_t;
+        constexpr TI BLOCKSIZE_COLS = 32;
+        constexpr TI N_BLOCKS_COLS = RL_TOOLS_DEVICES_CUDA_CEIL(SPEC::NUM_RNGS, BLOCKSIZE_COLS);
+        dim3 grid(N_BLOCKS_COLS);
+        dim3 block(BLOCKSIZE_COLS);
+#ifdef RL_TOOLS_DEBUG
+        utils::assert_exit(device, rng.states._data != nullptr, "rng not allocated");;
+#endif
+        devices::cuda::TAG<DEVICE, true> tag_device{};
+        random::cuda::kernels::init_rng_kernel<<<grid, block, 0, device.stream>>>(tag_device, rng, seed);
+        check_status(device);
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/random/operations_dummy.h

@@ -0,0 +1,72 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_UTILS_RANDOM_OPERATIONS_DUMMY_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_UTILS_RANDOM_OPERATIONS_DUMMY_H
+
+#include "../devices/dummy.h"
+#include "../utils/generic/typing.h"
+#include "operations_generic.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template <typename DEV_SPEC, typename SPEC>
+    void malloc(devices::Dummy<DEV_SPEC>& device, devices::random::Dummy::ENGINE<SPEC>& rng){ }
+    template <typename DEV_SPEC, typename SPEC>
+    void init(devices::Dummy<DEV_SPEC>& device, devices::random::Dummy::ENGINE<SPEC>& rng, typename devices::Dummy<DEV_SPEC>::index_t seed = 1){
+        rng.state = 10000 + seed;
+    };
+    namespace random{
+        template<typename T, typename RNG>
+        T uniform_int_distribution(const devices::random::Dummy& dev, T low, T high, RNG& rng){
+    //        static_assert(utils::typing::is_same_v<T, typename DEVICE::index_t>);
+    //        static_assert(utils::typing::is_same_v<RNG, typename DEVICE::index_t>);
+    //        // https://en.wikipedia.org/wiki/Xorshift
+    //        rng ^= (rng << 21);
+    //        rng ^= (rng >> 35);
+    //        rng ^= (rng << 4);
+    //        return rng % (high-low) + low;
+            return low;
+        }
+        template<typename T, typename RNG>
+        T uniform_real_distribution(const devices::random::Dummy& dev, T low, T high, RNG& rng){
+    //        static_assert(utils::typing::is_same_v<RNG, typename DEVICE::index_t>);
+    //        T r = (T)uniform_int_distribution<typename DEVICE::index_t, typename DEVICE::index_t>((typename DEVICE::index_t)0, (typename DEVICE::index_t)1<<31, rng) / (T)(1<<31) - 1;
+    //        return r * (high-low) + low;
+            return low;
+        }
+        namespace normal_distribution{
+            template<typename T, typename RNG>
+            T sample(const devices::random::Dummy& dev, T mean, T std, RNG& rng){
+                static_assert(utils::typing::is_same_v<T, float> || utils::typing::is_same_v<T, double>);
+                return 0;
+            }
+        }
+    //        static_assert(utils::typing::is_same_v<RNG, typename DEVICE::index_t>);
+    //        //
+    //        T x, y, r, res;
+    //        x = 0;
+    //        y = 0;
+    //        r = 0;
+    //        res = 0;
+    //
+    //        do {
+    //            x = (T)2.0 * (T)uniform_int_distribution<typename DEVICE::index_t, typename DEVICE::index_t>(0, 1<<31, rng) / (T)(1<<31) - 1;
+    //            y = (T)2.0 * (T)uniform_int_distribution<typename DEVICE::index_t, typename DEVICE::index_t>(0, 1<<31, rng) / (T)(1<<31) - 1;
+    //            r = x * x + y * y;
+    //        } while (r == 0.0 || r > 1.0);
+    //
+    //        T d = math::sqrt(-2.0 * math::log(r) / r);
+    //
+    //        T n1 = x * d;
+    //        T n2 = y * d;
+    //
+    //        res = n1 * std + mean;
+    //
+    //        return res;
+    //        return mean; }
+
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/random/operations_esp32.h

@@ -0,0 +1,45 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_UTILS_RANDOM_OPERATIONS_ESP32_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_UTILS_RANDOM_OPERATIONS_ESP32_H
+
+
+#include "../utils/generic/typing.h"
+#include "operations_generic.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::random{
+    template <typename DEV_SPEC>
+    devices::random::ESP32::index_t default_engine(const devices::ESP32<DEV_SPEC>& dev, devices::random::ESP32::index_t seed = 1){
+        return default_engine(devices::Generic<DEV_SPEC>{}, seed);
+    };
+    constexpr devices::random::ESP32::index_t next_max(const devices::random::ESP32& dev){
+        return devices::random::ESP32::MAX_INDEX;
+    }
+    template <typename TI, typename RNG>
+    auto split(const devices::random::ESP32& dev, TI split_id, RNG& rng){
+        return split(devices::random::Generic<devices::math::ESP32>{}, split_id, rng);
+    }
+    template<typename RNG>
+    void next(const devices::random::ESP32& dev, RNG& rng){
+        next(devices::random::Generic<devices::math::ESP32>{}, rng);
+    }
+
+    template<typename T, typename RNG>
+    T uniform_int_distribution(const devices::random::ESP32& dev, T low, T high, RNG& rng){
+        return uniform_int_distribution(devices::random::Generic<devices::math::ESP32>{}, low, high, rng);
+    }
+    template<typename T, typename RNG>
+    T uniform_real_distribution(const devices::random::ESP32& dev, T low, T high, RNG& rng){
+        return uniform_real_distribution(devices::random::Generic<devices::math::ESP32>{}, low, high, rng);
+    }
+    namespace normal_distribution{
+        template<typename T, typename RNG>
+        T sample(const devices::random::ESP32& dev, T mean, T std, RNG& rng){
+            return sample(devices::random::Generic<devices::math::ESP32>{}, mean, std, rng);
+        }
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif