hyperray 0.0.1__py3-none-any.whl

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

@@ -0,0 +1,57 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_LOGGING_OPERATIONS_CPU_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_LOGGING_OPERATIONS_CPU_H
+
+
+
+#include <iostream>
+#include <sstream>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template <typename DEVICE>
+    void init(DEVICE& dev, devices::logging::CPU& logger){ }
+    template <typename DEVICE, typename PARAM>
+    void init(DEVICE& dev, devices::logging::CPU& logger, PARAM& param){ }
+    template <typename DEVICE, typename... ARGS>
+    void log(DEVICE& device, devices::logging::CPU& logger, const ARGS&... args){
+        (std::cout << ... << args) << std::endl;
+    }
+    template <typename DEVICE, typename... ARGS>
+    void log(DEVICE& device, devices::logging::CPU& logger, devices::logging::Verbosity verbosity, const ARGS&... args){
+        if(verbosity > logger.verbosity){
+            return;
+        }
+        std::ostringstream message;
+        (message << ... << args) << '\n';
+        std::cerr << message.str() << std::flush;
+    }
+
+    template <typename DEVICE>
+    void set_step(DEVICE& device, devices::logging::CPU& logger, typename DEVICE::index_t step){ /* noop */ }
+    template <typename DEVICE>
+    typename DEVICE::index_t get_step(DEVICE& device, devices::logging::CPU& logger){return 0;}
+    template <typename DEVICE, typename ARG_1, typename ARG_2>
+    void construct(DEVICE& device, devices::logging::CPU& logger, ARG_1, ARG_2){ /* noop */ }
+    template <typename DEVICE>
+    void construct(DEVICE& device, devices::logging::CPU& logger){ /* noop */ }
+    template <typename DEVICE>
+    void free(DEVICE& device, devices::logging::CPU& logger){ /* noop */ }
+    template <typename DEVICE, typename TOPIC, typename ARG>
+    void add_scalar(DEVICE& device, devices::logging::CPU& logger, const TOPIC, const ARG){ /* noop */ }
+    template <typename DEVICE, typename TOPIC, typename ARG, typename CADENCE>
+    void add_scalar(DEVICE& device, devices::logging::CPU& logger, const TOPIC, const ARG, const CADENCE){ /* noop */ }
+    template <typename DEVICE, typename TOPIC, typename ARG, typename ARG_LEN, typename CADENCE>
+    void add_histogram(DEVICE& device, devices::logging::CPU& logger, const TOPIC, const ARG*, const ARG_LEN, const CADENCE){ /* noop */ }
+    template <typename DEVICE, typename TOPIC, typename ARG, typename ARG_LEN>
+    void add_histogram(DEVICE& device, devices::logging::CPU& logger, const TOPIC, const ARG*, const ARG_LEN){ /* noop */ }
+    template <typename DEVICE, typename TOPIC, typename TEXT>
+    void add_text(DEVICE& device, devices::logging::CPU& logger, const TOPIC, const TEXT){ /* noop */ }
+    template <typename DEVICE, typename TOPIC, typename TEXT, typename CADENCE>
+    void add_text(DEVICE& device, devices::logging::CPU& logger, const TOPIC, const TEXT, const CADENCE){ /* noop */ }
+    template <typename DEVICE, typename HPARAMS, typename METRICS>
+    void add_hparams(DEVICE& device, devices::logging::CPU& logger, const HPARAMS&, const METRICS&){ /* noop */ }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/logging/operations_cpu_tensorboard.h

@@ -0,0 +1,151 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_LOGGING_OPERATIONS_CPU_TENSORBOARD_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_LOGGING_OPERATIONS_CPU_TENSORBOARD_H
+
+#include "../containers/matrix/matrix.h"
+
+#include <filesystem>
+#include <cassert>
+#include "operations_cpu.h"
+
+#ifdef RL_TOOLS_ENABLE_LIBATTOPNG
+#include <libattopng/libattopng.h>
+#endif
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    namespace logging::tensorboard{
+        template <typename DEVICE, typename KEY_TYPE>
+        void count_topic(DEVICE& device, devices::logging::CPU_TENSORBOARD<>& logger, KEY_TYPE key){ }
+        template <typename DEVICE, typename KEY_TYPE>
+        void count_topic(DEVICE& device, devices::logging::CPU_TENSORBOARD_FREQUENCY_EXTENSION& logger, KEY_TYPE key){
+            if(!logger.topic_frequency_dict.count(key)){
+                logger.topic_frequency_dict.insert({key, 0});
+            }
+            logger.topic_frequency_dict[key] += 1;
+        }
+        template <typename DEVICE>
+        void print_topic_frequencies(DEVICE& device, devices::logging::CPU_TENSORBOARD_FREQUENCY_EXTENSION& logger){
+            std::cout << "Tensorboard Topic Frequencies:" << std::endl;
+            std::vector<std::pair<std::string, int>> vec(logger.topic_frequency_dict.begin(), logger.topic_frequency_dict.end());
+            std::sort(vec.begin(), vec.end(),
+                      [](const std::pair<std::string, int>& a, const std::pair<std::string, int>& b) {
+                          return a.second > b.second; // For descending order
+                      }
+            );
+            for (const auto& [key, val] : vec) {
+                std::cout << key << " => " << val << std::endl;
+            }
+        }
+    }
+    template <typename DEVICE, typename SPEC>
+    void init(DEVICE& device, devices::logging::CPU_TENSORBOARD<SPEC>& logger){ }
+    template <typename DEVICE, typename SPEC>
+    void init(DEVICE& device, devices::logging::CPU_TENSORBOARD<SPEC>& logger, std::filesystem::path run_dir){
+        utils::assert_exit(device, logger.tb == nullptr, "Tensorboard logger already initialized (double init can cause file corruption)");
+        if (!std::filesystem::is_directory(run_dir) || !std::filesystem::exists(run_dir)) {
+            std::filesystem::create_directories(run_dir);
+        }
+
+        auto log_file = run_dir / std::string("logs.tfevents");
+        std::cerr << "Tensorboard Logger logging to: " << std::filesystem::absolute(log_file).string() << std::endl;
+        TensorBoardLoggerOptions opts;
+        opts.flush_period_s(1);
+        logger.tb = new TensorBoardLogger(log_file.string(), opts);
+    }
+    template <typename DEVICE, typename SPEC>
+    void free(DEVICE& device, devices::logging::CPU_TENSORBOARD<SPEC>& logger){
+        delete logger.tb;
+    }
+    template <typename DEVICE, typename SPEC>
+    void set_step(DEVICE& device, devices::logging::CPU_TENSORBOARD<SPEC>& logger, typename DEVICE::index_t step){
+        logger.step = step;
+    }
+    template <typename DEVICE, typename SPEC>
+    typename DEVICE::index_t get_step(DEVICE& device, devices::logging::CPU_TENSORBOARD<SPEC>& logger){
+        return logger.step;
+    }
+    template <typename DEVICE, typename KEY_TYPE, typename VALUE_TYPE, typename CADANCE_TYPE, typename SPEC>
+    void add_scalar(DEVICE& device, devices::logging::CPU_TENSORBOARD<SPEC>& logger, const KEY_TYPE key, const VALUE_TYPE value, const CADANCE_TYPE cadence){
+        std::lock_guard<std::mutex> lock(logger.mutex);
+        if(logger.tb){
+            if(logger.step % cadence == 0){
+                logger.tb->add_scalar(key, logger.step, (float)value);
+                logging::tensorboard::count_topic(device, logger, key);
+            }
+        }
+    }
+    template <typename DEVICE, typename KEY_TYPE, typename VALUE_TYPE, typename SPEC>
+    void add_scalar(DEVICE& device, devices::logging::CPU_TENSORBOARD<SPEC>& logger, const KEY_TYPE key, const VALUE_TYPE value){
+        add_scalar(device, logger, key, value, (typename DEVICE::index_t)1);
+    }
+    template <typename DEVICE, typename KEY_TYPE, typename T, typename TI, typename CADANCE_TYPE, typename SPEC>
+    void add_histogram(DEVICE& device, devices::logging::CPU_TENSORBOARD<SPEC>& logger, const KEY_TYPE key, const T* values, const TI n_values, const CADANCE_TYPE cadence = (typename DEVICE::index_t)1){
+        std::lock_guard<std::mutex> lock(logger.mutex);
+        if(logger.tb){
+            if(logger.step % cadence == 0){
+                logger.tb->add_histogram(key, logger.step, values, n_values);
+                logging::tensorboard::count_topic(device, logger, key);
+            }
+        }
+    }
+    template <typename DEVICE, typename KEY_TYPE, typename T, typename TI, typename SPEC>
+    void add_histogram(DEVICE& device, devices::logging::CPU_TENSORBOARD<SPEC>& logger, const KEY_TYPE key, const T* values, const TI n_values){
+        add_histogram(device, logger, key, values, n_values, (typename DEVICE::index_t)1);
+    }
+    template <typename DEVICE, typename KEY_TYPE, typename TEXT_TYPE, typename CADENCE_TYPE, typename SPEC>
+    void add_text(DEVICE& device, devices::logging::CPU_TENSORBOARD<SPEC>& logger, const KEY_TYPE key, const TEXT_TYPE text, const CADENCE_TYPE cadence){
+        std::lock_guard<std::mutex> lock(logger.mutex);
+        if(logger.tb){
+            if(logger.step % cadence == 0){
+                logger.tb->add_text(key, logger.step, text);
+                logging::tensorboard::count_topic(device, logger, key);
+            }
+        }
+    }
+    template <typename DEVICE, typename KEY_TYPE, typename TEXT_TYPE, typename SPEC>
+    void add_text(DEVICE& device, devices::logging::CPU_TENSORBOARD<SPEC>& logger, const KEY_TYPE key, const TEXT_TYPE text){
+        add_text(device, logger, key, text, (typename DEVICE::index_t)1);
+    }
+    template <typename DEVICE, typename SPEC>
+    void add_hparams(DEVICE& device, devices::logging::CPU_TENSORBOARD<SPEC>& logger, const std::map<std::string, HParamValue>& hparams, const std::vector<std::string>& metrics){
+        std::lock_guard<std::mutex> lock(logger.mutex);
+        if(logger.tb){
+            logger.tb->add_hparams(hparams, metrics);
+        }
+    }
+#ifdef RL_TOOLS_ENABLE_LIBATTOPNG
+    template <typename DEVICE, typename KEY_TYPE, typename LOGGING_SPEC, typename SPEC>
+    void add_image(DEVICE& device, devices::logging::CPU_TENSORBOARD<LOGGING_SPEC>& logger, const KEY_TYPE key, rl_tools::Matrix<SPEC> values){
+        std::lock_guard<std::mutex> lock(logger.mutex);
+        if(logger.tb){
+            using T = typename SPEC::T;
+            using TI = typename DEVICE::index_t;
+            libattopng_t* png = libattopng_new(SPEC::COLS, SPEC::ROWS, PNG_RGBA);
+
+            for (TI y = 0; y < SPEC::ROWS; y++) {
+                for (TI x = 0; x < SPEC::COLS; x++) {
+                    uint8_t r = math::clamp<T>(device.math, get(values, x, y) * 255.0, 0, 255);
+                    uint8_t g = r;
+                    uint8_t b = r;
+                    uint8_t a = 255;
+                    uint32_t color = r | ((g) << 8) | ((b) << 16) | ((a) << 24);
+                    libattopng_set_pixel(png, x, y, color);
+                }
+            }
+            size_t len;
+            char *data = libattopng_get_data(png, &len);
+            std::string image_data = std::string(data, len);
+            std::cout << "adding image at step: " << logger.step << std::endl;
+            logger.tb->add_image(key, logger.step, image_data, SPEC::ROWS, SPEC::COLS, 4, "Test", "Image");
+            libattopng_destroy(png);
+            logging::tensorboard::count_topic(device, logger, key);
+        }
+    }
+#else
+    template <typename DEVICE, typename LOGGER_SPEC, typename SPEC>
+    void add_image(DEVICE& device, devices::logging::CPU_TENSORBOARD<LOGGER_SPEC>& logger, Matrix<SPEC> values){ }
+#endif
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

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

@@ -0,0 +1,65 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_UTILS_LOGGING_OPERATIONS_CUDA_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_UTILS_LOGGING_OPERATIONS_CUDA_H
+
+
+#include "../devices/cuda.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template <typename DEVICE>
+    RL_TOOLS_FUNCTION_PLACEMENT void init(DEVICE& device, devices::logging::CUDA* logger){ }
+    template <typename DEVICE, typename PARAM>
+    RL_TOOLS_FUNCTION_PLACEMENT void init(DEVICE& device, devices::logging::CUDA* logger, PARAM& param){ }
+    template <typename DEVICE, typename A>
+    RL_TOOLS_FUNCTION_PLACEMENT void log(DEVICE& device, devices::logging::CUDA* logger, const char * a, const char * b){
+        RL_TOOLS_HOST_ONLY(std::cout << a << b << std::endl);
+    }
+    template <typename DEVICE, typename A>
+    RL_TOOLS_FUNCTION_PLACEMENT void log(DEVICE& device, devices::logging::CUDA* logger, const A a){ }
+    template <typename DEVICE, typename A, typename B>
+    RL_TOOLS_FUNCTION_PLACEMENT void log(DEVICE& device, devices::logging::CUDA* logger, const A a, const B b){ }
+    template <typename DEVICE, typename A, typename B, typename C>
+    RL_TOOLS_FUNCTION_PLACEMENT void log(DEVICE& device, devices::logging::CUDA* logger, const A a, const B b, const C c){ }
+    template <typename DEVICE, typename A, typename B, typename C, typename D>
+    RL_TOOLS_FUNCTION_PLACEMENT void log(DEVICE& device, devices::logging::CUDA* logger, const A a, const B b, const C c, const D d){ }
+    template <typename DEVICE, typename A, typename B, typename C, typename D, typename E>
+    RL_TOOLS_FUNCTION_PLACEMENT void log(DEVICE& device, devices::logging::CUDA* logger, const A a, const B b, const C c, const D d, const E e){ }
+    template <typename DEVICE, typename A, typename B, typename C, typename D, typename E, typename F>
+    RL_TOOLS_FUNCTION_PLACEMENT void log(DEVICE& device, devices::logging::CUDA* logger, const A a, const B b, const C c, const D d, const E e, const F f){ }
+    template <typename DEVICE, typename A, typename B, typename C, typename D, typename E, typename F, typename G>
+    RL_TOOLS_FUNCTION_PLACEMENT void log(DEVICE& device, devices::logging::CUDA* logger, const A a, const B b, const C c, const D d, const E e, const F f, const G g){ }
+    template <typename DEVICE, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H>
+    RL_TOOLS_FUNCTION_PLACEMENT void log(DEVICE& device, devices::logging::CUDA* logger, const A a, const B b, const C c, const D d, const E e, const F f, const G g, const H h){ }
+    template <typename DEVICE, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I>
+    RL_TOOLS_FUNCTION_PLACEMENT void log(DEVICE& device, devices::logging::CUDA* logger, const A a, const B b, const C c, const D d, const E e, const F f, const G g, const H h, const I i){ }
+    template <typename DEVICE, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J>
+    RL_TOOLS_FUNCTION_PLACEMENT void log(DEVICE& device, devices::logging::CUDA* logger, const A a, const B b, const C c, const D d, const E e, const F f, const G g, const H h, const I i, const J j){ }
+    template <typename DEVICE, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J, typename K>
+    RL_TOOLS_FUNCTION_PLACEMENT void log(DEVICE& device, devices::logging::CUDA* logger, const A a, const B b, const C c, const D d, const E e, const F f, const G g, const H h, const I i, const J j, const K k){ }
+    template <typename DEVICE>
+    RL_TOOLS_FUNCTION_PLACEMENT void set_step(DEVICE& device, devices::logging::CUDA* logger, typename DEVICE::index_t step){ /* noop */ }
+    template <typename DEVICE, typename ARG_1, typename ARG_2>
+    RL_TOOLS_FUNCTION_PLACEMENT void construct(DEVICE& device, devices::logging::CUDA* logger, ARG_1, ARG_2){ /* noop */ }
+    template <typename DEVICE>
+    RL_TOOLS_FUNCTION_PLACEMENT void construct(DEVICE& device, devices::logging::CUDA* logger){ /* noop */ }
+    template <typename DEVICE>
+    RL_TOOLS_FUNCTION_PLACEMENT void free(DEVICE& device, devices::logging::CUDA* logger){ /* noop */ }
+    template <typename DEVICE, typename TOPIC, typename ARG>
+    RL_TOOLS_FUNCTION_PLACEMENT void add_scalar(DEVICE& device, devices::logging::CUDA* logger, const TOPIC, const ARG){ /* noop */ }
+    template <typename DEVICE, typename TOPIC, typename ARG, typename CADENCE>
+    RL_TOOLS_FUNCTION_PLACEMENT void add_scalar(DEVICE& device, devices::logging::CUDA* logger, const TOPIC, const ARG, const CADENCE){ /* noop */ }
+    template <typename DEVICE, typename TOPIC, typename ARG, typename ARG_LEN, typename CADENCE>
+    RL_TOOLS_FUNCTION_PLACEMENT void add_histogram(DEVICE& device, devices::logging::CUDA* logger, const TOPIC, const ARG*, const ARG_LEN, const CADENCE){ /* noop */ }
+    template <typename DEVICE, typename TOPIC, typename ARG, typename ARG_LEN>
+    RL_TOOLS_FUNCTION_PLACEMENT void add_histogram(DEVICE& device, devices::logging::CUDA* logger, const TOPIC, const ARG*, const ARG_LEN){ /* noop */ }
+    template <typename DEVICE, typename TOPIC, typename TEXT>
+    RL_TOOLS_FUNCTION_PLACEMENT void add_text(DEVICE& device, devices::logging::CUDA* logger, const TOPIC, const TEXT){ /* noop */ }
+    template <typename DEVICE, typename TOPIC, typename TEXT, typename CADENCE>
+    RL_TOOLS_FUNCTION_PLACEMENT void add_text(DEVICE& device, devices::logging::CUDA* logger, const TOPIC, const TEXT, const CADENCE){ /* noop */ }
+    template <typename DEVICE, typename HPARAMS, typename METRICS>
+    RL_TOOLS_FUNCTION_PLACEMENT void add_hparams(DEVICE& device, devices::logging::CUDA* logger, const HPARAMS&, const METRICS&){ /* noop */ }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

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

@@ -0,0 +1,45 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_LOGGING_OPERATIONS_DUMMY_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_LOGGING_OPERATIONS_DUMMY_H
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template <typename DEVICE>
+    void init(DEVICE& device, devices::logging::Dummy& logger){ }
+    template <typename DEVICE, typename PARAM>
+    void init(DEVICE& device, devices::logging::Dummy& logger, PARAM& param){ }
+    template <typename DEVICE, typename A>
+    RL_TOOLS_FUNCTION_PLACEMENT void log(DEVICE& device, devices::logging::Dummy& logger, const A a){
+    }
+    template <typename DEVICE, typename A, typename B>
+    RL_TOOLS_FUNCTION_PLACEMENT void log(DEVICE& device, devices::logging::Dummy& logger, const A a, const B b){
+    }
+    template <typename DEVICE, typename A, typename B, typename C, typename D>
+    RL_TOOLS_FUNCTION_PLACEMENT void log(DEVICE& device, devices::logging::Dummy& logger, const A a, const B b, const C c, const D d){
+    }
+    template <typename DEVICE>
+    void set_step(DEVICE& device, devices::logging::Dummy& logger, typename DEVICE::index_t step){ /* noop */ }
+    template <typename DEVICE, typename ARG_1, typename ARG_2>
+    void construct(DEVICE& device, devices::logging::Dummy& logger, ARG_1, ARG_2){ /* noop */ }
+    template <typename DEVICE>
+    void construct(DEVICE& device, devices::logging::Dummy& logger){ /* noop */ }
+    template <typename DEVICE>
+    void free(DEVICE& device, devices::logging::Dummy& logger){ /* noop */ }
+    template <typename DEVICE, typename TOPIC, typename ARG>
+    void add_scalar(DEVICE& device, devices::logging::Dummy& logger, const TOPIC, const ARG){ /* noop */ }
+    template <typename DEVICE, typename TOPIC, typename ARG, typename CADENCE>
+    void add_scalar(DEVICE& device, devices::logging::Dummy& logger, const TOPIC, const ARG, const CADENCE){ /* noop */ }
+    template <typename DEVICE, typename TOPIC, typename ARG, typename ARG_LEN, typename CADENCE>
+    void add_histogram(DEVICE& device, devices::logging::Dummy& logger, const TOPIC, const ARG*, const ARG_LEN, const CADENCE){ /* noop */ }
+    template <typename DEVICE, typename TOPIC, typename ARG, typename ARG_LEN>
+    void add_histogram(DEVICE& device, devices::logging::Dummy& logger, const TOPIC, const ARG*, const ARG_LEN){ /* noop */ }
+    template <typename DEVICE, typename TOPIC, typename TEXT>
+    void add_text(DEVICE& device, devices::logging::Dummy& logger, const TOPIC, const TEXT){ /* noop */ }
+    template <typename DEVICE, typename TOPIC, typename TEXT, typename CADENCE>
+    void add_text(DEVICE& device, devices::logging::Dummy& logger, const TOPIC, const TEXT, const CADENCE){ /* noop */ }
+    template <typename DEVICE, typename HPARAMS, typename METRICS>
+    void add_hparams(DEVICE& device, devices::logging::Dummy& logger, const HPARAMS&, const METRICS&){ /* noop */ }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/logging/operations_wasm32.h

@@ -0,0 +1,56 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_LOGGING_OPERATIONS_WASM32_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_LOGGING_OPERATIONS_WASM32_H
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template <typename DEVICE>
+    void init(DEVICE& device, devices::logging::WASM32& logger){ }
+    template <typename DEVICE, typename PARAM>
+    void init(DEVICE& device, devices::logging::WASM32& logger, PARAM& param){ }
+    template <typename DEVICE, typename A>
+    void log(DEVICE& device, devices::logging::WASM32& logger, const A a){ }
+    template <typename DEVICE, typename A, typename B>
+    void log(DEVICE& device, devices::logging::WASM32& logger, const A a, const B b){}
+    template <typename DEVICE, typename A, typename B, typename C>
+    void log(DEVICE& device, devices::logging::WASM32& logger, const A a, const B b, const C c){}
+    template <typename DEVICE, typename A, typename B, typename C, typename D>
+    void log(DEVICE& device, devices::logging::WASM32& logger, const A a, const B b, const C c, const D d){ }
+    template <typename DEVICE, typename A, typename B, typename C, typename D, typename E>
+    void log(DEVICE& device, devices::logging::WASM32& logger, const A a, const B b, const C c, const D d, const E e){ }
+    template <typename DEVICE, typename A, typename B, typename C, typename D, typename E, typename F>
+    void log(DEVICE& device, devices::logging::WASM32& logger, const A a, const B b, const C c, const D d, const E e, const F f){ }
+    template <typename DEVICE, typename A, typename B, typename C, typename D, typename E, typename F, typename G>
+    void log(DEVICE& device, devices::logging::WASM32& logger, const A a, const B b, const C c, const D d, const E e, const F f, const G g){ }
+    template <typename DEVICE, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H>
+    void log(DEVICE& device, devices::logging::WASM32& logger, const A a, const B b, const C c, const D d, const E e, const F f, const G g, const H h){ }
+    template <typename DEVICE, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I>
+    void log(DEVICE& device, devices::logging::WASM32& logger, const A a, const B b, const C c, const D d, const E e, const F f, const G g, const H h, const I i){ }
+    template <typename DEVICE, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I, typename J>
+    void log(DEVICE& device, devices::logging::WASM32& logger, const A a, const B b, const C c, const D d, const E e, const F f, const G g, const H h, const I i, const J j){ }
+    template <typename DEVICE>
+    void set_step(DEVICE& device, devices::logging::WASM32& logger, typename DEVICE::index_t step){ /* noop */ }
+    template <typename DEVICE, typename ARG_1, typename ARG_2>
+    void construct(DEVICE& device, devices::logging::WASM32& logger, ARG_1, ARG_2){ /* noop */ }
+    template <typename DEVICE>
+    void construct(DEVICE& device, devices::logging::WASM32& logger){ /* noop */ }
+    template <typename DEVICE>
+    void free(DEVICE& device, devices::logging::WASM32& logger){ /* noop */ }
+    template <typename DEVICE, typename TOPIC, typename ARG>
+    void add_scalar(DEVICE& device, devices::logging::WASM32& logger, const TOPIC, const ARG){ /* noop */ }
+    template <typename DEVICE, typename TOPIC, typename ARG, typename CADENCE>
+    void add_scalar(DEVICE& device, devices::logging::WASM32& logger, const TOPIC, const ARG, const CADENCE){ /* noop */ }
+    template <typename DEVICE, typename TOPIC, typename ARG, typename ARG_LEN, typename CADENCE>
+    void add_histogram(DEVICE& device, devices::logging::WASM32& logger, const TOPIC, const ARG*, const ARG_LEN, const CADENCE){ /* noop */ }
+    template <typename DEVICE, typename TOPIC, typename ARG, typename ARG_LEN>
+    void add_histogram(DEVICE& device, devices::logging::WASM32& logger, const TOPIC, const ARG*, const ARG_LEN){ /* noop */ }
+    template <typename DEVICE, typename TOPIC, typename TEXT>
+    void add_text(DEVICE& device, devices::logging::WASM32& logger, const TOPIC, const TEXT){ /* noop */ }
+    template <typename DEVICE, typename TOPIC, typename TEXT, typename CADENCE>
+    void add_text(DEVICE& device, devices::logging::WASM32& logger, const TOPIC, const TEXT, const CADENCE){ /* noop */ }
+    template <typename DEVICE, typename HPARAMS, typename METRICS>
+    void add_hparams(DEVICE& device, devices::logging::WASM32& logger, const HPARAMS&, const METRICS&){ /* noop */ }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

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

@@ -0,0 +1,98 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_MATH_OPERATIONS_ARM_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_MATH_OPERATIONS_ARM_H
+
+#include "operations_generic.h"
+
+#include "../devices/arm.h"
+
+#include <cmath>
+//#include <algorithm>
+
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::math {
+
+    template<typename T>
+    T sqrt(const devices::math::ARM&, const T x) {
+        return std::sqrt(x);
+    }
+    template<typename T>
+    T tanh(const devices::math::ARM&, const T x) {
+        return std::tanh(x);
+    }
+    template<typename T>
+    T exp(const devices::math::ARM&, const T x) {
+        return std::exp(x);
+    }
+    template<typename T>
+    T sin(const devices::math::ARM&, const T x) {
+        return std::sin(x);
+    }
+    template<typename T>
+    T cos(const devices::math::ARM&, const T x) {
+        return std::cos(x);
+    }
+    template<typename T>
+    T acos(const devices::math::ARM&, const T x) {
+        return std::acos(x);
+    }
+    template<typename TX, typename TY>
+    auto pow(const devices::math::ARM&, const TX x, const TY y) {
+        return std::pow(x, y);
+    }
+    template<typename T>
+    auto log(const devices::math::ARM&, const T x) {
+        return std::log(x);
+    }
+    template<typename T>
+    auto floor(const devices::math::ARM&, const T x) {
+        return std::floor(x);
+    }
+    template<typename T>
+    auto is_nan(const devices::math::ARM&, const T x) {
+        return std::isnan(x);
+    }
+    template<typename T>
+    auto is_finite(const devices::math::ARM&, const T x) {
+        return std::isfinite(x);
+    }
+    template<typename T>
+    T clamp(const devices::math::ARM&, T x, T min, T max){
+//        return std::clamp(x, min, max);
+        return x < min ? min : (x > max ? max : x);
+    }
+    template<typename T>
+    T min(const devices::math::ARM&, T x, T y){
+//        return std::min(x, y);
+        return x < y ? x : y;
+    }
+    template<typename T>
+    T max(const devices::math::ARM&, T x, T y){
+//        return std::max(x, y);
+        return x > y ? x : y;
+    }
+    template<typename T>
+    T abs(const devices::math::ARM&, T x){
+        return std::abs(x);
+    }
+    template<typename T>
+    T nan(const devices::math::ARM&){
+        return 0;
+    }
+    template<typename T>
+    T atan2(const devices::math::ARM& dev, T a, T b) {
+        return std::atan2(a, b);
+    }
+    template<typename T>
+    T fast_sigmoid(const devices::math::ARM& dev, T x) {
+        return fast_sigmoid(devices::math::Generic{}, x);
+    }
+    template<typename T>
+    T fast_tanh(const devices::math::ARM& dev, T x) {
+        return fast_tanh(devices::math::Generic{}, x);
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

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

@@ -0,0 +1,138 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_MATH_OPERATIONS_CPU_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_MATH_OPERATIONS_CPU_H
+
+#include "operations_generic.h"
+
+#include "../devices/cpu.h"
+
+#include <cmath>
+#include <stdint.h>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::math {
+    union is_nan_struct_float{
+        uint32_t i;
+        float f;
+    };
+    union is_nan_struct_double{
+        uint64_t i;
+        double f;
+    };
+#ifdef RL_TOOLS_DISABLE_FAST_MATH
+    template<typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT auto is_nan(const devices::math::CPU&, const T x) {
+        return std::isnan(x);
+    }
+#else
+    template <typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT bool is_nan(const devices::math::CPU, T){
+        return false;
+    }
+    RL_TOOLS_FUNCTION_PLACEMENT inline bool is_nan(const devices::math::CPU, const float x){
+        is_nan_struct_float u;
+        u.f = x;
+        return (u.i & 0x7f800000) == 0x7f800000 && (u.i & 0x007fffff) != 0;
+    }
+    RL_TOOLS_FUNCTION_PLACEMENT inline bool is_nan(const devices::math::CPU, const double x){
+        is_nan_struct_double u;
+        u.f = x;
+        return (u.i & 0x7ff0000000000000) == 0x7ff0000000000000 && (u.i & 0x000fffffffffffff) != 0;
+    }
+#endif
+
+    template<typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT T sqrt(const devices::math::CPU&, const T x) {
+        return std::sqrt(x);
+    }
+    template<typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT T cbrt(const devices::math::CPU&, const T x) {
+        return std::cbrt(x);
+    }
+    template<typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT T tanh(const devices::math::CPU&, const T x) {
+        return std::tanh(x);
+    }
+    template<typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT T exp(const devices::math::CPU&, const T x) {
+        return std::exp(x);
+    }
+    template<typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT T sin(const devices::math::CPU&, const T x) {
+        return std::sin(x);
+    }
+    template<typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT T cos(const devices::math::CPU&, const T x) {
+        return std::cos(x);
+    }
+    template<typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT T acos(const devices::math::CPU&, const T x) {
+        return std::acos(x);
+    }
+    template<typename TX, typename TY>
+    RL_TOOLS_FUNCTION_PLACEMENT constexpr auto pow(const devices::math::CPU&, const TX x, const TY y) {
+        return std::pow(x, y);
+    }
+    template<typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT auto log(const devices::math::CPU&, const T x) {
+        return std::log(x);
+    }
+    template<typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT auto floor(const devices::math::CPU&, const T x) {
+        return std::floor(x);
+    }
+
+    template<typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT auto is_finite(const devices::math::CPU&, const T x) {
+        return std::isfinite(x);
+    }
+    template<typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT T clamp(const devices::math::CPU&, T x, T min, T max){
+        return (x < min) ? min : (max < x) ? max : x;
+    }
+    template<typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT T min(const devices::math::CPU&, T x, T y){
+        return (y < x) ? y : x;
+    }
+    template<typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT T max(const devices::math::CPU&, T x, T y){
+        return (x < y) ? y : x;
+    }
+    template<typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT T abs(const devices::math::CPU&, T x){
+        if constexpr (utils::typing::is_same_v<T, float>){
+            return std::fabs(x);
+        }
+        else{
+            if constexpr (utils::typing::is_same_v<T, double>){
+                return std::abs(x);
+            }
+            else{
+                return (T)std::abs((float)x);
+            }
+        }
+    }
+    template<typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT T nan(const devices::math::CPU&){
+        return RL_TOOLS_HOST_ONLY(std::numeric_limits<T>::quiet_NaN());
+    }
+    template<typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT T infinity(const devices::math::CPU&){
+        return RL_TOOLS_HOST_ONLY(std::numeric_limits<T>::infinity());
+    }
+    template<typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT T fast_sigmoid(const devices::math::CPU& dev, T x) {
+        return fast_sigmoid(devices::math::Generic{}, x);
+    }
+    template<typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT T fast_tanh(const devices::math::CPU& dev, T x) {
+        return fast_tanh(devices::math::Generic{}, x);
+    }
+    template<typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT T atan2(const devices::math::CPU& dev, T a, T b) {
+        return std::atan2(a, b);
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif