fennec-org/fennec
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- More Documentation

Browse Source 
- Vulkan Configuration Implementations
 - Fixed build errors on GCC and Clang
This commit is contained in:
Medusa Slockbower
2026-07-18 23:48:00 -04:00
parent ed381c4178
commit cf909624df
164 changed files with 19857 additions and 5872 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
metaprogramming/float.h
View File

@@ -102,80 +102,80 @@ inline void float_h()
out << "" << '\n';
out << R"(/// \brief Does \f$float\f$ have an infinity?)" << '\n';
out << R"(/// \brief Does \emph{float} have an infinity?)" << '\n';
out << "#define FLT_HAS_INFINITY " << std::dec << std::numeric_limits<float>::has_infinity << '\n';
out << R"(/// \brief Does \f$float\f$ have a quiet NaN?)" << '\n';
out << R"(/// \brief Does \emph{float} have a quiet NaN?)" << '\n';
out << "#define FLT_HAS_QUIET_NAN " << std::dec << std::numeric_limits<float>::has_quiet_NaN << '\n';
out << R"(/// \brief Does \f$float\f$ have a signaling NaN?)" << '\n';
out << R"(/// \brief Does \emph{float} have a signaling NaN?)" << '\n';
out << "#define FLT_HAS_SIGNALING_NAN " << std::dec << std::numeric_limits<float>::has_signaling_NaN << '\n';
out << R"(/// \brief Does \f$float\f$ use denormalization?)" << '\n';
out << R"(/// \brief Does \emph{float} use denormalization?)" << '\n';
out << "#define FLT_HAS_DENORM " << std::dec << std::numeric_limits<float>::has_denorm << '\n';
out << R"(/// \brief Does \f$float\f$ have loss with denormalization?)" << '\n';
out << R"(/// \brief Does \emph{float} have loss with denormalization?)" << '\n';
out << "#define FLT_HAS_DENORM_LOSS " << std::dec << std::numeric_limits<float>::has_denorm_loss << '\n';
out << R"(/// \brief What rounding style does \f$float\f$ use?)" << '\n';
out << R"(/// \brief What rounding style does \emph{float} use?)" << '\n';
out << "#define FLT_ROUNDS " << std::dec << std::numeric_limits<float>::round_style << '\n';
out << R"(/// \brief Does \f$float\f$ use the IEEE floating point specification?)" << '\n';
out << R"(/// \brief Does \emph{float} use the IEEE floating point specification?)" << '\n';
out << "#define FLT_IS_IEC559 " << std::dec << std::numeric_limits<float>::is_iec559 << '\n';
out << R"(/// \brief The number of mantissa bits in \f$float\f$.)" << '\n';
out << R"(/// \brief The number of mantissa bits in \emph{float}.)" << '\n';
out << "#define FLT_MANT_DIG " << std::dec << std::numeric_limits<float>::digits << '\n';
out << R"(/// \brief The number of decimal digits guaranteed to be preserved in a \f$float\f$ &rarr; \f$text\f$ &rarr; \f$float\f$.)" << '\n';
out << R"(/// \brief The number of decimal digits guaranteed to be preserved in a \emph{float} &rarr; \emph{text} &rarr; \emph{float}.)" << '\n';
out << "#define FLT_DIG " << std::dec << std::numeric_limits<float>::digits10 << '\n';
out << R"(/// \brief The decimal precision required to serialize and deserialize a \f$float\f$.)" << '\n';
out << R"(/// \brief The decimal precision required to serialize and deserialize a \emph{float}.)" << '\n';
out << "#define FLT_DECIMAL_DIG " << std::dec << std::numeric_limits<float>::max_digits10 << '\n';
out << R"(/// \brief The radix, or integer base, used to represent a \f$float\f$.)" << '\n';
out << R"(/// \brief The radix, or integer base, used to represent a \emph{float}.)" << '\n';
out << "#define FLT_RADIX " << std::dec << std::numeric_limits<float>::radix << '\n';
out << R"(/// \brief The minimum negative integer such that \f${FLT_RADIX}^{FLT_MIN_EXP}\f$ results in a normalized \f$float\f$.)" << '\n';
out << R"(/// \brief The minimum negative integer such that \math{\textbf{FLT_RADIX}^\textbf{FLT_MIN_EXP}} results in a normalized \emph{float}.)" << '\n';
out << "#define FLT_MIN_EXP " << std::dec << std::numeric_limits<float>::min_exponent << '\n';
out << R"(/// \brief The maximum positive integer such that \f${FLT_RADIX}^{FLT_MAX_EXP}\f$ results in a non-infinite \f$float\f$.)" << '\n';
out << R"(/// \brief The maximum positive integer such that \math{\textbf{FLT_RADIX}^\textbf{FLT_MAX_EXP}} results in a non-infinite \emph{float}.)" << '\n';
out << "#define FLT_MAX_EXP " << std::dec << std::numeric_limits<float>::max_exponent << '\n';
out << R"(/// \brief The minimum negative integer such that \f${10}^{FLT_MIN_EXP}\f$ results in a normalized \f$float\f$.)" << '\n';
out << R"(/// \brief The minimum negative integer such that \math{{10}^\textbf{FLT_MIN_EXP}} results in a normalized \emph{float}.)" << '\n';
out << "#define FLT_MIN_10_EXP " << std::dec << std::numeric_limits<float>::min_exponent10 << '\n';
out << R"(/// \brief The maximum positive integer such that \f${10}^{FLT_MAX_EXP}\f$ results in a non-infinite \f$float\f$.)" << '\n';
out << R"(/// \brief The maximum positive integer such that \math{{10}^\textbf{FLT_MAX_EXP}} results in a non-infinite \emph{float}.)" << '\n';
out << "#define FLT_MAX_10_EXP " << std::dec << std::numeric_limits<float>::max_exponent10 << '\n';
out << R"(/// \brief Do arithmetics operations with \f$float\f$ trap?)" << '\n';
out << R"(/// \brief Do arithmetics operations with \emph{float} trap?)" << '\n';
out << "#define FLT_TRAPS " << std::dec << std::numeric_limits<float>::traps << '\n';
out << R"(/// \brief Do arithmetics operations with \f$float\f$ check for underflow?)" << '\n';
out << R"(/// \brief Do arithmetics operations with \emph{float} check for underflow?)" << '\n';
out << "#define FLT_TINYNESS_BEFORE " << std::dec << std::numeric_limits<float>::tinyness_before << '\n';
out << R"(/// \brief Smallest positive, finite, normal value of \f$float\f$.)" << '\n';
out << R"(/// \brief Smallest positive, finite, normal value of \emph{float}.)" << '\n';
out << "#define FLT_MIN " << "fennec::bit_cast<float>(0x" << std::hex << std::bit_cast<int>(std::numeric_limits<float>::min() ) << ")" << '\n';
out << R"(/// \brief Largest positive, finite value of \f$float\f$.)" << '\n';
out << R"(/// \brief Largest positive, finite value of \emph{float}.)" << '\n';
out << "#define FLT_MAX " << "fennec::bit_cast<float>(0x" << std::hex << std::bit_cast<int>(std::numeric_limits<float>::max() ) << ")" << '\n';
out << R"(/// \brief The difference between \f$1.0\f$ and the next representable value of \f$float\f$.)" << '\n';
out << R"(/// \brief The difference between \emph{1.0} and the next representable value of \emph{float}.)" << '\n';
out << "#define FLT_EPSILON " << "fennec::bit_cast<float>(0x" << std::hex << std::bit_cast<int>(std::numeric_limits<float>::epsilon() ) << ")" << '\n';
out << R"(/// \brief A value representing \f$\inf\f$ of type \f$float\f$.)" << '\n';
out << R"(/// \brief A value representing \emph{\inf} of type \emph{float}.)" << '\n';
out << "#define FLT_INF " << "fennec::bit_cast<float>(0x" << std::hex << std::bit_cast<int>(std::numeric_limits<float>::infinity() ) << ")" << '\n';
out << R"(/// \brief A value representing \f$NaN\f$ of type \f$float\f$ that does not trap.)" << '\n';
out << R"(/// \brief A value representing \emph{NaN} of type \emph{float} that does not trap.)" << '\n';
out << "#define FLT_QUIET_NAN " << "fennec::bit_cast<float>(0x" << std::hex << std::bit_cast<int>(std::numeric_limits<float>::quiet_NaN() ) << ")" << '\n';
out << R"(/// \brief A value representing \f$NaN\f$ of type \f$float\f$ that traps.)" << '\n';
out << R"(/// \brief A value representing \emph{NaN} of type \emph{float} that traps.)" << '\n';
out << "#define FLT_SIGNALING_NAN " << "fennec::bit_cast<float>(0x" << std::hex << std::bit_cast<int>(std::numeric_limits<float>::signaling_NaN()) << ")" << '\n';
out << R"(/// \brief Smallest positive, finite, subnormal value of \f$float\f$.)" << '\n';
out << R"(/// \brief Smallest positive, finite, subnormal value of \emph{float}.)" << '\n';
out << "#define FLT_DENORM_MIN " << "fennec::bit_cast<float>(0x" << std::hex << std::bit_cast<int>(std::numeric_limits<float>::denorm_min() ) << ")" << '\n';
out << R"(/// \brief Maximum rounding error of type \f$float\f$.)" << '\n';
out << R"(/// \brief Maximum rounding error of type \emph{float}.)" << '\n';
out << "#define FLT_ROUND_ERR " << "fennec::bit_cast<float>(0x" << std::hex << std::bit_cast<int>(std::numeric_limits<float>::round_error() ) << ")" << '\n';
out << "" << '\n';
@@ -209,80 +209,80 @@ inline void float_h()
out << "" << '\n';
out << R"(/// \brief Does \f$double\f$ have an infinity?)" << '\n';
out << R"(/// \brief Does \emph{double} have an infinity?)" << '\n';
out << "#define DBL_HAS_INFINITY " << std::dec << std::numeric_limits<double>::has_infinity << '\n';
out << R"(/// \brief Does \f$double\f$ have a quiet NaN?)" << '\n';
out << R"(/// \brief Does \emph{double} have a quiet NaN?)" << '\n';
out << "#define DBL_HAS_QUIET_NAN " << std::dec << std::numeric_limits<double>::has_quiet_NaN << '\n';
out << R"(/// \brief Does \f$double\f$ have a signaling NaN?)" << '\n';
out << R"(/// \brief Does \emph{double} have a signaling NaN?)" << '\n';
out << "#define DBL_HAS_SIGNALING_NAN " << std::dec << std::numeric_limits<double>::has_signaling_NaN << '\n';
out << R"(/// \brief Does \f$double\f$ use denormalization?)" << '\n';
out << R"(/// \brief Does \emph{double} use denormalization?)" << '\n';
out << "#define DBL_HAS_DENORM " << std::dec << std::numeric_limits<double>::has_denorm << '\n';
out << R"(/// \brief Does \f$double\f$ have loss with denormalization?)" << '\n';
out << R"(/// \brief Does \emph{double} have loss with denormalization?)" << '\n';
out << "#define DBL_HAS_DENORM_LOSS " << std::dec << std::numeric_limits<double>::has_denorm_loss << '\n';
out << R"(/// \brief What rounding style does \f$double\f$ use?)" << '\n';
out << R"(/// \brief What rounding style does \emph{double} use?)" << '\n';
out << "#define DBL_ROUNDS " << std::dec << std::numeric_limits<double>::round_style << '\n';
out << R"(/// \brief Does \f$double\f$ use the IEEE doubleing point specification?)" << '\n';
out << R"(/// \brief Does \emph{double} use the IEEE doubleing point specification?)" << '\n';
out << "#define DBL_IS_IEC559 " << std::dec << std::numeric_limits<double>::is_iec559 << '\n';
out << R"(/// \brief The number of mantissa bits in \f$double\f$.)" << '\n';
out << R"(/// \brief The number of mantissa bits in \emph{double}.)" << '\n';
out << "#define DBL_MANT_DIG " << std::dec << std::numeric_limits<double>::digits << '\n';
out << R"(/// \brief The number of decimal digits guaranteed to be preserved in a \f$double\f$ &rarr; \f$text\f$ &rarr; \f$double\f$.)" << '\n';
out << R"(/// \brief The number of decimal digits guaranteed to be preserved in a \emph{double} &rarr; \emph{text} &rarr; \emph{double}.)" << '\n';
out << "#define DBL_DIG " << std::dec << std::numeric_limits<double>::digits10 << '\n';
out << R"(/// \brief The decimal precision required to serialize and deserialize a \f$double\f$.)" << '\n';
out << R"(/// \brief The decimal precision required to serialize and deserialize a \emph{double}.)" << '\n';
out << "#define DBL_DECIMAL_DIG " << std::dec << std::numeric_limits<double>::max_digits10 << '\n';
out << R"(/// \brief The radix, or integer base, used to represent a \f$double\f$.)" << '\n';
out << R"(/// \brief The radix, or integer base, used to represent a \emph{double}.)" << '\n';
out << "#define DBL_RADIX " << std::dec << std::numeric_limits<double>::radix << '\n';
out << R"(/// \brief The minimum negative integer such that \f${DBL_RADIX}^{DBL_MIN_EXP}\f$ results in a normalized \f$double\f$.)" << '\n';
out << R"(/// \brief The minimum negative integer such that \math{\textbf{DBL_RADIX}^\textbf{DBL_MIN_EXP}} results in a normalized \emph{double}.)" << '\n';
out << "#define DBL_MIN_EXP " << std::dec << std::numeric_limits<double>::min_exponent << '\n';
out << R"(/// \brief The maximum positive integer such that \f${DBL_RADIX}^{DBL_MAX_EXP}\f$ results in a non-infinite \f$double\f$.)" << '\n';
out << R"(/// \brief The maximum positive integer such that \math{\textbf{DBL_RADIX}^\textbf{DBL_MAX_EXP}} results in a non-infinite \emph{double}.)" << '\n';
out << "#define DBL_MAX_EXP " << std::dec << std::numeric_limits<double>::max_exponent << '\n';
out << R"(/// \brief The minimum negative integer such that \f${10}^{DBL_MIN_EXP}\f$ results in a normalized \f$double\f$.)" << '\n';
out << R"(/// \brief The minimum negative integer such that \math{{10}^\textbf{DBL_MIN_EXP}} results in a normalized \emph{double}.)" << '\n';
out << "#define DBL_MIN_10_EXP " << std::dec << std::numeric_limits<double>::min_exponent10 << '\n';
out << R"(/// \brief The maximum positive integer such that \f${10}^{DBL_MAX_EXP}\f$ results in a non-infinite \f$double\f$.)" << '\n';
out << R"(/// \brief The maximum positive integer such that \math{{10}^\textbf{DBL_MAX_EXP}} results in a non-infinite \emph{double}.)" << '\n';
out << "#define DBL_MAX_10_EXP " << std::dec << std::numeric_limits<double>::max_exponent10 << '\n';
out << R"(/// \brief Do arithmetics operations with \f$double\f$ trap?)" << '\n';
out << R"(/// \brief Do arithmetics operations with \emph{double} trap?)" << '\n';
out << "#define DBL_TRAPS " << std::dec << std::numeric_limits<double>::traps << '\n';
out << R"(/// \brief Do arithmetics operations with \f$double\f$ check for underflow?)" << '\n';
out << R"(/// \brief Do arithmetics operations with \emph{double} check for underflow?)" << '\n';
out << "#define DBL_TINYNESS_BEFORE " << std::dec << std::numeric_limits<double>::tinyness_before << '\n';
out << R"(/// \brief Smallest positive, finite, normal value of \f$double\f$.)" << '\n';
out << R"(/// \brief Smallest positive, finite, normal value of \emph{double}.)" << '\n';
out << "#define DBL_MIN " << "fennec::bit_cast<double>(0x" << std::hex << std::bit_cast<long long>(std::numeric_limits<double>::min() ) << "ll)" << '\n';
out << R"(/// \brief Largest positive, finite value of \f$double\f$.)" << '\n';
out << R"(/// \brief Largest positive, finite value of \emph{double}.)" << '\n';
out << "#define DBL_MAX " << "fennec::bit_cast<double>(0x" << std::hex << std::bit_cast<long long>(std::numeric_limits<double>::max() ) << "ll)" << '\n';
out << R"(/// \brief The difference between \f$1.0\f$ and the next representable value of \f$double\f$.)" << '\n';
out << R"(/// \brief The difference between \emph{1.0} and the next representable value of \emph{double}.)" << '\n';
out << "#define DBL_EPSILON " << "fennec::bit_cast<double>(0x" << std::hex << std::bit_cast<long long>(std::numeric_limits<double>::epsilon() ) << "ll)" << '\n';
out << R"(/// \brief A value representing \f$\inf\f$ of type \f$double\f$.)" << '\n';
out << R"(/// \brief A value representing \emph{\inf} of type \emph{double}.)" << '\n';
out << "#define DBL_INF " << "fennec::bit_cast<double>(0x" << std::hex << std::bit_cast<long long>(std::numeric_limits<double>::infinity() ) << "ll)" << '\n';
out << R"(/// \brief A value representing \f$NaN\f$ of type \f$double\f$ that does not trap.)" << '\n';
out << R"(/// \brief A value representing \emph{NaN} of type \emph{double} that does not trap.)" << '\n';
out << "#define DBL_QUIET_NAN " << "fennec::bit_cast<double>(0x" << std::hex << std::bit_cast<long long>(std::numeric_limits<double>::quiet_NaN() ) << "ll)" << '\n';
out << R"(/// \brief A value representing \f$NaN\f$ of type \f$double\f$ that traps.)" << '\n';
out << R"(/// \brief A value representing \emph{NaN} of type \emph{double} that traps.)" << '\n';
out << "#define DBL_SIGNALING_NAN " << "fennec::bit_cast<double>(0x" << std::hex << std::bit_cast<long long>(std::numeric_limits<double>::signaling_NaN()) << "ll)" << '\n';
out << R"(/// \brief Smallest positive, finite, subnormal value of \f$double\f$.)" << '\n';
out << R"(/// \brief Smallest positive, finite, subnormal value of \emph{double}.)" << '\n';
out << "#define DBL_DENORM_MIN " << "fennec::bit_cast<double>(0x" << std::hex << std::bit_cast<long long>(std::numeric_limits<double>::denorm_min() ) << "ll)" << '\n';
out << R"(/// \brief Maximum rounding error of type \f$double\f$.)" << '\n';
out << R"(/// \brief Maximum rounding error of type \emph{double}.)" << '\n';
out << "#define DBL_ROUND_ERR " << "fennec::bit_cast<double>(0x" << std::hex << std::bit_cast<long long>(std::numeric_limits<double>::round_error() ) << "ll)" << '\n';
out << "" << '\n';