tb_math.hpp

#ifndef TurtleBrains_Math_hpp
#define TurtleBrains_Math_hpp

#include <turtle_brains/core/tb_configuration.hpp>
#include <turtle_brains/math/tb_constants.hpp>

#include <cmath>

namespace TurtleBrains
{
    namespace Math
    {
        template<typename Type> bool IsEqual(const Type& leftValue, const Type& rightValue)
        {
            return leftValue == rightValue;
        }

        inline bool IsEqual(const float leftValue, const float rightValue, const float tolerance = tbMath::kTolerance)
        {
            return fabsf(leftValue - rightValue) <= tolerance;
        }

        inline bool IsEqual(const double leftValue, const double rightValue, const double tolerance = tbMath::kTolerance)
        {
            return fabs(leftValue - rightValue) <= tolerance;
        }

        template<typename Type> bool IsZero(const Type& value)
        {
            return value == 0;
        }

        inline bool IsZero(const float value, const float tolerance = tbMath::kTolerance)
        {
            return (fabsf(value)) <= tolerance;
        }

        inline bool IsZero(const double value, const double tolerance = tbMath::kTolerance)
        {
            return (fabs(value)) <= tolerance;
        }

        template <typename T> constexpr const T& Maximum(const T& leftValue, const T& rightValue) noexcept
        {
            return (leftValue < rightValue) ? rightValue : leftValue;
        }

        template <typename T> constexpr const T& Minimum(const T& leftValue, const T& rightValue) noexcept
        {
            return (leftValue < rightValue) ? leftValue : rightValue;
        }

        template <typename T> constexpr const T& Clamp(const T& value, const T& minimumValue, const T& maximumValue) noexcept
        {
            return (value < minimumValue) ? minimumValue : (maximumValue < value) ? maximumValue : value;
        }

    }; /* namespace Math */
}; /* namespace TurtleBrains */

namespace tbMath = TurtleBrains::Math;

#endif /* TurtleBrains_Math_hpp */