tb_angle.hpp

 
#ifndef TurtleBrains_Angle_hpp
#define TurtleBrains_Angle_hpp
 
#include <turtle_brains/core/tb_error.hpp>
#include <turtle_brains/math/tb_constants.hpp>
#include <turtle_brains/math/tb_math.hpp>
 
#include <iostream>
 
namespace TurtleBrains
{
    namespace Math
    {
 
        enum class AngleUnit
        {
            Degrees, 
            Radians  
        };
 
        template<typename Type> class TypedAngle
        {
        public:
            inline static TypedAngle Degrees(const Type angleInDegrees)
            {
                return TypedAngle(angleInDegrees, AngleUnit::Degrees);
            }
 
            inline static TypedAngle Radians(const Type angleInRadians)
            {
                return TypedAngle(angleInRadians, AngleUnit::Radians);
            }
 
            inline static TypedAngle Zero(void)
            {
                return TypedAngle(Type(0.0), AngleUnit::Degrees);
            }
 
 
            inline TypedAngle(void) :
                mAngle(0)
            {
            }
 
 
            inline explicit TypedAngle(const Type& angle, const AngleUnit units) :
                mAngle((AngleUnit::Radians == units) ? angle : tbMath::Convert::DegreesToRadians(angle))
            {
            }
 
            inline Type AsRadians(void) const { return mAngle; }
 
            inline Type AsDegrees(void) const { return tbMath::Convert::RadiansToDegrees(mAngle); }
 
            inline Type As(const AngleUnit& angleUnits) const
            {
                switch (angleUnits)
                {
                case AngleUnit::Degrees: return AsDegrees();
                case AngleUnit::Radians: return AsRadians();
                };
 
                // 2024-09-22: Mostly to stop the compiler warnings.
                tb_error("Expected not to reach this point...");
                return Type(0.0);
            }
 
 
            //This is untested, written 2022-08-28
            inline void Normalize(void)
            {
                mAngle = std::fmod(mAngle, tbMath::Pi<Type>());
            }
 
            bool operator==(const TypedAngle& other) const
            {
                return tbMath::IsEqual(mAngle, other.mAngle);
            }
 
            bool operator!=(const TypedAngle& other) const
            {
                return !tbMath::IsEqual(mAngle, other.mAngle);
            }
 
            bool operator<(const TypedAngle& other) const
            {
                return mAngle < other.mAngle;
            }
 
            bool operator<=(const TypedAngle& other) const
            {
                return mAngle <= other.mAngle;
            }
 
            bool operator>(const TypedAngle& other) const
            {
                return mAngle > other.mAngle;
            }
 
            bool operator>=(const TypedAngle& other) const
            {
                return mAngle >= other.mAngle;
            }
 
            template<typename ToType> explicit operator TypedAngle<ToType>(void) const
            {
                return TypedAngle<ToType>(static_cast<ToType>(mAngle), AngleUnit::Radians);
            }
 
            TypedAngle operator-() const { return Radians(-mAngle); }
 
 
            TypedAngle operator+(const TypedAngle& other) const { return Radians(mAngle + other.mAngle); }
            TypedAngle& operator+=(const TypedAngle& other) { mAngle += other.mAngle; return *this; }
            TypedAngle operator-(const TypedAngle& other) const { return Radians(mAngle - other.mAngle); }
            TypedAngle& operator-=(const TypedAngle& other) { mAngle -= other.mAngle; return *this; }
 
            TypedAngle operator*(const TypedAngle& other) const { return Radians(mAngle * other.mAngle); }
            TypedAngle operator*(const Type& scalar) const { return Radians(mAngle * scalar); }
            friend TypedAngle operator*(const Type& scalar, const TypedAngle& rhs) { return Radians(scalar * rhs.mAngle); }
            TypedAngle& operator*=(const Type& scalar) { mAngle *= scalar; return *this; }
 
            TypedAngle operator/(const TypedAngle& other) const { return Radians(mAngle / other.mAngle); }
            TypedAngle operator/(const Type& scalar) const { return Radians(mAngle / scalar); }
            //Left out the scalar / Angle because it doesn't seem like a useful construct.  5 / 4radians ... ???
            TypedAngle& operator/=(const Type& scalar) { mAngle /= scalar; return *this; }
 
        private:
            Type mAngle; //Stored as radians.
        };
 
        typedef TypedAngle<float> Angle;
 
        template<typename Type> std::ostream& operator<<(std::ostream& output, const tbMath::TypedAngle<Type>& angle)
        {
            output << angle.AsDegrees() << " degrees";
            return output;
        }
 
    }; /* namespace Math */
}; /* namespace TurtleBrains */
 
namespace tbMath = TurtleBrains::Math;
 
//
// @note Visual Studio 2015 (at least) requires the literal operator to be either a 'long double' or 'const char*', this defeats the ability
//   to use the templated versions above, and thus may lose some precision - but at least we get it working for floats?
//
//template<typename Type> tbMath::TypedAngle<Type> operator "" _radians (Type value) { return tbMath::TypedAngle<Type>(value, tbMath::AngleUnit::Radians); }
//template<typename Type> tbMath::TypedAngle<Type> operator "" _degrees (Type value) { return tbMath::TypedAngle<Type>(value, tbMath::AngleUnit::Degrees); }
//
 
inline tbMath::Angle operator ""_radians(long double value) { return tbMath::Angle::Radians(static_cast<float>(value)); }
 
inline tbMath::Angle operator ""_degrees(long double value) { return tbMath::Angle::Degrees(static_cast<float>(value)); }
 
#endif /* TurtleBrains_Angle_hpp */