hyperray 0.0.1__py3-none-any.whl

hyperdrone/_vendor/rl-tools/include/metra/metra.h

@@ -0,0 +1,381 @@
+#ifndef METRA_METRA_H
+#define METRA_METRA_H
+// metra: one-liner metric logging (commit/run/name/value) to a metra server (tools/metra), e.g. metra::log("pendulum/return", 1.23);
+// Freestanding, C++17, STL-only; POSTs via the curl CLI. Holds a static per-process run id (a deliberate exception to the rl_tools no-global-state convention).
+// METRA_URL: server base URL, unset disables logging. METRA_COMMIT: overrides commit detection (git rev-parse HEAD). METRA_COMMIT_TIME: overrides commit time detection (git show -s --format=%ct HEAD, unix seconds). METRA_RUN: overrides the generated run id.
+// The METRA_COMMIT/METRA_COMMIT_TIME compile definitions (set by cmake/autodetect/git-hash.cmake at configure time) are fallbacks for binaries that run outside a git checkout.
+
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <ctime>
+#include <string>
+#include <vector>
+#include <fstream>
+#include <iostream>
+#include <filesystem>
+#include <random>
+#include <system_error>
+#if defined(__APPLE__)
+#include <TargetConditionals.h>
+#endif
+#if defined(_WIN32)
+#include <process.h>
+#else
+#include <unistd.h>
+#endif
+
+#define METRA_STRINGIFY_INNER(x) #x
+#define METRA_STRINGIFY(x) METRA_STRINGIFY_INNER(x)
+
+namespace metra{
+    struct Config{
+        std::string url;
+        std::string commit;
+        std::string commit_time;
+        std::string run;
+    };
+    namespace detail{
+        inline bool shell_quote(const std::string& input, std::string& output){
+#if defined(_WIN32)
+            if(input.find('"') != std::string::npos || input.find('%') != std::string::npos){
+                return false;
+            }
+            output = "\"" + input + "\"";
+#else
+            if(input.find('\'') != std::string::npos){
+                return false;
+            }
+            output = "'" + input + "'";
+#endif
+            return true;
+        }
+        inline long process_id(){
+#if defined(_WIN32)
+            return _getpid();
+#else
+            return long(getpid());
+#endif
+        }
+        inline std::string json_escape(const std::string& input){
+            std::string output;
+            output.reserve(input.size());
+            for(char character: input){
+                unsigned char code = (unsigned char)character;
+                if(character == '"'){
+                    output += "\\\"";
+                }
+                else if(character == '\\'){
+                    output += "\\\\";
+                }
+                else if(code < 0x20){
+                    char buffer[8];
+                    std::snprintf(buffer, sizeof(buffer), "\\u%04x", code);
+                    output += buffer;
+                }
+                else{
+                    output += character;
+                }
+            }
+            return output;
+        }
+        inline std::string json_number(double value){
+            if(!std::isfinite(value)){ // JSON has no NaN/Inf; a null row still records that the run produced a non-finite value
+                return "null";
+            }
+            char buffer[32];
+            std::snprintf(buffer, sizeof(buffer), "%.17g", value);
+            for(const char* character = buffer; *character != '\0'; character++){
+                if(*character == 'n' || *character == 'N' || *character == 'i' || *character == 'I'){ // under -ffast-math isfinite can fold to true, but printf still renders nan/inf bit patterns
+                    return "null";
+                }
+            }
+            return buffer;
+        }
+        inline std::string json_array(const std::vector<double>& values){
+            std::string output = "[";
+            for(std::size_t value_i = 0; value_i < values.size(); value_i++){
+                if(value_i > 0){
+                    output += ",";
+                }
+                output += json_number(values[value_i]);
+            }
+            output += "]";
+            return output;
+        }
+        inline std::string random_hex(unsigned length){
+            std::random_device device;
+            std::string hex;
+            hex.reserve(length);
+            for(unsigned character_i = 0; character_i < length; character_i++){
+                hex += "0123456789abcdef"[device() & 0xFu];
+            }
+            return hex;
+        }
+        inline std::string hostname(){
+#if defined(_WIN32)
+            const char* name = std::getenv("COMPUTERNAME");
+            return (name != nullptr && name[0] != '\0') ? name : "unknown-host";
+#else
+            char buffer[256];
+            if(gethostname(buffer, sizeof(buffer)) != 0){
+                return "unknown-host";
+            }
+            buffer[sizeof(buffer) - 1] = '\0';
+            return buffer;
+#endif
+        }
+        inline std::string default_run_id(){
+            std::time_t now = std::time(nullptr);
+            std::tm time_components{};
+#if defined(_WIN32)
+            localtime_s(&time_components, &now);
+#else
+            localtime_r(&now, &time_components);
+#endif
+            char timestamp[32];
+            std::strftime(timestamp, sizeof(timestamp), "%Y%m%d_%H%M%S", &time_components);
+            return std::string(timestamp) + "_" + hostname() + "_" + std::to_string(process_id()) + "_" + random_hex(8);
+        }
+        inline std::string command_output(const char* command){
+#if defined(__APPLE__) && TARGET_OS_IOS
+            return "";
+#else
+#if defined(_WIN32)
+            FILE* pipe = _popen(command, "r");
+#else
+            FILE* pipe = popen(command, "r");
+#endif
+            if(pipe == nullptr){
+                return "";
+            }
+            char buffer[128];
+            std::string output;
+            while(std::fgets(buffer, sizeof(buffer), pipe) != nullptr){
+                output += buffer;
+            }
+#if defined(_WIN32)
+            _pclose(pipe);
+#else
+            pclose(pipe);
+#endif
+            while(!output.empty() && (output.back() == '\n' || output.back() == '\r')){
+                output.pop_back();
+            }
+            return output;
+#endif
+        }
+        inline bool is_commit_hash(const std::string& value){
+            if(value.size() != 40){
+                return false;
+            }
+            for(char character: value){
+                bool valid = (character >= '0' && character <= '9') || (character >= 'a' && character <= 'f');
+                if(!valid){
+                    return false;
+                }
+            }
+            return true;
+        }
+        inline bool is_unix_seconds(const std::string& value){
+            if(value.empty()){
+                return false;
+            }
+            for(char character: value){
+                if(character < '0' || character > '9'){
+                    return false;
+                }
+            }
+            return true;
+        }
+        inline std::string detect_commit(){
+            const char* environment_commit = std::getenv("METRA_COMMIT");
+            if(environment_commit != nullptr && environment_commit[0] != '\0'){
+                return environment_commit;
+            }
+#if defined(_WIN32)
+            std::string output = command_output("git rev-parse HEAD 2>NUL");
+#else
+            std::string output = command_output("git rev-parse HEAD 2>/dev/null");
+#endif
+            if(is_commit_hash(output)){
+                return output;
+            }
+#if defined(METRA_COMMIT)
+            if(is_commit_hash(METRA_STRINGIFY(METRA_COMMIT))){
+                return METRA_STRINGIFY(METRA_COMMIT);
+            }
+#endif
+            return "no-hash";
+        }
+        inline std::string detect_commit_time(){
+            const char* environment_commit_time = std::getenv("METRA_COMMIT_TIME");
+            if(environment_commit_time != nullptr && is_unix_seconds(environment_commit_time)){
+                return environment_commit_time;
+            }
+#if defined(_WIN32)
+            std::string output = command_output("git show -s --format=%ct HEAD 2>NUL");
+#else
+            std::string output = command_output("git show -s --format=%ct HEAD 2>/dev/null");
+#endif
+            if(is_unix_seconds(output)){
+                return output;
+            }
+#if defined(METRA_COMMIT_TIME)
+            if(is_unix_seconds(METRA_STRINGIFY(METRA_COMMIT_TIME))){
+                return METRA_STRINGIFY(METRA_COMMIT_TIME);
+            }
+#endif
+            return "";
+        }
+        inline std::string build_payload(const Config& config, const std::string& name, const std::string& value_json){
+            std::string payload = "{\"commit\":\"" + json_escape(config.commit) + "\",";
+            if(is_unix_seconds(config.commit_time)){
+                payload += "\"commit_time\":" + config.commit_time + ",";
+            }
+            payload += "\"run\":\"" + json_escape(config.run) + "\",\"name\":\"" + json_escape(name) + "\",\"value\":" + value_json + "}";
+            return payload;
+        }
+        inline bool post_json(const Config& config, const std::string& payload, std::string& error_output){
+#if defined(__APPLE__) && TARGET_OS_IOS
+            error_output = "metra: metric posting is unavailable on iOS";
+            return false;
+#else
+            std::error_code error_code;
+            std::filesystem::path temporary_directory = std::filesystem::temp_directory_path(error_code);
+            if(error_code){
+                error_output = "metra: cannot determine temporary directory: " + error_code.message();
+                return false;
+            }
+            std::filesystem::path payload_path = temporary_directory / ("metra_" + std::to_string(process_id()) + "_" + random_hex(8) + ".json");
+            {
+                std::ofstream payload_file(payload_path, std::ios::binary);
+                payload_file << payload;
+                if(!payload_file.good()){
+                    error_output = "metra: failed to write payload file " + payload_path.string();
+                    return false;
+                }
+            }
+            std::string url = config.url + "/api/log";
+            std::string quoted_payload_path, quoted_url, quoted_header;
+            if(!shell_quote(payload_path.string(), quoted_payload_path)){
+                std::filesystem::remove(payload_path, error_code);
+                error_output = "metra: unsupported character in path: " + payload_path.string();
+                return false;
+            }
+            if(!shell_quote(url, quoted_url)){
+                std::filesystem::remove(payload_path, error_code);
+                error_output = "metra: unsupported character in URL: " + url;
+                return false;
+            }
+            shell_quote("Content-Type: application/json", quoted_header);
+#if defined(_WIN32)
+            const char* null_device = "NUL";
+#else
+            const char* null_device = "/dev/null";
+#endif
+            std::string command = "curl -f -s -S -m 5 --connect-timeout 2 -X POST -H " + quoted_header + " --data-binary @" + quoted_payload_path + " -o " + null_device + " " + quoted_url;
+            int status = std::system(command.c_str());
+            std::filesystem::remove(payload_path, error_code);
+            if(status != 0){
+                error_output = "metra: logging to " + url + " failed (curl exit status " + std::to_string(status) + ")";
+                if(status == 127 || status == 32512){
+                    error_output += ". Is curl installed and on the PATH?";
+                }
+                else if(status == 22 || status == 5632){
+                    error_output += ". The server rejected the request; check the payload and the server version.";
+                }
+                else{
+                    error_output += ". Check METRA_URL and network connectivity.";
+                }
+                return false;
+            }
+            return true;
+#endif
+        }
+    }
+    inline Config config_from_environment(){
+        Config config;
+#if !defined(__APPLE__) || !TARGET_OS_IOS
+        const char* url = std::getenv("METRA_URL");
+        if(url != nullptr && url[0] != '\0'){
+            config.url = url;
+            if(config.url.back() == '/'){
+                config.url.pop_back();
+            }
+        }
+#endif
+        config.commit = detail::detect_commit();
+        const char* environment_commit = std::getenv("METRA_COMMIT");
+        const char* environment_commit_time = std::getenv("METRA_COMMIT_TIME");
+        if(environment_commit == nullptr || environment_commit[0] == '\0' || environment_commit_time != nullptr){ // an overridden commit must not be paired with the auto-detected HEAD time
+            config.commit_time = detail::detect_commit_time();
+        }
+        const char* run = std::getenv("METRA_RUN");
+        config.run = (run != nullptr && run[0] != '\0') ? run : detail::default_run_id();
+        return config;
+    }
+    inline const Config& global_config(){
+        static const Config config = config_from_environment(); // the static per-process run id
+        return config;
+    }
+    inline bool log_raw(const Config& config, const std::string& name, const std::string& value_json, std::string& error_output){
+        if(config.url.empty()){
+            return true;
+        }
+        if(name.empty()){
+            error_output = "metra: metric name must not be empty";
+            return false;
+        }
+        return detail::post_json(config, detail::build_payload(config, name, value_json), error_output);
+    }
+    inline bool log(const Config& config, const std::string& name, double value, std::string& error_output){
+        return log_raw(config, name, detail::json_number(value), error_output);
+    }
+    inline bool log(const Config& config, const std::string& name, const std::vector<double>& values, std::string& error_output){
+        return log_raw(config, name, detail::json_array(values), error_output);
+    }
+    namespace detail{
+        inline bool log_global(const std::string& name, const std::string& value_json){
+            const Config& config = global_config();
+            if(config.url.empty()){
+                static const bool notified = []{
+#if defined(__APPLE__) && TARGET_OS_IOS
+                    std::cerr << "metra: metric logging disabled on iOS" << std::endl;
+#else
+                    std::cerr << "metra: METRA_URL not set, metric logging disabled" << std::endl;
+#endif
+                    return true;
+                }();
+                (void)notified;
+                return true;
+            }
+            static int consecutive_failures = 0; // races on this counter are benign (worst case a few extra attempts); atomics are avoided repo-wide
+            if(consecutive_failures >= 3){
+                return false;
+            }
+            std::string error_output;
+            if(!log_raw(config, name, value_json, error_output)){
+                consecutive_failures++;
+                std::cerr << error_output << std::endl;
+                if(consecutive_failures >= 3){
+                    std::cerr << "metra: disabling metric logging after " << consecutive_failures << " consecutive failures" << std::endl;
+                }
+                return false;
+            }
+            consecutive_failures = 0;
+            return true;
+        }
+    }
+    inline bool log_raw(const std::string& name, const std::string& value_json){
+        return detail::log_global(name, value_json);
+    }
+    inline bool log(const std::string& name, double value){
+        return detail::log_global(name, detail::json_number(value));
+    }
+    inline bool log(const std::string& name, const std::vector<double>& values){
+        return detail::log_global(name, detail::json_array(values));
+    }
+}
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/containers/matrix/matrix.h

@@ -0,0 +1,143 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_CONTAINERS_MATRIX_MATRIX_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_CONTAINERS_MATRIX_MATRIX_H
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    namespace matrix{
+        namespace layouts{
+
+            template <typename TI, TI ALIGNMENT = 1>
+            struct RowMajorAlignment{
+                template <TI ROWS, TI COLS>
+                static constexpr TI ROW_PITCH = ((COLS + ALIGNMENT - 1) / ALIGNMENT) * ALIGNMENT;
+                template <TI ROWS, TI COLS>
+                static constexpr TI COL_PITCH = 1;
+            };
+
+            template <typename TI, TI ALIGNMENT = 1>
+            using RowMajorAlignmentOptimized = RowMajorAlignment<TI, ALIGNMENT>;
+
+            template <typename TI, TI T_ROW_PITCH, TI T_COL_PITCH>
+            struct Fixed{
+                template <TI ROWS, TI COLS>
+                static constexpr TI ROW_PITCH = T_ROW_PITCH;
+                template <TI ROWS, TI COLS>
+                static constexpr TI COL_PITCH = T_COL_PITCH;
+            };
+
+            template <typename TI>
+            using DEFAULT = layouts::RowMajorAlignmentOptimized<TI>; // row-major by default
+
+        }
+        template <typename T_T, typename T_TI, T_TI T_ROWS, T_TI T_COLS, bool T_DYNAMIC_ALLOCATION = true, typename LAYOUT_FACTORY = matrix::layouts::DEFAULT<T_TI>, bool T_CONST = false>
+        struct Specification{
+            using T = T_T;
+            using TI = T_TI;
+            static constexpr TI ROWS = T_ROWS;
+            static constexpr TI COLS = T_COLS;
+            static constexpr TI ROW_PITCH = LAYOUT_FACTORY::template ROW_PITCH<ROWS, COLS>;
+            static constexpr TI COL_PITCH = LAYOUT_FACTORY::template COL_PITCH<ROWS, COLS>;
+            static constexpr bool DYNAMIC_ALLOCATION = T_DYNAMIC_ALLOCATION;
+            using LAYOUT = layouts::Fixed<TI, ROW_PITCH, COL_PITCH>;
+            static constexpr bool CONST = T_CONST;
+
+            static_assert(COL_PITCH * T_COLS <= ROW_PITCH || ROW_PITCH * T_ROWS <= COL_PITCH, "Pitches of the matrix dimensions are not compatible");
+            static constexpr bool ROW_MAJOR = ROWS * ROW_PITCH >= COL_PITCH * COLS;
+            static constexpr TI SIZE = ROW_MAJOR ? ROWS * ROW_PITCH : COLS * COL_PITCH;
+            static constexpr TI SIZE_BYTES = SIZE * sizeof(T); // todo: discount size for views
+        };
+        template <auto T_ROWS, auto T_COLS> // todo: replace old view() calling convention by new ViewSpec based one
+        struct ViewSpec{
+            static constexpr auto ROWS = T_ROWS;
+            static constexpr auto COLS = T_COLS;
+        };
+    }
+    namespace matrix{
+        template <typename T, typename TI, TI SIZE>
+        struct MatrixStatic{
+            static constexpr bool DYNAMIC_ALLOCATION = false;
+            T _data[SIZE];
+        };
+        template <typename T, typename TI, TI SIZE_BYTES, bool CONST = false>
+        struct MatrixDynamic{
+            static constexpr bool DYNAMIC_ALLOCATION = true;
+            T* RL_TOOLS_RESTRICT _data = nullptr;
+        };
+        template <typename T, typename TI, TI SIZE_BYTES>
+        struct MatrixDynamic<T, TI, SIZE_BYTES, true>{
+            static constexpr bool DYNAMIC_ALLOCATION = true;
+            const T* RL_TOOLS_RESTRICT _data = nullptr;
+        };
+    }
+
+    template <typename T_SPEC>
+    struct Matrix: utils::typing::conditional_t<T_SPEC::DYNAMIC_ALLOCATION, matrix::MatrixDynamic<typename T_SPEC::T, typename T_SPEC::TI, T_SPEC::SIZE_BYTES, T_SPEC::CONST>, matrix::MatrixStatic<typename T_SPEC::T, typename T_SPEC::TI, T_SPEC::SIZE>>{
+        using SPEC = T_SPEC;
+        using T = typename SPEC::T;
+        using TI = typename SPEC::TI;
+        static constexpr TI ROWS = SPEC::ROWS;
+        static constexpr TI COLS = SPEC::COLS;
+        static constexpr TI ROW_PITCH = SPEC::ROW_PITCH;
+        static constexpr TI COL_PITCH = SPEC::COL_PITCH;
+
+        using VIEW_LAYOUT = matrix::layouts::Fixed<typename SPEC::TI, SPEC::ROW_PITCH, SPEC::COL_PITCH>;
+
+        template<typename SPEC::TI ROWS = SPEC::ROWS, typename SPEC::TI COLS = SPEC::COLS>
+        using VIEW = Matrix<matrix::Specification<T, TI, ROWS, COLS, true, VIEW_LAYOUT>>;
+//        virtual void _abstract_tag(){};
+//        // pure virtual function to make this class abstract (should be instantiated by either the MatrixStatic or MatrixDynamic subclasses class)
+//        virtual void _abstract_tag() = 0;
+        // Matrix() = default;
+//        T* _data = nullptr;
+//        Matrix() = default;
+//        Matrix(T* data): _data(data){};
+    };
+//    template<typename T_SPEC>
+//    struct MatrixDynamic: Matrix<T_SPEC>{
+//        using T = typename MatrixDynamic::T;
+//        using TI = typename MatrixDynamic::TI;
+//        using SPEC = T_SPEC;
+//
+//        template<typename SPEC::TI ROWS, typename SPEC::TI COLS>
+//        using VIEW = MatrixDynamic<matrix::Specification<T, TI, ROWS, COLS, typename MatrixDynamic::VIEW_LAYOUT, true>>;
+////        virtual void _abstract_tag(){};
+//    };
+//    struct MatrixDynamicTag{
+//        template<typename T_SPEC>
+//        using type = MatrixDynamic<T_SPEC>;
+//    };
+//    template<typename T_SPEC>
+//    struct MatrixStatic: Matrix<T_SPEC>{
+//        using T = typename MatrixStatic::T;
+//        using TI = typename MatrixStatic::TI;
+//        using SPEC = T_SPEC;
+//
+//        template<typename SPEC::TI ROWS, typename SPEC::TI COLS>
+//        using VIEW = MatrixDynamic<matrix::Specification<T, TI, ROWS, COLS, typename MatrixStatic::VIEW_LAYOUT, true>>;
+////        virtual void _abstract_tag(){};
+//
+//        alignas(T) unsigned char _data_memory[SPEC::SIZE_BYTES];
+//        MatrixStatic(): Matrix<T_SPEC>((T*)_data_memory){};
+//    };
+//    struct MatrixStaticTag{
+//        template<typename T_SPEC>
+//        using type = MatrixStatic<T_SPEC>;
+//    };
+//    namespace matrix{
+//        template <typename T, typename TI>
+//        using Empty = Matrix<matrix::Specification<T, TI, 0, 0>>;
+//    }
+
+
+    namespace containers{
+        template<typename SPEC_1, typename SPEC_2>
+        constexpr bool check_structure = SPEC_1::ROWS == SPEC_2::ROWS && SPEC_1::COLS == SPEC_2::COLS;
+        template<typename SPEC_1, typename SPEC_2>
+        constexpr bool check_memory_layout = check_structure<SPEC_1, SPEC_2> && SPEC_1::ROW_PITCH == SPEC_2::ROW_PITCH && SPEC_1::COL_PITCH == SPEC_2::COL_PITCH && utils::typing::is_same_v<typename SPEC_1::T, typename SPEC_2::T> && SPEC_1::SIZE_BYTES == SPEC_2::SIZE_BYTES; // check if e.g. direct memory copy is possible
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/containers/matrix/operations_arm.h

@@ -0,0 +1,33 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_CONTAINERS_MATRIX_OPERATIONS_ARM_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_CONTAINERS_MATRIX_OPERATIONS_ARM_H
+
+#include "operations_generic.h"
+// #include <cstring> // formemcpy
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template<typename SOURCE_DEV_SPEC, typename TARGET_DEV_SPEC, typename SOURCE_SPEC, typename TARGET_SPEC>
+    void copy_view(devices::ARM<SOURCE_DEV_SPEC>& source_device, devices::ARM<TARGET_DEV_SPEC>& target_device, const Matrix<SOURCE_SPEC>& source, Matrix<TARGET_SPEC>& target){
+        using SOURCE_DEVICE = devices::ARM<SOURCE_DEV_SPEC>;
+        static_assert(containers::check_structure<SOURCE_SPEC, TARGET_SPEC>);
+        using SPEC = SOURCE_SPEC;
+        vectorize_unary<SOURCE_DEVICE, SOURCE_SPEC, TARGET_SPEC, containers::vectorization::operators::copy<typename SOURCE_DEVICE::SPEC::MATH, typename SPEC::T>>(source_device, source, target);
+    }
+    template<typename SOURCE_DEV_SPEC, typename TARGET_DEV_SPEC, typename SPEC_1, typename SPEC_2>
+    void copy(devices::ARM<SOURCE_DEV_SPEC>& source_device, devices::ARM<TARGET_DEV_SPEC>& target_device, const Matrix<SPEC_1>& source, Matrix<SPEC_2>& target){
+        static_assert(containers::check_structure<SPEC_1, SPEC_2>);
+        using DEVICE = devices::ARM<SOURCE_DEV_SPEC>;
+        using TI = typename DEVICE::index_t;
+        if constexpr(containers::check_memory_layout<SPEC_1, SPEC_2>){
+            for(TI i = 0; i < SPEC_1::SIZE; i++){
+                target._data[i] = source._data[i];
+            }
+        }
+        else{
+            copy_view(source_device, target_device, source, target);
+        }
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif