hyperray 0.0.1__py3-none-any.whl

hyperdrone/_vendor/rl-tools/include/rl_tools/utils/generic/integrators.h

@@ -0,0 +1,103 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_UTILS_GENERIC_INTEGRATORS_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_UTILS_GENERIC_INTEGRATORS_H
+
+#include "../../rl_tools.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::utils::integrators{
+    template<typename DEVICE, typename T, typename PARAMETER_TYPE, typename STATE, auto ACTION_DIM, auto DYNAMICS>
+    RL_TOOLS_FUNCTION_PLACEMENT void euler(DEVICE& device, const PARAMETER_TYPE& params, const STATE& state, const T action[ACTION_DIM], const T dt, STATE& next_state) {
+        DYNAMICS(device, params, state, action, next_state);
+        scalar_multiply(device, next_state, dt);
+        add_accumulate(device, state, next_state);
+    }
+    template<typename DEVICE, typename T, typename PARAMETER_TYPE, typename STATE, auto ACTION_DIM, auto DYNAMICS>
+    RL_TOOLS_FUNCTION_PLACEMENT void rk4(DEVICE& device, const PARAMETER_TYPE& params, const STATE& state, const T action[ACTION_DIM], const T dt, STATE& next_state) {
+        STATE k1, k2, k3, k4, temp_state;
+        k1 = state;
+        k2 = state;
+        k3 = state;
+        k4 = state;
+
+        // Step 1
+        DYNAMICS(device, params, state, action, k1);
+
+        // Step 2
+        temp_state = state;
+        scalar_multiply_accumulate(device, k1, dt / 2, temp_state);
+        DYNAMICS(device, params, temp_state, action, k2);
+
+        // Step 3
+        temp_state = state;
+        scalar_multiply_accumulate(device, k2, dt / 2, temp_state);
+        DYNAMICS(device, params, temp_state, action, k3);
+
+        // Step 4
+        temp_state = state;
+        scalar_multiply_accumulate(device, k3, dt, temp_state);
+        DYNAMICS(device, params, temp_state, action, k4);
+
+        // Final step
+        next_state = state;
+        scalar_multiply_accumulate(device, k1, dt / 6, next_state);
+        scalar_multiply_accumulate(device, k2, dt / 3, next_state);
+        scalar_multiply_accumulate(device, k3, dt / 3, next_state);
+        scalar_multiply_accumulate(device, k4, dt / 6, next_state);
+    }
+
+    // register-optimized
+//    template<typename DEVICE, typename T, typename PARAMETER_TYPE, typename STATE, auto ACTION_DIM, auto DYNAMICS>
+//    RL_TOOLS_FUNCTION_PLACEMENT void rk4(DEVICE& device, const PARAMETER_TYPE& params, const STATE& state, const T action[ACTION_DIM], const T dt, STATE& next_state) {
+//        next_state = state;
+//        STATE& k1 = next_state; //[STATE_DIM];
+//        k1 = state;
+//
+//        // flops: 157
+//        DYNAMICS(device, params, state, action, k1);
+//
+//        STATE var = state;
+//
+//        // flops: 13
+//        scalar_multiply(device, k1, dt / 2, var);
+//
+//        {
+//            STATE k2 = state;
+//            add_accumulate(device, state, var);
+//            // flops: 157
+//            DYNAMICS(device, params, var, action, k2);
+//            // flops: 13
+//            scalar_multiply(device, k2, dt / 2, var);
+//            // flops: 13
+//            scalar_multiply_accumulate(device, k2, 2, k1);
+//        }
+//        {
+//            STATE k3 = state;
+//            add_accumulate(device, state, var);
+//            // flops: 157
+//            DYNAMICS(device, params, var, action, k3);
+//            // flops: 13
+//            scalar_multiply(device, k3, dt, var);
+//            // flops: 13
+//            scalar_multiply_accumulate(device, k3, 2, k1);
+//        }
+//
+//
+//        {
+//            STATE k4 = state;
+//            add_accumulate(device, state, var);
+//            // flops: 157
+//            DYNAMICS(device, params, var, action, k4);
+//            add_accumulate(device, k4, k1);
+//        }
+//
+//        // flops: 13
+//        scalar_multiply(device, k1, dt / 6.0);
+//        add_accumulate(device, state, k1);
+//        // total flops: 157 + 13 + 157 + 13 + 13 + 157 + 13 + 13 + 157 + 13 = 706
+//    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/utils/generic/memcpy.h

@@ -0,0 +1,16 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_UTILS_GENERIC_MEMCPY_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_UTILS_GENERIC_MEMCPY_H
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+//namespace rl_tools::utils{
+//    template<typename T, typename ST>
+//    void memcpy(T* source, const T* target, ST size) {
+//        for(ST i = 0; i < size; i++) {
+//            target[i] = source[i];
+//        }
+//    }
+//}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/utils/generic/tuple/operations_generic.h

@@ -0,0 +1,48 @@
+#include "../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_UTILS_GENERIC_TUPLE_OPERATIONS_GENERIC_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_UTILS_GENERIC_TUPLE_OPERATIONS_GENERIC_H
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools {
+    template <typename DEVICE, typename T_TI>
+    RL_TOOLS_FUNCTION_PLACEMENT void malloc(DEVICE& device, utils::Tuple<T_TI>& tuple){ }
+    template <typename DEVICE, typename T_TI, typename CURRENT_TYPE, typename... Types>
+    RL_TOOLS_FUNCTION_PLACEMENT void malloc(DEVICE& device, utils::Tuple<T_TI, CURRENT_TYPE, Types...>& tuple){
+        malloc(device, tuple.content);
+        if constexpr(sizeof...(Types) > 0){
+            malloc(device, static_cast<utils::Tuple<T_TI, Types...>&>(tuple));
+        }
+    }
+    template <typename DEVICE, typename T_TI, template <typename> typename F>
+    RL_TOOLS_FUNCTION_PLACEMENT void malloc(DEVICE& device, utils::MapTuple<utils::Tuple<T_TI>, F>& tuple){ }
+    template <typename DEVICE, typename T_TI, template <typename> typename F, typename CURRENT_TYPE, typename... Types>
+    RL_TOOLS_FUNCTION_PLACEMENT void malloc(DEVICE& device, utils::MapTuple<utils::Tuple<T_TI, CURRENT_TYPE, Types...>, F>& tuple){
+        malloc(device, tuple.content);
+        if constexpr(sizeof...(Types) > 0){
+            malloc(device, static_cast<utils::MapTuple<utils::Tuple<T_TI, Types...>, F>&>(tuple));
+        }
+    }
+
+    template <typename DEVICE, typename T_TI>
+    RL_TOOLS_FUNCTION_PLACEMENT void free(DEVICE& device, utils::Tuple<T_TI>& tuple){ }
+    template <typename DEVICE, typename T_TI, typename CURRENT_TYPE, typename... Types>
+    RL_TOOLS_FUNCTION_PLACEMENT void free(DEVICE& device, utils::Tuple<T_TI, CURRENT_TYPE, Types...>& tuple){
+        free(device, tuple.content);
+        if constexpr(sizeof...(Types) > 0){
+            free(device, static_cast<utils::Tuple<T_TI, Types...>&>(tuple));
+        }
+    }
+    template <typename DEVICE, typename T_TI, template <typename> typename F>
+    RL_TOOLS_FUNCTION_PLACEMENT void free(DEVICE& device, utils::MapTuple<utils::Tuple<T_TI>, F>& tuple){ }
+    template <typename DEVICE, typename T_TI, template <typename> typename F, typename CURRENT_TYPE, typename... Types>
+    RL_TOOLS_FUNCTION_PLACEMENT void free(DEVICE& device, utils::MapTuple<utils::Tuple<T_TI, CURRENT_TYPE, Types...>, F>& tuple){
+        free(device, tuple.content);
+        if constexpr(sizeof...(Types) > 0){
+            free(device, static_cast<utils::MapTuple<utils::Tuple<T_TI, Types...>, F>&>(tuple));
+        }
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/utils/generic/tuple/tuple.h

@@ -0,0 +1,147 @@
+#include "../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_UTILS_GENERIC_TUPLE_TUPLE_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_UTILS_GENERIC_TUPLE_TUPLE_H
+
+#include "../../../rl_tools.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools {
+    namespace utils{
+        template<typename T_TI, typename... Types>
+        struct Tuple {
+            using TI = T_TI;
+        };
+
+        template<typename T_TI>
+        struct Tuple<T_TI> {
+        };
+
+        template<typename T_TI, typename Head, typename... Tail>
+        struct Tuple<T_TI, Head, Tail...> : Tuple<T_TI, Tail...> {
+            using NEXT = Tuple<T_TI, Tail...>;
+            Head content;
+        };
+
+        template<typename TUPLE, template<typename> typename F>
+        struct MapTuple;
+
+        template<typename T_TI, template<typename> typename F>
+        struct MapTuple<Tuple<T_TI>, F> {
+            using type = Tuple<T_TI>;
+        };
+
+
+        template<typename T_TI, typename Head, typename... Tail, template<typename> typename F>
+        struct MapTuple<Tuple<T_TI, Head, Tail...>, F> : MapTuple<Tuple<T_TI, Tail...>, F> {
+            using CONTENT = typename F<Head>::CONTENT;
+            CONTENT content;
+        };
+
+        template <typename TUPLE>
+        struct tuple_size;
+
+        template <typename TI, typename... TYPES>
+        struct tuple_size<Tuple<TI, TYPES...>> {
+            static constexpr TI value = sizeof...(TYPES);
+        };
+
+        template <typename TUPLE, typename T>
+        struct tuple_append;
+
+        template <typename TI, typename... TYPES, typename T>
+        struct tuple_append<Tuple<TI, TYPES...>, T> {
+            using type = Tuple<TI, TYPES..., T>;
+        };
+
+        template <typename TUPLE, typename T>
+        using tuple_append_t = typename tuple_append<TUPLE, T>::type;
+
+        template <auto INDEX, typename TUPLE>
+        struct tuple_element;
+
+        namespace detail {
+            template <typename TI, TI... Is>
+            struct index_sequence {};
+
+            template <typename TI, bool DONE, TI N, TI... Is>
+            struct make_index_sequence_impl;
+            template <typename TI, TI N, TI... Is>
+            struct make_index_sequence_impl<TI, true, N, Is...> {
+                using type = index_sequence<TI, Is...>;
+            };
+            template <typename TI, TI N, TI... Is>
+            struct make_index_sequence_impl<TI, false, N, Is...> {
+                using type = typename make_index_sequence_impl<TI, N - 1 == 0, N - 1, N - 1, Is...>::type;
+            };
+            template <typename TI, TI N>
+            using make_index_sequence = typename make_index_sequence_impl<TI, N == 0, N>::type;
+
+            template <typename TI, TI Index, typename T>
+            struct TupleLeaf {
+                using type = T;
+            };
+
+            template <typename SEQ, typename TI, typename... Ts>
+            struct TupleIndex;
+            template <typename TI, TI... Is, typename... Ts>
+            struct TupleIndex<index_sequence<TI, Is...>, TI, Ts...> : TupleLeaf<TI, Is, Ts>... {};
+
+            template <typename TI, TI I, typename T>
+            TupleLeaf<TI, I, T> select_leaf(const TupleLeaf<TI, I, T>&);
+        }
+
+        template <auto INDEX, typename TI, typename... TYPES>
+        struct tuple_element<INDEX, Tuple<TI, TYPES...>> {
+            static_assert(static_cast<TI>(INDEX) < sizeof...(TYPES), "tuple_element index out of bounds");
+            using Indexed = detail::TupleIndex<detail::make_index_sequence<TI, sizeof...(TYPES)>, TI, TYPES...>;
+            using type = typename decltype(detail::select_leaf<TI, static_cast<TI>(INDEX)>(Indexed{}))::type;
+        };
+    }
+    template<typename TI>
+    RL_TOOLS_FUNCTION_PLACEMENT constexpr TI length(utils::Tuple<TI> &tuple) {
+        return 0;
+    }
+
+    template<typename TI, typename CURRENT_TYPE, typename... Types>
+    RL_TOOLS_FUNCTION_PLACEMENT constexpr TI length(utils::Tuple<TI, CURRENT_TYPE, Types...> &tuple) {
+        return 1 + length(static_cast<utils::Tuple<TI, Types...> &>(tuple));
+    }
+
+    template<auto INDEX, typename TI, typename CURRENT_TYPE, typename... Types>
+    RL_TOOLS_FUNCTION_PLACEMENT constexpr auto &get(utils::Tuple<TI, CURRENT_TYPE, Types...> &tuple) {
+        if constexpr (INDEX == 0) {
+            return tuple.content;
+        } else {
+            return get<INDEX - 1>(static_cast<utils::Tuple<TI, Types...> &>(tuple));
+        }
+    }
+    template<auto INDEX, typename TI, typename CURRENT_TYPE, typename... Types>
+    RL_TOOLS_FUNCTION_PLACEMENT constexpr const auto &get(const utils::Tuple<TI, CURRENT_TYPE, Types...> &tuple) {
+        if constexpr (INDEX == 0) {
+            return tuple.content;
+        } else {
+            return get<INDEX - 1>(static_cast<const utils::Tuple<TI, Types...> &>(tuple));
+        }
+    }
+
+    template<auto INDEX, typename TI, typename CURRENT_TYPE, typename... Types, template <typename> typename F>
+    RL_TOOLS_FUNCTION_PLACEMENT constexpr auto &get(utils::MapTuple<utils::Tuple<TI, CURRENT_TYPE, Types...>, F> &tuple) {
+        if constexpr (INDEX == 0) {
+            return tuple.content;
+        } else {
+            return get<INDEX - 1>(static_cast<utils::MapTuple<utils::Tuple<TI, Types...>, F> &>(tuple));
+        }
+    }
+    template<auto INDEX, typename TI, typename CURRENT_TYPE, typename... Types, template <typename> typename F>
+    RL_TOOLS_FUNCTION_PLACEMENT constexpr const auto &get(const utils::MapTuple<utils::Tuple<TI, CURRENT_TYPE, Types...>, F> &tuple) {
+        if constexpr (INDEX == 0) {
+            return tuple.content;
+        } else {
+            return get<INDEX - 1>(static_cast<const utils::MapTuple<utils::Tuple<TI, Types...>, F> &>(tuple));
+        }
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/utils/generic/typing.h

@@ -0,0 +1,122 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_UTILS_GENERIC_TYPING_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_UTILS_GENERIC_TYPING_H
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::utils::typing {
+    template<class T, T v>
+    struct integral_constant {
+        static constexpr T value = v;
+        using value_type = T;
+        using type = integral_constant; // using injected-class-name
+        constexpr operator value_type() const noexcept { return value; }
+        constexpr value_type operator()() const noexcept { return value; } // since c++14
+    };
+    using false_type = integral_constant<bool, false>;
+    using true_type = integral_constant<bool, true>;
+
+    template<class T, class U>
+    struct is_same : false_type {};
+
+    template<class T>
+    struct is_same<T, T> : true_type {};
+
+    template< class T, class U >
+    inline constexpr bool is_same_v = is_same<T, U>::value;
+
+
+    template<class T> struct is_reference : false_type {};
+    template<class T> struct is_reference<T&> : true_type {};
+    template<class T> struct is_reference<T&&> : true_type {};
+    template <class T>
+    constexpr bool is_reference_v = is_reference<T>::value;
+
+    template<class T>
+    struct remove_reference{
+        typedef T type;
+    };
+    template<class T>
+    struct remove_reference<T&>{
+        typedef T type;
+    };
+
+    template<class T>
+    using remove_reference_t = typename remove_reference<T>::type;
+
+    template< class T > struct remove_pointer                    {typedef T type;};
+    template< class T > struct remove_pointer<T*>                {typedef T type;};
+    template< class T > struct remove_pointer<T* const>          {typedef T type;};
+    template< class T > struct remove_pointer<T* volatile>       {typedef T type;};
+    template< class T > struct remove_pointer<T* const volatile> {typedef T type;};
+
+    template<bool B, class T = void>
+    struct enable_if {};
+
+    template<class T>
+    struct enable_if<true, T> { typedef T type; };
+
+    template< bool B, class T = void >
+    using enable_if_t = typename enable_if<B,T>::type;
+
+    template< class T > struct remove_cv                   { typedef T type; };
+    template< class T > struct remove_cv<const T>          { typedef T type; };
+    template< class T > struct remove_cv<volatile T>       { typedef T type; };
+    template< class T > struct remove_cv<const volatile T> { typedef T type; };
+
+    template< class T > struct remove_const                { typedef T type; };
+    template< class T > struct remove_const<const T>       { typedef T type; };
+
+    template< class T > struct remove_volatile             { typedef T type; };
+    template< class T > struct remove_volatile<volatile T> { typedef T type; };
+
+    template< class T >
+    using remove_cv_t = typename remove_cv<T>::type;
+
+    template<bool condition>
+    struct warn_if{};
+
+    template<> struct [[deprecated]] warn_if<false>{constexpr warn_if() = default;};
+
+    template<bool B, class T, class F>
+    struct conditional { using type = T; };
+
+    template<class T, class F>
+    struct conditional<false, T, F> { using type = F; };
+
+    template< bool B, class T, class F >
+    using conditional_t = typename conditional<B,T,F>::type;
+
+    template <bool value, typename... Args>
+    inline constexpr bool dependent_bool_value = value;
+    template <typename... Args>
+    inline constexpr bool dependent_false = dependent_bool_value<false, Args...>;
+
+    template <typename Base, typename Derived>
+    class IsSubclass {
+    private:
+        typedef char Yes[1];
+        typedef char No[2];
+
+        static Yes& test(Base*);
+        static No& test(...);
+
+    public:
+        enum { value = sizeof(test(static_cast<Derived*>(0))) == sizeof(Yes) };
+    };
+
+    template <typename Base, typename Derived>
+    constexpr bool is_base_of_v = IsSubclass<Base, Derived>::value;
+
+    template <typename...>
+    using void_t = void;
+
+    // unevaluated-context lvalue for expression detection (std::declval is not freestanding)
+    template <typename T>
+    T& declared_lvalue();
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#define rl_tools_static_warn(x, ...) ((void) warn_if<x>())
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/utils/generic/vector_operations.h

@@ -0,0 +1,172 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_UTILS_GENERIC_VECTOR_OPERATIONS_GENERIC_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_UTILS_GENERIC_VECTOR_OPERATIONS_GENERIC_H
+
+#include "../../rl_tools.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::utils::vector_operations{
+    template <typename DEVICE, typename T, auto N>
+    RL_TOOLS_FUNCTION_PLACEMENT void scalar_multiply(const T v[N], const T s, T out[N]) {
+        for(typename DEVICE::index_t i = 0; i < N; i++) {
+            out[i] = v[i]*s;
+        }
+    }
+
+    template <typename DEVICE, typename T, auto N>
+    RL_TOOLS_FUNCTION_PLACEMENT void scalar_multiply(T v[N], const T s) {
+        for(typename DEVICE::index_t i = 0; i < N; i++) {
+            v[i] *= s;
+        }
+    }
+
+    template <typename DEVICE, typename T, auto N>
+    RL_TOOLS_FUNCTION_PLACEMENT void scalar_multiply_accumulate(const T v[N], T s, T out[N]) {
+        for(typename DEVICE::index_t i = 0; i < N; i++) {
+            out[i] += v[i]*s;
+        }
+    }
+
+    template <typename DEVICE, typename T, auto M, auto N>
+    RL_TOOLS_FUNCTION_PLACEMENT void matrix_vector_product(const T A[M][N], const T v[N], T out[M]) {
+        for(typename DEVICE::index_t i = 0; i < M; i++) {
+            out[i] = 0;
+            for(typename DEVICE::index_t j = 0; j < N; j++) {
+                out[i] += A[i][j]*v[j];
+            }
+        }
+    }
+
+    template <typename DEVICE, typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT void cross_product(const T v1[3], const T v2[3], T out[3]) {
+        // flops: 2 * 3 = 6
+        out[0] = v1[1]*v2[2] - v1[2]*v2[1];
+        out[1] = v1[2]*v2[0] - v1[0]*v2[2];
+        out[2] = v1[0]*v2[1] - v1[1]*v2[0];
+    }
+
+    template <typename DEVICE, typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT void cross_product_accumulate(const T v1[3], const T v2[3], T out[3]) {
+        out[0] += v1[1]*v2[2] - v1[2]*v2[1];
+        out[1] += v1[2]*v2[0] - v1[0]*v2[2];
+        out[2] += v1[0]*v2[1] - v1[1]*v2[0];
+    }
+
+    template <typename DEVICE, typename T, auto N>
+    RL_TOOLS_FUNCTION_PLACEMENT void add(const T v1[N], const T v2[N], T out[N]) {
+        for(typename DEVICE::index_t i = 0; i < N; i++) {
+            out[i] = v1[i] + v2[i];
+        }
+    }
+    template <typename DEVICE, typename T, auto N>
+    RL_TOOLS_FUNCTION_PLACEMENT void add_accumulate(const T v1[N], const T v2[N], T out[N]) {
+        for(typename DEVICE::index_t i = 0; i < N; i++) {
+            out[i] += v1[i] + v2[i];
+        }
+    }
+    template <typename DEVICE, typename T, auto N>
+    RL_TOOLS_FUNCTION_PLACEMENT void add_accumulate(T const v[N], T out[N]) {
+        for(typename DEVICE::index_t i = 0; i < N; i++) {
+            out[i] += v[i];
+        }
+    }
+
+    template <typename DEVICE, typename T, auto N>
+    RL_TOOLS_FUNCTION_PLACEMENT void sub(T const v1[N], const T v2[N], T out[N]) {
+        for(typename DEVICE::index_t i = 0; i < N; i++) {
+            out[i] = v1[i] - v2[i];
+        }
+    }
+    template <typename DEVICE, typename T, auto N>
+    RL_TOOLS_FUNCTION_PLACEMENT void sub(T const v1[N], const T v2, T out[N]) {
+        for(typename DEVICE::index_t i = 0; i < N; i++) {
+            out[i] = v1[i] - v2;
+        }
+    }
+    template <typename DEVICE, typename T, auto N>
+    RL_TOOLS_FUNCTION_PLACEMENT void sub_accumulate(const T v1[N], const T v2[N], T out[N]) {
+        for(typename DEVICE::index_t i = 0; i < N; i++) {
+            out[i] += v1[i] - v2[i];
+        }
+    }
+    template <typename DEVICE, typename T, auto N>
+    RL_TOOLS_FUNCTION_PLACEMENT void sub_accumulate(const T v[N], T out[N]) {
+        for(typename DEVICE::index_t i = 0; i < N; i++) {
+            out[i] -= v[i];
+        }
+    }
+
+    template <typename DEVICE, typename T, auto N>
+    RL_TOOLS_FUNCTION_PLACEMENT void fill(T v[N], T s) {
+        for(typename DEVICE::index_t i = 0; i < N; i++) {
+            v[i] = s;
+        }
+    }
+
+    template <typename DEVICE, typename T, auto N>
+    RL_TOOLS_FUNCTION_PLACEMENT void assign(const T source[N], T target[N]) {
+        for(typename DEVICE::index_t i = 0; i < N; i++) {
+            target[i] = source[i];
+        }
+    }
+
+    template <typename DEVICE, typename T, auto M, auto N>
+    RL_TOOLS_FUNCTION_PLACEMENT void assign(const T source[M][N], T target[M][N]) {
+        for(typename DEVICE::index_t i = 0; i < M; i++) {
+            for(typename DEVICE::index_t j = 0; j < N; j++) {
+                target[i][j] = source[i][j];
+            }
+        }
+    }
+
+    template <typename DEVICE, typename T, auto M, auto N, auto P>
+    RL_TOOLS_FUNCTION_PLACEMENT void assign(const T source[M][N][P], T target[M][N][P]) {
+        for(typename DEVICE::index_t i = 0; i < M; i++) {
+            for(typename DEVICE::index_t j = 0; j < N; j++) {
+                for(typename DEVICE::index_t k = 0; k < P; k++) {
+                    target[i][j][k] = source[i][j][k];
+                }
+            }
+        }
+    }
+    template <typename DEVICE, typename T, auto M, auto N, auto P>
+    RL_TOOLS_FUNCTION_PLACEMENT void assign(const T source[P], T target[M][N][P]) {
+        for(typename DEVICE::index_t i = 0; i < M; i++) {
+            for(typename DEVICE::index_t j = 0; j < N; j++) {
+                for(typename DEVICE::index_t k = 0; k < P; k++) {
+                    target[i][j][k] = source[k];
+                }
+            }
+        }
+    }
+
+    template <typename DEVICE, typename T, auto N>
+    RL_TOOLS_FUNCTION_PLACEMENT T norm(const T source[N]) {
+        T acc = 0;
+        for(typename DEVICE::index_t i = 0; i < N; i++) {
+            acc += source[i]*source[i];
+        }
+        typename DEVICE::SPEC::MATH math_dev;
+        return math::sqrt(math_dev, acc);
+    }
+    template <typename DEVICE, typename T, auto N>
+    RL_TOOLS_FUNCTION_PLACEMENT void normalize(const T source[N], T target[N]) {
+        T n = norm(source);
+        for(typename DEVICE::index_t i = 0; i < N; i++) {
+            target[i] = source[i]/n;
+        }
+    }
+    template <typename DEVICE, typename T, auto N>
+    RL_TOOLS_FUNCTION_PLACEMENT T mean(const T source[N]) {
+        T acc = 0;
+        for(typename DEVICE::index_t i = 0; i < N; i++) {
+            acc += source[i];
+        }
+        return acc/N;
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/utils/polyak/operations_cuda.h

@@ -0,0 +1,53 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_UTILS_POLYAK_OPERATIONS_CUDA_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_UTILS_POLYAK_OPERATIONS_CUDA_H
+
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::utils::polyak {
+    // todo: polyak factor as template parameter (reciprocal INT e.g.)
+    namespace internal {
+        template<typename DEVICE, typename SOURCE_SPEC, typename TARGET_SPEC, bool SQUARE=false>
+        __global__
+        void update_kernel(const Matrix<SOURCE_SPEC> source, Matrix<TARGET_SPEC> target, const typename SOURCE_SPEC::T polyak) {
+            static_assert(containers::check_structure<SOURCE_SPEC, TARGET_SPEC>);
+            using SPEC = SOURCE_SPEC;
+            using T = typename SPEC::T;
+            using TI = typename DEVICE::index_t;
+            constexpr TI ROWS = SPEC::ROWS;
+            constexpr TI COLS = SPEC::COLS;
+            TI col_i = threadIdx.x + blockIdx.x * blockDim.x;
+            TI row_i = threadIdx.y + blockIdx.y * blockDim.y;
+            if(col_i < COLS && row_i < ROWS){
+                T s = get(source, row_i, col_i);
+                if constexpr(SQUARE){
+                    s *= s;
+                }
+                set(target, row_i, col_i, polyak * get(target, row_i, col_i) + (1 - polyak) * s);
+            }
+        }
+    }
+    template<typename DEV_SPEC, typename SOURCE_SPEC, typename TARGET_SPEC, bool SQUARE=false>
+    void update(devices::CUDA<DEV_SPEC>& device, const Matrix<SOURCE_SPEC>& source, Matrix<TARGET_SPEC>& target, const typename SOURCE_SPEC::T polyak) {
+        static_assert(containers::check_structure<SOURCE_SPEC, TARGET_SPEC>);
+        using DEVICE = devices::CUDA<DEV_SPEC>;
+        using SPEC = SOURCE_SPEC;
+        constexpr typename devices::CUDA<DEV_SPEC>::index_t BLOCKSIZE_ROWS = 32;
+        constexpr typename devices::CUDA<DEV_SPEC>::index_t BLOCKSIZE_COLS = 32;
+        constexpr typename devices::CUDA<DEV_SPEC>::index_t N_BLOCKS_ROWS = RL_TOOLS_DEVICES_CUDA_CEIL(SPEC::ROWS, BLOCKSIZE_ROWS);
+        constexpr typename devices::CUDA<DEV_SPEC>::index_t N_BLOCKS_COLS = RL_TOOLS_DEVICES_CUDA_CEIL(SPEC::COLS, BLOCKSIZE_COLS);
+        dim3 activation_grid(N_BLOCKS_COLS, N_BLOCKS_ROWS);
+        dim3 activation_block(BLOCKSIZE_COLS, BLOCKSIZE_ROWS);
+        internal::update_kernel<DEVICE, SOURCE_SPEC, TARGET_SPEC, SQUARE><<<activation_grid, activation_block, 0, device.stream>>>(source, target, polyak);
+        check_status(device);
+    }
+    template<typename DEV_SPEC, typename SOURCE_SPEC, typename TARGET_SPEC>
+    void update_squared(devices::CUDA<DEV_SPEC>& dev, const Matrix<SOURCE_SPEC>& source, Matrix<TARGET_SPEC>& target, const typename SOURCE_SPEC::T polyak) {
+        update<DEV_SPEC, SOURCE_SPEC, TARGET_SPEC, true>(dev, source, target, polyak);
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+
+#endif