hyperdrone 0.1.0__py3-none-any.whl

hyperdrone/_vendor/rl-tools/include/rl_tools/containers/tensor/persist_code.h

@@ -0,0 +1,130 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_CONTAINERS_TENSOR_PERSIST_CODE_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_CONTAINERS_TENSOR_PERSIST_CODE_H
+
+#include "../../persist/code.h"
+#include "../../utils/generic/typing.h"
+#include "../matrix/persist_code.h"
+#include <sstream>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    namespace tensor::persist_code{
+        template <typename TUPLE, int I, int N>
+        void emit_values_impl(std::stringstream& ss){
+            if constexpr(I < N){
+                ss << ", " << get<I>(TUPLE{});
+                emit_values_impl<TUPLE, I + 1, N>(ss);
+            }
+        }
+        template <typename TUPLE>
+        void emit_values(std::stringstream& ss){
+            emit_values_impl<TUPLE, 0, length(TUPLE{})>(ss);
+        }
+    }
+    template<typename DEVICE, typename SPEC>
+    persist::Code save_code_split(DEVICE& device, Tensor<SPEC>& tensor, std::string name, bool const_declaration=true, typename DEVICE::index_t indent=0){
+        using T = typename SPEC::T;
+        using TI = typename DEVICE::index_t;
+        static_assert(utils::typing::is_same_v<containers::persist::STORAGE_TYPE, unsigned char>);
+        static_assert(sizeof(T) % sizeof(containers::persist::STORAGE_TYPE) == 0);
+        std::stringstream indent_ss;
+        for(TI i=0; i < indent; i++){
+            indent_ss << "    ";
+        }
+        std::string ind = indent_ss.str();
+        std::stringstream ss_header;
+        ss_header << "// NOTE: This code export assumes that the endianness of the target platform is the same as the endianness of the source platform\n";
+        ss_header << "#include <rl_tools/containers/tensor/tensor.h>\n";
+        std::stringstream ss;
+        ss << ind << "namespace " << name << " {\n";
+        ss << ind << "    " << (const_declaration ? "constexpr " : "") << containers::persist::get_type_string<T>() << " memory[] = {";
+
+        auto m = matrix_view(device, tensor);
+        using MATRIX_SPEC = typename decltype(m)::SPEC;
+        bool first = true;
+        std::stringstream data_ss;
+        data_ss << std::uppercase << std::hexfloat << std::setprecision(6);
+        for(TI i=0; i < MATRIX_SPEC::ROWS; i++){
+            for(TI j=0; j < MATRIX_SPEC::COLS; j++){
+                if(!first){
+                    data_ss << ", ";
+                }
+                auto value = get(m, i, j);
+                first = false;
+                if (!std::isfinite(value)) {
+                    if (value < 0){
+                        data_ss << '-';
+                    }
+                    data_ss << "0x0p+0f/* nan/inf */";
+                } else {
+                    data_ss << value << (utils::typing::is_same_v<T, float> ? "f" : "");
+                }
+            }
+        }
+        ss << data_ss.str();
+        ss << "};\n";
+        ss << ind << "    using SHAPE = RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::tensor::Shape<" << containers::persist::get_type_string<TI>() << ", ";
+        for(TI dim_i=0; dim_i < length(typename SPEC::SHAPE{}); dim_i++){
+            if(dim_i > 0){
+                ss << ", ";
+            }
+            ss << get(device, typename SPEC::SHAPE{}, dim_i);
+        }
+        ss << ">;\n";
+        ss << ind << "    using SPEC = RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::tensor::Specification<";
+        ss << containers::persist::get_type_string<T>() << ", ";
+        ss << containers::persist::get_type_string<TI>() << ", ";
+        ss << "SHAPE, ";
+        constexpr bool DYNAMIC_ALLOCATION = true; // it is not dynamically allocated but the statically allocated exported arrays are assigned to the pointer of the tensor. This is easier than initializing a static array inside the tensor directly
+        ss << (DYNAMIC_ALLOCATION ? "true" : "false") << ", ";
+        ss << "RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::tensor::RowMajorStride<SHAPE>, ";
+        constexpr bool CONST = true;
+        ss << (CONST ? "true" : "false");
+        ss << ">;\n";
+        ss << ind << "    using CONTAINER_TYPE = RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::Tensor<SPEC>;\n";
+        ss << ind << "    " << (const_declaration ? "constexpr " : "") << "CONTAINER_TYPE container = {(" << containers::persist::get_type_string<T>() << "*)" << "memory}; \n";
+        ss << ind << "}\n";
+        return {ss_header.str(), ss.str()};
+    }
+    template<typename DEVICE, typename SPEC>
+    std::string save_code(DEVICE& device, Tensor<SPEC>& m, std::string name, bool const_declaration, typename DEVICE::index_t indent=0){
+        auto code = save_code_split(device, m, name, const_declaration, indent);
+        return code.header + code.body;
+    }
+    template <typename DEVICE, typename SPEC>
+    std::string json(DEVICE& device, Tensor<SPEC>& m){
+        using T = typename SPEC::T;
+        using TI = typename DEVICE::index_t;
+        std::string data;
+        data += "[";
+        if constexpr(SPEC::SHAPE::LENGTH > 1){
+            for(TI i=0; i < SPEC::SHAPE::template GET<0>; ++i){
+                if (i != 0){
+                    data += ", ";
+                }
+                auto next_m = view(device, m, i);
+                data += json(device, next_m);
+            }
+        }
+        else{
+            for(TI i=0; i < SPEC::SHAPE::template GET<0>; i++){
+                T value = get(device, m, i);
+                if (i != 0){
+                    data += ", ";
+                }
+                if (math::is_nan(device.math, value)) {
+                    data += "null";
+                }
+                else{
+                    data += std::to_string(value);
+                }
+            }
+        }
+        data += "]";
+        return data;
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

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

@@ -0,0 +1,490 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_CONTAINERS_TENSOR_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_CONTAINERS_TENSOR_H
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    namespace tensor{
+        template <typename T_TI, T_TI... T_VALUES>
+        struct Tuple{
+            using TI = T_TI;
+            static constexpr TI LENGTH = sizeof...(T_VALUES);
+            template <TI N>
+            static constexpr TI _get_at() {
+                static_assert(N < LENGTH, "Index out of bounds in Tuple::GET");
+                if constexpr(LENGTH == 0){
+                    return static_cast<TI>(0);
+                }
+                else{
+                    constexpr TI values[] = {T_VALUES...};
+                    return values[N];
+                }
+            }
+            template <TI N>
+            static constexpr TI GET = _get_at<N>();
+
+            static constexpr TI _first() {
+                if constexpr(LENGTH == 0){
+                    return static_cast<TI>(0);
+                }
+                else{
+                    constexpr TI values[] = {T_VALUES...};
+                    return values[0];
+                }
+            }
+            static constexpr TI FIRST = _first();
+            static constexpr TI _last() {
+                if constexpr(LENGTH == 0){
+                    return static_cast<TI>(0);
+                }
+                else{
+                    constexpr TI values[] = {T_VALUES...};
+                    return values[LENGTH - 1];
+                }
+            }
+            static constexpr TI LAST = _last();
+        };
+
+        template <typename TI, TI... T_DIMS>
+        struct Shape: Tuple<TI, T_DIMS...> {
+        };
+
+        template <typename TI, TI... T_DIMS>
+        struct Stride: Tuple<TI, T_DIMS...> {
+        };
+
+    }
+    // all these should be just static constexpr members like FIRST, LAST etc.
+    template <typename TI, TI... VALUES>
+    RL_TOOLS_FUNCTION_PLACEMENT TI constexpr length(tensor::Tuple<TI, VALUES...>){
+        return static_cast<TI>(sizeof...(VALUES));
+    }
+    template <typename TI, TI... VALUES>
+    RL_TOOLS_FUNCTION_PLACEMENT TI constexpr product(tensor::Tuple<TI, VALUES...>){
+        return (static_cast<TI>(1) * ... * VALUES);
+    }
+    template <auto TARGET_INDEX_INPUT, typename TI, TI... VALUES>
+    RL_TOOLS_FUNCTION_PLACEMENT TI constexpr get(tensor::Tuple<TI, VALUES...>){
+        constexpr TI TARGET_INDEX = TARGET_INDEX_INPUT;
+        static_assert(TARGET_INDEX >= 0, "Index out of bounds");
+        static_assert(TARGET_INDEX < static_cast<TI>(sizeof...(VALUES)), "Index out of bounds");
+        return tensor::Tuple<TI, VALUES...>::template GET<TARGET_INDEX>;
+    }
+    template <typename DEVICE, typename TI, TI... VALUES>
+    RL_TOOLS_FUNCTION_PLACEMENT TI get(DEVICE& device, const tensor::Tuple<TI, VALUES...>, TI index){
+        utils::assert_exit(device, index >= 0 && index < static_cast<TI>(sizeof...(VALUES)), "Index out of bounds");
+        if constexpr(sizeof...(VALUES) == 0){
+            return static_cast<TI>(0);
+        }
+        else{
+            constexpr TI values[] = {VALUES...};
+            return values[index];
+        }
+    }
+    template <typename TI, TI... VALUES>
+    RL_TOOLS_FUNCTION_PLACEMENT TI constexpr get_last(tensor::Tuple<TI, VALUES...>){
+        static_assert(sizeof...(VALUES) > 0, "Cannot get last element of empty Tuple");
+        return get<static_cast<TI>(sizeof...(VALUES) - 1)>(tensor::Tuple<TI, VALUES...>{});
+    }
+    namespace tensor {
+        namespace shape_math {
+            using SizeType = decltype(sizeof(0));
+
+            template <typename T, SizeType N>
+            struct ConstexprArray {
+                T data[N > 0 ? N : 1];
+            };
+
+            template <SizeType... Is>
+            struct IndexSequence {};
+
+            template <SizeType N, SizeType... Is>
+            struct MakeIndexSequenceImpl : MakeIndexSequenceImpl<N - 1, N - 1, Is...> {};
+
+            template <SizeType... Is>
+            struct MakeIndexSequenceImpl<0, Is...> {
+                using type = IndexSequence<Is...>;
+            };
+
+            template <SizeType N>
+            using MakeIndexSequence = typename MakeIndexSequenceImpl<N>::type;
+
+            template <typename ELEMENT>
+            RL_TOOLS_FUNCTION_PLACEMENT constexpr SizeType rank() {
+                return static_cast<SizeType>(length(ELEMENT{}));
+            }
+
+            template <typename ELEMENT, SizeType... Is>
+            RL_TOOLS_FUNCTION_PLACEMENT constexpr auto element_to_array_unpack(IndexSequence<Is...>) {
+                using TI = typename ELEMENT::TI;
+                return ConstexprArray<TI, sizeof...(Is)>{{get<static_cast<TI>(Is)>(ELEMENT{})...}};
+            }
+
+            template <typename ELEMENT>
+            RL_TOOLS_FUNCTION_PLACEMENT constexpr auto element_to_array() {
+                return element_to_array_unpack<ELEMENT>(MakeIndexSequence<rank<ELEMENT>()>{});
+            }
+
+            template <typename LEFT, typename RIGHT>
+            constexpr auto _concat_compute() {
+                using TI = typename LEFT::TI;
+                constexpr SizeType LEFT_RANK = rank<LEFT>();
+                constexpr SizeType RIGHT_RANK = rank<RIGHT>();
+                constexpr auto left = element_to_array<LEFT>();
+                constexpr auto right = element_to_array<RIGHT>();
+                ConstexprArray<TI, LEFT_RANK + RIGHT_RANK> out{};
+                for(SizeType i = 0; i < LEFT_RANK; ++i){
+                    out.data[i] = left.data[i];
+                }
+                for(SizeType i = 0; i < RIGHT_RANK; ++i){
+                    out.data[LEFT_RANK + i] = right.data[i];
+                }
+                return out;
+            }
+
+            template <typename LEFT, typename RIGHT, SizeType... Is>
+            constexpr auto concat_helper(IndexSequence<Is...>) {
+                static_assert(utils::typing::is_same_v<typename LEFT::TI, typename RIGHT::TI>, "Concat requires matching TI types");
+                using TI = typename LEFT::TI;
+                constexpr auto out = _concat_compute<LEFT, RIGHT>();
+                return Tuple<TI, out.data[Is]...>{};
+            }
+
+            template <typename LEFT, typename RIGHT>
+            using Concat = decltype(concat_helper<LEFT, RIGHT>(
+                MakeIndexSequence<rank<LEFT>() + rank<RIGHT>()>{}));
+
+            template <auto NEW_ELEMENT, typename TI, TI... Vs>
+            constexpr Tuple<TI, Vs..., static_cast<TI>(NEW_ELEMENT)> append_helper(Tuple<TI, Vs...>);
+
+            template <auto NEW_ELEMENT, typename TI, TI... Vs>
+            constexpr Tuple<TI, static_cast<TI>(NEW_ELEMENT), Vs...> prepend_helper(Tuple<TI, Vs...>);
+
+            template <typename TI, SizeType N>
+            RL_TOOLS_FUNCTION_PLACEMENT constexpr TI leading_product(ConstexprArray<TI, N> in, SizeType trailing_dims) {
+                TI out = 1;
+                for (SizeType i = 0; i + trailing_dims < N; ++i) {
+                    out *= in.data[i];
+                }
+                return out;
+            }
+
+            template <typename TI, TI FIRST, TI... REST>
+            constexpr Tuple<TI, REST...> pop_front_helper(Tuple<TI, FIRST, REST...>);
+
+            template <typename ELEMENT, SizeType... Is>
+            constexpr auto pop_back_helper(IndexSequence<Is...>) {
+                using TI = typename ELEMENT::TI;
+                return Tuple<TI, ELEMENT::template GET<static_cast<TI>(Is)>...>{};
+            }
+
+            template <typename ELEMENT, SizeType N>
+            constexpr auto _cumulative_product_compute() {
+                using TI = typename ELEMENT::TI;
+                constexpr auto in = element_to_array<ELEMENT>();
+                ConstexprArray<TI, N> r{};
+                if constexpr (N > 0) {
+                    r.data[N - 1] = in.data[N - 1];
+                    for (SizeType i = N - 1; i > 0; --i) r.data[i - 1] = r.data[i] * in.data[i - 1];
+                }
+                return r;
+            }
+
+            template <typename ELEMENT, SizeType... Is>
+            constexpr auto cumulative_product_helper(IndexSequence<Is...>) {
+                using TI = typename ELEMENT::TI;
+                constexpr auto out = _cumulative_product_compute<ELEMENT, sizeof...(Is)>();
+                return Tuple<TI, out.data[Is]...>{};
+            }
+
+            template <typename ELEMENT, auto NEW_ELEMENT, auto OFFSET, SizeType... Is>
+            constexpr auto replace_helper(IndexSequence<Is...>) {
+                static_assert(OFFSET < rank<ELEMENT>(), "Replace index out of bounds");
+                using TI = typename ELEMENT::TI;
+                return Tuple<TI, (Is == static_cast<SizeType>(OFFSET)
+                    ? static_cast<TI>(NEW_ELEMENT)
+                    : ELEMENT::template GET<static_cast<TI>(Is)>)...>{};
+            }
+
+            template <typename ELEMENT, auto NEW_ELEMENT, auto OFFSET>
+            constexpr auto _insert_compute() {
+                using TI = typename ELEMENT::TI;
+                constexpr SizeType N = rank<ELEMENT>();
+                constexpr auto in = element_to_array<ELEMENT>();
+                ConstexprArray<TI, N + 1> r{};
+                for (SizeType i = 0; i < static_cast<SizeType>(OFFSET); ++i) r.data[i] = in.data[i];
+                r.data[static_cast<SizeType>(OFFSET)] = static_cast<TI>(NEW_ELEMENT);
+                for (SizeType i = static_cast<SizeType>(OFFSET); i < N; ++i) r.data[i + 1] = in.data[i];
+                return r;
+            }
+
+            template <typename ELEMENT, auto NEW_ELEMENT, auto OFFSET, SizeType... Is>
+            constexpr auto insert_helper(IndexSequence<Is...>) {
+                static_assert(OFFSET <= rank<ELEMENT>(), "Insert index out of bounds");
+                using TI = typename ELEMENT::TI;
+                constexpr auto out = _insert_compute<ELEMENT, NEW_ELEMENT, OFFSET>();
+                return Tuple<TI, out.data[Is]...>{};
+            }
+
+            template <typename ELEMENT, auto OFFSET, SizeType... Is>
+            constexpr auto remove_helper(IndexSequence<Is...>) {
+                static_assert(OFFSET < rank<ELEMENT>(), "Remove index out of bounds");
+                using TI = typename ELEMENT::TI;
+                return Tuple<TI, ELEMENT::template GET<static_cast<TI>(
+                    Is < static_cast<SizeType>(OFFSET) ? Is : Is + 1)>...>{};
+            }
+        }
+
+        template <typename ELEMENT, auto NEW_ELEMENT>
+        using Append = decltype(shape_math::append_helper<NEW_ELEMENT>(ELEMENT{}));
+
+        template <typename ELEMENT, auto NEW_ELEMENT>
+        using Prepend = decltype(shape_math::prepend_helper<NEW_ELEMENT>(ELEMENT{}));
+
+        template <typename ELEMENT>
+        using PopFront = decltype(shape_math::pop_front_helper(ELEMENT{}));
+
+        template <typename ELEMENT>
+        using PopBack = decltype(shape_math::pop_back_helper<ELEMENT>(
+            shape_math::MakeIndexSequence<(shape_math::rank<ELEMENT>() > 0 ? shape_math::rank<ELEMENT>() - 1 : 0)>{}));
+
+        template <typename ELEMENT>
+        using CumulativeProduct = decltype(shape_math::cumulative_product_helper<ELEMENT>(
+            shape_math::MakeIndexSequence<shape_math::rank<ELEMENT>()>{}));
+
+        template <typename ELEMENT, auto NEW_ELEMENT, auto NEW_ELEMENT_OFFSET>
+        using Replace = decltype(shape_math::replace_helper<ELEMENT, NEW_ELEMENT, NEW_ELEMENT_OFFSET>(
+            shape_math::MakeIndexSequence<shape_math::rank<ELEMENT>()>{}));
+
+        template <typename ELEMENT, auto NEW_ELEMENT, auto NEW_ELEMENT_OFFSET>
+        using Insert = decltype(shape_math::insert_helper<ELEMENT, NEW_ELEMENT, NEW_ELEMENT_OFFSET>(
+            shape_math::MakeIndexSequence<shape_math::rank<ELEMENT>() + 1>{}));
+
+        template <typename ELEMENT, auto ELEMENT_OFFSET>
+        using Remove = decltype(shape_math::remove_helper<ELEMENT, ELEMENT_OFFSET>(
+            shape_math::MakeIndexSequence<(shape_math::rank<ELEMENT>() > 0 ? shape_math::rank<ELEMENT>() - 1 : 0)>{}));
+
+        namespace row_major_stride_detail{
+            template <typename TI, auto ELEMENT_STRIDE, TI... VALUES>
+            struct Build;
+            template <typename TI, auto ELEMENT_STRIDE>
+            struct Build<TI, ELEMENT_STRIDE>{
+                using TYPE = Stride<TI>;
+            };
+            template <typename TI, auto ELEMENT_STRIDE, TI FIRST, TI... REST>
+            struct Build<TI, ELEMENT_STRIDE, FIRST, REST...>{
+                static constexpr TI CURRENT_STRIDE = (static_cast<TI>(ELEMENT_STRIDE) * ... * REST);
+                using TYPE = Prepend<typename Build<TI, ELEMENT_STRIDE, REST...>::TYPE, CURRENT_STRIDE>;
+            };
+            template <auto ELEMENT_STRIDE, typename TI, TI... VALUES>
+            constexpr typename Build<TI, ELEMENT_STRIDE, VALUES...>::TYPE build(Tuple<TI, VALUES...>);
+        }
+
+        template <typename SHAPE, auto ELEMENT_STRIDE=1>
+        using RowMajorStride = decltype(row_major_stride_detail::build<ELEMENT_STRIDE>(SHAPE{}));
+
+        template <typename SHAPE, typename STRIDE>
+        constexpr typename SHAPE::TI max_span(){
+            static_assert(length(SHAPE{}) == length(STRIDE{}));
+            if constexpr(length(SHAPE{}) == 1){
+                return get<0>(SHAPE{}) * get<0>(STRIDE{});
+            }
+            else{
+                using NEXT_SHAPE = PopFront<SHAPE>;
+                using NEXT_STRIDE = PopFront<STRIDE>;
+                auto previous = max_span<NEXT_SHAPE, NEXT_STRIDE>();
+                auto current = get<0>(SHAPE{}) * get<0>(STRIDE{});
+                return previous > current ? previous : current;
+            }
+        }
+
+        template <typename T_T, typename T_TI, typename T_SHAPE, bool T_DYNAMIC_ALLOCATION=true, typename T_STRIDE = RowMajorStride<T_SHAPE>, bool T_CONST=false>
+        struct Specification{
+            using T = T_T;
+            using TI = T_TI;
+            using SHAPE = T_SHAPE;
+            using STRIDE = T_STRIDE;
+            static constexpr bool DYNAMIC_ALLOCATION = T_DYNAMIC_ALLOCATION;
+            static constexpr bool CONST = T_CONST;
+            static constexpr TI SIZE = max_span<SHAPE, STRIDE>();
+            static constexpr TI SIZE_BYTES = SIZE * sizeof(T);
+
+        };
+        template<auto T_DIM, auto T_SIZE=0>
+        struct ViewSpec{
+            static constexpr auto DIM = T_DIM;
+            static constexpr auto SIZE = T_SIZE;
+        };
+        template <typename SHAPE, typename STRIDE>
+        RL_TOOLS_FUNCTION_PLACEMENT bool constexpr generalized_row_major(){
+            static_assert(length(SHAPE{}) == length(STRIDE{}));
+            constexpr auto rank = shape_math::rank<SHAPE>();
+            if constexpr(rank <= 1){
+                return true;
+            }
+            else{
+                constexpr auto shape = shape_math::element_to_array<SHAPE>();
+                constexpr auto stride = shape_math::element_to_array<STRIDE>();
+                for(typename shape_math::SizeType i = rank - 1; i > 0; --i){
+                    if(shape.data[i] * stride.data[i] > stride.data[i - 1]){
+                        return false;
+                    }
+                }
+                return true;
+            }
+        }
+        template <typename A, typename B>
+       RL_TOOLS_FUNCTION_PLACEMENT  bool constexpr same_dimensions_shape(){
+            if constexpr(length(A{}) != length(B{})){
+                return false;
+            }
+            constexpr auto a = shape_math::element_to_array<A>();
+            constexpr auto b = shape_math::element_to_array<B>();
+            constexpr auto rank = shape_math::rank<A>();
+            if constexpr(rank == 0){
+                return true;
+            }
+            else{
+                for(typename shape_math::SizeType i = 0; i < rank; ++i){
+                    if(a.data[i] != b.data[i]){
+                        return false;
+                    }
+                }
+                return true;
+            }
+        }
+        template <typename SPEC_A, typename SPEC_B>
+        RL_TOOLS_FUNCTION_PLACEMENT bool constexpr same_dimensions(){
+            return same_dimensions_shape<typename SPEC_A::SHAPE, typename SPEC_B::SHAPE>();
+        }
+
+
+        template <typename SHAPE, typename STRIDE, bool RELAX_MAJOR=false>
+        RL_TOOLS_FUNCTION_PLACEMENT bool constexpr _dense_row_major_layout_shape(){
+            static_assert(length(SHAPE{}) > 0);
+            if(length(STRIDE{}) != length(SHAPE{})){
+                return false;
+            }
+            constexpr auto rank = shape_math::rank<SHAPE>();
+            constexpr auto shape = shape_math::element_to_array<SHAPE>();
+            constexpr auto stride = shape_math::element_to_array<STRIDE>();
+            if constexpr(rank == 1){
+                return RELAX_MAJOR || stride.data[0] == 1;
+            }
+            else{
+                for(typename shape_math::SizeType i = 0; i + 1 < rank; ++i){
+                    const auto expected = stride.data[i + 1] * shape.data[i + 1];
+                    const bool is_last_pair = (i + 1 == rank - 1);
+                    if constexpr(RELAX_MAJOR){
+                        if(is_last_pair){
+                            if(stride.data[i] < expected){
+                                return false;
+                            }
+                        }
+                        else{
+                            const bool contiguous = stride.data[i] == expected;
+                            const bool relaxed_broadcast = (shape.data[i] == 1) && (stride.data[i] >= expected);
+                            if(!(contiguous || relaxed_broadcast)){
+                                return false;
+                            }
+                        }
+                    }
+                    else{
+                        const bool contiguous = stride.data[i] == expected;
+                        const bool relaxed_broadcast = (shape.data[i] == 1) && (stride.data[i] >= expected);
+                        if(!(contiguous || relaxed_broadcast)){
+                            return false;
+                        }
+                    }
+                }
+                return true;
+            }
+        }
+        template <typename SPEC, bool RELAX_MAJOR=false>
+        RL_TOOLS_FUNCTION_PLACEMENT bool constexpr dense_row_major_layout(){
+            return _dense_row_major_layout_shape<typename SPEC::SHAPE, typename SPEC::STRIDE, RELAX_MAJOR>();
+        }
+        namespace spec::view{
+            namespace range{
+                template <typename SHAPE, typename VIEW_SPEC>
+                using Shape = tensor::Replace<SHAPE, VIEW_SPEC::SIZE, VIEW_SPEC::DIM>;
+                template <typename STRIDE, typename VIEW_SPEC>
+                using Stride = STRIDE;
+                template <typename SPEC, typename VIEW_SPEC, bool T_CONST>
+                using Specification = tensor::Specification<typename SPEC::T, typename SPEC::TI, Shape<typename SPEC::SHAPE, VIEW_SPEC>, true, Stride<typename SPEC::STRIDE, VIEW_SPEC>, T_CONST>;
+            }
+            namespace point{
+                template <typename SHAPE, typename VIEW_SPEC>
+                using Shape = tensor::Remove<SHAPE, VIEW_SPEC::DIM>;
+                template <typename STRIDE, typename VIEW_SPEC>
+                using Stride = tensor::Remove<STRIDE, VIEW_SPEC::DIM>;
+                template <typename SPEC, typename VIEW_SPEC, bool T_CONST>
+                using Specification = tensor::Specification<typename SPEC::T, typename SPEC::TI, Shape<typename SPEC::SHAPE, VIEW_SPEC>, true, Stride<typename SPEC::STRIDE, VIEW_SPEC>, T_CONST>;
+            }
+        }
+    }
+
+    namespace tensor{
+        template <typename T, typename TI, TI SIZE>
+        struct TensorStatic{
+            static constexpr bool DYNAMIC_ALLOCATION = false;
+            static_assert(SIZE > 0, "MSVC does not allow SIZE=0");
+            T _data[SIZE];
+        };
+        template <typename T>
+        struct TensorStaticEmpty{
+            static constexpr bool DYNAMIC_ALLOCATION = false;
+            T* _data = nullptr;
+        };
+        template <typename T, typename TI, TI SIZE, bool CONST = false>
+        struct TensorDynamic{
+            static constexpr bool DYNAMIC_ALLOCATION = true;
+            T* _data = nullptr;
+        };
+        template <typename T, typename TI, TI SIZE>
+        struct TensorDynamic<T, TI, SIZE, true>{
+            static constexpr bool DYNAMIC_ALLOCATION = true;
+            const T* _data;
+        };
+    }
+
+    template <typename T_SPEC>
+    struct Tensor: utils::typing::conditional_t<T_SPEC::DYNAMIC_ALLOCATION, tensor::TensorDynamic<typename T_SPEC::T, typename T_SPEC::TI, T_SPEC::SIZE, T_SPEC::CONST>, utils::typing::conditional_t<(T_SPEC::SIZE > 0), tensor::TensorStatic<typename T_SPEC::T, typename T_SPEC::TI, T_SPEC::SIZE>, tensor::TensorStaticEmpty<typename T_SPEC::T>>>{
+        using SPEC = T_SPEC;
+        using SHAPE = typename SPEC::SHAPE;
+        using T = typename SPEC::T;
+        template <typename VIEW_SPEC>
+        using VIEW_POINT = Tensor<tensor::spec::view::point::Specification<SPEC, VIEW_SPEC, SPEC::CONST>>;
+        template <typename VIEW_SPEC>
+        using VIEW_RANGE = Tensor<tensor::spec::view::range::Specification<SPEC, VIEW_SPEC, SPEC::CONST>>;
+        // Tensor() = default;
+//        Tensor(DATA_TYPE data): _data(data){};
+    };
+
+    template <typename T, typename TI, TI SIZE>
+    RL_TOOLS_FUNCTION_PLACEMENT auto data(tensor::TensorStatic<T, TI, SIZE>& tensor){
+        return tensor._data;
+    }
+    template <typename T, typename TI, TI SIZE>
+    RL_TOOLS_FUNCTION_PLACEMENT auto data(const tensor::TensorStatic<T, TI, SIZE>& tensor){
+        return &tensor._data[0];
+    }
+
+    template <typename T, typename TI, TI SIZE, bool CONST>
+    RL_TOOLS_FUNCTION_PLACEMENT auto data(tensor::TensorDynamic<T, TI, SIZE, CONST>& tensor){
+        return tensor._data;
+    }
+    template <typename T, typename TI, TI SIZE, bool CONST>
+    RL_TOOLS_FUNCTION_PLACEMENT auto data(const tensor::TensorDynamic<T, TI, SIZE, CONST>& tensor){
+        return &tensor._data[0];
+    }
+
+    template <typename T, typename TI, TI SIZE, bool CONST>
+    RL_TOOLS_FUNCTION_PLACEMENT T** data_pointer(tensor::TensorDynamic<T, TI, SIZE, CONST>& tensor){
+        return &tensor._data;
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif