autogen.h

Go to the documentation of this file.

#pragma once
 
#include <mim/axiom.h>
#include <mim/plugin.h>
 
/// @namespace mim::plug::math @ref math 
namespace mim {
namespace plug::math {
 
static constexpr plugin_t Plugin_Id = 0x3825490000000000;
 
/// @name %%math.F
///@{
enum class F : flags_t {
};
enum class F : flags_t {…};
 
///@}
 
/// @name %%math.f16
///@{
enum class f16 : flags_t {
};
enum class f16 : flags_t {…};
 
///@}
 
/// @name %%math.f32
///@{
enum class f32 : flags_t {
};
enum class f32 : flags_t {…};
 
///@}
 
/// @name %%math.f64
///@{
enum class f64 : flags_t {
};
enum class f64 : flags_t {…};
 
///@}
 
/// @name %%math.bf16
///@{
enum class bf16 : flags_t {
};
enum class bf16 : flags_t {…};
 
///@}
 
/// @name %%math.nvtf32
///@{
enum class nvtf32 : flags_t {
};
enum class nvtf32 : flags_t {…};
 
///@}
 
/// @name %%math.amdfp24
///@{
enum class amdfp24 : flags_t {
};
enum class amdfp24 : flags_t {…};
 
///@}
 
/// @name %%math.pxr24
///@{
enum class pxr24 : flags_t {
};
enum class pxr24 : flags_t {…};
 
///@}
 
/// @name %%math.F16
///@{
enum class F16 : flags_t {
};
enum class F16 : flags_t {…};
 
///@}
 
/// @name %%math.F32
///@{
enum class F32 : flags_t {
};
enum class F32 : flags_t {…};
 
///@}
 
/// @name %%math.F64
///@{
enum class F64 : flags_t {
};
enum class F64 : flags_t {…};
 
///@}
 
/// @name %%math.BF16
///@{
enum class BF16 : flags_t {
};
enum class BF16 : flags_t {…};
 
///@}
 
/// @name %%math.NVTF32
///@{
enum class NVTF32 : flags_t {
};
enum class NVTF32 : flags_t {…};
 
///@}
 
/// @name %%math.AMDFP24
///@{
enum class AMDFP24 : flags_t {
};
enum class AMDFP24 : flags_t {…};
 
///@}
 
/// @name %%math.PXR24
///@{
enum class PXR24 : flags_t {
};
enum class PXR24 : flags_t {…};
 
///@}
 
/// @name %%math.arith
///@{
enum class arith : flags_t {
    add = 0x3825490000000f00,
    sub = 0x3825490000000f01,
    mul = 0x3825490000000f02,
    div = 0x3825490000000f03,
    rem = 0x3825490000000f04,
};
enum class arith : flags_t {…};
 
template<arith>
const Def* normalize_arith(const Def*, const Def*, const Def*);
 
///@}
 
/// @name %%math.minus
///@{
enum class minus : flags_t {
};
enum class minus : flags_t {…};
 
///@}
 
/// @name %%math.extrema
///@{
enum class extrema : flags_t {
    im = 0x3825490000001100,
    fmin = im,
    iM = 0x3825490000001101,
    fmax = iM,
    Im = 0x3825490000001102,
    ieee754min = Im,
    IM = 0x3825490000001103,
    ieee754max = IM,
};
enum class extrema : flags_t {…};
 
template<extrema>
const Def* normalize_extrema(const Def*, const Def*, const Def*);
 
///@}
 
/// @name %%math.tri
///@{
enum class tri : flags_t {
    ahff = 0x3825490000001200,
    sin = ahff,
    ahfF = 0x3825490000001201,
    cos = ahfF,
    ahFf = 0x3825490000001202,
    tan = ahFf,
    ahFF = 0x3825490000001203,
    aHff = 0x3825490000001204,
    sinh = aHff,
    h = aHff,
    aHfF = 0x3825490000001205,
    cosh = aHfF,
    aHFf = 0x3825490000001206,
    tanh = aHFf,
    aHFF = 0x3825490000001207,
    Ahff = 0x3825490000001208,
    asin = Ahff,
    a = Ahff,
    AhfF = 0x3825490000001209,
    acos = AhfF,
    AhFf = 0x382549000000120a,
    atan = AhFf,
    AhFF = 0x382549000000120b,
    AHff = 0x382549000000120c,
    asinh = AHff,
    AHfF = 0x382549000000120d,
    acosh = AHfF,
    AHFf = 0x382549000000120e,
    atanh = AHFf,
    AHFF = 0x382549000000120f,
};
enum class tri : flags_t {…};
 
template<tri>
const Def* normalize_tri(const Def*, const Def*, const Def*);
 
///@}
 
/// @name %%math.pow
///@{
enum class pow : flags_t {
};
enum class pow : flags_t {…};
 
const Def* normalize_pow(const Def*, const Def*, const Def*);
///@}
 
/// @name %%math.rt
///@{
enum class rt : flags_t {
    sq = 0x3825490000001400,
    cb = 0x3825490000001401,
};
enum class rt : flags_t {…};
 
template<rt>
const Def* normalize_rt(const Def*, const Def*, const Def*);
 
///@}
 
/// @name %%math.exp
///@{
enum class exp : flags_t {
    lbb = 0x3825490000001500,
    exp = lbb,
    lbB = 0x3825490000001501,
    exp2 = lbB,
    bin = lbB,
    lBb = 0x3825490000001502,
    exp10 = lBb,
    dec = lBb,
    lBB = 0x3825490000001503,
    Lbb = 0x3825490000001504,
    log = Lbb,
    LbB = 0x3825490000001505,
    log2 = LbB,
    LBb = 0x3825490000001506,
    log10 = LBb,
    LBB = 0x3825490000001507,
};
enum class exp : flags_t {…};
 
template<exp>
const Def* normalize_exp(const Def*, const Def*, const Def*);
 
///@}
 
/// @name %%math.er
///@{
enum class er : flags_t {
    f = 0x3825490000001600,
    fc = 0x3825490000001601,
};
enum class er : flags_t {…};
 
template<er>
const Def* normalize_er(const Def*, const Def*, const Def*);
 
///@}
 
/// @name %%math.gamma
///@{
enum class gamma : flags_t {
    t = 0x3825490000001700,
    l = 0x3825490000001701,
};
enum class gamma : flags_t {…};
 
template<gamma>
const Def* normalize_gamma(const Def*, const Def*, const Def*);
 
///@}
 
/// @name %%math.abs
///@{
enum class abs : flags_t {
};
enum class abs : flags_t {…};
 
const Def* normalize_abs(const Def*, const Def*, const Def*);
///@}
 
/// @name %%math.round
///@{
enum class round : flags_t {
    f = 0x3825490000001900,
    c = 0x3825490000001901,
    r = 0x3825490000001902,
    t = 0x3825490000001903,
};
enum class round : flags_t {…};
 
template<round>
const Def* normalize_round(const Def*, const Def*, const Def*);
 
///@}
 
/// @name %%math.cmp
///@{
enum class cmp : flags_t {
    ugle = 0x3825490000001a00,
    f = ugle,
    uglE = 0x3825490000001a01,
    e = uglE,
    ugLe = 0x3825490000001a02,
    l = ugLe,
    ugLE = 0x3825490000001a03,
    le = ugLE,
    uGle = 0x3825490000001a04,
    g = uGle,
    uGlE = 0x3825490000001a05,
    ge = uGlE,
    uGLe = 0x3825490000001a06,
    ne = uGLe,
    uGLE = 0x3825490000001a07,
    o = uGLE,
    Ugle = 0x3825490000001a08,
    u = Ugle,
    UglE = 0x3825490000001a09,
    ue = UglE,
    UgLe = 0x3825490000001a0a,
    ul = UgLe,
    UgLE = 0x3825490000001a0b,
    ule = UgLE,
    UGle = 0x3825490000001a0c,
    ug = UGle,
    UGlE = 0x3825490000001a0d,
    uge = UGlE,
    UGLe = 0x3825490000001a0e,
    une = UGLe,
    UGLE = 0x3825490000001a0f,
    t = UGLE,
};
enum class cmp : flags_t {…};
 
template<cmp>
const Def* normalize_cmp(const Def*, const Def*, const Def*);
 
///@}
 
/// @name %%math.conv
///@{
enum class conv : flags_t {
    s2f = 0x3825490000001b00,
    u2f = 0x3825490000001b01,
    f2s = 0x3825490000001b02,
    f2u = 0x3825490000001b03,
    f2f = 0x3825490000001b04,
};
enum class conv : flags_t {…};
 
template<conv>
const Def* normalize_conv(const Def*, const Def*, const Def*);
 
///@}
 
/// @name %%math.slf
///@{
enum class slf : flags_t {
};
enum class slf : flags_t {…};
 
///@}
 
/// @name %%math.sgn
///@{
enum class sgn : flags_t {
};
enum class sgn : flags_t {…};
 
///@}
 
/// @name %%math.rrt
///@{
enum class rrt : flags_t {
};
enum class rrt : flags_t {…};
 
///@}
 
void register_normalizers(Normalizers& normalizers);
 
#define MIM_math_NORMALIZER_IMPL \
    void register_normalizers(Normalizers& normalizers) {\
        normalizers[flags_t(arith::add)] = &normalize_arith<arith::add>; \
        normalizers[flags_t(arith::sub)] = &normalize_arith<arith::sub>; \
        normalizers[flags_t(arith::mul)] = &normalize_arith<arith::mul>; \
        normalizers[flags_t(arith::div)] = &normalize_arith<arith::div>; \
        normalizers[flags_t(arith::rem)] = &normalize_arith<arith::rem>; \
        normalizers[flags_t(extrema::im)] = &normalize_extrema<extrema::im>; \
        normalizers[flags_t(extrema::iM)] = &normalize_extrema<extrema::iM>; \
        normalizers[flags_t(extrema::Im)] = &normalize_extrema<extrema::Im>; \
        normalizers[flags_t(extrema::IM)] = &normalize_extrema<extrema::IM>; \
        normalizers[flags_t(tri::ahff)] = &normalize_tri<tri::ahff>; \
        normalizers[flags_t(tri::ahfF)] = &normalize_tri<tri::ahfF>; \
        normalizers[flags_t(tri::ahFf)] = &normalize_tri<tri::ahFf>; \
        normalizers[flags_t(tri::ahFF)] = &normalize_tri<tri::ahFF>; \
        normalizers[flags_t(tri::aHff)] = &normalize_tri<tri::aHff>; \
        normalizers[flags_t(tri::aHfF)] = &normalize_tri<tri::aHfF>; \
        normalizers[flags_t(tri::aHFf)] = &normalize_tri<tri::aHFf>; \
        normalizers[flags_t(tri::aHFF)] = &normalize_tri<tri::aHFF>; \
        normalizers[flags_t(tri::Ahff)] = &normalize_tri<tri::Ahff>; \
        normalizers[flags_t(tri::AhfF)] = &normalize_tri<tri::AhfF>; \
        normalizers[flags_t(tri::AhFf)] = &normalize_tri<tri::AhFf>; \
        normalizers[flags_t(tri::AhFF)] = &normalize_tri<tri::AhFF>; \
        normalizers[flags_t(tri::AHff)] = &normalize_tri<tri::AHff>; \
        normalizers[flags_t(tri::AHfF)] = &normalize_tri<tri::AHfF>; \
        normalizers[flags_t(tri::AHFf)] = &normalize_tri<tri::AHFf>; \
        normalizers[flags_t(tri::AHFF)] = &normalize_tri<tri::AHFF>; \
        normalizers[flags_t(Annex::Base<pow>)] = &normalize_pow; \
        normalizers[flags_t(rt::sq)] = &normalize_rt<rt::sq>; \
        normalizers[flags_t(rt::cb)] = &normalize_rt<rt::cb>; \
        normalizers[flags_t(exp::lbb)] = &normalize_exp<exp::lbb>; \
        normalizers[flags_t(exp::lbB)] = &normalize_exp<exp::lbB>; \
        normalizers[flags_t(exp::lBb)] = &normalize_exp<exp::lBb>; \
        normalizers[flags_t(exp::lBB)] = &normalize_exp<exp::lBB>; \
        normalizers[flags_t(exp::Lbb)] = &normalize_exp<exp::Lbb>; \
        normalizers[flags_t(exp::LbB)] = &normalize_exp<exp::LbB>; \
        normalizers[flags_t(exp::LBb)] = &normalize_exp<exp::LBb>; \
        normalizers[flags_t(exp::LBB)] = &normalize_exp<exp::LBB>; \
        normalizers[flags_t(er::f)] = &normalize_er<er::f>; \
        normalizers[flags_t(er::fc)] = &normalize_er<er::fc>; \
        normalizers[flags_t(gamma::t)] = &normalize_gamma<gamma::t>; \
        normalizers[flags_t(gamma::l)] = &normalize_gamma<gamma::l>; \
        normalizers[flags_t(Annex::Base<abs>)] = &normalize_abs; \
        normalizers[flags_t(round::f)] = &normalize_round<round::f>; \
        normalizers[flags_t(round::c)] = &normalize_round<round::c>; \
        normalizers[flags_t(round::r)] = &normalize_round<round::r>; \
        normalizers[flags_t(round::t)] = &normalize_round<round::t>; \
        normalizers[flags_t(cmp::ugle)] = &normalize_cmp<cmp::ugle>; \
        normalizers[flags_t(cmp::uglE)] = &normalize_cmp<cmp::uglE>; \
        normalizers[flags_t(cmp::ugLe)] = &normalize_cmp<cmp::ugLe>; \
        normalizers[flags_t(cmp::ugLE)] = &normalize_cmp<cmp::ugLE>; \
        normalizers[flags_t(cmp::uGle)] = &normalize_cmp<cmp::uGle>; \
        normalizers[flags_t(cmp::uGlE)] = &normalize_cmp<cmp::uGlE>; \
        normalizers[flags_t(cmp::uGLe)] = &normalize_cmp<cmp::uGLe>; \
        normalizers[flags_t(cmp::uGLE)] = &normalize_cmp<cmp::uGLE>; \
        normalizers[flags_t(cmp::Ugle)] = &normalize_cmp<cmp::Ugle>; \
        normalizers[flags_t(cmp::UglE)] = &normalize_cmp<cmp::UglE>; \
        normalizers[flags_t(cmp::UgLe)] = &normalize_cmp<cmp::UgLe>; \
        normalizers[flags_t(cmp::UgLE)] = &normalize_cmp<cmp::UgLE>; \
        normalizers[flags_t(cmp::UGle)] = &normalize_cmp<cmp::UGle>; \
        normalizers[flags_t(cmp::UGlE)] = &normalize_cmp<cmp::UGlE>; \
        normalizers[flags_t(cmp::UGLe)] = &normalize_cmp<cmp::UGLe>; \
        normalizers[flags_t(cmp::UGLE)] = &normalize_cmp<cmp::UGLE>; \
        normalizers[flags_t(conv::s2f)] = &normalize_conv<conv::s2f>; \
        normalizers[flags_t(conv::u2f)] = &normalize_conv<conv::u2f>; \
        normalizers[flags_t(conv::f2s)] = &normalize_conv<conv::f2s>; \
        normalizers[flags_t(conv::f2u)] = &normalize_conv<conv::f2u>; \
        normalizers[flags_t(conv::f2f)] = &normalize_conv<conv::f2f>; \
    }
#define MIM_math_NORMALIZER_IMPL \ …
} // namespace plug::math
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
template<> constexpr flags_t Annex::Base<plug::math::F> = 0x3825490000000000;
template<> constexpr size_t Annex::Num<plug::math::F> = 0;
template<> constexpr flags_t Annex::Base<plug::math::f16> = 0x3825490000000100;
template<> constexpr size_t Annex::Num<plug::math::f16> = 0;
template<> constexpr flags_t Annex::Base<plug::math::f32> = 0x3825490000000200;
template<> constexpr size_t Annex::Num<plug::math::f32> = 0;
template<> constexpr flags_t Annex::Base<plug::math::f64> = 0x3825490000000300;
template<> constexpr size_t Annex::Num<plug::math::f64> = 0;
template<> constexpr flags_t Annex::Base<plug::math::bf16> = 0x3825490000000400;
template<> constexpr size_t Annex::Num<plug::math::bf16> = 0;
template<> constexpr flags_t Annex::Base<plug::math::nvtf32> = 0x3825490000000500;
template<> constexpr size_t Annex::Num<plug::math::nvtf32> = 0;
template<> constexpr flags_t Annex::Base<plug::math::amdfp24> = 0x3825490000000600;
template<> constexpr size_t Annex::Num<plug::math::amdfp24> = 0;
template<> constexpr flags_t Annex::Base<plug::math::pxr24> = 0x3825490000000700;
template<> constexpr size_t Annex::Num<plug::math::pxr24> = 0;
template<> constexpr flags_t Annex::Base<plug::math::F16> = 0x3825490000000800;
template<> constexpr size_t Annex::Num<plug::math::F16> = 0;
template<> constexpr flags_t Annex::Base<plug::math::F32> = 0x3825490000000900;
template<> constexpr size_t Annex::Num<plug::math::F32> = 0;
template<> constexpr flags_t Annex::Base<plug::math::F64> = 0x3825490000000a00;
template<> constexpr size_t Annex::Num<plug::math::F64> = 0;
template<> constexpr flags_t Annex::Base<plug::math::BF16> = 0x3825490000000b00;
template<> constexpr size_t Annex::Num<plug::math::BF16> = 0;
template<> constexpr flags_t Annex::Base<plug::math::NVTF32> = 0x3825490000000c00;
template<> constexpr size_t Annex::Num<plug::math::NVTF32> = 0;
template<> constexpr flags_t Annex::Base<plug::math::AMDFP24> = 0x3825490000000d00;
template<> constexpr size_t Annex::Num<plug::math::AMDFP24> = 0;
template<> constexpr flags_t Annex::Base<plug::math::PXR24> = 0x3825490000000e00;
template<> constexpr size_t Annex::Num<plug::math::PXR24> = 0;
template<> constexpr flags_t Annex::Base<plug::math::arith> = 0x3825490000000f00;
template<> constexpr size_t Annex::Num<plug::math::arith> = 5;
template<> constexpr flags_t Annex::Base<plug::math::minus> = 0x3825490000001000;
template<> constexpr size_t Annex::Num<plug::math::minus> = 0;
template<> constexpr flags_t Annex::Base<plug::math::extrema> = 0x3825490000001100;
template<> constexpr size_t Annex::Num<plug::math::extrema> = 4;
template<> constexpr flags_t Annex::Base<plug::math::tri> = 0x3825490000001200;
template<> constexpr size_t Annex::Num<plug::math::tri> = 16;
template<> constexpr flags_t Annex::Base<plug::math::pow> = 0x3825490000001300;
template<> constexpr size_t Annex::Num<plug::math::pow> = 0;
template<> constexpr flags_t Annex::Base<plug::math::rt> = 0x3825490000001400;
template<> constexpr size_t Annex::Num<plug::math::rt> = 2;
template<> constexpr flags_t Annex::Base<plug::math::exp> = 0x3825490000001500;
template<> constexpr size_t Annex::Num<plug::math::exp> = 8;
template<> constexpr flags_t Annex::Base<plug::math::er> = 0x3825490000001600;
template<> constexpr size_t Annex::Num<plug::math::er> = 2;
template<> constexpr flags_t Annex::Base<plug::math::gamma> = 0x3825490000001700;
template<> constexpr size_t Annex::Num<plug::math::gamma> = 2;
template<> constexpr flags_t Annex::Base<plug::math::abs> = 0x3825490000001800;
template<> constexpr size_t Annex::Num<plug::math::abs> = 0;
template<> constexpr flags_t Annex::Base<plug::math::round> = 0x3825490000001900;
template<> constexpr size_t Annex::Num<plug::math::round> = 4;
template<> constexpr flags_t Annex::Base<plug::math::cmp> = 0x3825490000001a00;
template<> constexpr size_t Annex::Num<plug::math::cmp> = 16;
template<> constexpr flags_t Annex::Base<plug::math::conv> = 0x3825490000001b00;
template<> constexpr size_t Annex::Num<plug::math::conv> = 5;
template<> constexpr flags_t Annex::Base<plug::math::slf> = 0x3825490000001c00;
template<> constexpr size_t Annex::Num<plug::math::slf> = 0;
template<> constexpr flags_t Annex::Base<plug::math::sgn> = 0x3825490000001d00;
template<> constexpr size_t Annex::Num<plug::math::sgn> = 0;
template<> constexpr flags_t Annex::Base<plug::math::rrt> = 0x3825490000001e00;
template<> constexpr size_t Annex::Num<plug::math::rrt> = 0;
 
template<> struct Axiom::Match<plug::math::f16> { using type = Axiom; };
template<> struct Axiom::Match<plug::math::f32> { using type = Axiom; };
template<> struct Axiom::Match<plug::math::f64> { using type = Axiom; };
template<> struct Axiom::Match<plug::math::bf16> { using type = Axiom; };
template<> struct Axiom::Match<plug::math::nvtf32> { using type = Axiom; };
template<> struct Axiom::Match<plug::math::amdfp24> { using type = Axiom; };
template<> struct Axiom::Match<plug::math::pxr24> { using type = Axiom; };
template<> struct Axiom::Match<plug::math::F16> { using type = Axiom; };
template<> struct Axiom::Match<plug::math::F32> { using type = Axiom; };
template<> struct Axiom::Match<plug::math::F64> { using type = Axiom; };
template<> struct Axiom::Match<plug::math::BF16> { using type = Axiom; };
template<> struct Axiom::Match<plug::math::NVTF32> { using type = Axiom; };
template<> struct Axiom::Match<plug::math::AMDFP24> { using type = Axiom; };
template<> struct Axiom::Match<plug::math::PXR24> { using type = Axiom; };
template<> struct Axiom::Match<plug::math::minus> { using type = Axiom; };
template<> struct Axiom::Match<plug::math::slf> { using type = Axiom; };
template<> struct Axiom::Match<plug::math::sgn> { using type = Axiom; };
template<> struct Axiom::Match<plug::math::rrt> { using type = Axiom; };
 
#endif
} // namespace mim
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
template<> struct fe::is_bit_enum<mim::plug::math::arith> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::math::extrema> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::math::tri> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::math::rt> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::math::exp> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::math::er> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::math::gamma> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::math::round> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::math::cmp> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::math::conv> : std::true_type {};
 
#endif