Fixed further documentation in the Math Library

include/fennec/lang/conditional_types.h

@@ -48,17 +48,26 @@ namespace fennec
 /// \tparam B the value of the condition
 /// \tparam T type to use when \f$B == true\f$
 /// \tparam F type to use when \f$B == false\f$
-template<bool_t B, typename T, typename F> struct conditional;
+template<bool_t B, typename T, typename F>
+struct conditional;
+
 
 /// \brief Shorthand for ```typename conditional<ConditionV, TrueT, FalseT>::type```
-template<bool_t B, typename T, typename F> using  conditional_t = typename conditional<B, T, F>::type;
+template<bool_t B, typename T, typename F>
+using conditional_t
+	= typename conditional<B, T, F>::type;
 
 
-/// \internal specialization of fennec::conditional for \c true case
-template<typename T, typename F> struct conditional<true, T, F> : type_transform<T>{};
+// specialization of fennec::conditional for \c true case
+template<typename T, typename F>
+struct conditional<true, T, F>
+	: type_transform<T>{};
 
-/// \internal specialization of fennec::conditional for \c false case
-template<typename T, typename F> struct conditional<false, T, F> : type_transform<F>{};
+
+// specialization of fennec::conditional for \c false case
+template<typename T, typename F>
+struct conditional<false, T, F>
+	: type_transform<F>{};
 
 }
 

include/fennec/lang/constants.h

@@ -55,23 +55,30 @@ template<typename T, T V> struct integral_constant
 	constexpr operator T() const noexcept { return V; }
 };
 
+
 ///
 ///
 /// \brief metaprogramming boolean constant
 ///
 /// \details
 /// \tparam V value of the constant
-template<bool_t V> struct bool_constant : integral_constant<bool_t, V> {};
+template<bool_t V>
+struct bool_constant
+	: integral_constant<bool_t, V> {};
+
 
 ///
 ///
 /// \brief metaprogramming true constant
-struct true_type  : bool_constant<true>  {};
+struct true_type
+	: bool_constant<true>  {};
+
 
 ///
 ///
 /// \brief metaprogramming false constant
-struct false_type : bool_constant<false> {};
+struct false_type
+	: bool_constant<false> {};
 
 }
 

include/fennec/lang/detail/__type_traits.h

@@ -16,14 +16,10 @@
 //  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 // =====================================================================================================================
 
-/// \file __type_traits.h
-/// \internal
-
 #ifndef FENNEC_LANG_DETAIL_TYPE_TRAITS_H
 #define FENNEC_LANG_DETAIL_TYPE_TRAITS_H
 
 #include <fennec/lang/constants.h>
-#include <fennec/lang/type_traits.h>
 #include <fennec/lang/float.h>
 
 namespace fennec

include/fennec/lang/limits.h

@@ -28,6 +28,8 @@
 namespace fennec
 {
 
+///
+/// \brief enum for determining rounding styles
 enum float_round_style
 {
 	round_indeterminate       = -1

include/fennec/lang/sequences.h

@@ -199,23 +199,23 @@ struct concat_sequence<index_sequence<SequenceV0...>, index_sequence<SequenceV1.
 
 // Internal ============================================================================================================
 
-/// \internal Implementation for Generating an \ref integer_sequence
+// Implementation for Generating an \ref integer_sequence
 template<typename T, size_t N> struct make_integer_sequence : concat_sequence_t<make_integer_sequence_t<T, N / 2>, make_integer_sequence_t<T, N - N / 2>>{};
 
-/// \internal Base Case of \f$N=0\f$
+// Base Case of \f$N=0\f$
 template<typename T> struct make_integer_sequence<T, 0> : integer_sequence<T> {};
 
-/// \internal Base Case of \f$N=1\f$
+// Base Case of \f$N=1\f$
 template<typename T> struct make_integer_sequence<T, 1> : integer_sequence<T, 0>{};
 
 
-/// \internal Implementation for Generating an \ref integer_sequence
+// Implementation for Generating an \ref integer_sequence
 template<size_t N> struct make_index_sequence : concat_sequence_t<make_index_sequence_t<N / 2>, make_index_sequence_t<N - N / 2>>{};
 
-/// \internal Base Case of \f$N=0\f$
+// Base Case of \f$N=0\f$
 template<> struct make_index_sequence<0> : index_sequence<> {};
 
-/// \internal Base Case of \f$N=1\f$
+// Base Case of \f$N=1\f$
 template<> struct make_index_sequence<1> : index_sequence<0>{};
 
 

include/fennec/lang/type_transforms.h

@@ -76,7 +76,7 @@ template<typename T> using add_pointer_t = typename add_pointer<T>::type;
 /// \tparam T Resultant Type
 template<typename T> struct remove_pointer : type_transform<T> {};
 
-/// \internal specialization for T*
+// specialization for T*
 template<typename T> struct remove_pointer<T*> : type_transform<T> {};
 
 ///
@@ -110,10 +110,10 @@ template<typename T> using  add_reference_t = typename add_reference<T>::type;
 /// \tparam T Reference Type
 template<typename T> struct remove_reference : type_transform<T> {};
 
-/// \internal specialization for ```T&```
+// specialization for ```T&```
 template<typename T> struct remove_reference<T&> : type_transform<T> {};
 
-/// \internal specialization for ```T&&```
+// specialization for ```T&&```
 template<typename T> struct remove_reference<T&&> : type_transform<T> {};
 
 ///
@@ -138,7 +138,7 @@ template<typename T> struct add_const : type_transform<const T> {};
 /// \brief shorthand for ```typename add_const<T>::type```
 template<typename T> using add_const_t = typename add_const<T>::type;
 
-/// \internal specialization for const types
+// specialization for const types
 template<typename T> struct add_const<const T> : type_transform<const T> {};
 
 
@@ -155,7 +155,7 @@ template<typename T> struct remove_const : type_transform<T> {};
 /// \brief shorthand for ```typename remove_const<T>::type```
 template<typename T> using remove_const_t = typename remove_const<T>::type;
 
-/// \internal specialization for const types
+// specialization for const types
 template<typename T> struct remove_const<const T> : type_transform<T> {};
 
 
@@ -173,7 +173,7 @@ template<typename T> struct add_volatile : type_transform<volatile T> {};
 /// \brief shorthand for ```typename add_volatile<T>::type```
 template<typename T> using add_volatile_t = typename add_volatile<T>::type;
 
-/// \internal specialization for volatile types
+// specialization for volatile types
 template<typename T> struct add_volatile<volatile T> : type_transform<volatile T> {};
 
 
@@ -190,7 +190,7 @@ template<typename T> struct remove_volatile : type_transform<T> {};
 /// \brief shorthand for ```typename remove_volatile<T>::type```
 template<typename T> using remove_volatile_t = typename remove_volatile<T>::type;
 
-/// \internal specialization for volatile types
+// specialization for volatile types
 template<typename T> struct remove_volatile<volatile T> : type_transform<T> {};
 
 
@@ -209,13 +209,13 @@ template<typename T> struct add_cv : type_transform<const volatile T> {};
 /// \brief shorthand for ```typename add_cv<T>::type```
 template<typename T> using add_cv_t = typename add_cv<T>::type;
 
-/// \internal specialization for const types
+// specialization for const types
 template<typename T> struct add_cv<const T> : type_transform<const volatile T> {};
 
-/// \internal specialization for volatile types
+// specialization for volatile types
 template<typename T> struct add_cv<volatile T> : type_transform<const volatile T> {};
 
-/// \internal specialization for const volatile types
+// specialization for const volatile types
 template<typename T> struct add_cv<const volatile T> : type_transform<const volatile T> {};
 
 
@@ -229,13 +229,13 @@ template<typename T> struct add_cv<const volatile T> : type_transform<const vola
 /// \tparam T Reference Type
 template<typename T> struct remove_cv : type_transform<T> {};
 
-/// \internal specialization for const types
+// specialization for const types
 template<typename T> struct remove_cv<const T> : type_transform<T> {};
 
-/// \internal specialization for volatile types
+// specialization for volatile types
 template<typename T> struct remove_cv<volatile T> : type_transform<T> {};
 
-/// \internal specialization for const volatile types
+// specialization for const volatile types
 template<typename T> struct remove_cv<const volatile T> : type_transform<T> {};
 
 ///