Math modul. More...

#include <math.hpp>

Public Member Functions
	math ()=delete
	Deleted explicit constructor.

Static Public Member Functions
static constexpr float	epsilon ()
	Single precision epsilon.

static constexpr float	pi ()
	Single precision PI.

static constexpr float	to_radians (float degrees)
	Converts degrees to radians.

static constexpr float	to_degrees (float radians)
	Converts radians to degrees.

static constexpr std::pair< float, float >	normal (float x, float y)
	Returns the normal vector of a vector.

static float	length (float x, float y)
	Returns the length of a vector.

static float	angle (float x, float y)
	Returns the angle of a vector.

static std::pair< float, float >	normalize (float x, float y)
	Normalizes a vector.

static float	move_x (float length, float angle)
	Moves the x component of a vector.

static float	move_y (float length, float angle)
	Moves the y component of a vector.

static std::array< float, 4 >	transformation_matrix (float angle, float scale)
	Creates a transformation matrix.

static constexpr float	transform_x (float x, float y, std::array< float, 4 > const &transformation_matrix)
	Transforms the x component of a vector.

static constexpr float	transform_y (float x, float y, std::array< float, 4 > const &transformation_matrix)
	Transforms the y component of a vector.

template<typename T >
static T	random (T minimum=std::numeric_limits< T >::lowest(), T maximum=std::numeric_limits< T >::max())
	Returns a random numeric value from an interval.

template<typename T >
static bool	random (float probability=(float) true/2)
	Returns a random boolean value.

Detailed Description

Math modul.

Definition at line 37 of file math.hpp.

Member Function Documentation

◆ epsilon()

static constexpr float wze::math::epsilon ( )

inlinestaticnodiscardconstexpr

Single precision epsilon.

Definition at line 47 of file math.hpp.

                                                   {
        // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers,readability-magic-numbers)
        return .01;
    }

◆ pi()

static constexpr float wze::math::pi ( )

inlinestaticnodiscardconstexpr

Single precision PI.

Definition at line 55 of file math.hpp.

                                              {
        // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers,readability-magic-numbers)
        return 3.1415927;
    }

◆ to_radians()

static constexpr float wze::math::to_radians ( float degrees )

inlinestaticnodiscardconstexpr

Converts degrees to radians.

Parameters

degrees Angle in degrees.

Returns: Angle in radians.

Definition at line 65 of file math.hpp.

                                                                   {
        // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers,readability-magic-numbers)
        return degrees * pi() / 180;
    }

◆ to_degrees()

static constexpr float wze::math::to_degrees ( float radians )

inlinestaticnodiscardconstexpr

Converts radians to degrees.

Parameters

radians Angle in radians.

Returns: Angle in degrees.

Definition at line 75 of file math.hpp.

                                                                   {
        // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers,readability-magic-numbers)
        return radians * 180 / pi();
    }

◆ normal()

static constexpr std::pair< float, float > wze::math::normal	(	float	x,
		float	y )

inlinestaticnodiscardconstexpr

Returns the normal vector of a vector.

Parameters

x	X component of the vector.
y	Y component of the vector.

Returns: Normal vector of the vector.

Definition at line 86 of file math.hpp.

                                                                           {
        return {y, -x};
    }

◆ length()

float wze::math::length	(	float	x,
		float	y )

staticnodiscard

Returns the length of a vector.

Parameters

x	X component of the vector.
y	Y component of the vector.

Returns: Length of the vector.

Definition at line 33 of file math.cpp.

                                      {
    return sqrtf(powf(x, 2) + powf(y, 2));
}

◆ angle()

float wze::math::angle	(	float	x,
		float	y )

staticnodiscard

Returns the angle of a vector.

Parameters

x	X component of the vector.
y	Y component of the vector.

Returns: Angle of the vector.

Definition at line 37 of file math.cpp.

                                     {
    return atan2f(y, x);
}

◆ normalize()

std::pair< float, float > wze::math::normalize	(	float	x,
		float	y )

staticnodiscard

Normalizes a vector.

Parameters

x	X component of the vector.
y	Y component of the vector.

Returns: Normalized vector.

Definition at line 41 of file math.cpp.

                                                         {
    if ((bool)x || (bool)y) {
        float length{math::length(x, y)};
        return {x / length, y / length};
    }
    return {0, 0};
}

◆ move_x()

float wze::math::move_x	(	float	length,
		float	angle )

staticnodiscard

Moves the x component of a vector.

Parameters

length	Length of the movement.
angle	Angle of the movement.

Returns: Moved x component of the vector.

Definition at line 49 of file math.cpp.

                                               {
    return length * cosf(angle);
}

◆ move_y()

float wze::math::move_y	(	float	length,
		float	angle )

staticnodiscard

Moves the y component of a vector.

Parameters

length	Length of the movement.
angle	Angle of the movement

Returns: Moved y component of the vector.

Definition at line 53 of file math.cpp.

                                               {
    return length * sinf(angle);
}

◆ transformation_matrix()

std::array< float, 4 > wze::math::transformation_matrix	(	float	angle,
		float	scale )

staticnodiscard

Creates a transformation matrix.

Parameters

angle	Angle of the transformation matrix.
scale	Scale of the transformation matrix.

Returns: Created transformation matrix.

Definition at line 57 of file math.cpp.

                                                                   {
    float cosine_scale{cosf(angle) * scale};
    float sine_scale{sinf(angle) * scale};
    return {cosine_scale, -sine_scale, sine_scale, cosine_scale};
}

◆ transform_x()

static constexpr float wze::math::transform_x	(	float	x,
		float	y,
		std::array< float, 4 > const &	transformation_matrix )

inlinestaticnodiscardconstexpr

Transforms the x component of a vector.

Parameters

x	X component of the vector.
y	Y component of the vector.
transformation_matrix	Transformation matrix.

Returns: Transformed x component of the vector.

Definition at line 148 of file math.hpp.

                                                                 {
        return (x * transformation_matrix.at(0)) +
               (y * transformation_matrix.at(1));
    }

◆ transform_y()

static constexpr float wze::math::transform_y	(	float	x,
		float	y,
		std::array< float, 4 > const &	transformation_matrix )

inlinestaticnodiscardconstexpr

Transforms the y component of a vector.

Parameters

x	X component of the vector.
y	Y component of the vector.
transformation_matrix	Transformation matrix.

Returns: Transformed y component of the vector.

Definition at line 162 of file math.hpp.

                                                                 {
        return (x * transformation_matrix.at(2)) +
               (y * transformation_matrix.at(3));
    }

◆ random() [1/2]

template<typename T >

static T wze::math::random	(	T	minimum = std::numeric_limits<T>::lowest(),
		T	maximum = std::numeric_limits<T>::max() )

inlinestaticnodiscard

Returns a random numeric value from an interval.

Template Parameters

T	Numeric type.

Parameters

minimum	Minimum inclusive value of the interval.
maximum	Maximum inclusive value of the interval.

Returns: Random numeric value from the interval.

Definition at line 176 of file math.hpp.

                                                                         {
        static_assert(!std::is_same_v<T, bool>);
        if constexpr (std::is_integral_v<T>) {
            return std::uniform_int_distribution<T>{minimum,
                                                    maximum}(_mt19937_64);
        } else if constexpr (std::is_floating_point_v<T>) {
            return std::uniform_real_distribution<T>{minimum,
                                                     maximum}(_mt19937_64);
        }
    }

◆ random() [2/2]

template<typename T >

static bool wze::math::random ( float probability = (float)true / 2 )

inlinestaticnodiscard

Returns a random boolean value.

Parameters

T	Boolean type.
probability	Probability of a true value.

Returns: Random boolean value.

Definition at line 195 of file math.hpp.

                                                                          {
        static_assert(std::is_same_v<T, bool>);
        return std::bernoulli_distribution{(double)probability}(_mt19937_64);
    }

The documentation for this class was generated from the following files:

include/wizard_engine/math.hpp
src/math.cpp

	Wizard Engine 2D cross-platform game engine built around SDL2

Public Member Functions

Static Public Member Functions

Detailed Description

Member Function Documentation

◆ epsilon()

◆ pi()

◆ to_radians()

◆ to_degrees()

◆ normal()

◆ length()

◆ angle()

◆ normalize()

◆ move_x()

◆ move_y()

◆ transformation_matrix()

◆ transform_x()

◆ transform_y()

◆ random() [1/2]

◆ random() [2/2]