From e6b3d45e2e12d616185a506ec90387e0873edd06 Mon Sep 17 00:00:00 2001
From: Medusa Slockbower <mslockbo@gmail.com>
Date: Mon, 26 May 2025 13:40:54 -0400
Subject: [PATCH] Fixed Documentation for Common Math Library

---
 include/fennec/lang/intrinsics.h |   3 +
 include/fennec/lang/limits.h     |   1 +
 include/fennec/lang/types.h      |  12 +-
 include/fennec/math/common.h     | 452 ++++++++-----------------------
 metaprogramming/main.cpp         |   5 +-
 5 files changed, 120 insertions(+), 353 deletions(-)

diff --git a/include/fennec/lang/intrinsics.h b/include/fennec/lang/intrinsics.h
index 43e9d42..780bded 100644
--- a/include/fennec/lang/intrinsics.h
+++ b/include/fennec/lang/intrinsics.h
@@ -21,7 +21,10 @@
 #define FENNEC_LANG_INTRINSICS_H
 
 # if defined(__has_builtin)
+
+// bitcast is slightly more efficient for build times than using memcpy
 #   define FENNEC_HAS_BUILTIN_BITCAST __has_builtin(__builtin_bit_cast)
+
 # endif
 
 #endif // FENNEC_LANG_INTRINSICS_H
diff --git a/include/fennec/lang/limits.h b/include/fennec/lang/limits.h
index 40a9711..2ebdf3e 100644
--- a/include/fennec/lang/limits.h
+++ b/include/fennec/lang/limits.h
@@ -19,6 +19,7 @@
 
 #ifndef FENNEC_LANG_LIMITS_H
 #define FENNEC_LANG_LIMITS_H
+
 #include <cmath>
 #include <fennec/lang/types.h>
 #include <fennec/lang/type_traits.h>
diff --git a/include/fennec/lang/types.h b/include/fennec/lang/types.h
index 0fe297c..2941911 100644
--- a/include/fennec/lang/types.h
+++ b/include/fennec/lang/types.h
@@ -59,15 +59,15 @@ using schar_t = signed char;
 using uchar_t = unsigned char;
 
 ///
-/// \brief A short type, capable of holding signed 16-bit integer
-using short_t  = signed short;
+/// \brief A signed short type, capable of holding signed 16-bit integer
+using short_t = signed short;
 
 ///
-/// \brief A short type, capable of holding an unsigned signed 16-bit integer
+/// \brief An unsigned short type, capable of holding an unsigned signed 16-bit integer
 using ushort_t = unsigned short;
 
 ///
-/// \brief A    signed integer type, size varies by implementation, but typically 32-bit
+/// \brief A signed integer type, size varies by implementation, but typically 32-bit
 using int_t = signed int;
 
 ///
@@ -91,11 +91,11 @@ using llong_t  = signed long long;
 using ullong_t = unsigned long long;
 
 ///
-/// \brief A single-precision floating-point type, with a size of 32-bits
+/// \brief A single-precision floating-point type, typically with a size of 32-bits
 using float_t = float;
 
 ///
-/// \brief A double-point type, with a size of 64-bits
+/// \brief A double-point type, typically with a size of 64-bits
 using double_t = double;
 /// @}
 
diff --git a/include/fennec/math/common.h b/include/fennec/math/common.h
index 5f19acd..eee217d 100644
--- a/include/fennec/math/common.h
+++ b/include/fennec/math/common.h
@@ -49,19 +49,19 @@
 ///     <th style="vertical-align: top">Description
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
-///         \ref fennec::abs(genIType) "genIType abs(genIType)" <br>
-///         \ref fennec::abs(genFType) "genFType abs(genFType)" <br>
-///         \ref fennec::abs(genDType) "genDType abs(genDType)"
+///         \ref fennec::abs(fennec::genType) "genIType abs(genIType)" <br>
+///         \ref fennec::abs(fennec::genType) "genFType abs(genFType)" <br>
+///         \ref fennec::abs(fennec::genType) "genDType abs(genDType)"
 ///     <td width="50%" style="vertical-align: top">
-///         \copydoc fennec::abs(genFType)
+///         \copydetails fennec::abs(fennec::genType)
 ///
 ///
 /// <tr><td width="50%" style="vertical-align: top" class="odd_c"> <br>
-///         \ref fennec::sign(genIType) "genIType sign(genIType)" <br>
-///         \ref fennec::sign(genFType) "genFType sign(genFType)" <br>
-///         \ref fennec::sign(genDType) "genDType sign(genDType)"
+///         \ref fennec::sign(fennec::genType) "genIType sign(genIType)" <br>
+///         \ref fennec::sign(fennec::genType) "genFType sign(genFType)" <br>
+///         \ref fennec::sign(fennec::genType) "genDType sign(genDType)"
 ///     <td width="50%" style="vertical-align: top" class="odd_c">
-///         \copydoc fennec::sign(genFType)
+///         \copydetails fennec::sign(fennec::genType)
 ///
 /// </table>
 ///
@@ -73,38 +73,38 @@
 ///     <th style="vertical-align: top">Description
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
-///         \ref fennec::floor(genFType)"genFType floor(genFType)" <br>
-///         \ref fennec::floor(genDType)"genDType floor(genDType)"
+///         \ref fennec::floor(fennec::genType) "genFType floor(genFType)" <br>
+///         \ref fennec::floor(fennec::genType) "genDType floor(genDType)"
 ///     <td width="50%" style="vertical-align: top">
-///         \copydoc fennec::floor(genFType)
+///         \copydetails fennec::floor(fennec::genType)
 ///
 ///
 /// <tr><td width="50%" style="vertical-align: top" class="odd_c"> <br>
-///         \ref fennec::ceil(genFType)"genFType ceil(genFType)" <br>
-///         \ref fennec::ceil(genDType)"genDType ceil(genDType)"
+///         \ref fennec::ceil(fennec::genType) "genFType ceil(genFType)" <br>
+///         \ref fennec::ceil(fennec::genType) "genDType ceil(genDType)"
 ///     <td width="50%" style="vertical-align: top" class="odd_c">
-///         \copydoc fennec::ceil(genFType)
+///         \copydetails fennec::ceil(fennec::genType)
 ///
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
-///         \ref fennec::round(genFType)"genFType round(genFType)" <br>
-///         \ref fennec::round(genDType)"genDType round(genDType)"
+///         \ref fennec::round(fennec::genType) "genFType round(genFType)" <br>
+///         \ref fennec::round(fennec::genType) "genDType round(genDType)"
 ///     <td width="50%" style="vertical-align: top">
-///         \copydoc fennec::round(genFType)
+///         \copydetails fennec::round(fennec::genType)
 ///
 ///
 /// <tr><td width="50%" style="vertical-align: top" class="odd_c"> <br>
-///         \ref fennec::roundEven(genFType)"genFType roundEven(genFType)" <br>
-///         \ref fennec::roundEven(genDType)"genDType roundEven(genDType)"
+///         \ref fennec::roundEven(fennec::genType) "genFType roundEven(genFType)" <br>
+///         \ref fennec::roundEven(fennec::genType) "genDType roundEven(genDType)"
 ///     <td width="50%" style="vertical-align: top" class="odd_c">
-///         \copydoc fennec::roundEven(genFType)
+///         \copydetails fennec::roundEven(fennec::genType)
 ///
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
-///         \ref fennec::trunc(genFType)"genFType trunc(genFType)" <br>
-///         \ref fennec::trunc(genDType)"genDType trunc(genDType)"
+///         \ref fennec::trunc(fennec::genType) "genFType trunc(genFType)" <br>
+///         \ref fennec::trunc(fennec::genType) "genDType trunc(genDType)"
 ///     <td width="50%" style="vertical-align: top">
-///         \copydoc fennec::trunc(genFType)
+///         \copydetails fennec::trunc(fennec::genType)
 ///
 /// </table>
 ///
@@ -116,48 +116,48 @@
 ///     <th style="vertical-align: top">Description
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
-///         \ref fennec::fract(genFType)"genFType fract(genFType)" <br>
-///         \ref fennec::fract(genDType)"genDType fract(genDType)"
+///         \ref fennec::fract(fennec::genType) "genFType fract(genFType)" <br>
+///         \ref fennec::fract(fennec::genType) "genDType fract(genDType)"
 ///     <td width="50%" style="vertical-align: top">
-///         \copydoc fennec::fract(genFType)
+///         \copydetails fennec::fract(fennec::genType)
 ///
 /// <tr><td width="50%" style="vertical-align: top" class="odd_c"> <br>
-///         \ref fennec::mod(genFType, float)"genDType mod(genFType, float)" <br>
-///         \ref fennec::mod(genFType, genFType)"genFType mod(genFType, genFType)" <br>
-///         \ref fennec::mod(genDType, genDType)"genDType mod(genDType, double)" <br>
-///         \ref fennec::mod(genDType, double)"genDType mod(genDType, genDType)"
+///         \ref fennec::mod(fennec::genType, fennec::genType) "genFType mod(genFType, float)"    <br>
+///         \ref fennec::mod(fennec::genType, fennec::genType) "genFType mod(genFType, genFType)" <br>
+///         \ref fennec::mod(fennec::genType, fennec::genType) "genDType mod(genDType, double)"   <br>
+///         \ref fennec::mod(fennec::genType, fennec::genType) "genDType mod(genDType, genDType)"
 ///     <td width="50%" style="vertical-align: top" class="odd_c">
-///         \copydoc fennec::mod(genFType, genFType)
+///         \copydetails fennec::mod(fennec::genType, fennec::genType)
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
-///         \ref fennec::modf(genFType, genFType&)"genDType modf(genDType, out genFType)" <br>
-///         \ref fennec::modf(genDType, genDType&)"genDType modf(genDType, out genDType)"
+///         \ref fennec::modf(fennec::genType, fennec::genType&) "genFType modf(genFType, out genFType)" <br>
+///         \ref fennec::modf(fennec::genType, fennec::genType&) "genDType modf(genDType, out genDType)"
 ///     <td width="50%" style="vertical-align: top">
-///         \copydoc fennec::modf(genFType, genFType&)
+///         \copydetails fennec::modf(fennec::genType, fennec::genType&)
 ///
 /// <tr><td width="50%" style="vertical-align: top" class="odd_c"> <br>
-///         \ref fennec::isnan(genFType)"genBType isnan(genFType)" <br>
-///         \ref fennec::isnan(genDType)"genBType isnan(genDType)"
+///         \ref fennec::isnan(fennec::genType) "genBType isnan(genFType)" <br>
+///         \ref fennec::isnan(fennec::genType) "genBType isnan(genDType)"
 ///     <td width="50%" style="vertical-align: top" class="odd_c">
-///         \copydoc fennec::isnan(genFType)
+///         \copydetails fennec::isnan(fennec::genType)
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
-///         \ref fennec::isinf(genFType)"genBType isinf(genFType)" <br>
-///         \ref fennec::isinf(genDType)"genBType isinf(genDType)"
+///         \ref fennec::isinf(fennec::genType) "genBType isinf(genFType)" <br>
+///         \ref fennec::isinf(fennec::genType) "genBType isinf(genDType)"
 ///     <td width="50%" style="vertical-align: top">
-///         \copydoc fennec::isinf(genFType)
+///         \copydetails fennec::isinf(fennec::genType)
 ///
 /// <tr><td width="50%" style="vertical-align: top" class="odd_c"> <br>
-///         \ref fennec::frexp(genFType, genIType&)"genFType frexp(genDType, out genIType)" <br>
-///         \ref fennec::frexp(genDType, genIType&)"genDType frexp(genDType, out genIType)"
+///         \ref fennec::frexp(fennec::genType, fennec::genIType&) "genFType frexp(genFType, out genIType)" <br>
+///         \ref fennec::frexp(fennec::genType, fennec::genIType&) "genDType frexp(genDType, out genIType)"
 ///     <td width="50%" style="vertical-align: top" class="odd_c">
-///         \copydoc fennec::frexp(genFType, genIType&)
+///         \copydetails fennec::frexp(fennec::genType, fennec::genIType&)
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
-///         \ref fennec::ldexp(genFType, genIType)"genFType ldexp(genFType, genIType)" <br>
-///         \ref fennec::ldexp(genDType, genIType)"genDType ldexp(genDType, genIType)"
+///         \ref fennec::ldexp(fennec::genType, fennec::genIType) "genFType ldexp(genFType, genIType)" <br>
+///         \ref fennec::ldexp(fennec::genType, fennec::genIType) "genDType ldexp(genDType, genIType)"
 ///     <td width="50%" style="vertical-align: top">
-///         \copydoc fennec::ldexp(genFType, genIType)
+///         \copydetails fennec::ldexp(fennec::genType, fennec::genIType)
 ///
 /// </table>
 ///
@@ -169,16 +169,16 @@
 ///     <th style="vertical-align: top">Description
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
-///         \ref fennec::floatBitsToInt(genFType)"genIType floatBitsToInt(genFType)" <br>
-///         \ref fennec::floatBitsToUint(genFType)"genUType floatBitsToUint(genFType)"
+///         \ref fennec::floatBitsToInt(fennec::genType)  "genIType floatBitsToInt(genType)" <br>
+///         \ref fennec::floatBitsToUint(fennec::genType) "genUType floatBitsToUint(genType)"
 ///     <td width="50%" style="vertical-align: top">
-///         \copydoc fennec::floatBitsToUint(genFType)
+///         \copydetails fennec::floatBitsToUint(fennec::genType)
 ///
 /// <tr><td width="50%" style="vertical-align: top" class="odd_c"> <br>
-///         \ref fennec::intBitsToFloat(genIType)"genFType intBitsToFloat(genIType)" <br>
-///         \ref fennec::uintBitsToFloat(genUType)"genFType uintBitsToFloat(genUType)"
+///         \ref fennec::intBitsToFloat(fennec::genIType)  "genFType intBitsToFloat(genIType)" <br>
+///         \ref fennec::uintBitsToFloat(fennec::genUType) "genFType uintBitsToFloat(genUType)"
 ///     <td width="50%" style="vertical-align: top" class="odd_c">
-///         \copydoc fennec::uintBitsToFloat(genUType)
+///         \copydetails fennec::uintBitsToFloat(fennec::genType)
 ///
 /// </table>
 ///
@@ -190,40 +190,40 @@
 ///     <th style="vertical-align: top">Description
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
-///         \ref fennec::min(genFType, float)"genFType min(genFType, float)" <br>
-///         \ref fennec::min(genFType, genFType)"genFType min(genFType, genFType)" <br>
-///         \ref fennec::min(genDType, double)"genDType min(genDType, double)" <br>
-///         \ref fennec::min(genDType, genDType)"genDType min(genDType, genDType)" <br>
-///         \ref fennec::min(genIType, int)"genIType min(genDType, int)" <br>
-///         \ref fennec::min(genIType, genIType)"genIType min(genIType, genIType)" <br>
-///         \ref fennec::min(genUType, fennec::uint)"genUType min(genUType, uint)" <br>
-///         \ref fennec::min(genUType, genUType)"genUType min(genUType, genUType)"
+///         \ref fennec::min(fennec::genType, fennec::genType) "genFType min(genFType, float)"    <br>
+///         \ref fennec::min(fennec::genType, fennec::genType) "genFType min(genFType, genFType)" <br>
+///         \ref fennec::min(fennec::genType, fennec::genType) "genDType min(genDType, double)"   <br>
+///         \ref fennec::min(fennec::genType, fennec::genType) "genDType min(genDType, genDType)" <br>
+///         \ref fennec::min(fennec::genType, fennec::genType) "genIType min(genDType, int)"      <br>
+///         \ref fennec::min(fennec::genType, fennec::genType) "genIType min(genIType, genIType)" <br>
+///         \ref fennec::min(fennec::genType, fennec::genType) "genUType min(genUType, uint)"     <br>
+///         \ref fennec::min(fennec::genType, fennec::genType) "genUType min(genUType, genUType)"
 ///     <td width="50%" style="vertical-align: top">
-///         \copydoc fennec::min(genFType, genFType)
+///         \copydetails fennec::min(fennec::genType, fennec::genType)
 ///
 /// <tr><td width="50%" style="vertical-align: top" class="odd_c"> <br>
-///         \ref fennec::max(genFType, float)"genFType max(genFType, float)" <br>
-///         \ref fennec::max(genFType, genFType)"genFType max(genFType, genFType)" <br>
-///         \ref fennec::max(genDType, double)"genDType max(genDType, double)" <br>
-///         \ref fennec::max(genDType, genDType)"genDType max(genDType, genDType)" <br>
-///         \ref fennec::max(genIType, int)"genIType max(genDType, int)" <br>
-///         \ref fennec::max(genIType, genIType)"genIType max(genIType, genIType)" <br>
-///         \ref fennec::max(genUType, fennec::uint)"genUType max(genUType, uint)" <br>
-///         \ref fennec::max(genUType, genUType)"genUType max(genUType, genUType)"
+///         \ref fennec::max(fennec::genType, fennec::genType) "genFType max(genFType, float)"    <br>
+///         \ref fennec::max(fennec::genType, fennec::genType) "genFType max(genFType, genFType)" <br>
+///         \ref fennec::max(fennec::genType, fennec::genType) "genDType max(genDType, double)"   <br>
+///         \ref fennec::max(fennec::genType, fennec::genType) "genDType max(genDType, genDType)" <br>
+///         \ref fennec::max(fennec::genType, fennec::genType) "genIType max(genDType, int)"      <br>
+///         \ref fennec::max(fennec::genType, fennec::genType) "genIType max(genIType, genIType)" <br>
+///         \ref fennec::max(fennec::genType, fennec::genType) "genUType max(genUType, uint)"     <br>
+///         \ref fennec::max(fennec::genType, fennec::genType) "genUType max(genUType, genUType)"
 ///     <td width="50%" style="vertical-align: top" class="odd_c">
-///         \copydoc fennec::max(genFType, genFType)
+///         \copydetails fennec::max(fennec::genType, fennec::genType)
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
-///         \ref fennec::clamp(genFType, float, float)"genFType clamp(genFType, float, float)" <br>
-///         \ref fennec::clamp(genFType, genFType, genFType)"genFType clamp(genFType, genFType, genFType)" <br>
-///         \ref fennec::clamp(genDType, double, double)"genDType clamp(genDType, double, double)" <br>
-///         \ref fennec::clamp(genDType, genDType, genDType)"genDType clamp(genDType, genDType, genDType)" <br>
-///         \ref fennec::clamp(genIType, int, int)"genIType clamp(genDType, int, int)" <br>
-///         \ref fennec::clamp(genIType, genIType, genIType)"genIType clamp(genIType, genIType, genIType)" <br>
-///         \ref fennec::clamp(genUType, fennec::uint, fennec::uint)"genUType clamp(genUType(genUType, uint)" <br>
-///         \ref fennec::clamp(genUType, genUType, genUType)"genUType clamp(genUType, genUType, genUType)"
+///         \ref fennec::clamp(fennec::genType, fennec::genType, fennec::genType) "genFType clamp(genFType, float, float)"       <br>
+///         \ref fennec::clamp(fennec::genType, fennec::genType, fennec::genType) "genFType clamp(genFType, genFType, genFType)" <br>
+///         \ref fennec::clamp(fennec::genType, fennec::genType, fennec::genType) "genDType clamp(genDType, double, double)"     <br>
+///         \ref fennec::clamp(fennec::genType, fennec::genType, fennec::genType) "genDType clamp(genDType, genDType, genDType)" <br>
+///         \ref fennec::clamp(fennec::genType, fennec::genType, fennec::genType) "genIType clamp(genDType, int, int)"           <br>
+///         \ref fennec::clamp(fennec::genType, fennec::genType, fennec::genType) "genIType clamp(genIType, genIType, genIType)" <br>
+///         \ref fennec::clamp(fennec::genType, fennec::genType, fennec::genType) "genUType clamp(genUType(genUType, uint)"      <br>
+///         \ref fennec::clamp(fennec::genType, fennec::genType, fennec::genType) "genUType clamp(genUType, genUType, genUType)"
 ///     <td width="50%" style="vertical-align: top">
-///         \copydoc fennec::clamp(genFType, genFType, genFType)
+///         \copydetails fennec::clamp(fennec::genType, fennec::genType, fennec::genType)
 ///
 /// </table>
 ///
@@ -235,37 +235,37 @@
 ///     <th style="vertical-align: top">Description
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
-///         \ref fennec::step(float, genFType)"step(float, genFType)" <br>
-///         \ref fennec::step(genFType, genFType)"step(genFType, genFType)" <br>
-///         \ref fennec::step(double, genDType)"step(double, genDType)" <br>
-///         \ref fennec::step(genDType, genDType)"step(genFType, genDType)"
+///         \ref fennec::step(fennec::genType, fennec::genType) "step(float, genFType)"    <br>
+///         \ref fennec::step(fennec::genType, fennec::genType) "step(genFType, genFType)" <br>
+///         \ref fennec::step(fennec::genType, fennec::genType) "step(double, genDType)"   <br>
+///         \ref fennec::step(fennec::genType, fennec::genType) "step(genFType, genDType)"
 ///     <td width="50%" style="vertical-align: top">
-///         \copydoc fennec::step(genFType, genFType)
+///         \copydetails fennec::step(fennec::genType, fennec::genType)
 ///
 /// <tr><td width="50%" style="vertical-align: top" class="odd_c"> <br>
-///         \ref fennec::smoothstep(float, float, genFType)"smoothstep(float, float, genFType)" <br>
-///         \ref fennec::smoothstep(genFType, genFType, genFType)"smoothstep(genFType, genFType, genFType)" <br>
-///         \ref fennec::smoothstep(double, double, genDType)"smoothstep(double, double, genDType)" <br>
-///         \ref fennec::smoothstep(genDType, genDType, genDType)"smoothstep(genFType, genFType, genDType)"
+///         \ref fennec::smoothstep(fennec::genType, fennec::genType, fennec::genType) "smoothstep(float, float, genFType)"       <br>
+///         \ref fennec::smoothstep(fennec::genType, fennec::genType, fennec::genType) "smoothstep(genFType, genFType, genFType)" <br>
+///         \ref fennec::smoothstep(fennec::genType, fennec::genType, fennec::genType) "smoothstep(double, double, genDType)"     <br>
+///         \ref fennec::smoothstep(fennec::genType, fennec::genType, fennec::genType) "smoothstep(genFType, genFType, genDType)"
 ///     <td width="50%" style="vertical-align: top" class="odd_c">
-///         \copydoc fennec::smoothstep(genFType, genFType, genFType)
+///         \copydetails fennec::smoothstep(fennec::genType, fennec::genType, fennec::genType)
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
-///         \ref fennec::mix(genFType, genFType, float)"mix(genFType, genFType, float)" <br>
-///         \ref fennec::mix(genFType, genFType, genFType)"mix(genFType, genFType, genFType)" <br>
-///         \ref fennec::mix(genDType, genDType, double)"mix(genDType, genDType, double)" <br>
-///         \ref fennec::mix(genDType, genDType, genDType)"mix(genDType, genDType, genDType)"
+///         \ref fennec::mix(fennec::genType, fennec::genType, fennec::genType) "mix(genFType, genFType, float)"    <br>
+///         \ref fennec::mix(fennec::genType, fennec::genType, fennec::genType) "mix(genFType, genFType, genFType)" <br>
+///         \ref fennec::mix(fennec::genType, fennec::genType, fennec::genType) "mix(genDType, genDType, double)"  <br>
+///         \ref fennec::mix(fennec::genType, fennec::genType, fennec::genType) "mix(genDType, genDType, genDType)"
 ///     <td width="50%" style="vertical-align: top">
-///         \copydoc fennec::mix(genFType, genFType, genFType)
+///         \copydetails fennec::mix(fennec::genType, fennec::genType, fennec::genType)
 ///
 /// <tr><td width="50%" style="vertical-align: top" class="odd_c"> <br>
-///         \ref fennec::mix(genBType, genBType, genBType)"mix(genBType, genBType, genBType)" <br>
-///         \ref fennec::mix(genIType, genIType, genBType)"mix(genIType, genIType, genBType)" <br>
-///         \ref fennec::mix(genUType, genUType, genBType)"mix(genUType, genUType, genBType)" <br>
-///         \ref fennec::mix(genFType, genFType, genBType)"mix(genFType, genFType, genBType)" <br>
-///         \ref fennec::mix(genDType, genDType, genBType)"mix(genDType, genDType, genBType)"
+///         \ref fennec::mix(fennec::genBType, fennec::genBType, fennec::genBType) "mix(genBType, genBType, genBType)" <br>
+///         \ref fennec::mix(fennec::genType,  fennec::genType,  fennec::genBType) "mix(genIType, genIType, genBType)" <br>
+///         \ref fennec::mix(fennec::genType,  fennec::genType,  fennec::genBType) "mix(genUType, genUType, genBType)" <br>
+///         \ref fennec::mix(fennec::genType,  fennec::genType,  fennec::genBType) "mix(genFType, genFType, genBType)" <br>
+///         \ref fennec::mix(fennec::genType,  fennec::genType,  fennec::genBType) "mix(genDType, genDType, genBType)"
 ///     <td width="50%" style="vertical-align: top" class="odd_c">
-///         \copydoc fennec::mix(genFType, genFType, genBType)
+///         \copydetails fennec::mix(fennec::genType, fennec::genType, fennec::genType)
 ///
 /// </table>
 ///
@@ -274,8 +274,8 @@
 
 
 #include <cmath>
-#include <fennec/math/vector.h>
 
+#include <fennec/math/vector.h>
 #include <fennec/memory/bits.h>
 
 namespace fennec
@@ -292,7 +292,6 @@ namespace fennec
 // Absolute Value ======================================================================================================
 
 ///
-/// \fn abs(genType)
 /// \brief Returns \f$x\f$ if \f$x \ge 0\f$, otherwise it returns \f$-x\f$
 ///
 /// \returns \f$x\f$ if \f$x \ge 0\f$, otherwise it returns \f$-x\f$. <br> <br>
@@ -316,7 +315,6 @@ constexpr vector<genType, i...> abs(const vector<genType, i...>& x)
 // Sign ================================================================================================================
 
 ///
-/// \fn sign(genType x)
 /// \brief Returns \f$1\f$ if \f$x > 0\f$, \f$0\f$ if \f$x = 0\f$, or \f$-1\f$ if \f$x<0\f$
 ///
 /// \returns \f$1\f$ if \f$x > 0\f$, \f$0\f$ if \f$x = 0\f$, or \f$-1\f$ if \f$x<0\f$ <br><br>
@@ -349,7 +347,6 @@ constexpr vector<genType, i...> sign(const vector<genType, i...>& x)
 // Floor ===============================================================================================================
 
 ///
-/// \fn floor(genType x)
 /// \brief Returns a value equal to the nearest integer that is less than or equal to \f$x\f$
 ///
 /// \returns a value equal to the nearest integer that is less than or equal to \f$x\f$ <br> <br>
@@ -373,7 +370,6 @@ constexpr vector<genType, i...> floor(const vector<genType, i...>& x)
 // Ceil ================================================================================================================
 
 ///
-/// \fn ceil(genType x)
 /// \brief Returns a value equal to the nearest integer that is greater than or equal to \f$x\f$
 ///
 /// \returns a value equal to the nearest integer that is greater than or equal to \f$x\f$ <br> <br>
@@ -397,7 +393,6 @@ constexpr vector<genType, i...> ceil(const vector<genType, i...>& x)
 // Round ===============================================================================================================
 
 ///
-/// \fn round(genType x)
 /// \brief Returns a value equal to the nearest integer. In C++, a fractional part of \f$0.5\f$ will always round up.
 ///
 /// \returns a value equal to the nearest integer.<br> <br>
@@ -421,7 +416,6 @@ constexpr vector<genType, i...> round(const vector<genType, i...>& x)
 // Round Even ==========================================================================================================
 
 ///
-/// \fn roundEven(genType x)
 /// \brief Returns a value equal to the nearest integer. In C++, a fractional part of \f$0.5\f$ will always
 ///        round to the nearest even integer.
 ///
@@ -447,7 +441,6 @@ constexpr vector<genType, i...> roundEven(const vector<genType, i...>& x)
 // Trunc ===============================================================================================================
 
 ///
-/// \fn trunc(genType x)
 /// \brief Returns a value equal to the nearest integer that is less than or equal to \f$x\f$
 ///
 /// \returns a value equal to the nearest integer that is less than or equal to \f$x\f$ <br> <br>
@@ -479,7 +472,6 @@ constexpr vector<genType, i...> trunc(const vector<genType, i...>& x)
 // Fract ===============================================================================================================
 
 ///
-/// \fn fract(genType x)
 /// \brief Returns \f$x - floor(x)\f$
 ///
 /// \returns \f$x - \text{floor}(x)\f$ <br> <br>
@@ -503,19 +495,6 @@ constexpr vector<genType, i...> fract(const vector<genType, i...>& x)
 // Mod =================================================================================================================
 
 ///
-/// \copydetails fennec::mod(genType, genType)
-template<typename genType>
-constexpr genType mod(genType x, float_t y)
-	{ return x - y * fennec::floor(x); }
-
-///
-/// \copydetails fennec::mod(genType, genType)
-template<typename genType>
-constexpr genType mod(genType x, double_t y)
-	{ return x - y * fennec::floor(x); }
-
-///
-/// \fn mod(genType x, genType y)
 /// \brief Modulus. Returns \f$x-y\cdot floor (x/y)\f$
 ///
 /// \returns \f$x-y\cdot\text{floor}(x/y)\f$ <br> <br>
@@ -544,7 +523,6 @@ constexpr vector<genType, i...> mod(const vector<genType, i...>& x, const vector
 // ModF ================================================================================================================
 
 ///
-/// \fn modf(genType x, genType& i)
 /// \brief Returns the fractional part of \f$x\f$ and stores the integral part in \f$i\f$.
 ///
 /// \returns the fractional part of \f$x\f$ and stores the integral part in \f$i\f$. <br> <br>
@@ -569,7 +547,6 @@ constexpr vector<genType, i...> modf(const vector<genType, i...>& x, vector<genT
 // Is NaN ==============================================================================================================
 
 ///
-/// \fn isnan(genType x)
 /// \brief Returns **true** if \f$x\f$ holds a NaN. Returns **false** otherwise.
 ///
 /// \returns **true** if \f$x\f$ holds a NaN. Returns **false** otherwise. <br> <br>
@@ -598,7 +575,6 @@ constexpr vector<genBType, i...> isnan(const vector<genType, i...>& x)
 // Is Inf ==============================================================================================================
 
 ///
-/// \fn isinf(genType x)
 /// \brief Returns **true** if \f$x\f$ holds a positive or negative infinity. Returns **false** otherwise. <br> <br>
 ///
 /// \returns **true** if \f$x\f$ holds a positive or negative infinity. Returns **false** otherwise.
@@ -628,7 +604,6 @@ constexpr genIType floatBitsToInt(genIType x)
 	{ return fennec::bit_cast<genIType>(x); }
 
 ///
-/// \fn floatBitsToUint(genFType x)
 /// \brief Returns a signed or unsigned integer value representing the encoding of a floating-point value.
 ///        The float value's bit-level representation is preserved.
 ///
@@ -656,7 +631,6 @@ constexpr genType intBitsToFloat(genIType x)
 
 
 ///
-/// \fn uintBitsToFloat(genUType x)
 /// \brief Returns a floating-point value corresponding to a signed or unsigned integer encoding of a floating-point value. <br> <br>
 ///
 /// \returns a floating-point value corresponding to a signed or unsigned integer encoding of a floating-point value. <br> <br>
@@ -698,7 +672,6 @@ constexpr vector<genType, i...> uintBitsToFloat(const vector<genUType, i...>& x)
 // fma =================================================================================================================
 
 ///
-/// \fn fennec::fma(genType, genType, genType)
 /// \brief Computes and returns \f$a \cdot b + c\f$. <br> <br>
 ///
 /// \returns \f$a \cdot b + c\f$.
@@ -724,7 +697,6 @@ constexpr vector<genType, i...> fma(const vector<genType, i...>& a, const vector
 // frexp ===============================================================================================================
 
 ///
-/// \fn fennec::frexp(genType, fennec::genIType&)
 /// \brief Splits \f$x\f$ into a floating-point significand in the range \f$[0.5,1.0]\f$, and an integral exponent of two,
 /// such that \f$x=sig \cdot 2^{exp}\f$.
 ///
@@ -754,7 +726,6 @@ constexpr vector<genType, i...> frexp(const vector<genType, i...>& x, vector<gen
 // ldexp ===============================================================================================================
 
 ///
-/// \fn fennec::ldexp(genType, fennec::genIType)
 /// \brief Builds a floating-point number from \f$x\f$ and the corresponding integral exponent of two in \f$exp\f$
 ///
 /// \returns \f${x}\cdot{2^{exp}}\f$
@@ -794,34 +765,7 @@ constexpr vector<genType, i...> ldexp(const vector<genType, i...>& x, const vect
 
 // Min =================================================================================================================
 
-
 ///
-/// \copydetails fennec::min(genType, genType)
-template<typename genType = int_t>
-constexpr genType min(genType x, int_t y)
-	{ return (y < x) ? y : x; }
-
-
-///
-/// \copydetails fennec::min(genType, genType)
-template<typename genType = uint_t>
-constexpr genType min(genType x, uint_t y)
-	{ return (y < x) ? y : x; }
-
-///
-/// \copydetails fennec::min(genType, genType)
-template<typename genType = float_t>
-constexpr genType min(genType x, float_t y)
-	{ return (y < x) ? y : x; }
-
-///
-/// \copydetails fennec::min(genType, genType)
-template<typename genType = double_t>
-constexpr genType min(genType x, double_t y)
-	{ return (y < x) ? y : x; }
-
-///
-/// \fn fennec::min(genType, genType)
 /// \brief Returns \f$y\f$ if \f$x<y;\f$ otherwise it returns \f$x\f$
 ///
 /// \returns \f$y\f$ if \f$x<y\f$, otherwise it returns \f$x\f$<br> <br>
@@ -837,20 +781,8 @@ constexpr genType min(genType x, genType y)
 
 // Vector Specializations ----------------------------------------------------------------------------------------------
 
-template<typename genType = int_t, size_t...i>
-constexpr vector<genType, i...> min(const vector<genType, i...>& x, int_t y)
-	{ return vector<genType, i...>(fennec::min(x[i], y) ...); }
-
-template<typename genType = uint_t, size_t...i>
-constexpr vector<genType, i...> min(const vector<genType, i...>& x, uint y)
-	{ return vector<genType, i...>(fennec::min(x[i], y) ...); }
-
 template<typename genType, size_t...i>
-constexpr vector<genType, i...> min(const vector<genType, i...>& x, float_t y)
-	{ return vector<genType, i...>(fennec::min(x[i], y) ...); }
-
-template<typename genType, size_t...i>
-constexpr vector<genType, i...> min(const vector<genType, i...>& x, double_t y)
+constexpr vector<genType, i...> min(const vector<genType, i...>& x, genType y)
 	{ return vector<genType, i...>(fennec::min(x[i], y) ...); }
 
 template<typename genType, size_t...i>
@@ -862,31 +794,6 @@ constexpr vector<genType, i...> min(const vector<genType, i...>& x, const vector
 // Max =================================================================================================================
 
 ///
-/// \copydetails fennec::max(genType, genType)
-template<typename genIType = int_t>
-constexpr genIType max(genIType x, int y)
-	{ return (x < y) ? y : x; }
-
-///
-/// \copydetails fennec::max(genType, genType)
-template<typename genUType = uint_t>
-constexpr genUType max(genUType x, uint y)
-	{ return (x < y) ? y : x; }
-
-///
-/// \copydetails fennec::max(genType, genType)
-template<typename genType = float_t>
-constexpr genType max(genType x, float_t y)
-	{ return (x < y) ? y : x; }
-
-///
-/// \copydetails fennec::max(genType, genType)
-template<typename genType = double_t>
-constexpr genType max(genType x, double_t y)
-	{ return (x < y) ? y : x; }
-
-///
-/// \fn fennec::max(genType, genType)
 /// \brief Returns \f$y\f$ if \f$y<x\f$, otherwise it returns \f$x\f$
 ///
 /// \returns \f$y\f$ if \f$y<x\f$, otherwise it returns \f$x\f$<br> <br>
@@ -902,20 +809,8 @@ constexpr genType max(genType x, genType y)
 
 // Vector Specializations ----------------------------------------------------------------------------------------------
 
-template<typename genType = int_t, size_t...i>
-constexpr vector<genType, i...> max(const vector<genType, i...>& x, int_t y)
-	{ return vector<genType, i...>(fennec::max(x[i], y) ...); }
-
-template<typename genType = uint_t, size_t...i>
-constexpr vector<genType, i...> max(const vector<genType, i...>& x, uint y)
-	{ return vector<genType, i...>(fennec::max(x[i], y) ...); }
-
 template<typename genType, size_t...i>
-constexpr vector<genType, i...> max(const vector<genType, i...>& x, float_t y)
-	{ return vector<genType, i...>(fennec::max(x[i], y) ...); }
-
-template<typename genType, size_t...i>
-constexpr vector<genType, i...> max(const vector<genType, i...>& x, double_t y)
+constexpr vector<genType, i...> max(const vector<genType, i...>& x, genType y)
 	{ return vector<genType, i...>(fennec::max(x[i], y) ...); }
 
 template<typename genType, size_t...i>
@@ -925,33 +820,7 @@ constexpr vector<genType, i...> max(const vector<genType, i...>& x, const vector
 
 // Clamp ===============================================================================================================
 
-
 ///
-/// \copydetails fennec::clamp(genType, genType, genType)
-template<typename genType = int_t>
-constexpr genType clamp(genType x, int_t minVal, int_t maxVal)
-	{ return min(max(x, minVal), maxVal); }
-
-///
-/// \copydetails fennec::clamp(genType, genType, genType)
-template<typename genType = uint_t>
-constexpr genType clamp(genType x, uint_t minVal, uint_t maxVal)
-	{ return min(max(x, minVal), maxVal); }
-
-///
-/// \copydetails fennec::clamp(genType, genType, genType)
-template<typename genType>
-constexpr genType clamp(genType x, float_t minVal, float_t maxVal)
-	{ return min(max(x, minVal), maxVal); }
-
-///
-/// \copydetails fennec::clamp(genType, genType, genType)
-template<typename genType>
-constexpr genType clamp(genType x, double_t minVal, double_t maxVal)
-	{ return min(max(x, minVal), maxVal); }
-
-///
-/// \fn fennec::clamp(genType, genType, genType)
 /// \brief Returns \f$min (max (x, minVal), maxVal)\f$
 ///
 /// \returns \f$\text{min}(\text{max}(x, minVal), maxVal)\f$. Results are undefined if \f$minVal > maxVal\f$<br> <br>
@@ -968,20 +837,8 @@ constexpr genType clamp(genType x, genType minVal, genType maxVal)
 
 // Vector Specializations ----------------------------------------------------------------------------------------------
 
-template<typename genType = int_t, size_t...i>
-constexpr vector<genType, i...> clamp(const vector<genType, i...>& x, int_t minVal, int_t maxVal)
-	{ return vector<genType, i...>(fennec::min(fennec::max(x[i], minVal), maxVal)...); }
-
-template<typename genType = uint_t, size_t...i>
-constexpr vector<genType, i...> clamp(const vector<genType, i...>& x, uint_t minVal, uint_t maxVal)
-	{ return vector<genType, i...>(fennec::min(fennec::max(x[i], minVal), maxVal)...); }
-
 template<typename genType, size_t...i>
-constexpr vector<genType, i...> clamp(const vector<genType, i...>& x, float_t minVal, float_t maxVal)
-	{ return vector<genType, i...>(fennec::min(fennec::max(x[i], minVal), maxVal)...); }
-
-template<typename genType, size_t...i>
-constexpr vector<genType, i...> clamp(const vector<genType, i...>& x, double_t minVal, double_t maxVal)
+constexpr vector<genType, i...> clamp(const vector<genType, i...>& x, genType minVal, genType maxVal)
 	{ return vector<genType, i...>(fennec::min(fennec::max(x[i], minVal), maxVal)...); }
 
 template<typename genType, size_t...i>
@@ -1002,19 +859,6 @@ constexpr vector<genType, i...> clamp(const vector<genType, i...>& x, const vect
 // Step ================================================================================================================
 
 ///
-/// \copydetails fennec::step(genType, genType)
-template<typename genType> requires(is_floating_point_v<genType>)
-constexpr genType step(float_t edge, genType x)
-	{ return x < edge ? 0.0  : 1.0;  }
-
-///
-/// \copydetails fennec::step(genType, genType)
-template<typename genType> requires(is_floating_point_v<genType>)
-constexpr genType step(double_t edge, genType x)
-	{ return x < edge ? 0.0  : 1.0;  }
-
-///
-/// \fn fennec::step(genType, genType)
 /// \brief Returns \f$0.0\f$ if \f$x<edge\f$, otherwise, it returns \f$1.0\f$
 ///
 /// \returns \f$0.0\f$ if \f$x<edge\f$, otherwise, it returns \f$1.0\f$<br> <br>
@@ -1031,11 +875,7 @@ constexpr genType step(genType edge, genType x)
 // Vector Specializations ----------------------------------------------------------------------------------------------
 
 template<typename genType, size_t...i> requires(is_floating_point_v<genType>)
-constexpr vector<genType, i...> step(float_t edge, const vector<genType, i...>& x)
-	{ return vector<genType, i...>(fennec::step(edge, x[i]) ...); }
-
-template<typename genType, size_t...i> requires(is_floating_point_v<genType>)
-constexpr vector<genType, i...> step(double_t edge, const vector<genType, i...>& x)
+constexpr vector<genType, i...> step(genType edge, const vector<genType, i...>& x)
 	{ return vector<genType, i...>(fennec::step(edge, x[i]) ...); }
 
 template<typename genType, size_t...i> requires(is_floating_point_v<genType>)
@@ -1045,21 +885,7 @@ constexpr vector<genType, i...> step(const vector<genType, i...>& edge, const ve
 
 // Smoothstep ==========================================================================================================
 
-
 ///
-/// \copydetails fennec::smoothstep(genType, genType, genType)
-template<typename genType> requires(is_floating_point_v<genType>)
-constexpr genType smoothstep(float_t edge0, float_t edge1, genType x)
-	{ genType t = fennec::clamp((x - edge0) / (edge1 - edge0)); return t * t * (3 - 2 * t); }
-
-///
-/// \copydetails fennec::smoothstep(genType, genType, genType)
-template<typename genType> requires(is_floating_point_v<genType>)
-constexpr genType smoothstep(double_t edge0, double_t edge1, genType x)
-	{ genType t = fennec::clamp((x - edge0) / (edge1 - edge0)); return t * t * (3 - 2 * t); }
-
-///
-/// \fn fennec::smoothstep(genType, genType, genType)
 /// \brief Returns \f$0.0\f$ if \f$x\le edge0\f$ and \f$1.0\f$ if \f$x\ge edge1\f$, and performs smooth Hermite
 ///        interpolation between \f$0\f$ and \f$1\f$ when \f$edge0<x<edge1\f$.
 ///
@@ -1087,11 +913,7 @@ constexpr genType smoothstep(genType edge0, genType edge1, genType x)
 // Vector Specializations ----------------------------------------------------------------------------------------------
 
 template<typename genType, size_t...i> requires(is_floating_point_v<genType>)
-constexpr vector<genType, i...> smoothstep(float_t edge0, float_t edge1, const vector<genType, i...>& x)
-	{ return vector<genType, i...>(fennec::smoothstep(edge0,    edge1,    x[i]) ...); }
-
-template<typename genType, size_t...i> requires(is_floating_point_v<genType>)
-constexpr vector<genType, i...> smoothstep(double_t edge0, double_t edge1, const vector<genType, i...>& x)
+constexpr vector<genType, i...> smoothstep(genType edge0, genType edge1, const vector<genType, i...>& x)
 	{ return vector<genType, i...>(fennec::smoothstep(edge0,    edge1,    x[i]) ...); }
 
 template<typename genType, size_t...i> requires(is_floating_point_v<genType>)
@@ -1101,21 +923,7 @@ constexpr vector<genType, i...> smoothstep(const vector<genType, i...>& edge0, c
 
 // Mix =================================================================================================================
 
-
 ///
-/// \copydetails fennec::mix(genType, genType, genType)
-template<typename genType> requires(is_floating_point_v<genType>)
-constexpr genType mix(genType x, genType y, float_t a)
-	{ return x * (1.0f - a) + y * a; }
-
-///
-/// \copydetails fennec::mix(genType, genType, genType)
-template<typename genType> requires(is_floating_point_v<genType>)
-constexpr genType mix(genType x, genType y, double_t a)
-	{ return x * (1.0 - a) + y * a; }
-
-///
-/// \fn fennec::mix(genType, genType, genType)
 /// \brief Returns the linear blend of \f$x\f$ and \f$y\f$, i.e., \f$x \cdot (1-a) + y \cdot a\f$
 ///
 /// \returns the linear blend of \f$x\f$ and \f$y\f$, i.e., \f$x \cdot (1-a) + y \cdot a\f$<br> <br>
@@ -1135,11 +943,7 @@ constexpr genType mix(genType x, genType y, genType a)
 // Vector Specializations ----------------------------------------------------------------------------------------------
 
 template<typename genType, size_t...i> requires(is_floating_point_v<genType>)
-constexpr vector<genType, i...> mix(const vector<genType, i...>& x, const vector<genType, i...>& y, float_t a)
-	{ return x * (1.0f - a) + y * a; }
-
-template<typename genType, size_t...i> requires(is_floating_point_v<genType>)
-constexpr vector<genType, i...> mix(const vector<genType, i...>& x, const vector<genType, i...>& y, double_t a)
+constexpr vector<genType, i...> mix(const vector<genType, i...>& x, const vector<genType, i...>& y, genType a)
 	{ return x * (1.0 - a) + y * a; }
 
 template<typename genType, size_t...i> requires(is_floating_point_v<genType>)
@@ -1149,27 +953,7 @@ constexpr vector<genType, i...> mix(const vector<genType, i...>& x, const vector
 
 // Mix (Bool) ==========================================================================================================
 
-
 ///
-/// \copydetails fennec::mix(genType, genType, fennec::genBType)
-template<typename genBType = bool_t> requires(is_bool_v<genBType>)
-constexpr genBType mix(genBType x, genBType y, genBType a)
-	{ return a ? y : x; }
-
-///
-/// \copydetails fennec::mix(genType, genType, fennec::genBType)
-template<typename genIType = int_t, typename genBType = bool_t> requires(is_bool_v<genBType> and is_integral_v<genIType> and is_signed_v<genIType>)
-constexpr genIType mix(genIType x, genIType y, genBType a)
-	{ return a ? y : x; }
-
-///
-/// \copydetails fennec::mix(genType, genType, fennec::genBType)
-template<typename genUType = uint_t, typename genBType = bool_t> requires(is_bool_v<genBType> and is_integral_v<genUType> and is_unsigned_v<genUType>)
-constexpr genUType mix(genUType x, genUType y, genBType a)
-	{ return a ? y : x; }
-
-///
-/// \fn fennec::mix(genType, genType, fennec::genBType)
 /// \brief Selects which value to return. For Vectors, when the boolean is a scalar, it selects the vector, otherwise, each component is selected.
 ///
 /// \returns \f$x\f$ when \f$a=T\f$, otherwise returns \f$y\f$
@@ -1191,20 +975,8 @@ constexpr genType mix(genType x, genType y, genBType a)
 
 // Vector Specializations ----------------------------------------------------------------------------------------------
 
-template<typename genBType = bool_t, size_t...i> requires(is_bool_v<genBType>)
-constexpr vector<genBType, i...> mix(const vector<genBType, i...>& x, const vector<genBType, i...>& y, bool_t a)
-	{ return genBType((a ? y[i] : x[i])...); }
-
-template<typename genIType = int_t, typename genBType = bool_t, size_t...i> requires(is_bool_v<genBType>)
-constexpr vector<genIType, i...> mix(const vector<genIType, i...>& x, const vector<genIType, i...>& y, bool_t a)
-	{ return genIType((a ? y[i] : x[i])...); }
-
-template<typename genUType = uint_t, typename genBType = bool_t, size_t...i> requires(is_bool_v<genBType> and is_integral_v<genUType> and is_unsigned_v<genUType>)
-constexpr vector<genUType, i...> mix(const vector<genUType, i...>& x, const vector<genUType, i...>& y, bool_t a)
-	{ return genUType((a ? y[i] : x[i])...); }
-
 template<typename genType, typename genBType = bool_t, size_t...i> requires(is_bool_v<genBType> and is_floating_point_v<genType>)
-constexpr vector<genType, i...> mix(const vector<genType, i...>& x, const vector<genType, i...>& y, bool_t a)
+constexpr vector<genType, i...> mix(const vector<genType, i...>& x, const vector<genType, i...>& y, genBType a)
 	{ return genDType((a ? y[i] : x[i])...); }
 
 
@@ -1212,14 +984,6 @@ template<typename genBType = bool_t, size_t...i> requires(is_bool_v<genBType>)
 constexpr vector<genBType, i...> mix(const vector<genBType, i...>& x, const vector<genBType, i...>& y, const vector<genBType, i...>& a)
 	{ return genBType((a[i] ? y[i] : x[i])...); }
 
-template<typename genIType = int_t, typename genBType = bool_t, size_t...i> requires(is_bool_v<genBType>)
-constexpr vector<genIType, i...> mix(const vector<genIType, i...>& x, const vector<genIType, i...>& y, const vector<genBType, i...>& a)
-	{ return genIType((a[i] ? y[i] : x[i])...); }
-
-template<typename genUType = uint_t, typename genBType = bool_t, size_t...i> requires(is_bool_v<genBType> and is_integral_v<genUType> and is_unsigned_v<genUType>)
-constexpr vector<genUType, i...> mix(const vector<genUType, i...>& x, const vector<genUType, i...>& y, const vector<genBType, i...>& a)
-	{ return genUType((a[i] ? y[i] : x[i])...); }
-
 template<typename genType, typename genBType = bool_t, size_t...i> requires(is_bool_v<genBType> and is_floating_point_v<genType>)
 constexpr vector<genType, i...> mix(const vector<genType, i...>& x, const vector<genType, i...>& y, const vector<genBType, i...>& a)
 	{ return genDType((a[i] ? y[i] : x[i])...); }
diff --git a/metaprogramming/main.cpp b/metaprogramming/main.cpp
index fb35f67..6c53b08 100644
--- a/metaprogramming/main.cpp
+++ b/metaprogramming/main.cpp
@@ -17,10 +17,9 @@
 // =====================================================================================================================
 
 #include <fstream>
-#include <math.h>
-#include <cfloat>
+#include <cmath>
 
-int main(int argc, const char** argv)
+int main(int, const char**)
 {
 	std::ofstream flt("float.h");