hyperray 0.0.1__py3-none-any.whl

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

@@ -0,0 +1,13 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_CONTAINERS_MATRIX_OPERATIONS_WASM32_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_CONTAINERS_MATRIX_OPERATIONS_WASM32_H
+
+#include "operations_generic.h"
+
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

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

@@ -0,0 +1,136 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_CONTAINERS_MATRIX_PERSIST_CODE_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_CONTAINERS_MATRIX_PERSIST_CODE_H
+
+#include "../../persist/code.h"
+#include "../../utils/generic/typing.h"
+#include <sstream>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    namespace containers::persist{
+        using STORAGE_TYPE = unsigned char;
+        static_assert(sizeof(STORAGE_TYPE) == 1);
+        constexpr auto INDEX_TYPE = "unsigned int";
+        template <typename T>
+        auto get_type_string(){
+            static_assert(utils::typing::is_same_v<T, float> || utils::typing::is_same_v<T, double>
+#if defined(RL_TOOLS_NUMERIC_TYPES_ENABLE_BF16)
+                || utils::typing::is_same_v<T, numeric_types::bf16>
+#endif
+                || utils::typing::is_same_v<T, int> || utils::typing::is_same_v<T, unsigned int> || utils::typing::is_same_v<T, long> || utils::typing::is_same_v<T, unsigned long> || utils::typing::is_same_v<T, long long> || utils::typing::is_same_v<T, unsigned long long> || utils::typing::is_same_v<T, char> || utils::typing::is_same_v<T, unsigned char> || utils::typing::is_same_v<T, short> || utils::typing::is_same_v<T, unsigned short>);
+            if constexpr(std::is_same_v<T, float>){
+                return "float";
+            } else if constexpr(std::is_same_v<T, double>){
+                return "double";
+#if defined(RL_TOOLS_NUMERIC_TYPES_ENABLE_BF16)
+            } else if constexpr(std::is_same_v<T, numeric_types::bf16>){
+                return "numeric_types::bf16";
+#endif
+            } else if constexpr(std::is_same_v<T, int>){
+                return "int";
+            } else if constexpr(std::is_same_v<T, unsigned int>){
+                return "unsigned int";
+            } else if constexpr(std::is_same_v<T, long>){
+                return "long";
+            } else if constexpr(std::is_same_v<T, unsigned long>){
+                return "unsigned long";
+            } else if constexpr(std::is_same_v<T, long long>){
+                return "long long";
+            } else if constexpr(std::is_same_v<T, unsigned long long>){
+                return "unsigned long long";
+            } else if constexpr(std::is_same_v<T, char>){
+                return "char";
+            } else if constexpr(std::is_same_v<T, unsigned char>){
+                return "unsigned char";
+            } else if constexpr(std::is_same_v<T, short>){
+                return "short";
+            } else if constexpr(std::is_same_v<T, unsigned short>){
+                return "unsigned short";
+            } else {
+                return "Unsupported type";
+            }
+        }
+    }
+    template<typename DEVICE, typename SPEC>
+    persist::Code save_code_split(DEVICE& device, Matrix<SPEC>& m, 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/matrix/matrix.h>\n";
+        std::stringstream ss;
+        ss << ind << "namespace " << name << " {\n";
+        ss << ind << "    " << (const_declaration ? "constexpr " : "") << containers::persist::get_type_string<T>() << " memory[] = {";
+        bool first = true;
+        std::stringstream data_ss;
+        data_ss << std::uppercase << std::hexfloat;
+        for(TI i=0; i < SPEC::ROWS; i++){
+            for(TI j=0; j < 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 CONTAINER_SPEC = RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::matrix::Specification<" << containers::persist::get_type_string<T>() << ", " << containers::persist::get_type_string<TI>() << ", " << SPEC::ROWS << ", " << SPEC::COLS << ", " << (SPEC::DYNAMIC_ALLOCATION ? "true" : "false") << ", " << "RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::matrix::layouts::RowMajorAlignment<" << containers::persist::get_type_string<TI>() << ", " << 1 << ">, true>;\n";
+        ss << ind << "    using CONTAINER_TYPE = RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::Matrix<CONTAINER_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, Matrix<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, Matrix<SPEC>& m){
+        using T = typename SPEC::T;
+        using TI = typename DEVICE::index_t;
+        std::string data;
+        data += "[";
+        for(TI i=0; i < SPEC::ROWS; i++){
+            if(i > 0){
+                data += ", ";
+            }
+            data += "[";
+            for(TI j=0; j < SPEC::COLS; j++){
+                if(j > 0){
+                    data += ", ";
+                }
+                T value = get(m, i, j);
+                if (math::is_nan(device.math, value)) {
+                    data += "null";
+                }
+                else{
+                    data += std::to_string(value);
+                }
+            }
+            data += "]";
+        }
+        data += "]";
+        return data;
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

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

@@ -0,0 +1 @@
+#include "operations_generic.h"

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

@@ -0,0 +1,94 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_CONTAINERS_TENSOR_OPERATIONS_CPU_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_CONTAINERS_TENSOR_OPERATIONS_CPU_H
+
+#include "tensor.h"
+#include "operations_generic.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template<typename DEV_SPEC, typename SPEC>
+    void print(devices::CPU<DEV_SPEC>& device, const Tensor<SPEC>& tensor, bool python_literal=false, typename DEV_SPEC::index_t level=0){
+        using TI = typename DEV_SPEC::index_t;
+        using T = typename SPEC::T;
+        if constexpr(length(typename SPEC::SHAPE{}) == 1){
+            std::cout << (python_literal ? "[" : "");
+            for(TI i=0; i < get<0>(typename SPEC::SHAPE{}); i++){
+                std::cout << get(device, tensor, i) << " " << (python_literal ? "," : "");
+            }
+            std::cout << (python_literal ? "]" : "");
+            std::cout << std::endl;
+        }
+        else{
+            if constexpr(length(typename SPEC::SHAPE{}) == 2){
+                if(python_literal){
+                    std::cout << "[" << std::endl;
+                }
+                for(TI i=0; i < get<0>(typename SPEC::SHAPE{}); i++){
+                    std::cout << (python_literal ? "[" : "");
+                    for(TI j=0; j < get<1>(typename SPEC::SHAPE{}); j++){
+                        T number = get(device, tensor, i, j);
+                        std::cout <<  std::setw(15) << std::scientific << std::setprecision(6);
+                        if constexpr (utils::typing::is_same_v<T, float> || utils::typing::is_same_v<T, double>){
+                            std::cout << number;
+                        }
+                        else{
+                            std::cout << (float)number;
+                        }
+                        if(python_literal){
+                            std::cout << ", ";
+                        }
+                    }
+                    std::cout << (python_literal ? "]," : "");
+                    std::cout << std::endl;
+                }
+                std::cout << (python_literal ? "]" : "") << std::endl;
+            }
+            else{
+                for(TI i=0; i < get<0>(typename SPEC::SHAPE{}); i++){
+                    for(TI j=0; j < level; j++){
+                        std::cout << " ";
+                    }
+                    std::cout << "dim[" << level << "] = " << i << ": " << std::endl;
+                    auto v = view(device, tensor, i);
+                    print(device, v, python_literal, level+1);
+                }
+            }
+        }
+    }
+    template<typename DEV_SPEC, typename TI, TI... VALUES>
+    void print(devices::CPU<DEV_SPEC>& device, tensor::Tuple<TI, VALUES...>, typename DEV_SPEC::index_t level=0, bool python_literal=false){
+        (void)device;
+        (void)python_literal;
+        (void)level;
+        if(level == 0){
+            std::cout << "[";
+        }
+        constexpr TI values[] = {VALUES...};
+        for(TI i = 0; i < static_cast<TI>(sizeof...(VALUES)); ++i){
+            if(i > 0){
+                std::cout << ", ";
+            }
+            std::cout << values[i];
+        }
+        std::cout << "]";
+        if(level == 0){
+            std::cout << std::endl;
+        }
+    }
+    template<typename DEV_SPEC, typename SPEC>
+    void print_serial(devices::CPU<DEV_SPEC>& device, const Tensor<SPEC>& tensor, bool print_index = false){
+        using T = typename SPEC::T;
+        T* data_pointer = data(tensor);
+        for(typename DEV_SPEC::index_t i=0; i < SPEC::SIZE; i++){
+            if(print_index){
+                std::cout << i << ": ";
+            }
+            std::cout << data_pointer[i] << std::endl;
+        }
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

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

@@ -0,0 +1,25 @@
+
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_CONTAINERS_TENSOR_OPERATIONS_ACCELERATE_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_CONTAINERS_TENSOR_OPERATIONS_ACCELERATE_H
+
+#include "tensor.h"
+#include "operations_cpu.h"
+#include "operations_cpu_blas.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template<typename DEV_SPEC, typename SPEC_1, typename SPEC_2, typename SPEC_OUT>
+    void matrix_multiply(devices::CPU_ACCELERATE<DEV_SPEC>& device, Tensor<SPEC_1>& t1, Tensor<SPEC_2>& t2, Tensor<SPEC_OUT>& result){
+        matrix_multiply(static_cast<devices::CPU_BLAS<DEV_SPEC>&>(device), t1, t2, result);
+    }
+    template<typename DEV_SPEC, typename SPEC_1, typename SPEC_2, typename SPEC_OUT>
+    void matrix_multiply_accumulate(devices::CPU_ACCELERATE<DEV_SPEC>& device, const Tensor<SPEC_1>& t1, const Tensor<SPEC_2>& t2, Tensor<SPEC_OUT>& result){
+        matrix_multiply_accumulate(static_cast<devices::CPU_BLAS<DEV_SPEC>&>(device), t1, t2, result);
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+
+#endif

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

@@ -0,0 +1,115 @@
+
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_CONTAINERS_TENSOR_OPERATIONS_BLAS_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_CONTAINERS_TENSOR_OPERATIONS_BLAS_H
+
+#include "tensor.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template<typename DEV_SPEC, typename SPEC_1, typename SPEC_2, typename SPEC_OUT>
+    void matrix_multiply(devices::CPU_BLAS<DEV_SPEC>& device, Tensor<SPEC_1>& t1, Tensor<SPEC_2>& t2, Tensor<SPEC_OUT>& result){
+#ifdef RL_TOOLS_ENABLE_TRACY
+        ZoneScoped;
+#endif
+        using DEVICE = devices::CPU_BLAS<DEV_SPEC>;
+        static_assert(length(typename SPEC_1::SHAPE{}) == 2);
+        static_assert(length(typename SPEC_2::SHAPE{}) == 2);
+        static_assert(length(typename SPEC_OUT::SHAPE{}) == 2);
+        static_assert(get<1>(typename SPEC_1::SHAPE{}) == get<0>(typename SPEC_2::SHAPE{}));
+        static_assert(get<0>(typename SPEC_1::SHAPE{}) == get<0>(typename SPEC_OUT::SHAPE{}));
+        static_assert(get<1>(typename SPEC_2::SHAPE{}) == get<1>(typename SPEC_OUT::SHAPE{}));
+        static_assert(tensor::dense_row_major_layout<SPEC_1>());
+        static_assert(tensor::dense_row_major_layout<SPEC_2>());
+        static_assert(tensor::dense_row_major_layout<SPEC_OUT>());
+        using T = typename SPEC_1::T;
+        using TI = typename DEVICE::index_t;
+
+        const TI M = get<0>(typename SPEC_1::SHAPE{});
+        const TI N = get<1>(typename SPEC_2::SHAPE{});
+        const TI K = get<1>(typename SPEC_1::SHAPE{});
+
+        // This operation can also handle transposed/column major matrices
+        CBLAS_TRANSPOSE transA = (get<0>(typename SPEC_1::STRIDE{}) < get<1>(typename SPEC_1::STRIDE{})) ? CblasTrans : CblasNoTrans;
+        CBLAS_TRANSPOSE transB = (get<0>(typename SPEC_2::STRIDE{}) < get<1>(typename SPEC_2::STRIDE{})) ? CblasTrans : CblasNoTrans;
+
+        const TI lda = (transA == CblasNoTrans) ? get<0>(typename SPEC_1::STRIDE{}) : get<1>(typename SPEC_1::STRIDE{});
+        const TI ldb = (transB == CblasNoTrans) ? get<0>(typename SPEC_2::STRIDE{}) : get<1>(typename SPEC_2::STRIDE{});
+        const TI ldc = get<0>(typename SPEC_OUT::STRIDE{});
+
+        const T alpha = 1.0;
+        const T beta = 0.0;
+
+        static_assert(utils::typing::is_same_v<T, float> || utils::typing::is_same_v<T, double>, "CPU BLAS Tensor: matrix_multiply: Only float and double are supported for now");
+        if constexpr(utils::typing::is_same_v<T, float>) {
+            cblas_sgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, M, N, K, alpha, t1._data, lda, t2._data, ldb, beta, result._data, ldc);
+        }
+        else{
+            cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, M, N, K, alpha, t1._data, lda, t2._data, ldb, beta, result._data, ldc);
+        }
+    }
+    template<typename DEV_SPEC, typename SPEC_1, typename SPEC_2, typename SPEC_OUT>
+    void matrix_multiply_accumulate(devices::CPU_BLAS<DEV_SPEC>& device, const Tensor<SPEC_1>& t1, const Tensor<SPEC_2>& t2, Tensor<SPEC_OUT>& result){
+#ifdef RL_TOOLS_ENABLE_TRACY
+        ZoneScoped; //N("tensor::matrix_multiply_accumulate");
+#endif
+        using DEVICE = devices::CPU_BLAS<DEV_SPEC>;
+        static_assert(length(typename SPEC_1::SHAPE{}) == 2);
+        static_assert(length(typename SPEC_2::SHAPE{}) == 2);
+        static_assert(length(typename SPEC_OUT::SHAPE{}) == 2);
+        static_assert(get<1>(typename SPEC_1::SHAPE{}) == get<0>(typename SPEC_2::SHAPE{}));
+        static_assert(get<0>(typename SPEC_1::SHAPE{}) == get<0>(typename SPEC_OUT::SHAPE{}));
+        static_assert(get<1>(typename SPEC_2::SHAPE{}) == get<1>(typename SPEC_OUT::SHAPE{}));
+        static_assert(get<0>(typename SPEC_1::STRIDE{}) == 1 || get<1>(typename SPEC_1::STRIDE{}) == 1);
+        static_assert(get<0>(typename SPEC_2::STRIDE{}) == 1 || get<1>(typename SPEC_2::STRIDE{}) == 1);
+        using T = typename SPEC_1::T;
+        using TI = typename DEVICE::index_t;
+        const TI M = get<0>(typename SPEC_1::SHAPE{});
+        const TI N = get<1>(typename SPEC_2::SHAPE{});
+        const TI K = get<1>(typename SPEC_1::SHAPE{});
+
+        // This operation can also handle transposed/column major matrices
+
+        CBLAS_TRANSPOSE transA = tensor::generalized_row_major<typename SPEC_1::SHAPE, typename SPEC_1::STRIDE>() ? CblasNoTrans : CblasTrans;
+        CBLAS_TRANSPOSE transB = tensor::generalized_row_major<typename SPEC_2::SHAPE, typename SPEC_2::STRIDE>() ? CblasNoTrans : CblasTrans;
+
+        const TI lda = (transA == CblasNoTrans) ? get<0>(typename SPEC_1::STRIDE{}) : get<1>(typename SPEC_1::STRIDE{});
+        const TI ldb = (transB == CblasNoTrans) ? get<0>(typename SPEC_2::STRIDE{}) : get<1>(typename SPEC_2::STRIDE{});
+        const TI ldc = get<0>(typename SPEC_OUT::STRIDE{});
+
+        const T alpha = 1.0;
+        const T beta = 1.0;  // We're accumulating, hence beta is 1.0
+//
+//        std::cout << "Shape: " << std::endl;
+//        print(device, typename SPEC_1::SHAPE{});
+//        std::cout << std::endl;
+//        print(device, typename SPEC_2::SHAPE{});
+//        std::cout << std::endl;
+//        std::cout << "Stride: " << std::endl;
+//        print(device, typename SPEC_1::STRIDE{});
+//        std::cout << std::endl;
+//        print(device, typename SPEC_2::STRIDE{});
+//        std::cout << std::endl;
+        static_assert(utils::typing::is_same_v<T, float> || utils::typing::is_same_v<T, double>, "CPU BLAS Tensor: matrix_multiply: Only float and double are supported for now");
+        if constexpr(utils::typing::is_same_v<T, float>){
+            cblas_sgemm(CblasRowMajor, transA, transB, M, N, K, alpha, t1._data, lda, t2._data, ldb, beta, result._data, ldc);
+        }
+        else{
+            cblas_dgemm(CblasRowMajor, transA, transB, M, N, K, alpha, t1._data, lda, t2._data, ldb, beta, result._data, ldc);
+        }
+    }
+//        for(TI row_i=0; row_i < get<0>(typename SPEC_1::SHAPE{}); ++row_i){
+//            for(TI col_j=0; col_j < get<1>(typename SPEC_2::SHAPE{}); ++col_j){
+//                T acc = get(device, result, row_i, col_j);
+//                for(TI k=0; k < get<1>(typename SPEC_1::SHAPE{}); ++k){
+//                    acc += get(device, t1, row_i, k) * get(device, t2, k, col_j);
+//                }
+//                set(device, result, acc, row_i, col_j);
+//            }
+//        }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+
+#endif

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

@@ -0,0 +1,25 @@
+
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_CONTAINERS_TENSOR_OPERATIONS_MKL_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_CONTAINERS_TENSOR_OPERATIONS_MKL_H
+
+#include "tensor.h"
+#include "operations_cpu.h"
+#include "operations_cpu_blas.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template<typename DEV_SPEC, typename SPEC_1, typename SPEC_2, typename SPEC_OUT>
+    void matrix_multiply(devices::CPU_MKL<DEV_SPEC>& device, Tensor<SPEC_1>& t1, Tensor<SPEC_2>& t2, Tensor<SPEC_OUT>& result){
+        matrix_multiply(static_cast<devices::CPU_BLAS<DEV_SPEC>&>(device), t1, t2, result);
+    }
+    template<typename DEV_SPEC, typename SPEC_1, typename SPEC_2, typename SPEC_OUT>
+    void matrix_multiply_accumulate(devices::CPU_MKL<DEV_SPEC>& device, const Tensor<SPEC_1>& t1, const Tensor<SPEC_2>& t2, Tensor<SPEC_OUT>& result){
+        matrix_multiply_accumulate(static_cast<devices::CPU_BLAS<DEV_SPEC>&>(device), t1, t2, result);
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+
+#endif

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

@@ -0,0 +1,25 @@
+
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_CONTAINERS_TENSOR_OPERATIONS_OPENBLAS_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_CONTAINERS_TENSOR_OPERATIONS_OPENBLAS_H
+
+#include "tensor.h"
+#include "operations_cpu.h"
+#include "operations_cpu_blas.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template<typename DEV_SPEC, typename SPEC_1, typename SPEC_2, typename SPEC_OUT>
+    void matrix_multiply(devices::CPU_OPENBLAS<DEV_SPEC>& device, Tensor<SPEC_1>& t1, Tensor<SPEC_2>& t2, Tensor<SPEC_OUT>& result){
+        matrix_multiply(static_cast<devices::CPU_BLAS<DEV_SPEC>&>(device), t1, t2, result);
+    }
+    template<typename DEV_SPEC, typename SPEC_1, typename SPEC_2, typename SPEC_OUT>
+    void matrix_multiply_accumulate(devices::CPU_OPENBLAS<DEV_SPEC>& device, const Tensor<SPEC_1>& t1, const Tensor<SPEC_2>& t2, Tensor<SPEC_OUT>& result){
+        matrix_multiply_accumulate(static_cast<devices::CPU_BLAS<DEV_SPEC>&>(device), t1, t2, result);
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+
+#endif