hyperverse 0.0.1__py3-none-any.whl

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

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

@@ -0,0 +1,314 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_CONTAINERS_MATRIX_OPERATIONS_CPU_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_CONTAINERS_MATRIX_OPERATIONS_CPU_H
+
+#include "operations_generic.h"
+
+#include <iostream>
+#include <iomanip>
+// #include <immintrin.h> // For AVX intrinsics
+#include <cstdlib>
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template<typename DEVICE, typename SPEC>
+    void print(DEVICE& device, const Matrix<SPEC>& m){
+        for(typename DEVICE::index_t row_i = 0; row_i < SPEC::ROWS; row_i++){
+            for(typename DEVICE::index_t col_i = 0; col_i < SPEC::COLS; col_i++){
+                std::cout << std::fixed << std::setw(12) << std::setprecision(6) << get(m, row_i, col_i) << " ";
+            }
+            std::cout << std::endl;
+        }
+    }
+    template<typename DEVICE, typename SPEC>
+    void print_python_literal(DEVICE& device, const Matrix<SPEC>& m){
+        std::cout << "[" << std::endl;
+        for(typename DEVICE::index_t row_i = 0; row_i < SPEC::ROWS; row_i++){
+            std::cout << "    [";
+            for(typename DEVICE::index_t col_i = 0; col_i < SPEC::COLS; col_i++){
+                std::cout << std::fixed << std::setw(12) << std::setprecision(6) << get(m, row_i, col_i);
+                if(col_i < SPEC::COLS - 1){
+                    std::cout << ", ";
+                }
+            }
+            std::cout << "],";
+            std::cout << std::endl;
+        }
+        std::cout << "]" << std::endl;
+    }
+    template<typename SOURCE_DEV_SPEC, typename TARGET_DEV_SPEC, typename SPEC_1, typename SPEC_2>
+    RL_TOOLS_FUNCTION_PLACEMENT void copy_view(devices::CPU<SOURCE_DEV_SPEC>& source_device, devices::CPU<TARGET_DEV_SPEC>& target_device, const Matrix<SPEC_1>& source, Matrix<SPEC_2>& target){
+        using SOURCE_DEVICE = devices::CPU<SOURCE_DEV_SPEC>;
+        static_assert(containers::check_structure<SPEC_1, SPEC_2>);
+        using SPEC = SPEC_1;
+        vectorize_unary<SOURCE_DEVICE, SPEC_1, SPEC_2, 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>
+    RL_TOOLS_FUNCTION_PLACEMENT void copy(devices::CPU<SOURCE_DEV_SPEC>& source_device, devices::CPU<TARGET_DEV_SPEC>& target_device, const Matrix<SPEC_1>& source, Matrix<SPEC_2>& target){
+        using SOURCE_DEVICE = devices::CPU<SOURCE_DEV_SPEC>;
+        using TI = typename SOURCE_DEVICE::index_t;
+        static_assert(containers::check_structure<SPEC_1, SPEC_2>);
+        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);
+        }
+    }
+    template<typename DEV_SPEC, typename SPEC, typename SPEC::TI ROWS, typename SPEC::TI COLS>
+    RL_TOOLS_FUNCTION_PLACEMENT auto view(devices::CPU<DEV_SPEC>& device, const Matrix<SPEC>& m, typename SPEC::TI row, typename SPEC::TI col){
+        using DEVICE = devices::CPU<DEV_SPEC>;
+        static_assert(SPEC::ROWS >= ROWS);
+        static_assert(SPEC::COLS >= COLS);
+#ifdef RL_TOOLS_DEBUG_CONTAINER_CHECK_BOUNDS
+        utils::assert_exit(device, (row + ROWS) <= SPEC::ROWS, "row + ROWS <= SPEC::ROWS");
+        utils::assert_exit(device, (col + COLS) <= SPEC::COLS, "col + COLS <= SPEC::COLS");
+#endif
+        return _view<DEVICE, SPEC, ROWS, COLS>(device, m, row, col);
+    }
+    template<typename DEV_SPEC, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT std::vector<std::vector<typename SPEC::T>> std_vector(devices::CPU<DEV_SPEC>& device, Matrix<SPEC>& matrix){
+        using DEVICE = devices::CPU<DEV_SPEC>;
+        using TI = typename DEVICE::index_t;
+        std::vector<std::vector<typename SPEC::T>> result;
+        for(TI row_i = 0; row_i < SPEC::ROWS; row_i++){
+            std::vector<typename SPEC::T> row;
+            for(TI col_i = 0; col_i < SPEC::COLS; col_i++){
+                row.push_back(get(matrix, row_i, col_i));
+            }
+            result.push_back(row);
+        }
+        return result;
+    }
+    template<typename DEVICE_SPEC, typename SPEC_A, typename SPEC_B, typename SPEC_C>
+    RL_TOOLS_FUNCTION_PLACEMENT void multiply_naive(devices::CPU<DEVICE_SPEC>& device, const Matrix<SPEC_A>& A, const Matrix<SPEC_B>& B, Matrix<SPEC_C>& C){
+        static_assert(SPEC_A::ROWS == SPEC_C::ROWS);
+        static_assert(SPEC_A::COLS == SPEC_B::ROWS);
+        static_assert(SPEC_B::COLS == SPEC_C::COLS);
+        using DEVICE = devices::CPU<DEVICE_SPEC>;
+
+        using TA = typename SPEC_A::T;
+        using TB = typename SPEC_B::T;
+        using TC = typename SPEC_C::T;
+        using TI = typename DEVICE::index_t;
+
+        constexpr TI M = SPEC_A::ROWS;
+        constexpr TI N = SPEC_B::COLS;
+        constexpr TI K = SPEC_A::COLS;
+
+        const TA * RL_TOOLS_RESTRICT A_data = A._data;
+        const TB * RL_TOOLS_RESTRICT B_data = B._data;
+        TC * RL_TOOLS_RESTRICT C_data = C._data;
+
+        for (TI i = 0; i < M * N; ++i) {
+            C_data[i] = (TC)0.0f;
+        }
+
+        for (TI i = 0; i < M; ++i) {
+            for (TI k_idx = 0; k_idx < K; ++k_idx) {
+                TA A_val = A_data[i * K + k_idx];
+                for (TI j = 0; j < N; ++j) {
+                    C_data[i * N + j] += A_val * B_data[k_idx * N + j];
+                }
+            }
+        }
+    }
+    template<typename DEVICE_SPEC, typename SPEC_A, typename SPEC_B, typename SPEC_C>
+    RL_TOOLS_FUNCTION_PLACEMENT void multiply_tiled(devices::CPU<DEVICE_SPEC>& device, const Matrix<SPEC_A>& A, const Matrix<SPEC_B>& B, Matrix<SPEC_C>& C) {
+        static_assert(SPEC_A::ROWS == SPEC_C::ROWS);
+        static_assert(SPEC_A::COLS == SPEC_B::ROWS);
+        static_assert(SPEC_B::COLS == SPEC_C::COLS);
+        using DEVICE = devices::CPU<DEVICE_SPEC>;
+
+        using TA = typename SPEC_A::T;
+        using TB = typename SPEC_B::T;
+        using TC = typename SPEC_C::T;
+        using TI = typename DEVICE::index_t;
+
+        constexpr TI M = SPEC_A::ROWS;
+        constexpr TI N = SPEC_B::COLS;
+        constexpr TI K = SPEC_A::COLS;
+        constexpr TI blockSize = 32;
+
+        const TA * RL_TOOLS_RESTRICT A_data = A._data;
+        const TB * RL_TOOLS_RESTRICT B_data = B._data;
+        TC * RL_TOOLS_RESTRICT C_data = C._data;
+
+        // Initialize C to zero
+        for (TI i = 0; i < M * N; ++i) {
+            C_data[i] = (TC) 0.0f;
+        }
+
+        for (TI ii = 0; ii < M; ii += blockSize){
+            for (TI kk = 0; kk < K; kk += blockSize){
+                for (TI jj = 0; jj < N; jj += blockSize){
+                    TI i_end = (ii + blockSize > M) ? M : ii + blockSize;
+                    TI k_end = (kk + blockSize > K) ? K : kk + blockSize;
+                    TI j_end = (jj + blockSize > N) ? N : jj + blockSize;
+                    for (TI i = ii; i < i_end; ++i) {
+                        for (TI k_idx = kk; k_idx < k_end; ++k_idx) {
+                            TA A_val = A_data[i * K + k_idx];
+                            for (TI j = jj; j < j_end; ++j) {
+                                C_data[i * N + j] += A_val * B_data[k_idx * N + j];
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // template<typename DEVICE_SPEC, typename INPUT_SPEC_A, typename INPUT_SPEC_B, typename OUTPUT_SPEC>
+    // void multiply_tiled_simd(devices::CPU<DEVICE_SPEC>& device, const Matrix<INPUT_SPEC_A>& A, const Matrix<INPUT_SPEC_B>& B, Matrix<OUTPUT_SPEC>& C) {
+    //     // Ensure matrix dimensions are compatible
+    //     static_assert(INPUT_SPEC_A::ROWS == OUTPUT_SPEC::ROWS, "A.rows must equal C.rows");
+    //     static_assert(INPUT_SPEC_A::COLS == INPUT_SPEC_B::ROWS, "A.cols must equal B.rows");
+    //     static_assert(INPUT_SPEC_B::COLS == OUTPUT_SPEC::COLS, "B.cols must equal C.cols");
+    //     using DEVICE = devices::CPU<DEVICE_SPEC>;
+    //
+    //     using T = typename OUTPUT_SPEC::T;
+    //     using TI = typename DEVICE_SPEC::index_t; // Corrected index type
+    //
+    //     constexpr TI M = INPUT_SPEC_A::ROWS;
+    //     constexpr TI N = INPUT_SPEC_B::COLS;
+    //     constexpr TI K = INPUT_SPEC_A::COLS;
+    //     constexpr TI blockSize = 32; // Adjust block size as needed
+    //
+    //     T* RL_TOOLS_RESTRICT A_data = A._data;
+    //     T* RL_TOOLS_RESTRICT B_data = B._data;
+    //     T* RL_TOOLS_RESTRICT C_data = C._data;
+    //
+    //     // Initialize C to zero
+    //     for (TI i = 0; i < M * N; ++i) {
+    //         C_data[i] = static_cast<T>(0);
+    //     }
+    //
+    //     // Tiled matrix multiplication with SIMD intrinsics
+    //     for (TI ii = 0; ii < M; ii += blockSize) {
+    //         for (TI kk = 0; kk < K; kk += blockSize) {
+    //             for (TI jj = 0; jj < N; jj += blockSize) {
+    //                 TI i_end = (ii + blockSize > M) ? M : ii + blockSize;
+    //                 TI k_end = (kk + blockSize > K) ? K : kk + blockSize;
+    //                 TI j_end = (jj + blockSize > N) ? N : jj + blockSize;
+    //
+    //                 for (TI i = ii; i < i_end; ++i) {
+    //                     for (TI k_idx = kk; k_idx < k_end; ++k_idx) {
+    //                         T A_val = A_data[i * K + k_idx];
+    //
+    //                         // SIMD vectorization over the j loop
+    //                         TI j = jj;
+    //                         // Process 8 elements at a time using AVX
+    //                         for (; j <= j_end - 8; j += 8) {
+    //                             // Load B and C data into vectors
+    //                             __m256 B_vec = _mm256_loadu_ps(&B_data[k_idx * N + j]);
+    //                             __m256 C_vec = _mm256_loadu_ps(&C_data[i * N + j]);
+    //                             __m256 A_vec = _mm256_set1_ps(A_val); // Broadcast A_val
+    //
+    //                             // Perform fused multiply-add: C_vec += A_vec * B_vec
+    //                             C_vec = _mm256_fmadd_ps(A_vec, B_vec, C_vec);
+    //
+    //                             // Store the result back to C_data
+    //                             _mm256_storeu_ps(&C_data[i * N + j], C_vec);
+    //                         }
+    //
+    //                         // Handle remaining elements
+    //                         for (; j < j_end; ++j) {
+    //                             C_data[i * N + j] += A_val * B_data[k_idx * N + j];
+    //                         }
+    //                     }
+    //                 }
+    //             }
+    //         }
+    //     }
+    // }
+    // template<typename DEVICE_SPEC, typename INPUT_SPEC_A, typename INPUT_SPEC_B, typename OUTPUT_SPEC>
+    // void multiply_tiled_simd_ptr(devices::CPU<DEVICE_SPEC>& device, const Matrix<INPUT_SPEC_A>& A, const Matrix<INPUT_SPEC_B>& B, Matrix<OUTPUT_SPEC>& C) {
+    //     // Ensure matrix dimensions are compatible
+    //     static_assert(INPUT_SPEC_A::ROWS == OUTPUT_SPEC::ROWS, "A.rows must equal C.rows");
+    //     static_assert(INPUT_SPEC_A::COLS == INPUT_SPEC_B::ROWS, "A.cols must equal B.rows");
+    //     static_assert(INPUT_SPEC_B::COLS == OUTPUT_SPEC::COLS, "B.cols must equal C.cols");
+    //
+    //     using T = typename OUTPUT_SPEC::T;
+    //     using TI = typename DEVICE_SPEC::index_t;
+    //
+    //     constexpr TI M = INPUT_SPEC_A::ROWS;
+    //     constexpr TI N = INPUT_SPEC_B::COLS;
+    //     constexpr TI K = INPUT_SPEC_A::COLS;
+    //     constexpr TI blockSize = 32; // Adjust as needed
+    //
+    //     T* RL_TOOLS_RESTRICT A_data = A._data;
+    //     T* RL_TOOLS_RESTRICT B_data = B._data;
+    //     T* RL_TOOLS_RESTRICT C_data = C._data;
+    //
+    //     // Initialize C to zero
+    //     std::fill(C_data, C_data + M * N, static_cast<T>(0));
+    //
+    //     // Tiled matrix multiplication with SIMD intrinsics and pointer arithmetic
+    //     for (TI ii = 0; ii < M; ii += blockSize) {
+    //         for (TI kk = 0; kk < K; kk += blockSize) {
+    //             for (TI jj = 0; jj < N; jj += blockSize) {
+    //                 TI i_end = std::min(ii + blockSize, M);
+    //                 TI k_end = std::min(kk + blockSize, K);
+    //                 TI j_end = std::min(jj + blockSize, N);
+    //
+    //                 for (TI i = ii; i < i_end; ++i) {
+    //                     T* RL_TOOLS_RESTRICT C_row_ptr = C_data + i * N + jj;
+    //                     T* RL_TOOLS_RESTRICT A_row_ptr = A_data + i * K + kk;
+    //
+    //                     for (TI k_idx = kk; k_idx < k_end; ++k_idx) {
+    //                         T A_val = A_row_ptr[k_idx - kk]; // Offset within the block
+    //                         T* RL_TOOLS_RESTRICT B_row_ptr = B_data + k_idx * N + jj;
+    //
+    //                         TI j = jj;
+    //
+    //                         // SIMD vectorization over the j loop
+    //                         for (; j <= j_end - 8; j += 8) {
+    //                             __m256 A_vec = _mm256_set1_ps(A_val);
+    //                             __m256 B_vec = _mm256_loadu_ps(B_row_ptr + (j - jj));
+    //                             __m256 C_vec = _mm256_loadu_ps(C_row_ptr + (j - jj));
+    //
+    //                             C_vec = _mm256_fmadd_ps(A_vec, B_vec, C_vec);
+    //
+    //                             _mm256_storeu_ps(C_row_ptr + (j - jj), C_vec);
+    //                         }
+    //
+    //                         // Handle remaining elements
+    //                         for (; j < j_end; ++j) {
+    //                             C_row_ptr[j - jj] += A_val * B_row_ptr[j - jj];
+    //                         }
+    //                     }
+    //                 }
+    //             }
+    //         }
+    //     }
+    // }
+
+    template<typename DEVICE_SPEC, typename INPUT_SPEC_A, typename INPUT_SPEC_B, typename OUTPUT_SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void multiply(devices::CPU<DEVICE_SPEC>& device, const Matrix<INPUT_SPEC_A>& A, const Matrix<INPUT_SPEC_B>& B, Matrix<OUTPUT_SPEC>& C){
+        using DEVICE = devices::CPU<DEVICE_SPEC>;
+        using TI = typename DEVICE::index_t;
+        constexpr TI M = INPUT_SPEC_A::ROWS;
+        constexpr TI N = INPUT_SPEC_B::COLS;
+        constexpr TI K = INPUT_SPEC_A::COLS;
+        if constexpr(INPUT_SPEC_A::COL_PITCH == 1 && INPUT_SPEC_B::COL_PITCH == 1 && OUTPUT_SPEC::COL_PITCH == 1 && INPUT_SPEC_A::ROW_PITCH == INPUT_SPEC_A::COLS && INPUT_SPEC_B::ROW_PITCH == INPUT_SPEC_B::COLS && OUTPUT_SPEC::ROW_PITCH == OUTPUT_SPEC::COLS){
+            if(M <= 32 || N <= 32 || K <= 32){
+                multiply_tiled(device, A, B, C);
+            }
+            else{
+                if(M <= 64 || N <= 64 || K <= 64){
+                    multiply_tiled(device, A, B, C);
+                } else {
+                    multiply_naive(device, A, B, C);
+                }
+            }
+        }
+        else{
+            multiply_generic<false>(device, A, B, C);
+        }
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

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

@@ -0,0 +1,37 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_CONTAINERS_MATRIX_OPERATIONS_CPU_ACCELERATE_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_CONTAINERS_MATRIX_OPERATIONS_CPU_ACCELERATE_H
+
+#include <Accelerate/Accelerate.h>
+#include "matrix.h"
+#include "operations_cpu_blas.h"
+#include "../../devices/cpu_accelerate.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template<typename DEV_SPEC, typename INPUT_SPEC_A, typename INPUT_SPEC_B, typename OUTPUT_SPEC>
+    void multiply(devices::CPU_ACCELERATE<DEV_SPEC>& device, const Matrix<INPUT_SPEC_A>& A, const Matrix<INPUT_SPEC_B>& B, Matrix<OUTPUT_SPEC>& output) {
+        multiply(static_cast<devices::CPU_BLAS<DEV_SPEC>&>(device), A, B, output);
+    }
+    template<typename DEV_SPEC, typename INPUT_SPEC_A, typename INPUT_SPEC_B, typename OUTPUT_SPEC>
+    void multiply_accumulate(devices::CPU_ACCELERATE<DEV_SPEC>& device, const Matrix<INPUT_SPEC_A>& A, const Matrix<INPUT_SPEC_B>& B, Matrix<OUTPUT_SPEC>& output) {
+        multiply_accumulate(static_cast<devices::CPU_BLAS<DEV_SPEC>&>(device), A, B, output);
+    }
+    template<typename SOURCE_DEVICE_SPEC, typename TARGET_DEVICE_SPEC, typename SOURCE_SPEC, typename TARGET_SPEC>
+    void copy(devices::CPU_ACCELERATE<SOURCE_DEVICE_SPEC>& source_device, devices::CPU_ACCELERATE<TARGET_DEVICE_SPEC>& target_device, const Matrix<SOURCE_SPEC>& source, Matrix<TARGET_SPEC>& target){
+        copy(static_cast<devices::CPU_BLAS<SOURCE_DEVICE_SPEC>&>(source_device), static_cast<devices::CPU_BLAS<TARGET_DEVICE_SPEC>&>(target_device), source, target);
+    }
+    template<typename SOURCE_DEVICE_SPEC, typename TARGET_DEVICE, typename SOURCE_SPEC, typename TARGET_SPEC>
+    void copy(devices::CPU_ACCELERATE<SOURCE_DEVICE_SPEC>& source_device, TARGET_DEVICE& target_device, const Matrix<SOURCE_SPEC>& source, Matrix<TARGET_SPEC>& target){
+        copy(static_cast<devices::CPU_BLAS<SOURCE_DEVICE_SPEC>&>(source_device), target_device, source, target);
+    }
+    template<typename SOURCE_DEVICE, typename TARGET_DEVICE_SPEC, typename SOURCE_SPEC, typename TARGET_SPEC>
+    void copy(SOURCE_DEVICE& source_device, devices::CPU_ACCELERATE<TARGET_DEVICE_SPEC>& target_device, const Matrix<SOURCE_SPEC>& source, Matrix<TARGET_SPEC>& target){
+        copy(source_device, static_cast<devices::CPU_BLAS<TARGET_DEVICE_SPEC>&>(target_device), source, target);
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif
+
+#include "operations_cpu_blas.h"

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

@@ -0,0 +1,67 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_CONTAINERS_MATRIX_OPERATIONS_CPU_BLAS_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_CONTAINERS_MATRIX_OPERATIONS_CPU_BLAS_H
+
+#include "operations_cpu.h"
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    namespace containers::matrix{
+        template<bool ACCUMULATE, typename DEV_SPEC, typename INPUT_SPEC_A, typename INPUT_SPEC_B, typename OUTPUT_SPEC>
+        void multiply_blas(devices::CPU_BLAS<DEV_SPEC>& device, const Matrix<INPUT_SPEC_A>& A, const Matrix<INPUT_SPEC_B>& B, Matrix<OUTPUT_SPEC>& output) {
+            static_assert(INPUT_SPEC_A::ROWS == OUTPUT_SPEC::ROWS);
+            static_assert(INPUT_SPEC_A::COLS == INPUT_SPEC_B::ROWS);
+            static_assert(INPUT_SPEC_B::COLS == OUTPUT_SPEC::COLS);
+            static_assert(INPUT_SPEC_A::ROW_PITCH == 1 || INPUT_SPEC_A::COL_PITCH == 1); // dense row- or column-major
+            static_assert(INPUT_SPEC_B::ROW_PITCH == 1 || INPUT_SPEC_B::COL_PITCH == 1); // dense row- or column-major
+
+            using T = typename OUTPUT_SPEC::T;
+            using TI = typename DEV_SPEC::index_t;
+
+            constexpr bool A_ROW_MAJOR = INPUT_SPEC_A::ROW_PITCH >= INPUT_SPEC_A::COLS;
+            constexpr bool B_ROW_MAJOR = INPUT_SPEC_B::ROW_PITCH >= INPUT_SPEC_B::COLS;
+            constexpr auto A_TRANSPOSE = A_ROW_MAJOR ? CblasNoTrans : CblasTrans;
+            constexpr auto B_TRANSPOSE = B_ROW_MAJOR ? CblasNoTrans : CblasTrans;
+
+            constexpr TI A_PITCH = A_ROW_MAJOR ? INPUT_SPEC_A::ROW_PITCH : INPUT_SPEC_A::COL_PITCH;
+            constexpr TI B_PITCH = B_ROW_MAJOR ? INPUT_SPEC_B::ROW_PITCH : INPUT_SPEC_B::COL_PITCH;
+
+            constexpr T alpha = 1;
+            constexpr T beta = ACCUMULATE ? 1 : 0;
+            constexpr auto m = OUTPUT_SPEC::ROWS;
+            constexpr auto k = INPUT_SPEC_A::COLS;
+            constexpr auto n = OUTPUT_SPEC::COLS;
+
+            if constexpr(utils::typing::is_same_v<T, float>){
+                cblas_sgemm(CblasRowMajor, A_TRANSPOSE, B_TRANSPOSE, m, n, k, alpha, A._data, A_PITCH, B._data, B_PITCH, beta, output._data, row_pitch(output));
+            }
+            else{
+                cblas_dgemm(CblasRowMajor, A_TRANSPOSE, B_TRANSPOSE, m, n, k, alpha, A._data, A_PITCH, B._data, B_PITCH, beta, output._data, row_pitch(output));
+            }
+        }
+    }
+    template<typename DEV_SPEC, typename INPUT_SPEC_A, typename INPUT_SPEC_B, typename OUTPUT_SPEC>
+    void multiply(devices::CPU_BLAS<DEV_SPEC>& device, const Matrix<INPUT_SPEC_A>& A, const Matrix<INPUT_SPEC_B>& B, Matrix<OUTPUT_SPEC>& output){
+        containers::matrix::multiply_blas<false>(device, A, B, output);
+    }
+    template<typename DEV_SPEC, typename INPUT_SPEC_A, typename INPUT_SPEC_B, typename OUTPUT_SPEC>
+    void multiply_accumulate(devices::CPU_BLAS<DEV_SPEC>& device, const Matrix<INPUT_SPEC_A>& A, const Matrix<INPUT_SPEC_B>& B, Matrix<OUTPUT_SPEC>& output){
+        containers::matrix::multiply_blas<true>(device, A, B, output);
+    }
+    template<typename SOURCE_DEVICE_SPEC, typename TARGET_DEVICE_SPEC, typename SOURCE_SPEC, typename TARGET_SPEC>
+    void copy(devices::CPU_BLAS<SOURCE_DEVICE_SPEC>& source_device, devices::CPU_BLAS<TARGET_DEVICE_SPEC>& target_device, const Matrix<SOURCE_SPEC>& source, Matrix<TARGET_SPEC>& target){
+        copy(static_cast<devices::CPU<SOURCE_DEVICE_SPEC>&>(source_device), static_cast<devices::CPU<TARGET_DEVICE_SPEC>&>(target_device), source, target);
+    }
+    template<typename SOURCE_DEVICE_SPEC, typename TARGET_DEVICE, typename SOURCE_SPEC, typename TARGET_SPEC>
+    void copy(devices::CPU_BLAS<SOURCE_DEVICE_SPEC>& source_device, TARGET_DEVICE& target_device, const Matrix<SOURCE_SPEC>& source, Matrix<TARGET_SPEC>& target){
+        copy(static_cast<devices::CPU<SOURCE_DEVICE_SPEC>&>(source_device), target_device, source, target);
+    }
+    template<typename SOURCE_DEVICE, typename TARGET_DEVICE_SPEC, typename SOURCE_SPEC, typename TARGET_SPEC>
+    void copy(SOURCE_DEVICE& source_device, devices::CPU_BLAS<TARGET_DEVICE_SPEC>& target_device, const Matrix<SOURCE_SPEC>& source, Matrix<TARGET_SPEC>& target){
+        copy(source_device, static_cast<devices::CPU<TARGET_DEVICE_SPEC>&>(target_device), source, target);
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+
+#endif

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

@@ -0,0 +1,38 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_CONTAINERS_MATRIX_OPERATIONS_CPU_MKL_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_CONTAINERS_MATRIX_OPERATIONS_CPU_MKL_H
+
+#include "matrix.h"
+#include "operations_cpu_blas.h"
+#include "../../devices/cpu_mkl.h"
+
+#include <mkl.h>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template<typename DEV_SPEC, typename INPUT_SPEC_A, typename INPUT_SPEC_B, typename OUTPUT_SPEC>
+    void multiply(devices::CPU_MKL<DEV_SPEC>& device, const Matrix<INPUT_SPEC_A>& A, const Matrix<INPUT_SPEC_B>& B, Matrix<OUTPUT_SPEC>& output) {
+        multiply(static_cast<devices::CPU_BLAS<DEV_SPEC>&>(device), A, B, output);
+    }
+    template<typename DEV_SPEC, typename INPUT_SPEC_A, typename INPUT_SPEC_B, typename OUTPUT_SPEC>
+    void multiply_accumulate(devices::CPU_MKL<DEV_SPEC>& device, const Matrix<INPUT_SPEC_A>& A, const Matrix<INPUT_SPEC_B>& B, Matrix<OUTPUT_SPEC>& output) {
+        multiply_accumulate(static_cast<devices::CPU_BLAS<DEV_SPEC>&>(device), A, B, output);
+    }
+    template<typename SOURCE_DEVICE_SPEC, typename TARGET_DEVICE_SPEC, typename SOURCE_SPEC, typename TARGET_SPEC>
+    void copy(devices::CPU_MKL<SOURCE_DEVICE_SPEC>& source_device, devices::CPU_MKL<TARGET_DEVICE_SPEC>& target_device, const Matrix<SOURCE_SPEC>& source, Matrix<TARGET_SPEC>& target){
+        copy(static_cast<devices::CPU_BLAS<SOURCE_DEVICE_SPEC>&>(source_device), static_cast<devices::CPU_BLAS<TARGET_DEVICE_SPEC>&>(target_device), source, target);
+    }
+    template<typename SOURCE_DEVICE_SPEC, typename TARGET_DEVICE, typename SOURCE_SPEC, typename TARGET_SPEC>
+    void copy(devices::CPU_MKL<SOURCE_DEVICE_SPEC>& source_device, TARGET_DEVICE& target_device, const Matrix<SOURCE_SPEC>& source, Matrix<TARGET_SPEC>& target){
+        copy(static_cast<devices::CPU_BLAS<SOURCE_DEVICE_SPEC>&>(source_device), target_device, source, target);
+    }
+    template<typename SOURCE_DEVICE, typename TARGET_DEVICE_SPEC, typename SOURCE_SPEC, typename TARGET_SPEC>
+    void copy(SOURCE_DEVICE& source_device, devices::CPU_MKL<TARGET_DEVICE_SPEC>& target_device, const Matrix<SOURCE_SPEC>& source, Matrix<TARGET_SPEC>& target){
+        copy(source_device, static_cast<devices::CPU_BLAS<TARGET_DEVICE_SPEC>&>(target_device), source, target);
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif
+
+#include "operations_cpu_blas.h"