Equality.hpp

#pragma once
#ifndef __H__OCULAR_ENGINE_MATH_EQUALITY__H__
#define __H__OCULAR_ENGINE_MATH_EQUALITY__H__

#include "MathCommon.hpp"
#include <cmath>

//------------------------------------------------------------------------------------------

namespace Ocular
{
    namespace Math
    {
        // We have overridden versions for double and float but maintain the use of templates for 
        // them (despite them not needing templates) to keep convention consistant between all types.

        // TODO: There is a different way of accomplishing this but I do not remember.

        template<typename T>
        static bool IsEqual(double const a, double const b, double epsilon = EPSILON_DOUBLE)
        {
            //return std::fabs(a - b) <= (((std::fabs(a) > std::fabs(b)) ? std::fabs(b) : std::fabs(a)) * epsilon);
            return std::abs(a - b) < epsilon;
        }
        
        template<typename T>
        static bool IsEqual(float const a, float const b, float epsilon = EPSILON_FLOAT)
        {
            //return std::fabs(a - b) <= (((std::fabs(a) > std::fabs(b)) ? std::fabs(b) : std::fabs(a)) * epsilon);
            return std::abs(a - b) < epsilon;
        }
        
        template<typename T>
        static bool IsEqual(T const a, T const b)
        {
            return (a == b);
        }

        template<typename T>
        static bool IsZero(T const a)
        {
            return IsEqual<T>(a, static_cast<T>(0));
        }

        template<typename T>
        static bool IsOne(T const a)
        {
            return IsEqual<T>(a, static_cast<T>(1));
        }
    }
}
//------------------------------------------------------------------------------------------

#endif