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

Fixed further documentation in the Math Library

Browse Source
This commit is contained in:
Medusa Slockbower 2025-05-26 14:58:38 -04:00
parent e6b3d45e2e
commit 1a27e37f66
14 changed files with 124 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
include/fennec/lang/conditional_types.h
View File

@ -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>{};
}

13
include/fennec/lang/constants.h
View File

@ -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> {};
}

4
include/fennec/lang/detail/__type_traits.h
View File

@ -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

2
include/fennec/lang/limits.h
View File

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

12
include/fennec/lang/sequences.h
View File

@ -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>{};

26
include/fennec/lang/type_transforms.h
View File

@ -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> {};
///

3
include/fennec/math/detail/__fwd.h
View File

@ -16,9 +16,6 @@
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
/// \file __fwd.h
/// \internal
#ifndef FWD_H
#define FWD_H

12
include/fennec/math/detail/__types.h
View File

@ -16,9 +16,6 @@
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
/// \file __types.h
/// \internal
#ifndef FENNEC_MATH_DETAIL_TYPES_H
#define FENNEC_MATH_DETAIL_TYPES_H
@ -30,11 +27,12 @@ namespace fennec
namespace detail
{
/// \internal
template<template<typename, size_t...> typename VectorT, typename ScalarT, size_t...IndicesV> VectorT<ScalarT, IndicesV...> __gen_vector(index_sequence<IndicesV...>);
template<template<typename, size_t...> typename VectorT, typename ScalarT, size_t...IndicesV>
VectorT<ScalarT, IndicesV...> __gen_vector(index_sequence<IndicesV...>);
/// \internal
template<template<typename, size_t...> typename MatrixT, typename ScalarT, size_t RowsV, size_t...IndicesV> MatrixT<ScalarT, RowsV, IndicesV...> __gen_matrix(index_sequence<IndicesV...>);
template<template<typename, size_t...> typename MatrixT, typename ScalarT, size_t RowsV, size_t...IndicesV>
MatrixT<ScalarT, RowsV, IndicesV...> __gen_matrix(index_sequence<IndicesV...>);
}

52
include/fennec/math/detail/__vector_traits.h
View File

@ -16,9 +16,6 @@
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
/// \file __vector_traits.h
/// \internal
#ifndef FENNEC_MATH_DETAIL_VECTOR_TRAITS_H
#define FENNEC_MATH_DETAIL_VECTOR_TRAITS_H
@ -33,17 +30,46 @@ namespace fennec
namespace detail
{
template<typename> struct __is_vector_helper : false_type {};
template<typename ScalarT, size_t...IndicesV> struct __is_vector_helper<vector<ScalarT, IndicesV...>> : true_type {};
template<typename VectorT, typename DataT, typename ScalarT, size_t...IndicesV>
struct __is_vector_helper<swizzle<VectorT, DataT, ScalarT, IndicesV...>> : true_type {};
template<typename>
struct __is_vector_helper
: false_type {};
template<typename> struct __component_count_helper;
template<typename TypeT> requires(is_arithmetic_v<TypeT>) struct __component_count_helper<TypeT> : integral_constant<size_t, 1> {};
template<typename ScalarT, size_t...IndicesV> struct __component_count_helper<vector<ScalarT, IndicesV...>> : integral_constant<size_t, sizeof...(IndicesV)> {};
template<typename VectorT, typename DataT, typename ScalarT, size_t...IndicesV> struct __component_count_helper<swizzle<VectorT, DataT, ScalarT, IndicesV...>> : integral_constant<size_t, sizeof...(IndicesV)> {};
template<typename ScalarT, size_t RowsV, size_t...ColIndicesV> struct __component_count_helper<matrix<ScalarT, RowsV, ColIndicesV...>> : integral_constant<size_t, RowsV * sizeof...(ColIndicesV)> {};
template<typename> struct __component_count_helper : integral_constant<size_t, 0> {};
template<typename ScalarT, size_t...IndicesV>
struct __is_vector_helper<vector<ScalarT, IndicesV...>>
: true_type {};
template<typename VectorT, typename DataT, typename ScalarT, size_t...IndicesV>
struct __is_vector_helper<swizzle<VectorT, DataT, ScalarT, IndicesV...>>
: true_type {};
template<typename>
struct __component_count_helper;
template<typename TypeT> requires(is_arithmetic_v<TypeT>)
struct __component_count_helper<TypeT>
: integral_constant<size_t, 1> {};
template<typename ScalarT, size_t...IndicesV>
struct __component_count_helper<vector<ScalarT, IndicesV...>>
: integral_constant<size_t, sizeof...(IndicesV)> {};
template<typename VectorT, typename DataT, typename ScalarT, size_t...IndicesV>
struct __component_count_helper<swizzle<VectorT, DataT, ScalarT, IndicesV...>>
: integral_constant<size_t, sizeof...(IndicesV)> {};
template<typename ScalarT, size_t RowsV, size_t...ColIndicesV>
struct __component_count_helper<matrix<ScalarT, RowsV, ColIndicesV...>>
: integral_constant<size_t, RowsV * sizeof...(ColIndicesV)> {};
template<typename>
struct __component_count_helper
: integral_constant<size_t, 0> {};
}

35
include/fennec/math/exponential.h
View File

@ -49,39 +49,39 @@
/// <th style="vertical-align: top">Description
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// \ref fennec::pow(fennec::genFType<>, fennec::genFType<>) "genFType pow(genFType, genFType)"
/// \ref fennec::pow(fennec::genType, fennec::genType) "genFType pow(genFType, genFType)"
/// <td width="50%" style="vertical-align: top">
/// \copydoc fennec::pow(fennec::genFType<>, fennec::genFType<>)
/// \copydoc fennec::pow(fennec::genType, fennec::genType)
///
/// <tr><td width="50%" style="vertical-align: top" class="odd_c"> <br>
/// \ref fennec::exp(fennec::genFType<>)"genFType exp(genFType)"
/// \ref fennec::exp(fennec::genType)"genFType exp(genFType)"
/// <td width="50%" style="vertical-align: top" class="odd_c">
/// \copydoc fennec::exp(fennec::genFType<>)
/// \copydoc fennec::exp(fennec::genType)
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// \ref fennec::exp2(fennec::genFType<>) "genFType exp2(genFType)"
/// \ref fennec::exp2(fennec::genType) "genFType exp2(genFType)"
/// <td width="50%" style="vertical-align: top">
/// \copydoc fennec::exp2(fennec::genFType<>)
/// \copydoc fennec::exp2(fennec::genType)
///
/// <tr><td width="50%" style="vertical-align: top" class="odd_c"> <br>
/// \ref fennec::log(fennec::genFType<>) "genFType log(genFType)"
/// \ref fennec::log(fennec::genType) "genFType log(genFType)"
/// <td width="50%" style="vertical-align: top" class="odd_c">
/// \copydoc fennec::log(fennec::genFType<>)
/// \copydoc fennec::log(fennec::genType)
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// \ref fennec::log2(fennec::genFType<>) "genFType log2(genFType)"
/// \ref fennec::log2(fennec::genType) "genFType log2(genFType)"
/// <td width="50%" style="vertical-align: top">
/// \copydoc fennec::log2(fennec::genFType<>)
/// \copydoc fennec::log2(fennec::genType)
///
/// <tr><td width="50%" style="vertical-align: top" class="odd_c"> <br>
/// \ref fennec::sqrt(fennec::genFType<>) "genFType sqrt(genFType)"
/// \ref fennec::sqrt(fennec::genType) "genFType sqrt(genFType)"
/// <td width="50%" style="vertical-align: top" class="odd_c">
/// \copydoc fennec::sqrt(fennec::genFType<>)
/// \copydoc fennec::sqrt(fennec::genType)
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// \ref fennec::inversesqrt(fennec::genFType<>) "genFType inversesqrt(genFType)"
/// \ref fennec::inversesqrt(fennec::genType) "genFType inversesqrt(genFType)"
/// <td width="50%" style="vertical-align: top">
/// \copydoc fennec::inversesqrt(fennec::genFType<>)
/// \copydoc fennec::inversesqrt(fennec::genType)
///
/// </table>
///
@ -95,7 +95,6 @@ namespace fennec
// pow -----------------------------------------------------------------------------------------------------------------
///
/// \fn fennec::pow(fennec::genType, fennec::genType)
/// \brief Returns \f$x\f$ raised to the \f$y\f$ power, i.e., \f$x^y\f$.
///
/// \returns \f$x\f$ raised to the \f$y\f$ power, i.e., \f$x^y\f$.<br><br>
@ -115,7 +114,6 @@ constexpr vector<genType, i...> pow(const vector<genType, i...> & x, const vecto
// exp -----------------------------------------------------------------------------------------------------------------
///
/// \fn fennec::exp(fennec::genType)
/// \brief Returns the natural exponentiation of \f$x\f$, i.e., \f$e^x\f$
///
/// \returns the natural exponentiation of \f$x\f$, i.e., \f$e^x\f$.<br><br>
@ -131,7 +129,6 @@ template<typename genType, size_t...i> constexpr vector<genType, i...> exp(const
// exp2 ----------------------------------------------------------------------------------------------------------------
///
///
/// \brief Returns 2 raised to the \f$x\f$ power, i.e., \f$e^x\f$
///
@ -148,7 +145,6 @@ template<typename genType, size_t...i> constexpr vector<genType, i...> exp2(cons
// log -----------------------------------------------------------------------------------------------------------------
///
/// \fn fennec::log(fennec::genType)
/// \brief Returns the natural logarithm of \f$x\f$.
///
/// \returns the natural logarithm of \f$x\f$, i.e., returns the value \f$y\f$ which satisfies the equation \f$x=e^y\f$.<br><br>
@ -165,7 +161,6 @@ template<typename genType, size_t...i> constexpr genType log(const vector<genTyp
// log2 ----------------------------------------------------------------------------------------------------------------
///
/// \fn fennec::log2(fennec::genType)
/// \brief Returns the base 2 logarithm of \f$x\f$.
///
/// \returns the base 2 logarithm of \f$x\f$, i.e., returns the value \f$y\f$ which satisfies the equation
@ -183,7 +178,6 @@ template<typename genType, size_t...i> constexpr genType log2(const vector<genTy
// sqrt ----------------------------------------------------------------------------------------------------------------
///
/// \fn fennec::sqrt(fennec::genType)
/// \brief Returns \f$\sqrt{x}\f$.
///
/// \returns \f$\sqrt{x}\f$. <br><br>
@ -200,7 +194,6 @@ template<typename genType, size_t...i> constexpr genType sqrt(const vector<genTy
// inversesqrt ---------------------------------------------------------------------------------------------------------
///
/// \fn fennec::inversesqrt(fennec::genType)
/// \brief Returns \f$\frac{1}{\sqrt{x}}\f$.
///
/// \returns \f$\frac{1}{\sqrt{x}}\f$.<br><br>

9
include/fennec/math/math.h
View File

@ -79,11 +79,14 @@
///
///
#include <fennec/math/swizzle.h>
#include <fennec/math/trigonometric.h>
#include <fennec/math/vector.h>
#include <fennec/math/vector_traits.h>
#include <fennec/math/swizzle.h>
#include <fennec/math/matrix.h>
#include <fennec/math/common.h>
#include <fennec/math/trigonometric.h>
#endif // FENNEC_MATH_H

1
include/fennec/math/swizzle.h
View File

@ -37,7 +37,6 @@
namespace fennec
{
///
///
/// \brief Structure for Handling Vector Swizzling
///

1
include/fennec/math/swizzle_storage.h
View File

@ -26,7 +26,6 @@ namespace fennec
namespace detail
{
///
///
/// \brief Backing storage struct for \ref fennec::swizzle "swizzle"
/// \tparam DataT Data Type

28
include/fennec/math/trigonometric.h
View File

@ -49,12 +49,12 @@
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// \ref fennec::degrees(genType) "genFType degrees(genFType)"
/// <td width="50%" style="vertical-align: top">
/// \copydoc fennec::degrees(genType)
/// \copydoc fennec::degrees(fennec::genType)
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// \ref fennec::radians(genType) "genFType radians(genFType)"
/// <td width="50%" style="vertical-align: top">
/// \copydoc fennec::radians(genType)
/// \copydoc fennec::radians(fennec::genType)
///
/// </table>
///
@ -69,33 +69,33 @@
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// \ref fennec::sin(genType) "genFType sin(genFType)"
/// <td width="50%" style="vertical-align: top">
/// \copydoc fennec::sin(genType)
/// \copydoc fennec::sin(fennec::genType)
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// \ref fennec::cos(genType) "genFType cos(genFType)"
/// <td width="50%" style="vertical-align: top">
/// \copydoc fennec::cos(genType)
/// \copydoc fennec::cos(fennec::genType)
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// \ref fennec::tan(genType) "genFType tan(genFType)"
/// <td width="50%" style="vertical-align: top">
/// \copydoc fennec::tan(genType)
/// \copydoc fennec::tan(fennec::genType)
///
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// \ref fennec::asin(genType) "genFType asin(genFType)"
/// <td width="50%" style="vertical-align: top">
/// \copydoc fennec::asin(genType)
/// \copydoc fennec::asin(fennec::genType)
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// \ref fennec::acos(genType) "genFType acos(genFType)"
/// <td width="50%" style="vertical-align: top">
/// \copydoc fennec::acos(genType)
/// \copydoc fennec::acos(fennec::genType)
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// \ref fennec::atan(genType) "genFType atan(genFType)"
/// <td width="50%" style="vertical-align: top">
/// \copydoc fennec::atan(genType)
/// \copydoc fennec::atan(fennec::genType)
///
/// </table>
///
@ -110,33 +110,33 @@
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// \ref fennec::sinh(genType) "genFType sinh(genFType)"
/// <td width="50%" style="vertical-align: top">
/// \copydoc fennec::sinh(genType)
/// \copydoc fennec::sinh(fennec::genType)
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// \ref fennec::cosh(genType) "genFType cosh(genFType)"
/// <td width="50%" style="vertical-align: top">
/// \copydoc fennec::cosh(genType)
/// \copydoc fennec::cosh(fennec::genType)
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// \ref fennec::tanh(genType) "genFType tanh(genFType)"
/// <td width="50%" style="vertical-align: top">
/// \copydoc fennec::tanh(genType)
/// \copydoc fennec::tanh(fennec::genType)
///
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// \ref fennec::asinh(genFType) "genFType asinh(genFType)"
/// <td width="50%" style="vertical-align: top">
/// \copydoc fennec::asinh(genType)
/// \copydoc fennec::asinh(fennec::genType)
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// \ref fennec::acosh(genFType) "genFType acosh(genFType)"
/// <td width="50%" style="vertical-align: top">
/// \copydoc fennec::acosh(genType)
/// \copydoc fennec::acosh(fennec::genType)
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// \ref fennec::atanh(genFType) "genFType atanh(genFType)"
/// <td width="50%" style="vertical-align: top">
/// \copydoc fennec::atanh(genType)
/// \copydoc fennec::atanh(fennec::genType)
///
/// </table>
///