MathLib: Assertions

Definition at line 132 of file Checks.hpp.

◆ CHECK_IF_EQUAL() [2/3]

void CHECK_IF_EQUAL	(	float	input,
		float	near_to,
		float	tolerance = `0.0002f`
	)

inline

Definition at line 127 of file Checks.hpp.

◆ CHECK_IF_EQUAL() [3/3]

void CHECK_IF_EQUAL	(	long double	input,
		long double	near_to,
		long double	tolerance = `0.0002l`
	)

inline

Definition at line 137 of file Checks.hpp.

◆ CHECK_IF_NOT_EQUAL() [1/3]

void CHECK_IF_NOT_EQUAL	(	double	input,
		double	near_to,
		double	tolerance = `0.0002`
	)

inline

Definition at line 163 of file Checks.hpp.

◆ CHECK_IF_NOT_EQUAL() [2/3]

void CHECK_IF_NOT_EQUAL	(	float	input,
		float	near_to,
		float	tolerance = `0.0002f`
	)

inline

Definition at line 158 of file Checks.hpp.

◆ CHECK_IF_NOT_EQUAL() [3/3]

void CHECK_IF_NOT_EQUAL	(	long double	input,
		long double	near_to,
		long double	tolerance = `0.0002l`
	)

inline

Definition at line 168 of file Checks.hpp.

◆ CHECK_IF_ZERO() [1/3]

void CHECK_IF_ZERO	(	double	input,
		double	tolerance = `0.0002`
	)

inline

Definition at line 194 of file Checks.hpp.

◆ CHECK_IF_ZERO() [2/3]

void CHECK_IF_ZERO	(	float	input,
		float	tolerance = `0.0002f`
	)

inline

Definition at line 189 of file Checks.hpp.

◆ CHECK_IF_ZERO() [3/3]

void CHECK_IF_ZERO	(	long double	input,
		long double	tolerance = `0.0002l`
	)

inline

Definition at line 199 of file Checks.hpp.

Friends

◆ CHECK_IF_EQUAL [1/10]

template<std::floating_point T>

template<std::floating_point OT = T>

void CHECK_IF_EQUAL	(	const BasicComplex< T > &	input,
		const BasicComplex< T > &	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Complex.hpp>

Compare two values for equality with a tolerance and causes an assertion when false

Parameters

input	The first value to compare
near_to	The second value to compare
tolerance	The minimum value for being considered equal

Returns: true if the two are equal within tolerance , false otherwise

Definition at line 406 of file Complex.hpp.

◆ CHECK_IF_EQUAL [2/10]

template<class T >

template<std::floating_point OT = T>
requires std::is_floating_point_v<T>

void CHECK_IF_EQUAL	(	const BasicDual< T > &	input,
		const BasicDual< T > &	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Dual.hpp>

Compare two values for equality with a tolerance and causes an assertion when false

Parameters

input	The first value to compare
near_to	The second value to compare
tolerance	The minimum value for being considered equal

Returns: true if the two are equal within tolerance , false otherwise

Definition at line 364 of file Dual.hpp.

◆ CHECK_IF_EQUAL [3/10]

template<class T >

template<std::floating_point OT = float>

void CHECK_IF_EQUAL	(	const BasicDualQuaternion< T > &	input,
		const BasicDualQuaternion< T > &	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/DualQuaternion.hpp>

Compare two values for equality with a tolerance and causes an assertion when false

Parameters

input	The first value to compare
near_to	The second value to compare
tolerance	The minimum value for being considered equal

Returns: true if the two are equal within tolerance , false otherwise

Definition at line 536 of file DualQuaternion.hpp.

◆ CHECK_IF_EQUAL [4/10]

template<class T >

template<std::floating_point OT = T>
requires std::is_floating_point_v<T>

void CHECK_IF_EQUAL	(	const BasicQuaternion< T > &	input,
		const BasicQuaternion< T > &	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Quaternion.hpp>

Compare two values for equality with a tolerance and causes an assertion when false

Parameters

input	The first value to compare
near_to	The second value to compare
tolerance	The minimum value for being considered equal

Returns: true if the two are equal within tolerance , false otherwise

Definition at line 501 of file Quaternion.hpp.

◆ CHECK_IF_EQUAL [5/10]

template<class Type >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<Type, U>

void CHECK_IF_EQUAL	(	const BasicVector2D< Type > &	input,
		BasicRef< U >	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

Compare two values for equality with a tolerance and causes an assertion when false

Parameters

input	The first value to compare
near_to	The second value to compare
tolerance	The minimum value for being considered equal

Returns: true if the two are equal within tolerance , false otherwise

Definition at line 1030 of file Vector2D.hpp.

◆ CHECK_IF_EQUAL [6/10]

template<class Type >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<Type, U>

void CHECK_IF_EQUAL	(	const BasicVector2D< Type > &	input,
		const BasicVector2D< U > &	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

Compare two values for equality with a tolerance and causes an assertion when false

Parameters

input	The first value to compare
near_to	The second value to compare
tolerance	The minimum value for being considered equal

Returns: true if the two are equal within tolerance , false otherwise

Definition at line 1013 of file Vector2D.hpp.

◆ CHECK_IF_EQUAL [7/10]

template<class Type >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<Type, U>

void CHECK_IF_EQUAL	(	const BasicVector3D< Type > &	input,
		BasicRef< U >	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

Compare two values for equality with a tolerance and causes an assertion when false

Parameters

input	The first value to compare
near_to	The second value to compare
tolerance	The minimum value for being considered equal

Returns: true if the two are equal within tolerance , false otherwise

Definition at line 1088 of file Vector3D.hpp.

◆ CHECK_IF_EQUAL [8/10]

template<class Type >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<Type, U>

void CHECK_IF_EQUAL	(	const BasicVector3D< Type > &	input,
		const BasicVector3D< U > &	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

Compare two values for equality with a tolerance and causes an assertion when false

Parameters

input	The first value to compare
near_to	The second value to compare
tolerance	The minimum value for being considered equal

Returns: true if the two are equal within tolerance , false otherwise

Definition at line 1071 of file Vector3D.hpp.

◆ CHECK_IF_EQUAL [9/10]

template<class Type >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<Type, U>

void CHECK_IF_EQUAL	(	const BasicVector4D< Type > &	input,
		BasicRef< U >	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

Compare two values for equality with a tolerance and causes an assertion when false

Parameters

input	The first value to compare
near_to	The second value to compare
tolerance	The minimum value for being considered equal

Returns: true if the two are equal within tolerance , false otherwise

Definition at line 1096 of file Vector4D.hpp.

◆ CHECK_IF_EQUAL [10/10]

template<class Type >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<Type, U>

void CHECK_IF_EQUAL	(	const BasicVector4D< Type > &	input,
		const BasicVector4D< U > &	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

Compare two values for equality with a tolerance and causes an assertion when false

Parameters

input	The first value to compare
near_to	The second value to compare
tolerance	The minimum value for being considered equal

Returns: true if the two are equal within tolerance , false otherwise

Definition at line 1079 of file Vector4D.hpp.

◆ CHECK_IF_NOT_EQUAL [1/10]

template<std::floating_point T>

template<std::floating_point OT = T>

void CHECK_IF_NOT_EQUAL	(	const BasicComplex< T > &	input,
		const BasicComplex< T > &	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Complex.hpp>

Compare two values for inequality with a tolerance and causes an assertion when false

Parameters

input	The first value to compare
near_to	The second value to compare
tolerance	The minimum value for being considered equal

Returns: true if the two are not equal outside tolerance , false otherwise

Definition at line 422 of file Complex.hpp.

◆ CHECK_IF_NOT_EQUAL [2/10]

template<class T >

template<std::floating_point OT = T>
requires std::is_floating_point_v<T>

void CHECK_IF_NOT_EQUAL	(	const BasicDual< T > &	input,
		const BasicDual< T > &	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Dual.hpp>

Compare two values for inequality with a tolerance and causes an assertion when false

Parameters

input	The first value to compare
near_to	The second value to compare
tolerance	The minimum value for being considered equal

Returns: true if the two are not equal outside tolerance , false otherwise

Definition at line 381 of file Dual.hpp.

◆ CHECK_IF_NOT_EQUAL [3/10]

template<class T >

template<std::floating_point OT = float>

void CHECK_IF_NOT_EQUAL	(	const BasicDualQuaternion< T > &	input,
		const BasicDualQuaternion< T > &	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/DualQuaternion.hpp>

Compare two values for inequality with a tolerance and causes an assertion when false

Parameters

input	The first value to compare
near_to	The second value to compare
tolerance	The minimum value for being considered equal

Returns: true if the two are not equal outside tolerance , false otherwise

Definition at line 552 of file DualQuaternion.hpp.

◆ CHECK_IF_NOT_EQUAL [4/10]

template<class T >

template<std::floating_point OT = T>
requires std::is_floating_point_v<T>

void CHECK_IF_NOT_EQUAL	(	const BasicQuaternion< T > &	input,
		const BasicQuaternion< T > &	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Quaternion.hpp>

Compare two values for inequality with a tolerance and causes an assertion when false

Parameters

input	The first value to compare
near_to	The second value to compare
tolerance	The minimum value for being considered equal

Returns: true if the two are not equal outside tolerance , false otherwise

Definition at line 518 of file Quaternion.hpp.

◆ CHECK_IF_NOT_EQUAL [5/10]

template<class Type >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<Type, U>

void CHECK_IF_NOT_EQUAL	(	const BasicVector2D< Type > &	input,
		BasicRef< U >	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

Compare two values for inequality with a tolerance and causes an assertion when false

Parameters

input	The first value to compare
near_to	The second value to compare
tolerance	The minimum value for being considered equal

Returns: true if the two are not equal outside tolerance , false otherwise

Definition at line 1064 of file Vector2D.hpp.

◆ CHECK_IF_NOT_EQUAL [6/10]

template<class Type >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<Type, U>

void CHECK_IF_NOT_EQUAL	(	const BasicVector2D< Type > &	input,
		const BasicVector2D< U > &	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

Compare two values for inequality with a tolerance and causes an assertion when false

Parameters

input	The first value to compare
near_to	The second value to compare
tolerance	The minimum value for being considered equal

Returns: true if the two are not equal outside tolerance , false otherwise

Definition at line 1047 of file Vector2D.hpp.

◆ CHECK_IF_NOT_EQUAL [7/10]

template<class Type >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<Type, U>

void CHECK_IF_NOT_EQUAL	(	const BasicVector3D< Type > &	input,
		BasicRef< U >	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

Compare two values for inequality with a tolerance and causes an assertion when false

Parameters

input	The first value to compare
near_to	The second value to compare
tolerance	The minimum value for being considered equal

Returns: true if the two are not equal outside tolerance , false otherwise

Definition at line 1122 of file Vector3D.hpp.

◆ CHECK_IF_NOT_EQUAL [8/10]

template<class Type >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<Type, U>

void CHECK_IF_NOT_EQUAL	(	const BasicVector3D< Type > &	input,
		const BasicVector3D< U > &	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

Compare two values for inequality with a tolerance and causes an assertion when false

Parameters

input	The first value to compare
near_to	The second value to compare
tolerance	The minimum value for being considered equal

Returns: true if the two are not equal outside tolerance , false otherwise

Definition at line 1105 of file Vector3D.hpp.

◆ CHECK_IF_NOT_EQUAL [9/10]

template<class Type >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<Type, U>

void CHECK_IF_NOT_EQUAL	(	const BasicVector4D< Type > &	input,
		BasicRef< U >	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

Compare two values for inequality with a tolerance and causes an assertion when false

Parameters

input	The first value to compare
near_to	The second value to compare
tolerance	The minimum value for being considered equal

Returns: true if the two are not equal outside tolerance , false otherwise

Definition at line 1130 of file Vector4D.hpp.

◆ CHECK_IF_NOT_EQUAL [10/10]

template<class Type >

template<class U , std::floating_point OT = float>
requires Concept::SameUnqualified<Type, U>

void CHECK_IF_NOT_EQUAL	(	const BasicVector4D< Type > &	input,
		const BasicVector4D< U > &	near_to,
		OT	tolerance = `OT{0.0002}`
	)

friend

Compare two values for inequality with a tolerance and causes an assertion when false

Parameters

input	The first value to compare
near_to	The second value to compare
tolerance	The minimum value for being considered equal

Returns: true if the two are not equal outside tolerance , false otherwise

Definition at line 1113 of file Vector4D.hpp.

◆ CHECK_IF_ZERO [1/7]

template<std::floating_point T>

template<std::floating_point OT = T>

void CHECK_IF_ZERO	(	const BasicComplex< T > &	input,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Complex.hpp>

Compare a value to near zero

Parameters

input	The first value to compare
tolerance	The minimum value for being considered equal

Returns: true if input is inside tolerance , false otherwise

Definition at line 439 of file Complex.hpp.

◆ CHECK_IF_ZERO [2/7]

template<class T >

template<std::floating_point OT = T>
requires std::is_floating_point_v<T>

void CHECK_IF_ZERO	(	const BasicDual< T > &	input,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Dual.hpp>

Compare a value to near zero

Parameters

input	The first value to compare
tolerance	The minimum value for being considered equal

Returns: true if input is inside tolerance , false otherwise

Definition at line 397 of file Dual.hpp.

◆ CHECK_IF_ZERO [3/7]

template<class T >

template<std::floating_point OT = float>

void CHECK_IF_ZERO	(	const BasicDualQuaternion< T > &	input,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/DualQuaternion.hpp>

Compare a value to near zero

Parameters

input	The first value to compare
tolerance	The minimum value for being considered equal

Returns: true if input is inside tolerance , false otherwise

Definition at line 567 of file DualQuaternion.hpp.

◆ CHECK_IF_ZERO [4/7]

template<class T >

template<std::floating_point OT = T>
requires std::is_floating_point_v<T>

void CHECK_IF_ZERO	(	const BasicQuaternion< T > &	input,
		OT	tolerance = `OT{0.0002}`
	)

friend

#include <lib/include/Math/math/Quaternion.hpp>

Compare a value to near zero

Parameters

input	The first value to compare
tolerance	The minimum value for being considered equal

Returns: true if input is inside tolerance , false otherwise

Definition at line 534 of file Quaternion.hpp.

◆ CHECK_IF_ZERO [5/7]

template<class Type >

template<std::floating_point OT = float>

void CHECK_IF_ZERO	(	const BasicVector2D< Type > &	input,
		OT	tolerance = `OT{0.0002}`
	)

friend

Compare a value to near zero

Parameters

input	The first value to compare
tolerance	The minimum value for being considered equal

Returns: true if input is inside tolerance , false otherwise

Definition at line 1079 of file Vector2D.hpp.

◆ CHECK_IF_ZERO [6/7]

template<class Type >

template<std::floating_point OT = float>

void CHECK_IF_ZERO	(	const BasicVector3D< Type > &	input,
		OT	tolerance = `OT{0.0002}`
	)

friend

Compare a value to near zero

Parameters

input	The first value to compare
tolerance	The minimum value for being considered equal

Returns: true if input is inside tolerance , false otherwise

Definition at line 1137 of file Vector3D.hpp.

◆ CHECK_IF_ZERO [7/7]

template<class Type >

template<std::floating_point OT = float>

void CHECK_IF_ZERO	(	const BasicVector4D< Type > &	input,
		OT	tolerance = `OT{0.0002}`
	)

friend