tb_constants.hpp

#ifndef TurtleBrains_Constants_hpp
#define TurtleBrains_Constants_hpp

namespace TurtleBrains
{
    namespace Math
    {
        template<typename Type> constexpr Type Pi(void) { return static_cast<Type>(3.141592653589793); }
        template<typename Type> constexpr Type TwoPi(void) { return static_cast<Type>(Pi<long double>() * 2.0); }

        static const float kPi = Pi<float>();       
        static const float kTwoPi = TwoPi<float>(); 

        static const float kTolerance(0.00001f);

        //Conversions
        const float kPoundsToKilograms(0.45359237f); 
        const float kKilogramsToPounds(1.0f / kPoundsToKilograms); 
        const float kInchesToMeters(0.0254f); 
        const float kMetersToInches(1.0f / kInchesToMeters); 
        const float kFeetToMeters(0.3048f); 
        const float kMetersToFeet(1.0f / kFeetToMeters); 
        const float kMilesToKilometers(1.609344f); 
        const float kKilometersToMiles(1.0f / kMilesToKilometers); 
        const float kFootPoundsToNewtonMeters(0.73756214837f); 
        const float kNewtonMetersToFootPounds(1.0f / kFootPoundsToNewtonMeters); 

        namespace Convert
        {   //Conversion Functions...  Most of these values were found from Google.
            //Rotations

            template<typename Type> constexpr Type DegreesToRadians(const Type& degrees) { return degrees * Pi<Type>() / Type(180.0); }

            template<typename Type> constexpr Type RadiansToDegrees(const Type& radians) { return radians * Type(180.0) / Pi<Type>(); }

            //Weights/Mass

            template<typename Type> constexpr Type PoundsToKilograms(const Type& pounds) { return static_cast<Type>(pounds * kPoundsToKilograms); }

            template<typename Type> constexpr Type KilogramsToPounds(const Type& kilograms) { return static_cast<Type>(kilograms * kKilogramsToPounds); }

            //Distances

            template<typename Type> constexpr Type InchesToMeters(const Type& inches) { return static_cast<Type>(inches * kInchesToMeters); }

            template<typename Type> constexpr Type FeetToMeters(const Type& feet) { return static_cast<Type>(feet * kFeetToMeters); };

            template<typename Type> constexpr Type MetersToFeet(const Type& meters) { return static_cast<Type>(meters * kMetersToFeet); };

            template<typename Type> constexpr Type MilesToKilometers(const Type& mile) { return static_cast<Type>(mile * kMilesToKilometers); }

            template<typename Type> constexpr Type KilometersToMiles(const Type& kilometers) { return static_cast<Type>(kilometers * kKilometersToMiles); }

            template<typename Type> constexpr Type KilometersToMeters(const Type& kmh) { return static_cast<Type>(kmh * 1000.0f); }

            //Speeds

            template<typename Type> constexpr Type MileHourToMeterSecond(const Type& mph) { return static_cast<Type>(mph / 2.2369362920544f); }

            template<typename Type> constexpr Type MeterSecondToMileHour(const Type& meterSec) { return static_cast<Type>(meterSec * 2.2369362920544f); }

            template<typename Type> constexpr Type KilometerHourToMeterSecond(const Type& kmh) { return static_cast<Type>(kmh / 3.6f); }

            template<typename Type> constexpr Type MeterSecondToKilometerHour(const Type& meterSecond) { return static_cast<Type>(meterSecond * 3.6f); }

            //Torque

            template<typename Type> constexpr Type FootPoundsToNewtonMeters(const Type& footPounds) { return static_cast<Type>(footPounds / kFootPoundsToNewtonMeters); }

            template<typename Type> constexpr Type NewtonMetersToFootPounds(const Type& newtonMeters) { return static_cast<Type>(newtonMeters / kNewtonMetersToFootPounds); }

            //Temperature

            template<typename Type> constexpr Type FahrenheitToCelsius(const Type& fahrenheit) { return static_cast<Type>((fahrenheit - 32.0f) / 1.8000f); }

            template<typename Type> constexpr Type CelsiusToFahrenheit(const Type& celsius) { return static_cast<Type>((celsius * 1.8000f) + 32.0f); }

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

namespace tbMath = TurtleBrains::Math;

#endif /* TurtleBrains_Constants_hpp */