math-common.hpp File Reference

#include <array>
#include <assert.h>
#include <cmath>
#include <concepts>
#include <numbers>
#include <ostream>
#include <type_traits>

Include dependency graph for math-common.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	mal_math::_detail::primitive_reference_wrapper< T >
	Reference wrapper for primitives which does not allow rebinding after instantiation. More...
struct	mal_math::_detail::is_mat< T >
	Trait to determine if a type is a matrix. More...
struct	mal_math::_detail::is_mat< mat< a, b, T > >
	Trait to determine if a type is a matrix. More...
struct	mal_math::_detail::is_mat< rmat< a, b, T > >
	Trait to determine if a type is a matrix. More...
struct	mal_math::_detail::is_reference_vec< T >
	Trait to determine if a type is a reference vector. More...
struct	mal_math::_detail::is_reference_vec< _detail::rvec< size, T > >
	Trait to determine if a type is a reference vector. More...
struct	mal_math::_detail::is_default_vec< T >
	Trait to determine if a type is a default vector. More...
struct	mal_math::_detail::is_default_vec< vec< size, T > >
	Trait to determine if a type is a default vector. More...

Namespaces
namespace	mal_math
	Contains mathematical utility functions and classes.
namespace	mal_math::_detail

Concepts
concept	mal_math::Primitive
	Concept that ensures a type is either floating point or integral.
concept	mal_math::AnyMat
	Concept to determine if a type is any kind of matrix.
concept	mal_math::AnyVec
	Concept to determine if a type is any kind of vector.
concept	mal_math::Vec
	Concept to determine if a type is a default vector.
concept	mal_math::RVec
	Concept to determine if a type is a reference vector.

Functions
template<class T > requires (!std::numeric_limits<T>::is_integer)
bool	mal_math::almost_equal (T x, T y, int ulp=2)
	Function to determine if two values are almost equal within a certain tolerance.
template<class T > requires (!std::numeric_limits<T>::is_integer)
constexpr T	mal_math::radians (T x) noexcept
	Function to convert degrees to radians.
template<Primitive T>
constexpr T	mal_math::clamp (T x, T min, T max) noexcept
	Function to clamp a value between a minimum and maximum.
template<Primitive T>
float	mal_math::cos (T x) noexcept
double	mal_math::cos (double x)
long double	mal_math::cos (long double x)
template<Primitive T>
float	mal_math::sin (T x) noexcept
double	mal_math::sin (double x)
long double	mal_math::sin (long double x)
template<Primitive T>
float	mal_math::tan (T x) noexcept
double	mal_math::tan (double x)
long double	mal_math::tan (long double x)
template<Primitive T>
float	mal_math::acos (T x) noexcept
double	mal_math::acos (double x)
long double	mal_math::acos (long double x)
template<Primitive T>
float	mal_math::asin (T x) noexcept
double	mal_math::asin (double x)
long double	mal_math::asin (long double x)
template<Primitive T>
float	mal_math::atan (T x) noexcept
double	mal_math::atan (double x)
long double	mal_math::atan (long double x)
template<Primitive T>
float	mal_math::atan2 (T x, T y) noexcept
double	mal_math::atan2 (double x, double y)
long double	mal_math::atan2 (long double x, long double y)
template<Primitive T>
float	mal_math::cosh (T x) noexcept
double	mal_math::cosh (double x)
long double	mal_math::cosh (long double x)
template<Primitive T>
float	mal_math::sinh (T x) noexcept
double	mal_math::sinh (double x)
long double	mal_math::sinh (long double x)
template<Primitive T>
float	mal_math::tanh (T x) noexcept
double	mal_math::tanh (double x)
long double	mal_math::tanh (long double x)
template<Primitive T>
float	mal_math::acosh (T x) noexcept
double	mal_math::acosh (double x)
long double	mal_math::acosh (long double x)
template<Primitive T>
float	mal_math::asinh (T x) noexcept
double	mal_math::asinh (double x)
long double	mal_math::asinh (long double x)
template<Primitive T>
float	mal_math::atanh (T x) noexcept
double	mal_math::atanh (double x)
long double	mal_math::atanh (long double x)
template<Primitive T>
float	mal_math::exp (T x) noexcept
double	mal_math::exp (double x)
long double	mal_math::exp (long double x)
template<Primitive T>
float	mal_math::exp2 (T x) noexcept
double	mal_math::exp2 (double x)
long double	mal_math::exp2 (long double x)
template<Primitive T>
float	mal_math::expm1 (T x) noexcept
double	mal_math::expm1 (double x)
long double	mal_math::expm1 (long double x)
template<Primitive T>
float	mal_math::log (T x) noexcept
double	mal_math::log (double x)
long double	mal_math::log (long double x)
template<Primitive T>
float	mal_math::log2 (T x) noexcept
double	mal_math::log2 (double x)
long double	mal_math::log2 (long double x)
template<Primitive T>
float	mal_math::log10 (T x) noexcept
double	mal_math::log10 (double x)
long double	mal_math::log10 (long double x)
template<Primitive T>
float	mal_math::log1p (T x) noexcept
double	mal_math::log1p (double x)
long double	mal_math::log1p (long double x)
template<Primitive T>
float	mal_math::logb (T x) noexcept
double	mal_math::logb (double x)
long double	mal_math::logb (long double x)
template<Primitive T>
float	mal_math::sqrt (T x) noexcept
double	mal_math::sqrt (double x)
long double	mal_math::sqrt (long double x)
template<Primitive T>
float	mal_math::inversesqrt (T x) noexcept
double	mal_math::inversesqrt (double x)
long double	mal_math::inversesqrt (long double x)
template<Primitive T>
T	mal_math::abs (T x) noexcept
template<Primitive T>
int	mal_math::sign (T x) noexcept
template<Primitive T>
T	mal_math::floor (T x) noexcept
template<Primitive T>
T	mal_math::ceil (T x) noexcept
template<Primitive T>
T	mal_math::trunc (T x) noexcept
template<Primitive T>
T	mal_math::round (T x) noexcept
template<Primitive T>
T	mal_math::roundEven (T x) noexcept
template<Primitive T>
T	mal_math::fract (T x) noexcept
template<Primitive T, Primitive U>
float	mal_math::mod (T x, U y) noexcept
double	mal_math::mod (double x, double y)
long double	mal_math::mod (long double x, long double y)
template<Primitive T, Primitive U>
float	mal_math::pow (T x, U y) noexcept
template<Primitive U>
double	mal_math::pow (double x, U y)
template<Primitive U>
long double	mal_math::pow (long double x, U y)

Variables
template<class T >
constexpr bool	mal_math::_detail::is_mat_v = is_mat<T>::value
	Boolean value which is true if the given type is a matrix.
template<class T >
constexpr bool	mal_math::_detail::is_reference_vec_v = is_reference_vec<T>::value
	Boolean value which is true if the given type is a reference vector.
template<class T >
constexpr bool	mal_math::_detail::is_default_vec_v = is_default_vec<T>::value
	Boolean value which is true if the given type is a common vector.
template<class T >
constexpr bool	mal_math::_detail::is_vec_v = is_reference_vec_v<T> || is_default_vec_v<T>
	Boolean value which is true if the given type is any vector.

Detailed Description

Author

malatindez (Vladyslav Ohlii)

Date

12/09/2023

This file provides a collection of mathematical utility structures and functions. It introduces various mathematical concepts such as vectors, matrices, and mathematical functions to assist in operations like vector and matrix arithmetic, transformations, and other common mathematical tasks.

Concepts:

• Primitive: Determines whether a type is integral or floating point.
• AnyMat: Determines whether a type is any kind of matrix.
• AnyVec: Determines whether a type is any kind of vector.
• Vec: Determines whether a type is a default vector.
• RVec: Determines whether a type is a reference vector.

Structures:

• vec: Represents a mathematical vector.
• mat: Represents a mathematical matrix.
• rmat: Represents a mathematical matrix with reference semantics.
• _detail::rvec: Represents a mathematical vector with reference semantics.
• _detail::primitive_reference_wrapper: A reference wrapper for primitive types with specific utilities.
• _detail::is_mat, _detail::is_default_vec, _detail::is_reference_vec: Type traits to determine specific types.

Mathematical functions:

• Trigonometric functions: sin, cos, tan, etc.
• Hyperbolic functions: sinh, cosh, tanh, etc.
• Exponential and logarithmic functions: exp, log, etc.
• Power and absolute functions: sqrt, abs, etc.
• Rounding and remainder functions: floor, ceil, round, etc.

Additional utilities:

• almost_equal: Compares two floating point numbers for approximate equality.
• radians: Converts degrees to radians.
• clamp: Clamps a value between a minimum and maximum.

Note

This file uses C++20 concepts for type-checking and constraints.

Definition in file math-common.hpp.