autogen.h

Go to the documentation of this file.

#pragma once
 
#include <mim/axm.h>
#include <mim/plugin.h>
 
/// @namespace mim::plug::matrix @ref matrix 
namespace mim {
namespace plug::matrix {
 
static constexpr plugin_t Plugin_Id = 0x3825532990000000;
 
/// @name %%matrix.Mat
///@{
enum class Mat : flags_t {
};
 
///@}
 
/// @name %%matrix.shape
///@{
enum class shape : flags_t {
};
 
const Def* normalize_shape(const Def*, const Def*, const Def*);
///@}
 
/// @name %%matrix.constMat
///@{
enum class constMat : flags_t {
};
 
///@}
 
/// @name %%matrix.read
///@{
enum class read : flags_t {
};
 
const Def* normalize_read(const Def*, const Def*, const Def*);
///@}
 
/// @name %%matrix.insert
///@{
enum class insert : flags_t {
};
 
const Def* normalize_insert(const Def*, const Def*, const Def*);
///@}
 
/// @name %%matrix.init
///@{
enum class init : flags_t {
};
 
///@}
 
/// @name %%matrix.prod
///@{
enum class prod : flags_t {
};
 
const Def* normalize_prod(const Def*, const Def*, const Def*);
///@}
 
/// @name %%matrix.transpose
///@{
enum class transpose : flags_t {
};
 
const Def* normalize_transpose(const Def*, const Def*, const Def*);
///@}
 
/// @name %%matrix.sum
///@{
enum class sum : flags_t {
};
 
///@}
 
/// @name %%matrix.map_reduce
///@{
enum class map_reduce : flags_t {
};
 
const Def* normalize_map_reduce(const Def*, const Def*, const Def*);
///@}
 
/// @name %%matrix.mapRed_prod
///@{
enum class mapRed_prod : flags_t {
};
 
///@}
 
/// @name %%matrix.mapRed_transpose
///@{
enum class mapRed_transpose : flags_t {
};
 
///@}
 
/// @name %%matrix.mapRed_sum
///@{
enum class mapRed_sum : flags_t {
};
 
///@}
 
/// @name %%matrix.lower_matrix_high_level_map_reduce
///@{
enum class lower_matrix_high_level_map_reduce : flags_t {
};
 
///@}
 
/// @name %%matrix.lower_matrix_medium_level
///@{
enum class lower_matrix_medium_level : flags_t {
};
 
///@}
 
/// @name %%matrix.lower_matrix_low_level
///@{
enum class lower_matrix_low_level : flags_t {
};
 
///@}
 
void register_normalizers(Normalizers& normalizers);
 
#define MIM_matrix_NORMALIZER_IMPL \
    void register_normalizers(Normalizers& normalizers) {\
        normalizers[flags_t(Annex::Base<shape>)] = &normalize_shape; \
        normalizers[flags_t(Annex::Base<read>)] = &normalize_read; \
        normalizers[flags_t(Annex::Base<insert>)] = &normalize_insert; \
        normalizers[flags_t(Annex::Base<prod>)] = &normalize_prod; \
        normalizers[flags_t(Annex::Base<transpose>)] = &normalize_transpose; \
        normalizers[flags_t(Annex::Base<map_reduce>)] = &normalize_map_reduce; \
    }
} // namespace plug::matrix
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
template<> constexpr flags_t Annex::Base<plug::matrix::Mat> = 0x3825532990000000;
template<> constexpr size_t Annex::Num<plug::matrix::Mat> = 0;
template<> constexpr flags_t Annex::Base<plug::matrix::shape> = 0x3825532990000100;
template<> constexpr size_t Annex::Num<plug::matrix::shape> = 0;
template<> constexpr flags_t Annex::Base<plug::matrix::constMat> = 0x3825532990000200;
template<> constexpr size_t Annex::Num<plug::matrix::constMat> = 0;
template<> constexpr flags_t Annex::Base<plug::matrix::read> = 0x3825532990000300;
template<> constexpr size_t Annex::Num<plug::matrix::read> = 0;
template<> constexpr flags_t Annex::Base<plug::matrix::insert> = 0x3825532990000400;
template<> constexpr size_t Annex::Num<plug::matrix::insert> = 0;
template<> constexpr flags_t Annex::Base<plug::matrix::init> = 0x3825532990000500;
template<> constexpr size_t Annex::Num<plug::matrix::init> = 0;
template<> constexpr flags_t Annex::Base<plug::matrix::prod> = 0x3825532990000600;
template<> constexpr size_t Annex::Num<plug::matrix::prod> = 0;
template<> constexpr flags_t Annex::Base<plug::matrix::transpose> = 0x3825532990000700;
template<> constexpr size_t Annex::Num<plug::matrix::transpose> = 0;
template<> constexpr flags_t Annex::Base<plug::matrix::sum> = 0x3825532990000800;
template<> constexpr size_t Annex::Num<plug::matrix::sum> = 0;
template<> constexpr flags_t Annex::Base<plug::matrix::map_reduce> = 0x3825532990000900;
template<> constexpr size_t Annex::Num<plug::matrix::map_reduce> = 0;
template<> constexpr flags_t Annex::Base<plug::matrix::mapRed_prod> = 0x3825532990000a00;
template<> constexpr size_t Annex::Num<plug::matrix::mapRed_prod> = 0;
template<> constexpr flags_t Annex::Base<plug::matrix::mapRed_transpose> = 0x3825532990000b00;
template<> constexpr size_t Annex::Num<plug::matrix::mapRed_transpose> = 0;
template<> constexpr flags_t Annex::Base<plug::matrix::mapRed_sum> = 0x3825532990000c00;
template<> constexpr size_t Annex::Num<plug::matrix::mapRed_sum> = 0;
template<> constexpr flags_t Annex::Base<plug::matrix::lower_matrix_high_level_map_reduce> = 0x3825532990000d00;
template<> constexpr size_t Annex::Num<plug::matrix::lower_matrix_high_level_map_reduce> = 0;
template<> constexpr flags_t Annex::Base<plug::matrix::lower_matrix_medium_level> = 0x3825532990000e00;
template<> constexpr size_t Annex::Num<plug::matrix::lower_matrix_medium_level> = 0;
template<> constexpr flags_t Annex::Base<plug::matrix::lower_matrix_low_level> = 0x3825532990000f00;
template<> constexpr size_t Annex::Num<plug::matrix::lower_matrix_low_level> = 0;
 
template<> struct Axm::IsANode<plug::matrix::mapRed_prod> { using type = Axm; };
template<> struct Axm::IsANode<plug::matrix::mapRed_transpose> { using type = Axm; };
template<> struct Axm::IsANode<plug::matrix::mapRed_sum> { using type = Axm; };
template<> struct Axm::IsANode<plug::matrix::lower_matrix_high_level_map_reduce> { using type = Axm; };
template<> struct Axm::IsANode<plug::matrix::lower_matrix_medium_level> { using type = Axm; };
template<> struct Axm::IsANode<plug::matrix::lower_matrix_low_level> { using type = Axm; };
 
#endif
} // namespace mim
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
 
#endif