Contains mathematical utility functions and classes. More...

Namespaces
namespace	_detail

namespace	random

Classes
struct	Intersection
	Represents the data of a ray's intersection with an object. More...

class	mat
	Definition of matrix with dimensions `rows` x `columns` and type `T` More...

struct	Plane
	Represents a plane in 3D space defined by its normal and two vectors. More...

class	qua
	Represents a quaternion with primitive type T. More...

class	Ray
	Represents a geometric ray in 3D space. More...

struct	rmat
	Definition of a reference matrix with dimensions `rows` x `columns` and type `T` More...

struct	Sphere
	A geometric representation of a sphere in 3D space. More...

struct	TBox
	A templated bounding box structure in 3D. More...

struct	Triangle
	Represents a triangle defined by three 3D points. More...

struct	vec
	Definition of the mathematical vector with fixed size `L` and type `T` More...

struct	vec< 2, T >
	2D vector template class. More...

struct	vec< 3, T >
	Represents a 3D vector of a given primitive type. More...

struct	vec< 4, T >
	Represents a 4D vector of a given primitive type. More...

Concepts
concept	Primitive
	Concept that ensures a type is either floating point or integral.

concept	AnyMat
	Concept to determine if a type is any kind of matrix.

concept	AnyVec
	Concept to determine if a type is any kind of vector.

concept	Vec
	Concept to determine if a type is a default vector.

concept	RVec
	Concept to determine if a type is a reference vector.

Typedefs
using	Box = TBox<float>
	Box defined with floats.

using	Boxf = TBox<float>
	Same as Box.

using	Boxd = TBox<double>
	Box defined with doubles.

using	mat4 = mat<4, 4, float>
	4x4 matrix with float elements.

using	dmat4 = mat<4, 4, double>
	4x4 matrix with double elements.

using	imat4 = mat<4, 4, int>
	4x4 matrix with integer elements.

using	mat4x4 = mat<4, 4, float>
	4x4 matrix with float elements.

using	dmat4x4 = mat<4, 4, double>
	4x4 matrix with double elements.

using	imat4x4 = mat<4, 4, int>
	4x4 matrix with integer elements.

using	mat3 = mat<3, 3, float>
	3x3 matrix with float elements.

using	dmat3 = mat<3, 3, double>
	3x3 matrix with double elements.

using	imat3 = mat<3, 3, int>
	3x3 matrix with integer elements.

using	mat3x3 = mat<3, 3, float>
	3x3 matrix with float elements.

using	dmat3x3 = mat<3, 3, double>
	3x3 matrix with double elements.

using	imat3x3 = mat<3, 3, int>
	3x3 matrix with integer elements.

using	mat2 = mat<2, 2, float>
	2x2 matrix with float elements.

using	dmat2 = mat<2, 2, double>
	2x2 matrix with double elements.

using	imat2 = mat<2, 2, int>
	2x2 matrix with integer elements.

using	mat2x2 = mat<2, 2, float>
	2x2 matrix with float elements.

using	dmat2x2 = mat<2, 2, double>
	2x2 matrix with double elements.

using	imat2x2 = mat<2, 2, int>
	2x2 matrix with integer elements.

using	mat2x3 = mat<2, 3, float>
	2x3 matrix with float elements.

using	dmat2x3 = mat<2, 3, double>
	2x3 matrix with double elements.

using	imat2x3 = mat<2, 3, int>
	2x3 matrix with integer elements.

using	mat3x2 = mat<3, 2, float>
	3x2 matrix with float elements.

using	dmat3x2 = mat<3, 2, double>
	3x2 matrix with double elements.

using	imat3x2 = mat<3, 2, int>
	3x2 matrix with integer elements.

using	mat2x4 = mat<2, 4, float>
	2x4 matrix with float elements.

using	dmat2x4 = mat<2, 4, double>
	2x4 matrix with double elements.

using	imat2x4 = mat<2, 4, int>
	2x4 matrix with integer elements.

using	mat4x2 = mat<4, 2, float>
	4x2 matrix with float elements.

using	dmat4x2 = mat<4, 2, double>
	4x2 matrix with double elements.

using	imat4x2 = mat<4, 2, int>
	4x2 matrix with integer elements.

using	mat3x4 = mat<3, 4, float>
	3x4 matrix with float elements.

using	dmat3x4 = mat<3, 4, double>
	3x4 matrix with double elements.

using	imat3x4 = mat<3, 4, int>
	3x4 matrix with integer elements.

using	mat4x3 = mat<4, 3, float>
	4x3 matrix with float elements.

using	dmat4x3 = mat<4, 3, double>
	4x3 matrix with double elements.

using	imat4x3 = mat<4, 3, int>
	4x3 matrix with integer elements.

using	rmat4 = rmat<4, 4, float>
	4x4 reference matrix to float elements.

using	drmat4 = rmat<4, 4, double>
	4x4 reference matrix to double elements.

using	irmat4 = rmat<4, 4, int>
	4x4 reference matrix to integer elements.

using	rmat4x4 = rmat<4, 4, float>
	4x4 reference matrix to float elements.

using	drmat4x4 = rmat<4, 4, double>
	4x4 reference matrix to double elements.

using	irmat4x4 = rmat<4, 4, int>
	4x4 reference matrix to integer elements.

using	rmat3 = rmat<3, 3, float>
	3x3 reference matrix to float elements.

using	drmat3 = rmat<3, 3, double>
	3x3 reference matrix to double elements.

using	irmat3 = rmat<3, 3, int>
	3x3 reference matrix to integer elements.

using	rmat3x3 = rmat<3, 3, float>
	3x3 reference matrix to float elements.

using	drmat3x3 = rmat<3, 3, double>
	3x3 reference matrix to double elements.

using	irmat3x3 = rmat<3, 3, int>
	3x3 reference matrix to integer elements.

using	rmat2 = rmat<2, 2, float>
	2x2 reference matrix to float elements.

using	drmat2 = rmat<2, 2, double>
	2x2 reference matrix to double elements.

using	irmat2 = rmat<2, 2, int>
	2x2 reference matrix to integer elements.

using	rmat2x2 = rmat<2, 2, float>
	2x2 reference matrix to float elements.

using	drmat2x2 = rmat<2, 2, double>
	2x2 reference matrix to double elements.

using	irmat2x2 = rmat<2, 2, int>
	2x2 reference matrix to integer elements.

using	rmat2x3 = rmat<2, 3, float>
	2x3 reference matrix to float elements.

using	drmat2x3 = rmat<2, 3, double>
	2x3 reference matrix to double elements.

using	irmat2x3 = rmat<2, 3, int>
	2x3 reference matrix to integer elements.

using	rmat3x2 = rmat<3, 2, float>
	3x2 reference matrix to float elements.

using	drmat3x2 = rmat<3, 2, double>
	3x2 reference matrix to double elements.

using	irmat3x2 = rmat<3, 2, int>
	3x2 reference matrix to integer elements.

using	rmat2x4 = rmat<2, 4, float>
	2x4 reference matrix to float elements.

using	drmat2x4 = rmat<2, 4, double>
	2x4 reference matrix to double elements.

using	irmat2x4 = rmat<2, 4, int>
	2x4 reference matrix to integer elements.

using	rmat4x2 = rmat<4, 2, float>
	4x2 reference matrix to float elements.

using	drmat4x2 = rmat<4, 2, double>
	4x2 reference matrix to double elements.

using	irmat4x2 = rmat<4, 2, int>
	4x2 reference matrix to integer elements.

using	rmat3x4 = rmat<3, 4, float>
	3x4 reference matrix to float elements.

using	drmat3x4 = rmat<3, 4, double>
	3x4 reference matrix to double elements.

using	irmat3x4 = rmat<3, 4, int>
	3x4 reference matrix to integer elements.

using	rmat4x3 = rmat<4, 3, float>
	4x3 reference matrix to float elements.

using	drmat4x3 = rmat<4, 3, double>
	4x3 reference matrix to double elements.

using	irmat4x3 = rmat<4, 3, int>
	4x3 reference matrix to integer elements.

using	quat = qua<float>

using	dquat = qua<double>

using	vec2 = vec<2, float>

using	dvec2 = vec<2, double>

using	ivec2 = vec<2, int>

using	uivec2 = vec<2, unsigned int>

using	vec3 = vec<3, float>

using	dvec3 = vec<3, double>

using	ivec3 = vec<3, int>

using	uivec3 = vec<3, unsigned int>

using	vec4 = vec<4, float>

using	dvec4 = vec<4, double>

using	ivec4 = vec<4, int>

using	uivec4 = vec<4, unsigned int>

Functions
template<AnyVec Vector>
constexpr vec< Vector::size, std::remove_const_t< typename Vector::type > >	reflect (Vector const &normal, Vector const &incident) noexcept
	Computes the reflection of an incident vector based on a surface's normal.

template<AnyVec Vector>
constexpr vec< Vector::size, std::remove_const_t< typename Vector::type > >	refract (Vector const &normal, Vector const &incident, float eta) noexcept
	Computes the refraction of a vector given an interface's normal and an index of refraction.

template<AnyMat U>
constexpr std::istream &	operator>> (std::istream &is, U &matrix)
	Reads a matrix from an input stream.

template<AnyMat U>
constexpr std::ostream &	operator<< (std::ostream &os, U const &matrix)
	Writes a matrix to an output stream.

template<AnyMat U, AnyMat V> requires (U::size.x == V::size.y)
constexpr auto	operator* (U const &lhs, V const &rhs)
	Multiplies two matrices.

template<AnyVec V, AnyMat M> requires (V::size == M::size.y)
constexpr auto	operator* (V const &left, M const &right)
	Multiplies a vector by a matrix.

template<AnyMat M, AnyVec V> requires (M::size.x == V::size)
constexpr auto	operator* (M const &left, V const &right)
	Multiplies a matrix by a vector.

template<AnyMat T, Primitive U>
constexpr mat< T::size.x, T::size.y, std::remove_const_t< typename T::type > >	operator* (T const &left, U const right)
	Multiplies a matrix by a primitive.

template<AnyMat T, Primitive U>
constexpr mat< T::size.x, T::size.y, std::remove_const_t< typename T::type > >	operator* (U const left, T const &right)
	Multiplies a matrix by a primitive.

template<AnyMat T, Primitive U>
constexpr mat< T::size.x, T::size.y, std::remove_const_t< typename T::type > >	operator- (T const &left, U const right)
	Subtracts a matrix from a primitive.

template<AnyMat T, Primitive U>
constexpr mat< T::size.x, T::size.y, std::remove_const_t< typename T::type > >	operator+ (U const left, T const &right)
	Adds a matrix to a primitive.

template<AnyMat T, AnyMat U> requires (T::size.x == U::size.x && T::size.y == U::size.y)
constexpr mat< T::size.x, T::size.y, std::remove_const_t< typename T::type > >	operator- (T const left, U const &right)
	Subtracts two matrices.

template<AnyMat T, AnyMat U> requires (T::size.x == U::size.x && T::size.y == U::size.y)
constexpr mat< T::size.x, T::size.y, std::remove_const_t< typename T::type > >	operator+ (T const &left, U const &right)
	Adds two matrices.

template<AnyMat T>
constexpr mat< T::size.y, T::size.x, std::remove_const_t< typename T::type > >	transpose (T const &matrix)
	Transposes a matrix.

template<AnyMat T>
constexpr rmat< T::size.y, T::size.x, typename T::type >	rtranspose (T &matrix)
	Transposes a matrix and returns a reference to it.

template<AnyMat T>
constexpr rmat< T::size.y, T::size.x, const typename T::type >	rctranspose (T const &matrix)
	Transposes a constant matrix and returns a constant reference to it.

template<AnyMat T> requires (T::size.x == T::size.y)
constexpr T::type	det (T const &matrix)
	Calculates the determinant of a square matrix.

template<AnyMat T> requires (T::size.x == T::size.y)
constexpr T::type	determinant (T const &matrix)
	Calculates the determinant of a square matrix.

template<AnyMat T> requires (T::size.x == T::size.y)
constexpr mat< T::size.x, T::size.y, std::remove_const_t< typename T::type > >	adj (T const &m)
	Computes the adjoint (or adjugate) of a square matrix.

template<AnyMat T> requires (T::size.x == T::size.y)
constexpr mat< T::size.x, T::size.y, std::remove_const_t< typename T::type > >	adjugate (T const &m)
	Alias for the adj() function to compute the adjugate of a matrix.

template<AnyMat T> requires (T::size.x == T::size.y)
constexpr mat< T::size.x, T::size.y, std::remove_const_t< typename T::type > >	inverse (T const &matrix)
	Calculates the inverse of a square matrix.

template<AnyMat T, AnyVec V> requires (T::size.x == T::size.y && T::size.x == 4 && V::size == 3)
constexpr mat< 4, 4, std::remove_const_t< typename T::type > >	translate (T const &matrix, V const &vec)
	Translates a matrix by a given vector.

template<AnyMat T, Primitive U, AnyVec V> requires (T::size.x == T::size.y && T::size.x == 4 && V::size == 3)
constexpr mat< 4, 4, std::remove_const_t< typename T::type > >	rotate (T const &matrix, U angle, V const &axis)
	Rotates a matrix by a given angle around a given axis.

template<AnyMat T, AnyVec V> requires (T::size.x == T::size.y && T::size.x == 4 && V::size == 3)
constexpr mat< 4, 4, std::remove_const_t< typename T::type > >	scale (T const &matrix, V const &scale)
	Scales a matrix by a given vector.

template<AnyVec Position> requires (Position::size == 3)
constexpr mat< 4, 4, std::remove_const_t< typename Position::type > >	look_at (Position const &eye, Position const &center, Position const &up)
	Generates a look-at matrix for camera positioning.

template<Primitive T>
constexpr mat< 4, 4, T >	perspective (T fov_y, T aspect_ratio, T z_near, T z_far)
	Generates a perspective projection matrix.

template<Primitive T>
constexpr mat< 4, 4, T >	ortho (T left, T right, T bottom, T top, T zNear, T zFar)
	Generates an orthographic projection matrix.

template<Primitive T>
constexpr void	invert_orthonormal (mat< 4, 4, T > const &src, mat< 4, 4, T > &dst)
	Inverts an orthonormal matrix in-place and stores the result in a destination matrix.

template<Primitive T>
constexpr void	invert_orthogonal (mat< 4, 4, T > const &src, mat< 4, 4, T > &dst)
	Inverts an orthogonal matrix in-place and stores the result in a destination matrix.

template<Primitive T>
constexpr mat< 4, 4, T >	invert_orthonormal (mat< 4, 4, T > const &src)
	Returns an inverted orthonormal matrix.

template<Primitive T>
constexpr mat< 4, 4, T >	invert_orthogonal (mat< 4, 4, T > const &src)
	Returns an inverted orthogonal matrix.

template<AnyMat T> requires (T::size.x == T::size.y && T::size.x == 2)
constexpr T::type	det_2 (T const &m)

template<AnyMat T> requires (T::size.x == T::size.y && T::size.x == 3)
constexpr T::type	det_3 (T const &m)

template<AnyMat T> requires (T::size.x == T::size.y && T::size.x == 4)
constexpr T::type	det_4 (T const &m)

template<Primitive T> requires (!std::numeric_limits<T>::is_integer)
constexpr mat< 4, 4, T >	perspective (T fov_y, T aspect_ratio, T z_near, T z_far)
	Generates a perspective projection matrix.

template<class T > requires (!std::numeric_limits<T>::is_integer)
bool	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	radians (T x) noexcept
	Function to convert degrees to radians.

template<Primitive T>
constexpr T	clamp (T x, T min, T max) noexcept
	Function to clamp a value between a minimum and maximum.

template<Primitive T>
float	cos (T x) noexcept

double	cos (double x)

long double	cos (long double x)

template<Primitive T>
float	sin (T x) noexcept

double	sin (double x)

long double	sin (long double x)

template<Primitive T>
float	tan (T x) noexcept

double	tan (double x)

long double	tan (long double x)

template<Primitive T>
float	acos (T x) noexcept

double	acos (double x)

long double	acos (long double x)

template<Primitive T>
float	asin (T x) noexcept

double	asin (double x)

long double	asin (long double x)

template<Primitive T>
float	atan (T x) noexcept

double	atan (double x)

long double	atan (long double x)

template<Primitive T>
float	atan2 (T x, T y) noexcept

double	atan2 (double x, double y)

long double	atan2 (long double x, long double y)

template<Primitive T>
float	cosh (T x) noexcept

double	cosh (double x)

long double	cosh (long double x)

template<Primitive T>
float	sinh (T x) noexcept

double	sinh (double x)

long double	sinh (long double x)

template<Primitive T>
float	tanh (T x) noexcept

double	tanh (double x)

long double	tanh (long double x)

template<Primitive T>
float	acosh (T x) noexcept

double	acosh (double x)

long double	acosh (long double x)

template<Primitive T>
float	asinh (T x) noexcept

double	asinh (double x)

long double	asinh (long double x)

template<Primitive T>
float	atanh (T x) noexcept

double	atanh (double x)

long double	atanh (long double x)

template<Primitive T>
float	exp (T x) noexcept

double	exp (double x)

long double	exp (long double x)

template<Primitive T>
float	exp2 (T x) noexcept

double	exp2 (double x)

long double	exp2 (long double x)

template<Primitive T>
float	expm1 (T x) noexcept

double	expm1 (double x)

long double	expm1 (long double x)

template<Primitive T>
float	log (T x) noexcept

double	log (double x)

long double	log (long double x)

template<Primitive T>
float	log2 (T x) noexcept

double	log2 (double x)

long double	log2 (long double x)

template<Primitive T>
float	log10 (T x) noexcept

double	log10 (double x)

long double	log10 (long double x)

template<Primitive T>
float	log1p (T x) noexcept

double	log1p (double x)

long double	log1p (long double x)

template<Primitive T>
float	logb (T x) noexcept

double	logb (double x)

long double	logb (long double x)

template<Primitive T>
float	sqrt (T x) noexcept

double	sqrt (double x)

long double	sqrt (long double x)

template<Primitive T>
float	inversesqrt (T x) noexcept

double	inversesqrt (double x)

long double	inversesqrt (long double x)

template<Primitive T>
T	abs (T x) noexcept

template<Primitive T>
int	sign (T x) noexcept

template<Primitive T>
T	floor (T x) noexcept

template<Primitive T>
T	ceil (T x) noexcept

template<Primitive T>
T	trunc (T x) noexcept

template<Primitive T>
T	round (T x) noexcept

template<Primitive T>
T	roundEven (T x) noexcept

template<Primitive T>
T	fract (T x) noexcept

template<Primitive T, Primitive U>
float	mod (T x, U y) noexcept

double	mod (double x, double y)

long double	mod (long double x, long double y)

template<Primitive T, Primitive U>
float	pow (T x, U y) noexcept

template<Primitive U>
double	pow (double x, U y)

template<Primitive U>
long double	pow (long double x, U y)

template<size_t size, Primitive T>
constexpr std::istream &	operator>> (std::istream &is, vec< size, T > &vec)
	Reads a vector of given size from an input stream.

template<size_t size, Primitive T>
constexpr std::ostream &	operator<< (std::ostream &os, vec< size, T > &vec)
	Writes a vector of given size to an output stream.

template<Primitive T, Primitive U>
constexpr qua< T >	operator* (U const value, qua< T > const &vector) noexcept
	Scalar-quaternion multiplication.

template<Primitive T, Primitive U>
constexpr qua< T >	operator/ (U const value, qua< T > const &vector) noexcept
	Scalar-quaternion division.

template<Primitive T, Primitive U>
constexpr qua< T >	operator* (qua< T > const &vector, U const value) noexcept
	Quaternion-scalar multiplication.

template<Primitive T, Primitive U>
constexpr qua< T >	operator/ (qua< T > const &vector, U const value) noexcept
	Quaternion-scalar division.

template<Primitive T, Primitive U>
constexpr qua< T >	operator+ (qua< T > const &left, qua< U > const &right) noexcept
	Quaternion addition.

template<Primitive T, Primitive U>
constexpr qua< T >	operator- (qua< T > const &left, qua< U > const &right) noexcept
	Quaternion subtraction.

template<Primitive T, Primitive U>
constexpr qua< T >	operator* (qua< T > const &left, qua< U > const &right) noexcept
	Quaternion multiplication.

template<Primitive T, Primitive U>
constexpr qua< T >	operator/ (qua< T > const &left, qua< U > const &right) noexcept
	Quaternion division.

template<Primitive T, Primitive U>
constexpr T	dot (qua< T > const &left, qua< U > const &right) noexcept
	Computes the dot product of two quaternions.

template<Primitive T>
constexpr T	angle (qua< T > const &quaternion) noexcept
	Computes the angle (or magnitude) of a quaternion.

template<Primitive T>
constexpr T	pitch (qua< T > const &quaternion) noexcept
	Computes the pitch from a quaternion.

template<Primitive T>
constexpr T	yaw (qua< T > const &quaternion) noexcept
	Computes the yaw from a quaternion.

template<Primitive T>
constexpr T	roll (qua< T > const &quaternion) noexcept
	Computes the roll from a quaternion.

template<Primitive T>
constexpr vec< 3, T >	QuaternionToEuler (qua< T > const &quaternion) noexcept
	Converts a quaternion to Euler angles.

template<Primitive T>
constexpr qua< T >	QuaternionFromEuler (vec< 3, T > const &angles) noexcept
	Creates a quaternion from Euler angles given in a vector.

template<Primitive T> requires (std::is_floating_point_v<T>)
constexpr qua< T >	QuaternionFromEuler (T roll, T pitch, T yaw) noexcept
	Creates a quaternion from individual Euler angles.

template<AnyMat U> requires (U::size.x == 3 && U::size.y == 3 && std::is_floating_point_v<typename U::type>)
constexpr qua< typename U::type >	QuaternionFromRotationMatrix (U const &mat) noexcept
	Creates a quaternion from a 3x3 rotation matrix.

template<Primitive T>
constexpr qua< T >	operator* (qua< T > const &q, qua< T > const &p) noexcept
	Quaternion-Quaternion multiplication.

template<Primitive T>
constexpr vec< 3, T >	operator* (qua< T > const &q, vec< 3, T > const &v) noexcept
	Quaternion-Vector multiplication.

template<Primitive T>
constexpr vec< 3, T >	operator* (vec< 3, T > const &v, qua< T > const &q) noexcept
	Vector-Quaternion multiplication.

template<Primitive T>
constexpr qua< T >	conjugate (qua< T > const &q) noexcept
	Computes the conjugate of a quaternion.

template<Primitive T>
constexpr qua< T >	inverse (qua< T > const &q) noexcept
	Computes the inverse of a quaternion.

template<Primitive T, Primitive U>
constexpr vec< 3, T >	cross (qua< T > const &left, vec< 3, U > const &right) noexcept
	Cross product between quaternion and vector.

template<Primitive T, Primitive U>
constexpr vec< 3, T >	cross (vec< 3, U > const &left, qua< T > const &right) noexcept
	Cross product between vector and quaternion.

template<Primitive T, Primitive U>
constexpr qua< T >	cross (qua< T > const &left, qua< U > const &right) noexcept
	Computes the cross product of two quaternions.

template<Primitive T>
constexpr mat< 4, 4, T >	rotate (mat< 4, 4, T > const &matrix, qua< T > const &q) noexcept
	Rotates a 4x4 matrix using a quaternion.

template<Primitive T>
constexpr T	length (qua< T > const &q) noexcept
	Computes the length (or magnitude) of a quaternion.

template<Primitive T>
constexpr qua< T >	normalize (qua< T > const &q) noexcept
	Normalizes a quaternion.

template<Primitive T>
constexpr std::istream &	operator>> (std::istream &is, qua< T > &vec)

template<Primitive T>
constexpr std::ostream &	operator<< (std::ostream &os, qua< T > &vec)

template<Primitive T>
qua< T > constexpr	conjugate (qua< T > const &q) noexcept
	Computes the conjugate of a quaternion.

template<Primitive T>
qua< T > constexpr	inverse (qua< T > const &q) noexcept
	Computes the inverse of a quaternion.

template<Primitive T>
constexpr qua< T >	rotate (mat< 4, 4, T > const &matrix, qua< T > const &q) noexcept
	Rotates a 4x4 matrix using a quaternion.

template<Primitive T, Primitive U>
constexpr vec< 3, T >	cross (vec< 3, T > const &left, vec< 3, U > const &right)
	Computes the cross product of two 3D vectors.

template<AnyVec U>
constexpr std::ostream &	operator<< (std::ostream &os, U &vec)
	Output stream operator overload for vector objects.

template<size_t n, AnyVec Vector> requires (n >= 2 && n <= Vector::size)
constexpr vec< n, typename Vector::type > &	as_rvec (Vector &v) noexcept
	Convert a given vector to a reference of vec with specified size and type.

template<AnyVec Vector>
constexpr vec< Vector::size, typename Vector::type > &	as_rvec (Vector &v) noexcept
	Convert a given vector to a reference of vec with the same size and type.

template<size_t n, Primitive U, AnyVec Vector> requires (n >= 2 && n <= Vector::size)
constexpr vec< n, U >	as_vec (Vector const &v) noexcept
	Create a new vector of a specified size and type from the given vector.

template<size_t n, AnyVec Vector> requires (n >= 2 && n <= Vector::size)
constexpr vec< n, std::remove_const_t< typename Vector::type > >	as_vec (Vector const &v) noexcept
	Create a new vector of a specified size from the given vector, preserving the type.

template<AnyVec Vector>
constexpr vec< Vector::size, std::remove_const_t< typename Vector::type > >	as_vec (Vector const &v) noexcept
	Create a new vector of the same size from the given vector, preserving the type.

template<size_t n, AnyVec Vector> requires (n >= 2 && n <= Vector::size)
constexpr vec< n, typename Vector::type > const &	as_crvec (Vector const &v) noexcept
	Convert a given const vector to a const reference of vec with specified size and type.

template<AnyVec Vector>
constexpr vec< Vector::size, typename Vector::type > const &	as_crvec (Vector const &v) noexcept
	Convert a given const vector to a const reference of vec with the same size and type.

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, T >	operator+ (vec< size, T > const &vector, U const value) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, T >	operator- (vec< size, T > const &vector, U const value) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, T >	operator* (vec< size, T > const &vector, U const value) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, T >	operator/ (vec< size, T > const &vector, U const value) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, T >	operator* (U const value, vec< size, T > const &vector) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, T >	operator/ (U const value, vec< size, T > const &vector) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, T >	operator+ (U const value, vec< size, T > const &vector) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, T >	operator- (U const value, vec< size, T > const &vector) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, std::remove_const_t< T > >	operator* (U const value, _detail::rvec< size, T > const &vector) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, std::remove_const_t< T > >	operator+ (_detail::rvec< size, T > const &vector, U const value) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, std::remove_const_t< T > >	operator- (_detail::rvec< size, T > const &vector, U const value) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, std::remove_const_t< T > >	operator* (_detail::rvec< size, T > const &vector, U const value) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, std::remove_const_t< T > >	operator/ (_detail::rvec< size, T > const &vector, U const value) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, std::remove_const_t< T > >	operator% (_detail::rvec< size, T > const &left, U const value) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, T >	operator+ (vec< size, T > const &left, vec< size, U > const &right) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, T >	operator- (vec< size, T > const &left, vec< size, U > const &right) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, T >	operator* (vec< size, T > const &left, vec< size, U > const &right) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, T >	operator/ (vec< size, T > const &left, vec< size, U > const &right) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, T >	operator% (vec< size, T > const &left, U const value) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, T >	operator% (vec< size, T > const &left, vec< size, U > const &right) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, std::remove_const_t< T > >	operator+ (_detail::rvec< size, T > const &left, vec< size, U > const &right) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, std::remove_const_t< T > >	operator- (_detail::rvec< size, T > const &left, vec< size, U > const &right) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, std::remove_const_t< T > >	operator* (_detail::rvec< size, T > const &left, vec< size, U > const &right) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, std::remove_const_t< T > >	operator/ (_detail::rvec< size, T > const &left, vec< size, U > const &right) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, std::remove_const_t< T > >	operator% (_detail::rvec< size, T > const &left, vec< size, U > const &right) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, std::remove_const_t< T > >	operator+ (_detail::rvec< size, T > const &left, _detail::rvec< size, U > const &right) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, std::remove_const_t< T > >	operator- (_detail::rvec< size, T > const &left, _detail::rvec< size, U > const &right) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, std::remove_const_t< T > >	operator* (_detail::rvec< size, T > const &left, _detail::rvec< size, U > const &right) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, std::remove_const_t< T > >	operator/ (_detail::rvec< size, T > const &left, _detail::rvec< size, U > const &right) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, std::remove_const_t< T > >	operator% (_detail::rvec< size, T > const &left, _detail::rvec< size, U > const &right) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, T >	operator+ (vec< size, T > const &left, _detail::rvec< size, U > const &right) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, T >	operator- (vec< size, T > const &left, _detail::rvec< size, U > const &right) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, T >	operator* (vec< size, T > const &left, _detail::rvec< size, U > const &right) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, T >	operator/ (vec< size, T > const &left, _detail::rvec< size, U > const &right) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, T >	operator% (vec< size, T > const &left, _detail::rvec< size, U > const &right) noexcept

template<AnyVec T, AnyVec U> requires (T::size == U::size)
constexpr bool	operator== (T const &left, U const &right) noexcept

template<AnyVec T, AnyVec U> requires (T::size == U::size)
constexpr bool	operator!= (T const &left, U const &right) noexcept

template<AnyVec T>
constexpr std::remove_const_t< typename T::type >	squared_length (T const &vector) noexcept
	Compute the squared length of the given vector.

template<AnyVec T>
constexpr auto	length (T const &vector) noexcept
	Compute the length (magnitude) of the given vector.

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	unit_vector (T const &vector) noexcept
	Compute the unit vector (normalized vector) of the given vector.

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	normalize (T const &vector) noexcept
	Normalize the given vector.

template<AnyVec T, AnyVec U> requires (T::size == U::size)
constexpr std::remove_const_t< typename T::type >	dot (T const &left, U const &right) noexcept
	Compute the dot product of two vectors.

template<AnyVec T, AnyVec U> requires (T::size == U::size)
constexpr std::remove_const_t< typename T::type >	angle (T const &left, U const &right) noexcept
	Compute the angle between two vectors.

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	cos (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	sin (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	tan (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	acos (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	asin (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	atan (T const &vector) noexcept

template<AnyVec T, AnyVec U> requires (T::size == U::size)
constexpr vec< T::size, std::remove_const_t< typename T::type > >	atan (T const &left, U const &right) noexcept

template<AnyVec T, AnyVec U> requires (T::size == U::size)
constexpr vec< T::size, std::remove_const_t< typename T::type > >	atan2 (T const &left, U const &right) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	cosh (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	sinh (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	tanh (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	acosh (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	asinh (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	atanh (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	exp (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	exp2 (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	expm1 (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	log (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	log2 (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	log10 (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	log1p (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	logb (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	sqrt (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	inversesqrt (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	abs (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	sign (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	floor (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	ceil (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	trunc (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	round (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	roundEven (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	fract (T const &vector) noexcept

template<AnyVec T>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	mod (T const &vector, typename T::type const &scalar) noexcept

template<AnyVec T, AnyVec U> requires (T::size == U::size)
constexpr vec< T::size, std::remove_const_t< typename T::type > >	mod (T const &left, U const &right) noexcept

template<AnyVec T, Primitive U>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	pow (T const &vector, U const pow) noexcept

template<AnyVec T, AnyVec U>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	pow (T const &vector1, U const &vector2) noexcept

template<AnyVec T, AnyVec U> requires (T::size == U::size && T::size == 3)
constexpr vec< 3, std::remove_const_t< typename T::type > >	cross (T const &left, U const &right) noexcept
	Compute the cross product of two 3D vectors.

template<Primitive T, Primitive U>
constexpr void	rclamp (T &left, U const min, U const max) noexcept
	Clamp the value of `left` between `min` and `max` in-place.

template<AnyVec T, AnyVec U> requires (T::size == U::size)
constexpr void	rclamp (T &left, U const min, U const max) noexcept
	Clamp the value of `left` between `min` and `max` in-place.

template<AnyVec T, Primitive U>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	clamp (T const &left, U const min, U const max) noexcept
	Clamp the value of `left` between `min` and `max`.

template<AnyVec T, AnyVec U> requires (T::size == U::size)
constexpr vec< T::size, std::remove_const_t< typename T::type > >	clamp (T const &left, U const &min, U const &max) noexcept
	Clamp the value of `left` between `min` and `max`.

template<Primitive T, Primitive U>
constexpr T	clamp (T left, U const min, U const max) noexcept
	Clamp the value of `left` between `min` and `max`.

template<AnyVec T, Primitive U>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	min (T const &left, U const min) noexcept
	Returns a new vector with each element being the minimum of the corresponding element in `left` and `max`.

template<AnyVec T, Primitive U>
constexpr vec< T::size, std::remove_const_t< typename T::type > >	max (T const &left, U const max) noexcept
	Returns a new vector with each element being the maximum of the corresponding element in `left` and `min`.

template<AnyVec T, AnyVec U> requires (T::size == U::size)
constexpr vec< T::size, std::remove_const_t< typename T::type > >	min (T const &left, U const &min) noexcept
	Returns a new vector with each element being the minimum of the corresponding elements in `left` and `right`.

template<AnyVec T, AnyVec U> requires (T::size == U::size)
constexpr vec< T::size, std::remove_const_t< typename T::type > >	max (T const &left, U const &max) noexcept
	Returns a new vector with each element being the maximum of the corresponding elements in `left` and `right`.

template<AnyVec T, AnyVec U> requires (T::size == U::size)
constexpr void	rmin (T &left, U const &max) noexcept
	Modifies `left` in-place, setting each element to the minimum of itself and the corresponding element in `max`.

template<AnyVec T, AnyVec U> requires (T::size == U::size)
constexpr void	rmax (T &left, U const &min) noexcept
	Modifies `left` in-place, setting each element to the maximum of itself and the corresponding element in `min`.

template<AnyVec T, Primitive U>
constexpr void	rmin (T &left, U const max) noexcept
	Modifies `left` in-place, setting each element to the minimum of itself and `max`.

template<AnyVec T, Primitive U>
constexpr void	rmax (T &left, U const min) noexcept
	Modifies `left` in-place, setting each element to the maximum of itself and `min`.

template<AnyVec T>
constexpr std::remove_const_t< typename T::type >	distance (T const &left, T const &right) noexcept
	Compute the distance between two vectors.

template<typename T , Primitive U>
constexpr auto	lerp (T const &from, T const &to, U const param) noexcept
	Linearly interpolate between two values.

template<typename T , Primitive U>
constexpr auto	mix (T const &from, T const &to, U const param) noexcept
	Mix between two values (same as lerp).

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, std::remove_const_t< T > >	operator+ (U const value, _detail::rvec< size, T > const &vector) noexcept

template<size_t size, Primitive T, Primitive U>
constexpr vec< size, std::remove_const_t< T > >	operator- (U const value, _detail::rvec< size, T > const &vector) noexcept

Detailed Description

Contains mathematical utility functions and classes.

A namespace dedicated for matrix mathematical operations and types.

The main namespace for the mathematical utilities.

Typedef Documentation

◆ Box

using mal_math::Box = TBox<float>

Box defined with floats.

Definition at line 166 of file box.hpp.

◆ Boxd

using mal_math::Boxd = TBox<double>

Box defined with doubles.

Definition at line 168 of file box.hpp.

◆ Boxf

using mal_math::Boxf = TBox<float>

Same as Box.

Definition at line 167 of file box.hpp.

◆ dmat2

using mal_math::dmat2 = mat<2, 2, double>

2x2 matrix with double elements.

Definition at line 93 of file mat.hpp.

◆ dmat2x2

using mal_math::dmat2x2 = mat<2, 2, double>

2x2 matrix with double elements.

Definition at line 105 of file mat.hpp.

◆ dmat2x3

using mal_math::dmat2x3 = mat<2, 3, double>

2x3 matrix with double elements.

Definition at line 117 of file mat.hpp.

◆ dmat2x4

using mal_math::dmat2x4 = mat<2, 4, double>

2x4 matrix with double elements.

Definition at line 141 of file mat.hpp.

◆ dmat3

using mal_math::dmat3 = mat<3, 3, double>

3x3 matrix with double elements.

Definition at line 69 of file mat.hpp.

◆ dmat3x2

using mal_math::dmat3x2 = mat<3, 2, double>

3x2 matrix with double elements.

Definition at line 129 of file mat.hpp.

◆ dmat3x3

using mal_math::dmat3x3 = mat<3, 3, double>

3x3 matrix with double elements.

Definition at line 81 of file mat.hpp.

◆ dmat3x4

using mal_math::dmat3x4 = mat<3, 4, double>

3x4 matrix with double elements.

Definition at line 165 of file mat.hpp.

◆ dmat4

using mal_math::dmat4 = mat<4, 4, double>

4x4 matrix with double elements.

Definition at line 45 of file mat.hpp.

◆ dmat4x2

using mal_math::dmat4x2 = mat<4, 2, double>

4x2 matrix with double elements.

Definition at line 153 of file mat.hpp.

◆ dmat4x3

using mal_math::dmat4x3 = mat<4, 3, double>

4x3 matrix with double elements.

Definition at line 177 of file mat.hpp.

◆ dmat4x4

using mal_math::dmat4x4 = mat<4, 4, double>

4x4 matrix with double elements.

Definition at line 57 of file mat.hpp.

◆ dquat

using mal_math::dquat = qua<double>

Definition at line 270 of file quaternion.hpp.

◆ drmat2

using mal_math::drmat2 = rmat<2, 2, double>

2x2 reference matrix to double elements.

Definition at line 237 of file mat.hpp.

◆ drmat2x2

using mal_math::drmat2x2 = rmat<2, 2, double>

2x2 reference matrix to double elements.

Definition at line 249 of file mat.hpp.

◆ drmat2x3

using mal_math::drmat2x3 = rmat<2, 3, double>

2x3 reference matrix to double elements.

Definition at line 261 of file mat.hpp.

◆ drmat2x4

using mal_math::drmat2x4 = rmat<2, 4, double>

2x4 reference matrix to double elements.

Definition at line 285 of file mat.hpp.

◆ drmat3

using mal_math::drmat3 = rmat<3, 3, double>

3x3 reference matrix to double elements.

Definition at line 213 of file mat.hpp.

◆ drmat3x2

using mal_math::drmat3x2 = rmat<3, 2, double>

3x2 reference matrix to double elements.

Definition at line 273 of file mat.hpp.

◆ drmat3x3

using mal_math::drmat3x3 = rmat<3, 3, double>

3x3 reference matrix to double elements.

Definition at line 225 of file mat.hpp.

◆ drmat3x4

using mal_math::drmat3x4 = rmat<3, 4, double>

3x4 reference matrix to double elements.

Definition at line 309 of file mat.hpp.

◆ drmat4

using mal_math::drmat4 = rmat<4, 4, double>

4x4 reference matrix to double elements.

Definition at line 189 of file mat.hpp.

◆ drmat4x2

using mal_math::drmat4x2 = rmat<4, 2, double>

4x2 reference matrix to double elements.

Definition at line 297 of file mat.hpp.

◆ drmat4x3

using mal_math::drmat4x3 = rmat<4, 3, double>

4x3 reference matrix to double elements.

Definition at line 321 of file mat.hpp.

◆ drmat4x4

using mal_math::drmat4x4 = rmat<4, 4, double>

4x4 reference matrix to double elements.

Definition at line 201 of file mat.hpp.

◆ dvec2

using mal_math::dvec2 = vec<2, double>

Definition at line 14 of file vec.hpp.

◆ dvec3

using mal_math::dvec3 = vec<3, double>

Definition at line 19 of file vec.hpp.

◆ dvec4

using mal_math::dvec4 = vec<4, double>

Definition at line 24 of file vec.hpp.

◆ imat2

using mal_math::imat2 = mat<2, 2, int>

2x2 matrix with integer elements.

Definition at line 97 of file mat.hpp.

◆ imat2x2

using mal_math::imat2x2 = mat<2, 2, int>

2x2 matrix with integer elements.

Definition at line 109 of file mat.hpp.

◆ imat2x3

using mal_math::imat2x3 = mat<2, 3, int>

2x3 matrix with integer elements.

Definition at line 121 of file mat.hpp.

◆ imat2x4

using mal_math::imat2x4 = mat<2, 4, int>

2x4 matrix with integer elements.

Definition at line 145 of file mat.hpp.

◆ imat3

using mal_math::imat3 = mat<3, 3, int>

3x3 matrix with integer elements.

Definition at line 73 of file mat.hpp.

◆ imat3x2

using mal_math::imat3x2 = mat<3, 2, int>

3x2 matrix with integer elements.

Definition at line 133 of file mat.hpp.

◆ imat3x3

using mal_math::imat3x3 = mat<3, 3, int>

3x3 matrix with integer elements.

Definition at line 85 of file mat.hpp.

◆ imat3x4

using mal_math::imat3x4 = mat<3, 4, int>

3x4 matrix with integer elements.

Definition at line 169 of file mat.hpp.

◆ imat4

using mal_math::imat4 = mat<4, 4, int>

4x4 matrix with integer elements.

Definition at line 49 of file mat.hpp.

◆ imat4x2

using mal_math::imat4x2 = mat<4, 2, int>

4x2 matrix with integer elements.

Definition at line 157 of file mat.hpp.

◆ imat4x3

using mal_math::imat4x3 = mat<4, 3, int>

4x3 matrix with integer elements.

Definition at line 181 of file mat.hpp.

◆ imat4x4

using mal_math::imat4x4 = mat<4, 4, int>

4x4 matrix with integer elements.

Definition at line 61 of file mat.hpp.

◆ irmat2

using mal_math::irmat2 = rmat<2, 2, int>

2x2 reference matrix to integer elements.

Definition at line 241 of file mat.hpp.

◆ irmat2x2

using mal_math::irmat2x2 = rmat<2, 2, int>

2x2 reference matrix to integer elements.

Definition at line 253 of file mat.hpp.

◆ irmat2x3

using mal_math::irmat2x3 = rmat<2, 3, int>

2x3 reference matrix to integer elements.

Definition at line 265 of file mat.hpp.

◆ irmat2x4

using mal_math::irmat2x4 = rmat<2, 4, int>

2x4 reference matrix to integer elements.

Definition at line 289 of file mat.hpp.

◆ irmat3

using mal_math::irmat3 = rmat<3, 3, int>

3x3 reference matrix to integer elements.

Definition at line 217 of file mat.hpp.

◆ irmat3x2

using mal_math::irmat3x2 = rmat<3, 2, int>

3x2 reference matrix to integer elements.

Definition at line 277 of file mat.hpp.

◆ irmat3x3

using mal_math::irmat3x3 = rmat<3, 3, int>

3x3 reference matrix to integer elements.

Definition at line 229 of file mat.hpp.

◆ irmat3x4

using mal_math::irmat3x4 = rmat<3, 4, int>

3x4 reference matrix to integer elements.

Definition at line 313 of file mat.hpp.

◆ irmat4

using mal_math::irmat4 = rmat<4, 4, int>

4x4 reference matrix to integer elements.

Definition at line 193 of file mat.hpp.

◆ irmat4x2

using mal_math::irmat4x2 = rmat<4, 2, int>

4x2 reference matrix to integer elements.

Definition at line 301 of file mat.hpp.

◆ irmat4x3

using mal_math::irmat4x3 = rmat<4, 3, int>

4x3 reference matrix to integer elements.

Definition at line 325 of file mat.hpp.

◆ irmat4x4

using mal_math::irmat4x4 = rmat<4, 4, int>

4x4 reference matrix to integer elements.

Definition at line 205 of file mat.hpp.

◆ ivec2

using mal_math::ivec2 = vec<2, int>

Definition at line 15 of file vec.hpp.

◆ ivec3

using mal_math::ivec3 = vec<3, int>

Definition at line 20 of file vec.hpp.

◆ ivec4

using mal_math::ivec4 = vec<4, int>

Definition at line 25 of file vec.hpp.

◆ mat2

using mal_math::mat2 = mat<2, 2, float>

2x2 matrix with float elements.

Definition at line 89 of file mat.hpp.

◆ mat2x2

using mal_math::mat2x2 = mat<2, 2, float>

2x2 matrix with float elements.

Definition at line 101 of file mat.hpp.

◆ mat2x3

using mal_math::mat2x3 = mat<2, 3, float>

2x3 matrix with float elements.

Definition at line 113 of file mat.hpp.

◆ mat2x4

using mal_math::mat2x4 = mat<2, 4, float>

2x4 matrix with float elements.

Definition at line 137 of file mat.hpp.

◆ mat3

using mal_math::mat3 = mat<3, 3, float>

3x3 matrix with float elements.

Definition at line 65 of file mat.hpp.

◆ mat3x2

using mal_math::mat3x2 = mat<3, 2, float>

3x2 matrix with float elements.

Definition at line 125 of file mat.hpp.

◆ mat3x3

using mal_math::mat3x3 = mat<3, 3, float>

3x3 matrix with float elements.

Definition at line 77 of file mat.hpp.

◆ mat3x4

using mal_math::mat3x4 = mat<3, 4, float>

3x4 matrix with float elements.

Definition at line 161 of file mat.hpp.

◆ mat4

using mal_math::mat4 = mat<4, 4, float>

4x4 matrix with float elements.

Definition at line 41 of file mat.hpp.

◆ mat4x2

using mal_math::mat4x2 = mat<4, 2, float>

4x2 matrix with float elements.

Definition at line 149 of file mat.hpp.

◆ mat4x3

using mal_math::mat4x3 = mat<4, 3, float>

4x3 matrix with float elements.

Definition at line 173 of file mat.hpp.

◆ mat4x4

using mal_math::mat4x4 = mat<4, 4, float>

4x4 matrix with float elements.

Definition at line 53 of file mat.hpp.

◆ quat

using mal_math::quat = qua<float>

Definition at line 269 of file quaternion.hpp.

◆ rmat2

using mal_math::rmat2 = rmat<2, 2, float>

2x2 reference matrix to float elements.

Definition at line 233 of file mat.hpp.

◆ rmat2x2

using mal_math::rmat2x2 = rmat<2, 2, float>

2x2 reference matrix to float elements.

Definition at line 245 of file mat.hpp.

◆ rmat2x3

using mal_math::rmat2x3 = rmat<2, 3, float>

2x3 reference matrix to float elements.

Definition at line 257 of file mat.hpp.

◆ rmat2x4

using mal_math::rmat2x4 = rmat<2, 4, float>

2x4 reference matrix to float elements.

Definition at line 281 of file mat.hpp.

◆ rmat3

using mal_math::rmat3 = rmat<3, 3, float>

3x3 reference matrix to float elements.

Definition at line 209 of file mat.hpp.

◆ rmat3x2

using mal_math::rmat3x2 = rmat<3, 2, float>

3x2 reference matrix to float elements.

Definition at line 269 of file mat.hpp.

◆ rmat3x3

using mal_math::rmat3x3 = rmat<3, 3, float>

3x3 reference matrix to float elements.

Definition at line 221 of file mat.hpp.

◆ rmat3x4

using mal_math::rmat3x4 = rmat<3, 4, float>

3x4 reference matrix to float elements.

Definition at line 305 of file mat.hpp.

◆ rmat4

using mal_math::rmat4 = rmat<4, 4, float>

4x4 reference matrix to float elements.

Definition at line 185 of file mat.hpp.

◆ rmat4x2

using mal_math::rmat4x2 = rmat<4, 2, float>

4x2 reference matrix to float elements.

Definition at line 293 of file mat.hpp.

◆ rmat4x3

using mal_math::rmat4x3 = rmat<4, 3, float>

4x3 reference matrix to float elements.

Definition at line 317 of file mat.hpp.

◆ rmat4x4

using mal_math::rmat4x4 = rmat<4, 4, float>

4x4 reference matrix to float elements.

Definition at line 197 of file mat.hpp.

◆ uivec2

using mal_math::uivec2 = vec<2, unsigned int>

Definition at line 16 of file vec.hpp.

◆ uivec3

using mal_math::uivec3 = vec<3, unsigned int>

Definition at line 21 of file vec.hpp.

◆ uivec4

using mal_math::uivec4 = vec<4, unsigned int>

Definition at line 26 of file vec.hpp.

◆ vec2

using mal_math::vec2 = vec<2, float>

Definition at line 13 of file vec.hpp.

◆ vec3

using mal_math::vec3 = vec<3, float>

Definition at line 18 of file vec.hpp.

◆ vec4

using mal_math::vec4 = vec<4, float>

Definition at line 23 of file vec.hpp.

Function Documentation

◆ abs() [1/2]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::abs ( T const & vector )

constexprnoexcept

Definition at line 565 of file vec_math.inl.

Here is the call graph for this function:

◆ abs() [2/2]

template<Primitive T>

T mal_math::abs ( T x )

inlinenodiscardnoexcept

Definition at line 310 of file math-common.hpp.

Here is the caller graph for this function:

◆ acos() [1/4]

double mal_math::acos ( double x )

inlinenodiscard

Definition at line 231 of file math-common.hpp.

◆ acos() [2/4]

long double mal_math::acos ( long double x )

inlinenodiscard

Definition at line 232 of file math-common.hpp.

◆ acos() [3/4]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::acos ( T const & vector )

constexprnoexcept

Definition at line 360 of file vec_math.inl.

Here is the call graph for this function:

◆ acos() [4/4]

template<Primitive T>

float mal_math::acos ( T x )

inlinenodiscardnoexcept

Definition at line 230 of file math-common.hpp.

Here is the caller graph for this function:

◆ acosh() [1/4]

double mal_math::acosh ( double x )

inlinenodiscard

Definition at line 259 of file math-common.hpp.

◆ acosh() [2/4]

long double mal_math::acosh ( long double x )

inlinenodiscard

Definition at line 260 of file math-common.hpp.

◆ acosh() [3/4]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::acosh ( T const & vector )

constexprnoexcept

Definition at line 445 of file vec_math.inl.

Here is the call graph for this function:

◆ acosh() [4/4]

template<Primitive T>

float mal_math::acosh ( T x )

inlinenodiscardnoexcept

Definition at line 258 of file math-common.hpp.

Here is the caller graph for this function:

◆ adj()

template<AnyMat T>
requires (T::size.x == T::size.y)

mat< T::size.x, T::size.y, std::remove_const_t< typename T::type > > mal_math::adj ( T const & m )

constexpr

Computes the adjoint (or adjugate) of a square matrix.

Template Parameters

T	A matrix type satisfying the AnyMat concept.

Parameters

m	The input matrix.

Returns: The adjoint of the input matrix.

Definition at line 209 of file mat_math.inl.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ adjugate()

template<AnyMat T>
requires (T::size.x == T::size.y)

mat< T::size.x, T::size.y, std::remove_const_t< typename T::type > > mal_math::adjugate ( T const & m )

constexpr

Alias for the adj() function to compute the adjugate of a matrix.

Definition at line 234 of file mat_math.inl.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ almost_equal()

template<class T >
requires (!std::numeric_limits<T>::is_integer)

bool mal_math::almost_equal	(	T	x,
		T	y,
		int	ulp = 2 )

nodiscard

Function to determine if two values are almost equal within a certain tolerance.

Definition at line 198 of file math-common.hpp.

◆ angle() [1/2]

template<Primitive T>

T mal_math::angle ( qua< T > const & quaternion )

nodiscardconstexprnoexcept

Computes the angle (or magnitude) of a quaternion.

Definition at line 238 of file quaternion.inl.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ angle() [2/2]

template<AnyVec T, AnyVec U>
requires (T::size == U::size)

std::remove_const_t< typename T::type > mal_math::angle	(	T const &	left,
		U const &	right )

constexprnoexcept

Compute the angle between two vectors.

Template Parameters

T	The type of the left vector.
U	The type of the right vector.

Parameters

left	The left vector.
right	The right vector.

Returns: The angle between the two vectors.

Note: Requires that both vectors have the same size.

Definition at line 323 of file vec_math.inl.

Here is the call graph for this function:

◆ as_crvec() [1/2]

template<size_t n, AnyVec Vector>
requires (n >= 2 && n <= Vector::size)

vec< n, typename Vector::type > const & mal_math::as_crvec ( Vector const & v )

nodiscardconstexprnoexcept

Convert a given const vector to a const reference of vec with specified size and type.

Template Parameters

n	The size of the resulting vector.
Vector	The type of the input vector.

Parameters

v	The input const vector to be converted.

Returns: A const reference to vec of size n and the type of Vector.

Note: Requires that n is between 2 and the size of the input Vector.

Definition at line 67 of file vec_math.inl.

◆ as_crvec() [2/2]

template<AnyVec Vector>

vec< Vector::size, typename Vector::type > const & mal_math::as_crvec ( Vector const & v )

nodiscardconstexprnoexcept

Convert a given const vector to a const reference of vec with the same size and type.

Template Parameters

Vector The type of the input vector.

Parameters

v	The input const vector to be converted.

Returns: A const reference to vec of the same size and type as the input Vector.

Definition at line 72 of file vec_math.inl.

Here is the call graph for this function:

◆ as_rvec() [1/2]

template<size_t n, AnyVec Vector>
requires (n >= 2 && n <= Vector::size)

vec< n, typename Vector::type > & mal_math::as_rvec ( Vector & v )

nodiscardconstexprnoexcept

Convert a given vector to a reference of vec with specified size and type.

Template Parameters

n	The size of the resulting vector.
Vector	The type of the input vector.

Parameters

v	The input vector to be converted.

Returns: A reference to vec of size n and the type of Vector.

Note: Requires that n is between 2 and the size of the input Vector.

Definition at line 56 of file vec_math.inl.

Here is the caller graph for this function:

◆ as_rvec() [2/2]

template<AnyVec Vector>

vec< Vector::size, typename Vector::type > & mal_math::as_rvec ( Vector & v )

nodiscardconstexprnoexcept

Convert a given vector to a reference of vec with the same size and type.

Template Parameters

Vector The type of the input vector.

Parameters

v	The input vector to be converted.

Returns: A reference to vec of the same size and type as the input Vector.

Definition at line 61 of file vec_math.inl.

Here is the call graph for this function:

◆ as_vec() [1/3]

template<size_t n, Primitive U, AnyVec Vector>
requires (n >= 2 && n <= Vector::size)

vec< n, U > mal_math::as_vec ( Vector const & v )

nodiscardconstexprnoexcept

Create a new vector of a specified size and type from the given vector.

Template Parameters

n	The size of the resulting vector.
U	The type of the resulting vector.
Vector	The type of the input vector.

Parameters

v	The input vector to be converted.

Returns: A new vec of size n and type U.

Note: Requires that n is between 2 and the size of the input Vector.

Definition at line 34 of file vec_math.inl.

Here is the caller graph for this function:

◆ as_vec() [2/3]

template<size_t n, AnyVec Vector>
requires (n >= 2 && n <= Vector::size)

vec< n, std::remove_const_t< typename Vector::type > > mal_math::as_vec ( Vector const & v )

nodiscardconstexprnoexcept

Create a new vector of a specified size from the given vector, preserving the type.

Template Parameters

n	The size of the resulting vector.
Vector	The type of the input vector.

Parameters

v	The input vector to be converted.

Returns: A new vec of size n and type derived from the input Vector.

Note: Requires that n is between 2 and the size of the input Vector.

Definition at line 45 of file vec_math.inl.

Here is the call graph for this function:

◆ as_vec() [3/3]

template<AnyVec Vector>

vec< Vector::size, std::remove_const_t< typename Vector::type > > mal_math::as_vec ( Vector const & v )

nodiscardconstexprnoexcept

Create a new vector of the same size from the given vector, preserving the type.

Template Parameters

Vector The type of the input vector.

Parameters

v	The input vector to be converted.

Returns: A new vec of the same size and type as the input Vector.

Definition at line 51 of file vec_math.inl.

Here is the call graph for this function:

◆ asin() [1/4]

double mal_math::asin ( double x )

inlinenodiscard

Definition at line 235 of file math-common.hpp.

◆ asin() [2/4]

long double mal_math::asin ( long double x )

inlinenodiscard

Definition at line 236 of file math-common.hpp.

◆ asin() [3/4]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::asin ( T const & vector )

constexprnoexcept

Definition at line 370 of file vec_math.inl.

Here is the call graph for this function:

◆ asin() [4/4]

template<Primitive T>

float mal_math::asin ( T x )

inlinenodiscardnoexcept

Definition at line 234 of file math-common.hpp.

Here is the caller graph for this function:

◆ asinh() [1/4]

double mal_math::asinh ( double x )

inlinenodiscard

Definition at line 263 of file math-common.hpp.

◆ asinh() [2/4]

long double mal_math::asinh ( long double x )

inlinenodiscard

Definition at line 264 of file math-common.hpp.

◆ asinh() [3/4]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::asinh ( T const & vector )

constexprnoexcept

Definition at line 435 of file vec_math.inl.

Here is the call graph for this function:

◆ asinh() [4/4]

template<Primitive T>

float mal_math::asinh ( T x )

inlinenodiscardnoexcept

Definition at line 262 of file math-common.hpp.

Here is the caller graph for this function:

◆ atan() [1/5]

double mal_math::atan ( double x )

inlinenodiscard

Definition at line 239 of file math-common.hpp.

◆ atan() [2/5]

long double mal_math::atan ( long double x )

inlinenodiscard

Definition at line 240 of file math-common.hpp.

◆ atan() [3/5]

template<AnyVec T, AnyVec U>
requires (T::size == U::size)

vec< T::size, std::remove_const_t< typename T::type > > mal_math::atan	(	T const &	left,
		U const &	right )

constexprnoexcept

Definition at line 390 of file vec_math.inl.

Here is the call graph for this function:

◆ atan() [4/5]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::atan ( T const & vector )

constexprnoexcept

Definition at line 380 of file vec_math.inl.

Here is the call graph for this function:

◆ atan() [5/5]

template<Primitive T>

float mal_math::atan ( T x )

inlinenodiscardnoexcept

Definition at line 238 of file math-common.hpp.

Here is the caller graph for this function:

◆ atan2() [1/4]

double mal_math::atan2	(	double	x,
		double	y )

inlinenodiscard

Definition at line 243 of file math-common.hpp.

◆ atan2() [2/4]

long double mal_math::atan2	(	long double	x,
		long double	y )

inlinenodiscard

Definition at line 244 of file math-common.hpp.

◆ atan2() [3/4]

template<AnyVec T, AnyVec U>
requires (T::size == U::size)

vec< T::size, std::remove_const_t< typename T::type > > mal_math::atan2	(	T const &	left,
		U const &	right )

constexprnoexcept

Definition at line 400 of file vec_math.inl.

Here is the call graph for this function:

◆ atan2() [4/4]

template<Primitive T>

float mal_math::atan2	(	T	x,
		T	y )

inlinenodiscardnoexcept

Definition at line 242 of file math-common.hpp.

Here is the caller graph for this function:

◆ atanh() [1/4]

double mal_math::atanh ( double x )

inlinenodiscard

Definition at line 267 of file math-common.hpp.

◆ atanh() [2/4]

long double mal_math::atanh ( long double x )

inlinenodiscard

Definition at line 268 of file math-common.hpp.

◆ atanh() [3/4]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::atanh ( T const & vector )

constexprnoexcept

Definition at line 455 of file vec_math.inl.

Here is the call graph for this function:

◆ atanh() [4/4]

template<Primitive T>

float mal_math::atanh ( T x )

inlinenodiscardnoexcept

Definition at line 266 of file math-common.hpp.

Here is the caller graph for this function:

◆ ceil() [1/2]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::ceil ( T const & vector )

constexprnoexcept

Definition at line 595 of file vec_math.inl.

Here is the call graph for this function:

◆ ceil() [2/2]

template<Primitive T>

T mal_math::ceil ( T x )

inlinenodiscardnoexcept

Definition at line 316 of file math-common.hpp.

Here is the caller graph for this function:

◆ clamp() [1/4]

template<AnyVec T, AnyVec U>
requires (T::size == U::size)

vec< T::size, std::remove_const_t< typename T::type > > mal_math::clamp	(	T const &	left,
		U const &	min,
		U const &	max )

nodiscardconstexprnoexcept

Clamp the value of left between min and max.

Template Parameters

T	Type of the value to be clamped.
U	Type of the boundary values.

Parameters

left	The value to be clamped.
min	The minimum value.
max	The maximum value.

Returns: The clamped value.

Definition at line 756 of file vec_math.inl.

Here is the call graph for this function:

◆ clamp() [2/4]

template<AnyVec T, Primitive U>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::clamp	(	T const &	left,
		U const	min,
		U const	max )

nodiscardconstexprnoexcept

Clamp the value of left between min and max.

Template Parameters

T	Type of the value to be clamped.
U	Type of the boundary values.

Parameters

left	The value to be clamped.
min	The minimum value.
max	The maximum value.

Returns: The clamped value.

Definition at line 734 of file vec_math.inl.

Here is the call graph for this function:

◆ clamp() [3/4]

template<Primitive T, Primitive U>

T mal_math::clamp	(	T	left,
		U const	min,
		U const	max )

nodiscardconstexprnoexcept

Clamp the value of left between min and max.

Template Parameters

T	Type of the value to be clamped.
U	Type of the boundary values.

Parameters

left	The value to be clamped.
min	The minimum value.
max	The maximum value.

Returns: The clamped value.

Definition at line 777 of file vec_math.inl.

Here is the call graph for this function:

◆ clamp() [4/4]

template<Primitive T>

T mal_math::clamp	(	T	x,
		T	min,
		T	max )

inlinenodiscardconstexprnoexcept

Function to clamp a value between a minimum and maximum.

Definition at line 215 of file math-common.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ conjugate() [1/2]

template<Primitive T>

qua< T > mal_math::conjugate ( qua< T > const & q )

nodiscardconstexprnoexcept

Computes the conjugate of a quaternion.

Definition at line 281 of file quaternion.inl.

Here is the caller graph for this function:

◆ conjugate() [2/2]

template<Primitive T>

qua< T > constexpr mal_math::conjugate ( qua< T > const & q )

nodiscardconstexprnoexcept

Computes the conjugate of a quaternion.

Definition at line 281 of file quaternion.inl.

Here is the caller graph for this function:

◆ cos() [1/4]

double mal_math::cos ( double x )

inlinenodiscard

Definition at line 219 of file math-common.hpp.

◆ cos() [2/4]

long double mal_math::cos ( long double x )

inlinenodiscard

Definition at line 220 of file math-common.hpp.

◆ cos() [3/4]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::cos ( T const & vector )

constexprnoexcept

Definition at line 329 of file vec_math.inl.

Here is the call graph for this function:

◆ cos() [4/4]

template<Primitive T>

float mal_math::cos ( T x )

inlinenodiscardnoexcept

Definition at line 218 of file math-common.hpp.

Here is the caller graph for this function:

◆ cosh() [1/4]

double mal_math::cosh ( double x )

inlinenodiscard

Definition at line 247 of file math-common.hpp.

◆ cosh() [2/4]

long double mal_math::cosh ( long double x )

inlinenodiscard

Definition at line 248 of file math-common.hpp.

◆ cosh() [3/4]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::cosh ( T const & vector )

constexprnoexcept

Definition at line 415 of file vec_math.inl.

Here is the call graph for this function:

◆ cosh() [4/4]

template<Primitive T>

float mal_math::cosh ( T x )

inlinenodiscardnoexcept

Definition at line 246 of file math-common.hpp.

Here is the caller graph for this function:

◆ cross() [1/5]

template<Primitive T, Primitive U>

qua< T > mal_math::cross	(	qua< T > const &	left,
		qua< U > const &	right )

nodiscardconstexprnoexcept

Computes the cross product of two quaternions.

Definition at line 303 of file quaternion.inl.

◆ cross() [2/5]

template<Primitive T, Primitive U>

vec< 3, T > mal_math::cross	(	qua< T > const &	left,
		vec< 3, U > const &	right )

nodiscardconstexprnoexcept

Cross product between quaternion and vector.

Definition at line 293 of file quaternion.inl.

Here is the caller graph for this function:

◆ cross() [3/5]

template<AnyVec T, AnyVec U>
requires (T::size == U::size && T::size == 3)

vec< 3, std::remove_const_t< typename T::type > > mal_math::cross	(	T const &	left,
		U const &	right )

constexprnoexcept

Compute the cross product of two 3D vectors.

Template Parameters

T	Type of the left vector.
U	Type of the right vector.

Parameters

left	The left vector.
right	The right vector.

Returns: The cross product of the two vectors.

Note: Requires that both vectors have a size of 3.

Definition at line 687 of file vec_math.inl.

◆ cross() [4/5]

template<Primitive T, Primitive U>

vec< 3, T > mal_math::cross	(	vec< 3, T > const &	left,
		vec< 3, U > const &	right )

constexpr

Computes the cross product of two 3D vectors.

Template Parameters

T	Type of the first vector.
U	Type of the second vector.

Parameters

left	First vector.
right	Second vector.

Returns: Cross product of the given vectors.

Definition at line 190 of file vec3.inl.

◆ cross() [5/5]

template<Primitive T, Primitive U>

vec< 3, T > mal_math::cross	(	vec< 3, U > const &	left,
		qua< T > const &	right )

nodiscardconstexprnoexcept

Cross product between vector and quaternion.

Definition at line 298 of file quaternion.inl.

Here is the call graph for this function:

◆ det()

template<AnyMat T>
requires (T::size.x == T::size.y)

T::type mal_math::det ( T const & matrix )

constexpr

Calculates the determinant of a square matrix.

Computes the determinant using an appropriate method based on the matrix size.

Template Parameters

T	A matrix type satisfying the AnyMat concept.

Parameters

matrix The matrix whose determinant is to be computed.

Returns: The determinant of the matrix.

Definition at line 191 of file mat_math.inl.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ det_2()

template<AnyMat T>
requires (T::size.x == T::size.y && T::size.x == 2)

T::type mal_math::det_2 ( T const & m )

constexpr

Definition at line 161 of file mat_math.inl.

Here is the caller graph for this function:

◆ det_3()

template<AnyMat T>
requires (T::size.x == T::size.y && T::size.x == 3)

T::type mal_math::det_3 ( T const & m )

constexpr

Definition at line 166 of file mat_math.inl.

Here is the caller graph for this function:

◆ det_4()

template<AnyMat T>
requires (T::size.x == T::size.y && T::size.x == 4)

T::type mal_math::det_4 ( T const & m )

constexpr

Definition at line 171 of file mat_math.inl.

Here is the caller graph for this function:

◆ determinant()

template<AnyMat T>
requires (T::size.x == T::size.y)

T::type mal_math::determinant ( T const & matrix )

constexpr

Calculates the determinant of a square matrix.

Template Parameters

T	A matrix type satisfying the AnyMat concept.

Parameters

matrix The matrix for which to compute the determinant.

Returns: The determinant of the matrix.

Definition at line 203 of file mat_math.inl.

Here is the call graph for this function:

◆ distance()

template<AnyVec T>

std::remove_const_t< typename T::type > mal_math::distance	(	T const &	left,
		T const &	right )

nodiscardconstexprnoexcept

Compute the distance between two vectors.

Template Parameters

T	Type of the vectors.

Parameters

left	The first vector.
right	The second vector.

Returns: The distance between the two vectors.

Definition at line 877 of file vec_math.inl.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dot() [1/2]

template<Primitive T, Primitive U>

T mal_math::dot	(	qua< T > const &	left,
		qua< U > const &	right )

nodiscardconstexprnoexcept

Computes the dot product of two quaternions.

Definition at line 227 of file quaternion.inl.

Here is the caller graph for this function:

◆ dot() [2/2]

template<AnyVec T, AnyVec U>
requires (T::size == U::size)

std::remove_const_t< typename T::type > mal_math::dot	(	T const &	left,
		U const &	right )

constexprnoexcept

Compute the dot product of two vectors.

Template Parameters

T	The type of the left vector.
U	The type of the right vector.

Parameters

left	The left vector.
right	The right vector.

Returns: The dot product of the two vectors.

Note: Requires that both vectors have the same size.

Definition at line 311 of file vec_math.inl.

◆ exp() [1/4]

double mal_math::exp ( double x )

inlinenodiscard

Definition at line 271 of file math-common.hpp.

◆ exp() [2/4]

long double mal_math::exp ( long double x )

inlinenodiscard

Definition at line 272 of file math-common.hpp.

◆ exp() [3/4]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::exp ( T const & vector )

constexprnoexcept

Definition at line 465 of file vec_math.inl.

Here is the call graph for this function:

◆ exp() [4/4]

template<Primitive T>

float mal_math::exp ( T x )

inlinenodiscardnoexcept

Definition at line 270 of file math-common.hpp.

Here is the caller graph for this function:

◆ exp2() [1/4]

double mal_math::exp2 ( double x )

inlinenodiscard

Definition at line 275 of file math-common.hpp.

◆ exp2() [2/4]

long double mal_math::exp2 ( long double x )

inlinenodiscard

Definition at line 276 of file math-common.hpp.

◆ exp2() [3/4]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::exp2 ( T const & vector )

constexprnoexcept

Definition at line 475 of file vec_math.inl.

Here is the call graph for this function:

◆ exp2() [4/4]

template<Primitive T>

float mal_math::exp2 ( T x )

inlinenodiscardnoexcept

Definition at line 274 of file math-common.hpp.

Here is the caller graph for this function:

◆ expm1() [1/4]

double mal_math::expm1 ( double x )

inlinenodiscard

Definition at line 279 of file math-common.hpp.

◆ expm1() [2/4]

long double mal_math::expm1 ( long double x )

inlinenodiscard

Definition at line 280 of file math-common.hpp.

◆ expm1() [3/4]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::expm1 ( T const & vector )

constexprnoexcept

Definition at line 485 of file vec_math.inl.

Here is the call graph for this function:

◆ expm1() [4/4]

template<Primitive T>

float mal_math::expm1 ( T x )

inlinenodiscardnoexcept

Definition at line 278 of file math-common.hpp.

Here is the caller graph for this function:

◆ floor() [1/2]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::floor ( T const & vector )

constexprnoexcept

Definition at line 585 of file vec_math.inl.

Here is the call graph for this function:

◆ floor() [2/2]

template<Primitive T>

T mal_math::floor ( T x )

inlinenodiscardnoexcept

Definition at line 314 of file math-common.hpp.

Here is the caller graph for this function:

◆ fract() [1/2]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::fract ( T const & vector )

constexprnoexcept

Definition at line 635 of file vec_math.inl.

Here is the call graph for this function:

◆ fract() [2/2]

template<Primitive T>

T mal_math::fract ( T x )

inlinenodiscardnoexcept

Definition at line 324 of file math-common.hpp.

Here is the caller graph for this function:

◆ inverse() [1/3]

template<Primitive T>

qua< T > mal_math::inverse ( qua< T > const & q )

nodiscardconstexprnoexcept

Computes the inverse of a quaternion.

Definition at line 287 of file quaternion.inl.

Here is the call graph for this function:

◆ inverse() [2/3]

template<Primitive T>

qua< T > constexpr mal_math::inverse ( qua< T > const & q )

nodiscardconstexprnoexcept

Computes the inverse of a quaternion.

Definition at line 287 of file quaternion.inl.

Here is the call graph for this function:

◆ inverse() [3/3]

template<AnyMat T>
requires (T::size.x == T::size.y)

mat< T::size.x, T::size.y, std::remove_const_t< typename T::type > > mal_math::inverse ( T const & matrix )

constexpr

Calculates the inverse of a square matrix.

Template Parameters

T	A matrix type satisfying the AnyMat concept.

Parameters

matrix The matrix for which to compute the inverse.

Returns: The inverse of the matrix.

Definition at line 240 of file mat_math.inl.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ inversesqrt() [1/4]

double mal_math::inversesqrt ( double x )

inlinenodiscard

Definition at line 307 of file math-common.hpp.

◆ inversesqrt() [2/4]

long double mal_math::inversesqrt ( long double x )

inlinenodiscard

Definition at line 308 of file math-common.hpp.

◆ inversesqrt() [3/4]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::inversesqrt ( T const & vector )

constexprnoexcept

Definition at line 555 of file vec_math.inl.

Here is the call graph for this function:

◆ inversesqrt() [4/4]

template<Primitive T>

float mal_math::inversesqrt ( T x )

inlinenodiscardnoexcept

Definition at line 306 of file math-common.hpp.

Here is the caller graph for this function:

◆ invert_orthogonal() [1/2]

template<Primitive T>

mat< 4, 4, T > mal_math::invert_orthogonal ( mat< 4, 4, T > const & src )

constexpr

Returns an inverted orthogonal matrix.

Template Parameters

T	A primitive type.

Parameters

src	The source orthogonal matrix.

Returns: The inverted orthogonal matrix.

Definition at line 423 of file mat_math.inl.

Here is the call graph for this function:

◆ invert_orthogonal() [2/2]

template<Primitive T>

void mal_math::invert_orthogonal	(	mat< 4, 4, T > const &	src,
		mat< 4, 4, T > &	dst )

constexpr

Inverts an orthogonal matrix in-place and stores the result in a destination matrix.

Template Parameters

T	A primitive type.

Parameters

src	The source orthogonal matrix.
dst	The destination matrix where the result will be stored.

Definition at line 369 of file mat_math.inl.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ invert_orthonormal() [1/2]

template<Primitive T>

mat< 4, 4, T > mal_math::invert_orthonormal ( mat< 4, 4, T > const & src )

constexpr

Returns an inverted orthonormal matrix.

Template Parameters

T	A primitive type.

Parameters

src	The source orthonormal matrix.

Returns: The inverted orthonormal matrix.

Definition at line 416 of file mat_math.inl.

Here is the call graph for this function:

◆ invert_orthonormal() [2/2]

template<Primitive T>

void mal_math::invert_orthonormal	(	mat< 4, 4, T > const &	src,
		mat< 4, 4, T > &	dst )

constexpr

Inverts an orthonormal matrix in-place and stores the result in a destination matrix.

Template Parameters

T	A primitive type.

Parameters

src	The source orthonormal matrix.
dst	The destination matrix where the result will be stored.

Definition at line 349 of file mat_math.inl.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ length() [1/2]

template<Primitive T>

T mal_math::length ( qua< T > const & q )

nodiscardconstexprnoexcept

Computes the length (or magnitude) of a quaternion.

Definition at line 403 of file quaternion.inl.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ length() [2/2]

template<AnyVec T>

auto mal_math::length ( T const & vector )

nodiscardconstexprnoexcept

Compute the length (magnitude) of the given vector.

Template Parameters

T	The vector type.

Parameters

vector The input vector.

Returns: The length of the vector.

Definition at line 294 of file vec_math.inl.

Here is the call graph for this function:

◆ lerp()

template<typename T , Primitive U>

auto mal_math::lerp	(	T const &	from,
		T const &	to,
		U const	param )

nodiscardconstexprnoexcept

Linearly interpolate between two values.

Template Parameters

T	Type of the values to interpolate between.
U	Type of the interpolation parameter.

Parameters

from	The starting value.
to	The target value.
param	The interpolation parameter (usually between 0 and 1).

Returns: The interpolated value.

Definition at line 882 of file vec_math.inl.

Here is the caller graph for this function:

◆ log() [1/4]

double mal_math::log ( double x )

inlinenodiscard

Definition at line 283 of file math-common.hpp.

◆ log() [2/4]

long double mal_math::log ( long double x )

inlinenodiscard

Definition at line 284 of file math-common.hpp.

◆ log() [3/4]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::log ( T const & vector )

constexprnoexcept

Definition at line 495 of file vec_math.inl.

Here is the call graph for this function:

◆ log() [4/4]

template<Primitive T>

float mal_math::log ( T x )

inlinenodiscardnoexcept

Definition at line 282 of file math-common.hpp.

Here is the caller graph for this function:

◆ log10() [1/4]

double mal_math::log10 ( double x )

inlinenodiscard

Definition at line 291 of file math-common.hpp.

◆ log10() [2/4]

long double mal_math::log10 ( long double x )

inlinenodiscard

Definition at line 292 of file math-common.hpp.

◆ log10() [3/4]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::log10 ( T const & vector )

constexprnoexcept

Definition at line 515 of file vec_math.inl.

Here is the call graph for this function:

◆ log10() [4/4]

template<Primitive T>

float mal_math::log10 ( T x )

inlinenodiscardnoexcept

Definition at line 290 of file math-common.hpp.

Here is the caller graph for this function:

◆ log1p() [1/4]

double mal_math::log1p ( double x )

inlinenodiscard

Definition at line 295 of file math-common.hpp.

◆ log1p() [2/4]

long double mal_math::log1p ( long double x )

inlinenodiscard

Definition at line 296 of file math-common.hpp.

◆ log1p() [3/4]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::log1p ( T const & vector )

constexprnoexcept

Definition at line 525 of file vec_math.inl.

Here is the call graph for this function:

◆ log1p() [4/4]

template<Primitive T>

float mal_math::log1p ( T x )

inlinenodiscardnoexcept

Definition at line 294 of file math-common.hpp.

Here is the caller graph for this function:

◆ log2() [1/4]

double mal_math::log2 ( double x )

inlinenodiscard

Definition at line 287 of file math-common.hpp.

◆ log2() [2/4]

long double mal_math::log2 ( long double x )

inlinenodiscard

Definition at line 288 of file math-common.hpp.

◆ log2() [3/4]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::log2 ( T const & vector )

constexprnoexcept

Definition at line 505 of file vec_math.inl.

Here is the call graph for this function:

◆ log2() [4/4]

template<Primitive T>

float mal_math::log2 ( T x )

inlinenodiscardnoexcept

Definition at line 286 of file math-common.hpp.

Here is the caller graph for this function:

◆ logb() [1/4]

double mal_math::logb ( double x )

inlinenodiscard

Definition at line 299 of file math-common.hpp.

◆ logb() [2/4]

long double mal_math::logb ( long double x )

inlinenodiscard

Definition at line 300 of file math-common.hpp.

◆ logb() [3/4]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::logb ( T const & vector )

constexprnoexcept

Definition at line 535 of file vec_math.inl.

Here is the call graph for this function:

◆ logb() [4/4]

template<Primitive T>

float mal_math::logb ( T x )

inlinenodiscardnoexcept

Definition at line 298 of file math-common.hpp.

Here is the caller graph for this function:

◆ look_at()

template<AnyVec Position>
requires (Position::size == 3)

mat< 4, 4, std::remove_const_t< typename Position::type > > mal_math::look_at	(	Position const &	eye,
		Position const &	center,
		Position const &	up )

constexpr

Generates a look-at matrix for camera positioning.

Template Parameters

Position A vector type.

Parameters

eye	The position of the observer.
center	The position where the observer is looking at.
up	The up direction for the observer.

Returns: A look-at matrix.

Definition at line 298 of file mat_math.inl.

Here is the call graph for this function:

◆ max() [1/2]

template<AnyVec T, AnyVec U>
requires (T::size == U::size)

vec< T::size, std::remove_const_t< typename T::type > > mal_math::max	(	T const &	left,
		U const &	max )

nodiscardconstexprnoexcept

Returns a new vector with each element being the maximum of the corresponding elements in left and right.

Template Parameters

T	Type of the left vector.
U	Type of the right vector.

Parameters

left	First input vector.
right	Second input vector.

Returns: Vector containing the element-wise maximum values.

Definition at line 820 of file vec_math.inl.

◆ max() [2/2]

template<AnyVec T, Primitive U>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::max	(	T const &	left,
		U const	max )

nodiscardconstexprnoexcept

Returns a new vector with each element being the maximum of the corresponding element in left and min.

Template Parameters

T	Vector type.
U	Primitive type for the min value.

Parameters

left	Input vector.
min	Minimum value for each element.

Returns: Vector containing the element-wise maximum values.

Definition at line 798 of file vec_math.inl.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ min() [1/2]

template<AnyVec T, AnyVec U>
requires (T::size == U::size)

vec< T::size, std::remove_const_t< typename T::type > > mal_math::min	(	T const &	left,
		U const &	min )

nodiscardconstexprnoexcept

Returns a new vector with each element being the minimum of the corresponding elements in left and right.

Template Parameters

T	Type of the left vector.
U	Type of the right vector.

Parameters

left	First input vector.
right	Second input vector.

Returns: Vector containing the element-wise minimum values.

Definition at line 809 of file vec_math.inl.

◆ min() [2/2]

template<AnyVec T, Primitive U>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::min	(	T const &	left,
		U const	min )

nodiscardconstexprnoexcept

Returns a new vector with each element being the minimum of the corresponding element in left and max.

Template Parameters

T	Vector type.
U	Primitive type for the max value.

Parameters

left	Input vector.
max	Maximum value for each element.

Returns: Vector containing the element-wise minimum values.

Definition at line 787 of file vec_math.inl.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mix()

template<typename T , Primitive U>

auto mal_math::mix	(	T const &	from,
		T const &	to,
		U const	param )

nodiscardconstexprnoexcept

Mix between two values (same as lerp).

Template Parameters

T	Type of the values to mix between.
U	Type of the mix parameter.

Parameters

from	The starting value.
to	The target value.
param	The mix parameter (usually between 0 and 1).

Returns: The mixed value.

Definition at line 887 of file vec_math.inl.

Here is the call graph for this function:

◆ mod() [1/5]

double mal_math::mod	(	double	x,
		double	y )

inlinenodiscard

Definition at line 327 of file math-common.hpp.

◆ mod() [2/5]

long double mal_math::mod	(	long double	x,
		long double	y )

inlinenodiscard

Definition at line 328 of file math-common.hpp.

◆ mod() [3/5]

template<AnyVec T, AnyVec U>
requires (T::size == U::size)

vec< T::size, std::remove_const_t< typename T::type > > mal_math::mod	(	T const &	left,
		U const &	right )

constexprnoexcept

Definition at line 655 of file vec_math.inl.

Here is the call graph for this function:

◆ mod() [4/5]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::mod	(	T const &	vector,
		typename T::type const &	scalar )

constexprnoexcept

Definition at line 645 of file vec_math.inl.

Here is the call graph for this function:

◆ mod() [5/5]

template<Primitive T, Primitive U>

float mal_math::mod	(	T	x,
		U	y )

inlinenodiscardnoexcept

Definition at line 326 of file math-common.hpp.

Here is the caller graph for this function:

◆ normalize() [1/2]

template<Primitive T>

qua< T > mal_math::normalize ( qua< T > const & q )

nodiscardconstexprnoexcept

Normalizes a quaternion.

Definition at line 408 of file quaternion.inl.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ normalize() [2/2]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::normalize ( T const & vector )

nodiscardconstexprnoexcept

Normalize the given vector.

Template Parameters

T	The vector type.

Parameters

vector The input vector.

Returns: The normalized vector.

Note: This function is synonymous to unit_vector.

Definition at line 305 of file vec_math.inl.

Here is the call graph for this function:

◆ operator!=()

template<AnyVec T, AnyVec U>
requires (T::size == U::size)

bool mal_math::operator!=	(	T const &	left,
		U const &	right )

nodiscardconstexprnoexcept

Definition at line 279 of file vec_math.inl.

◆ operator%() [1/6]

template<size_t size, Primitive T, Primitive U>

vec< size, std::remove_const_t< T > > mal_math::operator%	(	_detail::rvec< size, T > const &	left,
		_detail::rvec< size, U > const &	right )

nodiscardconstexprnoexcept

Definition at line 236 of file vec_math.inl.

◆ operator%() [2/6]

template<size_t size, Primitive T, Primitive U>

vec< size, std::remove_const_t< T > > mal_math::operator%	(	_detail::rvec< size, T > const &	left,
		U const	value )

nodiscardconstexprnoexcept

Definition at line 205 of file vec_math.inl.

◆ operator%() [3/6]

template<size_t size, Primitive T, Primitive U>

vec< size, std::remove_const_t< T > > mal_math::operator%	(	_detail::rvec< size, T > const &	left,
		vec< size, U > const &	right )

nodiscardconstexprnoexcept

Definition at line 210 of file vec_math.inl.

◆ operator%() [4/6]

template<size_t size, Primitive T, Primitive U>

vec< size, T > mal_math::operator%	(	vec< size, T > const &	left,
		_detail::rvec< size, U > const &	right )

nodiscardconstexprnoexcept

Definition at line 262 of file vec_math.inl.

◆ operator%() [5/6]

template<size_t size, Primitive T, Primitive U>

vec< size, T > mal_math::operator%	(	vec< size, T > const &	left,
		U const	value )

nodiscardconstexprnoexcept

Definition at line 139 of file vec_math.inl.

◆ operator%() [6/6]

template<size_t size, Primitive T, Primitive U>

vec< size, T > mal_math::operator%	(	vec< size, T > const &	left,
		vec< size, U > const &	right )

nodiscardconstexprnoexcept

Definition at line 144 of file vec_math.inl.

◆ operator*() [1/19]

template<size_t size, Primitive T, Primitive U>

vec< size, std::remove_const_t< T > > mal_math::operator*	(	_detail::rvec< size, T > const &	left,
		_detail::rvec< size, U > const &	right )

nodiscardconstexprnoexcept

Definition at line 226 of file vec_math.inl.

◆ operator*() [2/19]

template<size_t size, Primitive T, Primitive U>

vec< size, std::remove_const_t< T > > mal_math::operator*	(	_detail::rvec< size, T > const &	left,
		vec< size, U > const &	right )

nodiscardconstexprnoexcept

Definition at line 195 of file vec_math.inl.

◆ operator*() [3/19]

template<size_t size, Primitive T, Primitive U>

vec< size, std::remove_const_t< T > > mal_math::operator*	(	_detail::rvec< size, T > const &	vector,
		U const	value )

nodiscardconstexprnoexcept

Definition at line 175 of file vec_math.inl.

◆ operator*() [4/19]

template<AnyMat M, AnyVec V>
requires (M::size.x == V::size)

auto mal_math::operator*	(	M const &	left,
		V const &	right )

nodiscardconstexpr

Multiplies a matrix by a vector.

This function multiplies a matrix with a vector, resulting in a vector of the appropriate type and size.

Template Parameters

M	A matrix type satisfying the AnyMat concept.
V	A vector type satisfying the AnyVec concept.

Parameters

left	The matrix to be multiplied.
right	The vector to multiply the matrix with.

Returns: A vector that is the result of the multiplication.

Definition at line 71 of file mat_math.inl.

◆ operator*() [5/19]

template<Primitive T, Primitive U>

qua< T > mal_math::operator*	(	qua< T > const &	left,
		qua< U > const &	right )

nodiscardconstexprnoexcept

Quaternion multiplication.

Definition at line 216 of file quaternion.inl.

◆ operator*() [6/19]

template<Primitive T>

qua< T > mal_math::operator*	(	qua< T > const &	q,
		qua< T > const &	p )

nodiscardconstexprnoexcept

Quaternion-Quaternion multiplication.

Definition at line 376 of file quaternion.inl.

◆ operator*() [7/19]

template<Primitive T>

vec< 3, T > mal_math::operator*	(	qua< T > const &	q,
		vec< 3, T > const &	v )

nodiscardconstexprnoexcept

Quaternion-Vector multiplication.

Definition at line 381 of file quaternion.inl.

Here is the call graph for this function:

◆ operator*() [8/19]

template<Primitive T, Primitive U>

qua< T > mal_math::operator*	(	qua< T > const &	vector,
		U const	value )

nodiscardconstexprnoexcept

Quaternion-scalar multiplication.

Definition at line 196 of file quaternion.inl.

◆ operator*() [9/19]

template<AnyMat T, Primitive U>

mat< T::size.x, T::size.y, std::remove_const_t< typename T::type > > mal_math::operator*	(	T const &	left,
		U const	right )

nodiscardconstexpr

Multiplies a matrix by a primitive.

This function performs scalar multiplication on a matrix. It multiplies each element of the matrix by the given primitive.

Template Parameters

T	A matrix type satisfying the AnyMat concept.
U	A primitive type.

Parameters

left	The matrix to be multiplied.
right	The primitive value to multiply the matrix with.

Returns: A matrix where each element is multiplied by the primitive value.

Definition at line 89 of file mat_math.inl.

◆ operator*() [10/19]

template<AnyMat U, AnyMat V>
requires (U::size.x == V::size.y)

auto mal_math::operator*	(	U const &	lhs,
		V const &	rhs )

nodiscardconstexpr

Multiplies two matrices.

Computes the product of two matrices. Requires that the number of columns in the left-hand side matrix matches the number of rows in the right-hand side matrix.

Template Parameters

U	First matrix type
V	Second matrix type

Parameters

lhs	Left-hand side matrix
rhs	Right-hand side matrix

Returns: Product of the two matrices

Definition at line 33 of file mat_math.inl.

◆ operator*() [11/19]

template<AnyMat T, Primitive U>

mat< T::size.x, T::size.y, std::remove_const_t< typename T::type > > mal_math::operator*	(	U const	left,
		T const &	right )

nodiscardconstexpr

Multiplies a matrix by a primitive.

Performs scalar multiplication on a matrix by multiplying each element with a primitive value.

Template Parameters

T	A matrix type satisfying the AnyMat concept.
U	A primitive type.

Parameters

left	The primitive value.
right	The matrix.

Returns: A matrix where each element is multiplied by the primitive value.

Definition at line 94 of file mat_math.inl.

◆ operator*() [12/19]

template<size_t size, Primitive T, Primitive U>

vec< size, std::remove_const_t< T > > mal_math::operator*	(	U const	value,
		_detail::rvec< size, T > const &	vector )

nodiscardconstexprnoexcept

Definition at line 150 of file vec_math.inl.

◆ operator*() [13/19]

template<Primitive T, Primitive U>

qua< T > mal_math::operator*	(	U const	value,
		qua< T > const &	vector )

nodiscardconstexprnoexcept

Scalar-quaternion multiplication.

Definition at line 186 of file quaternion.inl.

◆ operator*() [14/19]

template<size_t size, Primitive T, Primitive U>

vec< size, T > mal_math::operator*	(	U const	value,
		vec< size, T > const &	vector )

nodiscardconstexprnoexcept

Definition at line 98 of file vec_math.inl.

◆ operator*() [15/19]

template<AnyVec V, AnyMat M>
requires (V::size == M::size.y)

auto mal_math::operator*	(	V const &	left,
		M const &	right )

nodiscardconstexpr

Multiplies a vector by a matrix.

This function is a specialized implementation of vector-matrix multiplication. The result is a vector with the appropriate type and size.

Template Parameters

V	A vector type satisfying the AnyVec concept.
M	A matrix type satisfying the AnyMat concept.

Parameters

left	The vector to be multiplied.
right	The matrix to multiply the vector with.

Returns: A vector that is the result of the multiplication.

Definition at line 54 of file mat_math.inl.

◆ operator*() [16/19]

template<Primitive T>

vec< 3, T > mal_math::operator*	(	vec< 3, T > const &	v,
		qua< T > const &	q )

nodiscardconstexprnoexcept

Vector-Quaternion multiplication.

Definition at line 391 of file quaternion.inl.

Here is the call graph for this function:

◆ operator*() [17/19]

template<size_t size, Primitive T, Primitive U>

vec< size, T > mal_math::operator*	(	vec< size, T > const &	left,
		_detail::rvec< size, U > const &	right )

nodiscardconstexprnoexcept

Definition at line 252 of file vec_math.inl.

◆ operator*() [18/19]

template<size_t size, Primitive T, Primitive U>

vec< size, T > mal_math::operator*	(	vec< size, T > const &	left,
		vec< size, U > const &	right )

nodiscardconstexprnoexcept

Definition at line 129 of file vec_math.inl.

◆ operator*() [19/19]

template<size_t size, Primitive T, Primitive U>

vec< size, T > mal_math::operator*	(	vec< size, T > const &	vector,
		U const	value )

nodiscardconstexprnoexcept

Definition at line 88 of file vec_math.inl.

◆ operator+() [1/11]

template<size_t size, Primitive T, Primitive U>

vec< size, std::remove_const_t< T > > mal_math::operator+	(	_detail::rvec< size, T > const &	left,
		_detail::rvec< size, U > const &	right )

nodiscardconstexprnoexcept

Definition at line 216 of file vec_math.inl.

◆ operator+() [2/11]

template<size_t size, Primitive T, Primitive U>

vec< size, std::remove_const_t< T > > mal_math::operator+	(	_detail::rvec< size, T > const &	left,
		vec< size, U > const &	right )

nodiscardconstexprnoexcept

Definition at line 185 of file vec_math.inl.

◆ operator+() [3/11]

template<size_t size, Primitive T, Primitive U>

vec< size, std::remove_const_t< T > > mal_math::operator+	(	_detail::rvec< size, T > const &	vector,
		U const	value )

nodiscardconstexprnoexcept

Definition at line 165 of file vec_math.inl.

◆ operator+() [4/11]

template<Primitive T, Primitive U>

qua< T > mal_math::operator+	(	qua< T > const &	left,
		qua< U > const &	right )

nodiscardconstexprnoexcept

Quaternion addition.

Definition at line 206 of file quaternion.inl.

◆ operator+() [5/11]

template<AnyMat T, AnyMat U>
requires (T::size.x == U::size.x && T::size.y == U::size.y)

mat< T::size.x, T::size.y, std::remove_const_t< typename T::type > > mal_math::operator+	(	T const &	left,
		U const &	right )

nodiscardconstexpr

Adds two matrices.

Performs element-wise addition of two matrices.

Template Parameters

T	A matrix type satisfying the AnyMat concept.
U	A matrix type satisfying the AnyMat concept.

Parameters

left	The first matrix.
right	The second matrix to be added to the first.

Returns: A matrix where each element is the result of the addition of corresponding elements.

Definition at line 116 of file mat_math.inl.

◆ operator+() [6/11]

template<AnyMat T, Primitive U>

mat< T::size.x, T::size.y, std::remove_const_t< typename T::type > > mal_math::operator+	(	U const	left,
		T const &	right )

nodiscardconstexpr

Adds a matrix to a primitive.

Adds a primitive to each element of the matrix.

Template Parameters

T	A matrix type satisfying the AnyMat concept.
U	A primitive type.

Parameters

left	The primitive value.
right	The matrix.

Returns: A matrix where each element is added to the primitive value.

Definition at line 105 of file mat_math.inl.

◆ operator+() [7/11]

template<size_t size, Primitive T, Primitive U>

vec< size, std::remove_const_t< T > > mal_math::operator+	(	U const	value,
		_detail::rvec< size, T > const &	vector )

nodiscardconstexprnoexcept

Definition at line 155 of file vec_math.inl.

◆ operator+() [8/11]

template<size_t size, Primitive T, Primitive U>

vec< size, T > mal_math::operator+	(	U const	value,
		vec< size, T > const &	vector )

nodiscardconstexprnoexcept

Definition at line 108 of file vec_math.inl.

◆ operator+() [9/11]

template<size_t size, Primitive T, Primitive U>

vec< size, T > mal_math::operator+	(	vec< size, T > const &	left,
		_detail::rvec< size, U > const &	right )

nodiscardconstexprnoexcept

Definition at line 242 of file vec_math.inl.

◆ operator+() [10/11]

template<size_t size, Primitive T, Primitive U>

vec< size, T > mal_math::operator+	(	vec< size, T > const &	left,
		vec< size, U > const &	right )

nodiscardconstexprnoexcept

Definition at line 119 of file vec_math.inl.

◆ operator+() [11/11]

template<size_t size, Primitive T, Primitive U>

vec< size, T > mal_math::operator+	(	vec< size, T > const &	vector,
		U const	value )

nodiscardconstexprnoexcept

Definition at line 78 of file vec_math.inl.

◆ operator-() [1/11]

template<size_t size, Primitive T, Primitive U>

vec< size, std::remove_const_t< T > > mal_math::operator-	(	_detail::rvec< size, T > const &	left,
		_detail::rvec< size, U > const &	right )

nodiscardconstexprnoexcept

Definition at line 221 of file vec_math.inl.

◆ operator-() [2/11]

template<size_t size, Primitive T, Primitive U>

vec< size, std::remove_const_t< T > > mal_math::operator-	(	_detail::rvec< size, T > const &	left,
		vec< size, U > const &	right )

nodiscardconstexprnoexcept

Definition at line 190 of file vec_math.inl.

◆ operator-() [3/11]

template<size_t size, Primitive T, Primitive U>

vec< size, std::remove_const_t< T > > mal_math::operator-	(	_detail::rvec< size, T > const &	vector,
		U const	value )

nodiscardconstexprnoexcept

Definition at line 170 of file vec_math.inl.

◆ operator-() [4/11]

template<Primitive T, Primitive U>

qua< T > mal_math::operator-	(	qua< T > const &	left,
		qua< U > const &	right )

nodiscardconstexprnoexcept

Quaternion subtraction.

Definition at line 211 of file quaternion.inl.

◆ operator-() [5/11]

template<AnyMat T, Primitive U>

mat< T::size.x, T::size.y, std::remove_const_t< typename T::type > > mal_math::operator-	(	T const &	left,
		U const	right )

nodiscardconstexpr

Subtracts a matrix from a primitive.

Subtracts each element of the matrix from a given primitive.

Template Parameters

T	A matrix type satisfying the AnyMat concept.
U	A primitive type.

Parameters

left	The matrix.
right	The primitive value.

Returns: A matrix where each element is subtracted from the primitive value.

Definition at line 100 of file mat_math.inl.

◆ operator-() [6/11]

template<AnyMat T, AnyMat U>
requires (T::size.x == U::size.x && T::size.y == U::size.y)

mat< T::size.x, T::size.y, std::remove_const_t< typename T::type > > mal_math::operator-	(	T const	left,
		U const &	right )

nodiscardconstexpr

Subtracts two matrices.

Performs element-wise subtraction of two matrices.

Template Parameters

T	A matrix type satisfying the AnyMat concept.
U	A matrix type satisfying the AnyMat concept.

Parameters

left	The first matrix.
right	The second matrix to be subtracted from the first.

Returns: A matrix where each element is the result of the subtraction of corresponding elements.

Definition at line 111 of file mat_math.inl.

◆ operator-() [7/11]

template<size_t size, Primitive T, Primitive U>

vec< size, std::remove_const_t< T > > mal_math::operator-	(	U const	value,
		_detail::rvec< size, T > const &	vector )

nodiscardconstexprnoexcept

Definition at line 160 of file vec_math.inl.

◆ operator-() [8/11]

template<size_t size, Primitive T, Primitive U>

vec< size, T > mal_math::operator-	(	U const	value,
		vec< size, T > const &	vector )

nodiscardconstexprnoexcept

Definition at line 113 of file vec_math.inl.

◆ operator-() [9/11]

template<size_t size, Primitive T, Primitive U>

vec< size, T > mal_math::operator-	(	vec< size, T > const &	left,
		_detail::rvec< size, U > const &	right )

nodiscardconstexprnoexcept

Definition at line 247 of file vec_math.inl.

◆ operator-() [10/11]

template<size_t size, Primitive T, Primitive U>

vec< size, T > mal_math::operator-	(	vec< size, T > const &	left,
		vec< size, U > const &	right )

nodiscardconstexprnoexcept

Definition at line 124 of file vec_math.inl.

◆ operator-() [11/11]

template<size_t size, Primitive T, Primitive U>

vec< size, T > mal_math::operator-	(	vec< size, T > const &	vector,
		U const	value )

nodiscardconstexprnoexcept

Definition at line 83 of file vec_math.inl.

◆ operator/() [1/10]

template<size_t size, Primitive T, Primitive U>

vec< size, std::remove_const_t< T > > mal_math::operator/	(	_detail::rvec< size, T > const &	left,
		_detail::rvec< size, U > const &	right )

nodiscardconstexprnoexcept

Definition at line 231 of file vec_math.inl.

◆ operator/() [2/10]

template<size_t size, Primitive T, Primitive U>

vec< size, std::remove_const_t< T > > mal_math::operator/	(	_detail::rvec< size, T > const &	left,
		vec< size, U > const &	right )

nodiscardconstexprnoexcept

Definition at line 200 of file vec_math.inl.

◆ operator/() [3/10]

template<size_t size, Primitive T, Primitive U>

vec< size, std::remove_const_t< T > > mal_math::operator/	(	_detail::rvec< size, T > const &	vector,
		U const	value )

nodiscardconstexprnoexcept

Definition at line 180 of file vec_math.inl.

◆ operator/() [4/10]

template<Primitive T, Primitive U>

qua< T > mal_math::operator/	(	qua< T > const &	left,
		qua< U > const &	right )

nodiscardconstexprnoexcept

Quaternion division.

Definition at line 221 of file quaternion.inl.

◆ operator/() [5/10]

template<Primitive T, Primitive U>

qua< T > mal_math::operator/	(	qua< T > const &	vector,
		U const	value )

nodiscardconstexprnoexcept

Quaternion-scalar division.

Definition at line 201 of file quaternion.inl.

◆ operator/() [6/10]

template<Primitive T, Primitive U>

qua< T > mal_math::operator/	(	U const	value,
		qua< T > const &	vector )

nodiscardconstexprnoexcept

Scalar-quaternion division.

Definition at line 191 of file quaternion.inl.

◆ operator/() [7/10]

template<size_t size, Primitive T, Primitive U>

vec< size, T > mal_math::operator/	(	U const	value,
		vec< size, T > const &	vector )

nodiscardconstexprnoexcept

Definition at line 103 of file vec_math.inl.

◆ operator/() [8/10]

template<size_t size, Primitive T, Primitive U>

vec< size, T > mal_math::operator/	(	vec< size, T > const &	left,
		_detail::rvec< size, U > const &	right )

nodiscardconstexprnoexcept

Definition at line 257 of file vec_math.inl.

◆ operator/() [9/10]

template<size_t size, Primitive T, Primitive U>

vec< size, T > mal_math::operator/	(	vec< size, T > const &	left,
		vec< size, U > const &	right )

nodiscardconstexprnoexcept

Definition at line 134 of file vec_math.inl.

◆ operator/() [10/10]

template<size_t size, Primitive T, Primitive U>

vec< size, T > mal_math::operator/	(	vec< size, T > const &	vector,
		U const	value )

nodiscardconstexprnoexcept

Definition at line 93 of file vec_math.inl.

◆ operator<<() [1/4]

template<Primitive T>

std::ostream & mal_math::operator<<	(	std::ostream &	os,
		qua< T > &	vec )

constexpr

Definition at line 176 of file quaternion.inl.

◆ operator<<() [2/4]

template<AnyVec U>

std::ostream & mal_math::operator<<	(	std::ostream &	os,
		U &	vec )

constexpr

Output stream operator overload for vector objects.

Definition at line 24 of file vec_math.inl.

◆ operator<<() [3/4]

template<AnyMat U>

std::ostream & mal_math::operator<<	(	std::ostream &	os,
		U const &	matrix )

constexpr

Writes a matrix to an output stream.

Output stream operator overload for const vector objects.

Converts the matrix into a string representation and inserts it into the given output stream.

Template Parameters

U	Any matrix type

Parameters

os	Output stream
matrix	Matrix to be written

Returns: Updated output stream

Definition at line 20 of file mat_math.inl.

◆ operator<<() [4/4]

template<size_t size, Primitive T>

std::ostream & mal_math::operator<<	(	std::ostream &	os,
		vec< size, T > &	vec )

constexpr

Writes a vector of given size to an output stream.

◆ operator==()

template<AnyVec T, AnyVec U>
requires (T::size == U::size)

bool mal_math::operator==	(	T const &	left,
		U const &	right )

nodiscardconstexprnoexcept

Definition at line 268 of file vec_math.inl.

◆ operator>>() [1/3]

template<Primitive T>

std::istream & mal_math::operator>>	(	std::istream &	is,
		qua< T > &	vec )

constexpr

Definition at line 167 of file quaternion.inl.

◆ operator>>() [2/3]

template<AnyMat U>

std::istream & mal_math::operator>>	(	std::istream &	is,
		U &	matrix )

constexpr

Reads a matrix from an input stream.

Input stream operator overload for vector objects.

Extracts values from the given input stream and fills the matrix accordingly.

Template Parameters

U	Any matrix type

Parameters

is	Input stream
matrix	Matrix to be filled with values

Returns: Updated input stream

Definition at line 8 of file mat_math.inl.

◆ operator>>() [3/3]

template<size_t size, Primitive T>

std::istream & mal_math::operator>>	(	std::istream &	is,
		vec< size, T > &	vec )

constexpr

Reads a vector of given size from an input stream.

◆ ortho()

template<Primitive T>

mat< 4, 4, T > mal_math::ortho	(	T	left,
		T	right,
		T	bottom,
		T	top,
		T	zNear,
		T	zFar )

constexpr

Generates an orthographic projection matrix.

Template Parameters

T	A primitive type for the function parameters.

Parameters

left	The left clipping plane distance.
right	The right clipping plane distance.
bottom	The bottom clipping plane distance.
top	The top clipping plane distance.
zNear	The near clipping plane distance.
zFar	The far clipping plane distance.

Returns: An orthographic projection matrix.

Definition at line 336 of file mat_math.inl.

◆ perspective() [1/2]

template<Primitive T>

mat< 4, 4, T > mal_math::perspective	(	T	fov_y,
		T	aspect_ratio,
		T	z_near,
		T	z_far )

constexpr

Generates a perspective projection matrix.

Template Parameters

T	A primitive type for the function parameters.

Parameters

fov_y	The vertical field of view in radians.
aspect_ratio	The aspect ratio of the viewport.
z_near	The near clipping plane distance.
z_far	The far clipping plane distance.

Returns: A perspective projection matrix.

Definition at line 319 of file mat_math.inl.

Here is the call graph for this function:

◆ perspective() [2/2]

template<Primitive T>
requires (!std::numeric_limits<T>::is_integer)

mat< 4, 4, T > mal_math::perspective	(	T	fov_y,
		T	aspect_ratio,
		T	z_near,
		T	z_far )

constexpr

Generates a perspective projection matrix.

Template Parameters

T	A primitive type for the function parameters.

Parameters

fov_y	The vertical field of view in radians.
aspect_ratio	The aspect ratio of the viewport.
z_near	The near clipping plane distance.
z_far	The far clipping plane distance.

Returns: A perspective projection matrix.

Definition at line 319 of file mat_math.inl.

Here is the call graph for this function:

◆ pitch()

template<Primitive T>

T mal_math::pitch ( qua< T > const & quaternion )

nodiscardconstexprnoexcept

Computes the pitch from a quaternion.

Definition at line 256 of file quaternion.inl.

Here is the caller graph for this function:

◆ pow() [1/5]

template<Primitive U>

double mal_math::pow	(	double	x,
		U	y )

inlinenodiscard

Definition at line 333 of file math-common.hpp.

◆ pow() [2/5]

template<Primitive U>

long double mal_math::pow	(	long double	x,
		U	y )

inlinenodiscard

Definition at line 335 of file math-common.hpp.

◆ pow() [3/5]

template<AnyVec T, Primitive U>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::pow	(	T const &	vector,
		U const	pow )

constexprnoexcept

Definition at line 666 of file vec_math.inl.

Here is the call graph for this function:

◆ pow() [4/5]

template<AnyVec T, AnyVec U>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::pow	(	T const &	vector1,
		U const &	vector2 )

constexprnoexcept

Definition at line 676 of file vec_math.inl.

Here is the call graph for this function:

◆ pow() [5/5]

template<Primitive T, Primitive U>

float mal_math::pow	(	T	x,
		U	y )

inlinenodiscardnoexcept

Definition at line 331 of file math-common.hpp.

Here is the caller graph for this function:

◆ QuaternionFromEuler() [1/2]

template<Primitive T>
requires (std::is_floating_point_v<T>)

qua< T > mal_math::QuaternionFromEuler	(	T	roll,
		T	pitch,
		T	yaw )

nodiscardconstexprnoexcept

Creates a quaternion from individual Euler angles.

Definition at line 326 of file quaternion.inl.

Here is the call graph for this function:

◆ QuaternionFromEuler() [2/2]

template<Primitive T>

qua< T > mal_math::QuaternionFromEuler ( vec< 3, T > const & angles )

nodiscardconstexprnoexcept

Creates a quaternion from Euler angles given in a vector.

Definition at line 313 of file quaternion.inl.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ QuaternionFromRotationMatrix()

template<AnyMat U>
requires (U::size.x == 3 && U::size.y == 3 && std::is_floating_point_v<typename U::type>)

qua< typename U::type > mal_math::QuaternionFromRotationMatrix ( U const & mat )

nodiscardconstexprnoexcept

Creates a quaternion from a 3x3 rotation matrix.

Definition at line 331 of file quaternion.inl.

◆ QuaternionToEuler()

template<Primitive T>

vec< 3, T > mal_math::QuaternionToEuler ( qua< T > const & quaternion )

nodiscardconstexprnoexcept

Converts a quaternion to Euler angles.

Definition at line 275 of file quaternion.inl.

Here is the call graph for this function:

◆ radians()

template<class T >
requires (!std::numeric_limits<T>::is_integer)

T mal_math::radians ( T x )

nodiscardconstexprnoexcept

Function to convert degrees to radians.

Definition at line 209 of file math-common.hpp.

Here is the caller graph for this function:

◆ rclamp() [1/2]

template<Primitive T, Primitive U>

void mal_math::rclamp	(	T &	left,
		U const	min,
		U const	max )

constexprnoexcept

Clamp the value of left between min and max in-place.

Template Parameters

T	Type of the value to be clamped.
U	Type of the boundary values.

Parameters

left	The value to be clamped.
min	The minimum value.
max	The maximum value.

Definition at line 695 of file vec_math.inl.

Here is the call graph for this function:

◆ rclamp() [2/2]

template<AnyVec T, AnyVec U>
requires (T::size == U::size)

void mal_math::rclamp	(	T &	left,
		U const	min,
		U const	max )

constexprnoexcept

Clamp the value of left between min and max in-place.

Template Parameters

T	Type of the value to be clamped.
U	Type of the boundary values.

Parameters

left	The value to be clamped.
min	The minimum value.
max	The maximum value.

Definition at line 719 of file vec_math.inl.

Here is the call graph for this function:

◆ rctranspose()

template<AnyMat T>

rmat< T::size.y, T::size.x, const typename T::type > mal_math::rctranspose ( T const & matrix )

constexpr

Transposes a constant matrix and returns a constant reference to it.

Swaps rows with columns in a constant matrix, returning a constant reference.

Template Parameters

T	A matrix type satisfying the AnyMat concept.

Parameters

matrix The matrix to be transposed.

Returns: A constant reference to the transposed matrix.

Definition at line 147 of file mat_math.inl.

◆ reflect()

template<AnyVec Vector>

vec< Vector::size, std::remove_const_t< typename Vector::type > > mal_math::reflect	(	Vector const &	normal,
		Vector const &	incident )

nodiscardconstexprnoexcept

Computes the reflection of an incident vector based on a surface's normal.

Given an incident vector and the normal at the point of incidence, this function calculates the direction that a perfectly reflected ray would take.

Template Parameters

Vector A vector type that should satisfy the AnyVec concept, having both size and type members.

Parameters

[in]	normal	The unit vector normal to the surface at the point of incidence.
[in]	incident	The unit vector pointing in the direction of the incoming ray.

Returns: vec<Vector::size, std::remove_const_t<typename Vector::type>> The reflected vector direction.

Note: Assumes both incident and normal are unit vectors. If they aren't, the result might not be correct.

Definition at line 56 of file math.hpp.

Here is the call graph for this function:

◆ refract()

template<AnyVec Vector>

vec< Vector::size, std::remove_const_t< typename Vector::type > > mal_math::refract	(	Vector const &	normal,
		Vector const &	incident,
		float	eta )

nodiscardconstexprnoexcept

Computes the refraction of a vector given an interface's normal and an index of refraction.

This function calculates the refracted direction of an incident vector at the boundary of two materials with a given index of refraction.

Template Parameters

Vector A vector type that should have a defined size and type member.

Parameters

[in]	normal	The unit vector normal to the interface at the point of incidence.
[in]	incident	The unit vector pointing in the direction of the incoming ray.
[in]	eta	The relative index of refraction (ratio of indices of refraction).

Returns: vec<Vector::size, std::remove_const_t<typename Vector::type>> The refracted vector direction.

Note: The returned vector may not be a unit vector if there is total internal reflection.

Definition at line 77 of file math.hpp.

Here is the call graph for this function:

◆ rmax() [1/2]

template<AnyVec T, AnyVec U>
requires (T::size == U::size)

void mal_math::rmax	(	T &	left,
		U const &	min )

constexprnoexcept

Modifies left in-place, setting each element to the maximum of itself and the corresponding element in min.

Template Parameters

T	Type of the vector to modify.
U	Type of the min vector.

Parameters

left	Vector to be modified.
min	Vector containing minimum values.

Definition at line 839 of file vec_math.inl.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rmax() [2/2]

template<AnyVec T, Primitive U>

void mal_math::rmax	(	T &	left,
		U const	min )

constexprnoexcept

Modifies left in-place, setting each element to the maximum of itself and min.

Modifies left in-place, setting its value to the maximum of itself and min.

Template Parameters

T	Type of the vector to modify.
U	Primitive type for the min value.

Parameters

left	Vector to be modified.
min	Minimum value for each element.

Template Parameters

T	Primitive type of the value to modify.
U	Primitive type for the min value.

Parameters

left	Value to be modified.
min	Minimum value.

Definition at line 857 of file vec_math.inl.

Here is the call graph for this function:

◆ rmin() [1/2]

template<AnyVec T, AnyVec U>
requires (T::size == U::size)

void mal_math::rmin	(	T &	left,
		U const &	max )

constexprnoexcept

Modifies left in-place, setting each element to the minimum of itself and the corresponding element in max.

Template Parameters

T	Type of the vector to modify.
U	Type of the max vector.

Parameters

left	Vector to be modified.
max	Vector containing maximum values.

Definition at line 830 of file vec_math.inl.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rmin() [2/2]

template<AnyVec T, Primitive U>

void mal_math::rmin	(	T &	left,
		U const	max )

constexprnoexcept

Modifies left in-place, setting each element to the minimum of itself and max.

Modifies left in-place, setting its value to the minimum of itself and max.

Template Parameters

T	Type of the vector to modify.
U	Primitive type for the max value.

Parameters

left	Vector to be modified.
max	Maximum value for each element.

Template Parameters

T	Primitive type of the value to modify.
U	Primitive type for the max value.

Parameters

left	Value to be modified.
max	Maximum value.

Definition at line 848 of file vec_math.inl.

Here is the call graph for this function:

◆ roll()

template<Primitive T>

T mal_math::roll ( qua< T > const & quaternion )

nodiscardconstexprnoexcept

Computes the roll from a quaternion.

Definition at line 268 of file quaternion.inl.

Here is the caller graph for this function:

◆ rotate() [1/3]

template<Primitive T>

mat< 4, 4, T > mal_math::rotate	(	mat< 4, 4, T > const &	matrix,
		qua< T > const &	q )

nodiscardconstexprnoexcept

Rotates a 4x4 matrix using a quaternion.

Definition at line 397 of file quaternion.inl.

Here is the call graph for this function:

◆ rotate() [2/3]

template<Primitive T>

qua< T > mal_math::rotate	(	mat< 4, 4, T > const &	matrix,
		qua< T > const &	q )

nodiscardconstexprnoexcept

Rotates a 4x4 matrix using a quaternion.

Definition at line 397 of file quaternion.inl.

Here is the call graph for this function:

◆ rotate() [3/3]

template<AnyMat T, Primitive U, AnyVec V>
requires (T::size.x == T::size.y && T::size.x == 4 && V::size == 3)

mat< 4, 4, std::remove_const_t< typename T::type > > mal_math::rotate	(	T const &	matrix,
		U	angle,
		V const &	axis )

constexpr

Rotates a matrix by a given angle around a given axis.

Template Parameters

T	A matrix type satisfying the AnyMat concept.
U	A primitive type representing the angle.
V	A vector type representing the rotation axis.

Parameters

matrix	The matrix to be rotated.
angle	The rotation angle.
axis	The rotation axis.

Returns: A matrix that has been rotated by the given angle around the given axis.

Definition at line 256 of file mat_math.inl.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ round() [1/2]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::round ( T const & vector )

constexprnoexcept

Definition at line 615 of file vec_math.inl.

Here is the call graph for this function:

◆ round() [2/2]

template<Primitive T>

T mal_math::round ( T x )

inlinenodiscardnoexcept

Definition at line 320 of file math-common.hpp.

Here is the caller graph for this function:

◆ roundEven() [1/2]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::roundEven ( T const & vector )

constexprnoexcept

Definition at line 625 of file vec_math.inl.

Here is the call graph for this function:

◆ roundEven() [2/2]

template<Primitive T>

T mal_math::roundEven ( T x )

inlinenodiscardnoexcept

Definition at line 322 of file math-common.hpp.

Here is the caller graph for this function:

◆ rtranspose()

template<AnyMat T>

rmat< T::size.y, T::size.x, typename T::type > mal_math::rtranspose ( T & matrix )

constexpr

Transposes a matrix and returns a reference to it.

Swaps rows with columns in a matrix, returning a reference.

Template Parameters

T	A matrix type satisfying the AnyMat concept.

Parameters

matrix The matrix to be transposed.

Returns: A reference to the transposed matrix.

Definition at line 134 of file mat_math.inl.

◆ scale()

template<AnyMat T, AnyVec V>
requires (T::size.x == T::size.y && T::size.x == 4 && V::size == 3)

mat< 4, 4, std::remove_const_t< typename T::type > > mal_math::scale	(	T const &	matrix,
		V const &	scale )

constexpr

Scales a matrix by a given vector.

Template Parameters

T	A matrix type satisfying the AnyMat concept.
V	A vector type representing the scaling factors.

Parameters

matrix	The matrix to be scaled.
scale	The scaling vector.

Returns: A matrix that has been scaled by the given vector.

Definition at line 287 of file mat_math.inl.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sign() [1/2]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::sign ( T const & vector )

constexprnoexcept

Definition at line 575 of file vec_math.inl.

Here is the call graph for this function:

◆ sign() [2/2]

template<Primitive T>

int mal_math::sign ( T x )

inlinenodiscardnoexcept

Definition at line 312 of file math-common.hpp.

Here is the caller graph for this function:

◆ sin() [1/4]

double mal_math::sin ( double x )

inlinenodiscard

Definition at line 223 of file math-common.hpp.

◆ sin() [2/4]

long double mal_math::sin ( long double x )

inlinenodiscard

Definition at line 224 of file math-common.hpp.

◆ sin() [3/4]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::sin ( T const & vector )

constexprnoexcept

Definition at line 340 of file vec_math.inl.

Here is the call graph for this function:

◆ sin() [4/4]

template<Primitive T>

float mal_math::sin ( T x )

inlinenodiscardnoexcept

Definition at line 222 of file math-common.hpp.

Here is the caller graph for this function:

◆ sinh() [1/4]

double mal_math::sinh ( double x )

inlinenodiscard

Definition at line 251 of file math-common.hpp.

◆ sinh() [2/4]

long double mal_math::sinh ( long double x )

inlinenodiscard

Definition at line 252 of file math-common.hpp.

◆ sinh() [3/4]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::sinh ( T const & vector )

constexprnoexcept

Definition at line 405 of file vec_math.inl.

Here is the call graph for this function:

◆ sinh() [4/4]

template<Primitive T>

float mal_math::sinh ( T x )

inlinenodiscardnoexcept

Definition at line 250 of file math-common.hpp.

Here is the caller graph for this function:

◆ sqrt() [1/4]

double mal_math::sqrt ( double x )

inlinenodiscard

Definition at line 303 of file math-common.hpp.

◆ sqrt() [2/4]

long double mal_math::sqrt ( long double x )

inlinenodiscard

Definition at line 304 of file math-common.hpp.

◆ sqrt() [3/4]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::sqrt ( T const & vector )

constexprnoexcept

Definition at line 545 of file vec_math.inl.

Here is the call graph for this function:

◆ sqrt() [4/4]

template<Primitive T>

float mal_math::sqrt ( T x )

inlinenodiscardnoexcept

Definition at line 302 of file math-common.hpp.

Here is the caller graph for this function:

◆ squared_length()

template<AnyVec T>

std::remove_const_t< typename T::type > mal_math::squared_length ( T const & vector )

nodiscardconstexprnoexcept

Compute the squared length of the given vector.

Template Parameters

T	The vector type.

Parameters

vector The input vector.

Returns: The squared length of the vector.

Definition at line 284 of file vec_math.inl.

Here is the caller graph for this function:

◆ tan() [1/4]

double mal_math::tan ( double x )

inlinenodiscard

Definition at line 227 of file math-common.hpp.

◆ tan() [2/4]

long double mal_math::tan ( long double x )

inlinenodiscard

Definition at line 228 of file math-common.hpp.

◆ tan() [3/4]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::tan ( T const & vector )

constexprnoexcept

Definition at line 350 of file vec_math.inl.

Here is the call graph for this function:

◆ tan() [4/4]

template<Primitive T>

float mal_math::tan ( T x )

inlinenodiscardnoexcept

Definition at line 226 of file math-common.hpp.

Here is the caller graph for this function:

◆ tanh() [1/4]

double mal_math::tanh ( double x )

inlinenodiscard

Definition at line 255 of file math-common.hpp.

◆ tanh() [2/4]

long double mal_math::tanh ( long double x )

inlinenodiscard

Definition at line 256 of file math-common.hpp.

◆ tanh() [3/4]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::tanh ( T const & vector )

constexprnoexcept

Definition at line 425 of file vec_math.inl.

Here is the call graph for this function:

◆ tanh() [4/4]

template<Primitive T>

float mal_math::tanh ( T x )

inlinenodiscardnoexcept

Definition at line 254 of file math-common.hpp.

Here is the caller graph for this function:

◆ translate()

template<AnyMat T, AnyVec V>
requires (T::size.x == T::size.y && T::size.x == 4 && V::size == 3)

mat< 4, 4, std::remove_const_t< typename T::type > > mal_math::translate	(	T const &	matrix,
		V const &	vec )

constexpr

Translates a matrix by a given vector.

Template Parameters

T	A matrix type satisfying the AnyMat concept.
V	A vector type satisfying the AnyVec concept.

Parameters

matrix	The matrix to be translated.
vec	The translation vector.

Returns: A matrix that has been translated by the given vector.

Definition at line 246 of file mat_math.inl.

◆ transpose()

template<AnyMat T>

mat< T::size.y, T::size.x, std::remove_const_t< typename T::type > > mal_math::transpose ( T const & matrix )

constexpr

Transposes a matrix.

Swaps rows with columns in a matrix.

Template Parameters

T	A matrix type satisfying the AnyMat concept.

Parameters

matrix The matrix to be transposed.

Returns: A new matrix that is the transpose of the given matrix.

Definition at line 121 of file mat_math.inl.

◆ trunc() [1/2]

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::trunc ( T const & vector )

constexprnoexcept

Definition at line 605 of file vec_math.inl.

Here is the call graph for this function:

◆ trunc() [2/2]

template<Primitive T>

T mal_math::trunc ( T x )

inlinenodiscardnoexcept

Definition at line 318 of file math-common.hpp.

Here is the caller graph for this function:

◆ unit_vector()

template<AnyVec T>

vec< T::size, std::remove_const_t< typename T::type > > mal_math::unit_vector ( T const & vector )

nodiscardconstexprnoexcept

Compute the unit vector (normalized vector) of the given vector.

Template Parameters

T	The vector type.

Parameters

vector The input vector.

Returns: The unit vector.

Definition at line 300 of file vec_math.inl.

Here is the call graph for this function:

◆ yaw()

template<Primitive T>

T mal_math::yaw ( qua< T > const & quaternion )

nodiscardconstexprnoexcept

Computes the yaw from a quaternion.

Definition at line 263 of file quaternion.inl.

Here is the call graph for this function:

Here is the caller graph for this function:

Namespaces

Classes

Concepts

Typedefs

Functions

Detailed Description

Typedef Documentation

◆ Box

◆ Boxd

◆ Boxf

◆ dmat2

◆ dmat2x2

◆ dmat2x3

◆ dmat2x4

◆ dmat3

◆ dmat3x2

◆ dmat3x3

◆ dmat3x4

◆ dmat4

◆ dmat4x2

◆ dmat4x3

◆ dmat4x4

◆ dquat

◆ drmat2

◆ drmat2x2

◆ drmat2x3

◆ drmat2x4

◆ drmat3

◆ drmat3x2

◆ drmat3x3

◆ drmat3x4

◆ drmat4

◆ drmat4x2

◆ drmat4x3

◆ drmat4x4

◆ dvec2

◆ dvec3

◆ dvec4

◆ imat2

◆ imat2x2

◆ imat2x3

◆ imat2x4

◆ imat3

◆ imat3x2

◆ imat3x3

◆ imat3x4

◆ imat4

◆ imat4x2

◆ imat4x3

◆ imat4x4

◆ irmat2

◆ irmat2x2

◆ irmat2x3

◆ irmat2x4

◆ irmat3

◆ irmat3x2

◆ irmat3x3

◆ irmat3x4

◆ irmat4

◆ irmat4x2

◆ irmat4x3

◆ irmat4x4

◆ ivec2

◆ ivec3

◆ ivec4

◆ mat2

◆ mat2x2

◆ mat2x3

◆ mat2x4

◆ mat3

◆ mat3x2

◆ mat3x3

◆ mat3x4

◆ mat4

◆ mat4x2

◆ mat4x3

◆ mat4x4

◆ quat

◆ rmat2

◆ rmat2x2