Angle.hpp

[詳解]

#pragma once
 
#include "KisaragiMath.hpp"
#include "../RangeNum.hpp"
#include "../utility.hpp"
 
namespace Kisaragi_Lib
{
    template <typename Num>
    class Radian;
 
    template <typename Num>
    class Degree;
 
    /// <summary>
    /// 精度レベル（度数法）
    /// </summary>
    /// <typeparam name="Num">使用する小数点型</typeparam>
    template<typename Num,
        std::enable_if_t<std::is_floating_point<Num>::value,int> = 0>
    class ANGLE_DEGREE_EPSILON
    {
    public:
        inline constexpr static Num E_LOOSE      = 1e-3;
        inline constexpr static Num E_NORMAL        = 1e-6;
        inline constexpr static Num E_STRICT        = 1e-9;
        inline constexpr static Num E_VERYSTRICT    = 1e-12;
    };
 
    /// <summary>
    /// 精度レベル（ラジアン）
    /// </summary>
    /// <typeparam name="Num">使用する小数点型</typeparam>
    template<typename Num,
        std::enable_if_t<std::is_floating_point<Num>::value, int> = 0>
    class ANGLE_RADIAN_EPSILON
    {
    public:
        inline constexpr static Num E_LOOSE      = 1e-3  * PI / DEGREES_HALF;
        inline constexpr static Num E_NORMAL        = 1e-6  * PI / DEGREES_HALF;
        inline constexpr static Num E_STRICT        = 1e-9  * PI / DEGREES_HALF;
        inline constexpr static Num E_VERYSTRICT    = 1e-12 * PI / DEGREES_HALF;
    };
 
 
 
    /// <summary>
    /// 度数法の値型
    /// </summary>
    /// <typeparam name="Num">角度の値型</typeparam>
    template<typename Num>
    class Degree
    {
        static_assert(std::is_floating_point<Num>::value, "Degreeに小数点型で無い型が渡されました");
 
    private:
        RangeNum<Num, LoopOutOfRange> angle{ 0, 360 };
 
 
    public:
 
        /// <summary>
        /// 比較の際に許す誤差の範囲
        /// </summary>
        RangeNum<Num, LoopOutOfRange> epsilon{ 0, 360 };
 
        Degree()
        {
            epsilon = ANGLE_DEGREE_EPSILON<Num>::E_LOOSE;
        }
 
        Degree(Num _num)
        {
            angle = _num;
            epsilon = ANGLE_DEGREE_EPSILON<Num>::E_LOOSE;
        }
 
        /********************************************************
        *
        *  operator
        *
        ********************************************************/
 
        template<typename T>
        Degree<Num>& operator +=(T _add)
        {
            angle += _add;
 
            return *this;
        }
 
        Radian<Num> ToRadian() const;
 
        operator Num () const
        {
            return angle;
        }
 
        /********************************************************
        *
        *  比較演算子
        *
        ********************************************************/
 
 
        bool operator==(const Degree<Num>& _degree) const
        {
            return this->EpsilonIf(_degree,epsilon);
        }
 
        bool operator==(const Radian<Num>& _radian) const 
        {
            return this->EpsilonIf(_radian, epsilon);
        }
 
        bool operator==(const Num& _angle) const
        {
            return this->EpsilonIf(_angle, epsilon);
        }
 
 
        /// <summary>
        /// 差が許容範囲内か調べる
        /// </summary>
        /// <param name="_degree">度数法の角度</param>
        /// <param name="_epsilon">許容範囲</param>
        /// <returns>許容範囲か否か</returns>
        bool EpsilonIf(const Degree<Num>& _degree, const Num& _epsilon) const
        {
            return Kisaragi_Lib::EpsilonIf((Num)angle, (Num)_degree.angle, (Num)_epsilon);
        }
 
        /// <summary>
        /// 差が許容範囲内か調べる
        /// </summary>
        /// <param name="_degree">弧度法の角度</param>
        /// <param name="_epsilon">許容範囲</param>
        /// <returns>許容範囲か否か</returns>
        bool EpsilonIf(const Radian<Num>& _radian, const Num& _epsilon) const
        {
            return Kisaragi_Lib::EpsilonIf((Num)angle, (Num)_radian.ToDegree(), (Num)_epsilon);
        }
 
        /// <summary>
        /// 差が許容範囲内か調べる
        /// </summary>
        /// <param name="_degree">度数法の角度</param>
        /// <param name="_epsilon">許容範囲</param>
        /// <returns>許容範囲か否か</returns>
        bool EpsilonIf(const Num& _angle, const Num& _epsilon) const
        {
            return Kisaragi_Lib::EpsilonIf((Num)angle, (Num)_angle, (Num)_epsilon);
        }
        
 
    };
 
    /// <summary>
    /// 弧度法
    /// </summary>
    /// <typeparam name="Num"></typeparam>
    template<typename Num>
    class Radian
    {
        static_assert(std::is_floating_point<Num>::value, "Degreeに小数点型で無い型が渡されました");
 
    private:
        RangeNum<Num, LoopOutOfRange> angle{ 0, (Num)TWO_PI };
 
    public:
 
        /// <summary>
        /// 比較の際に許す誤差の範囲
        /// </summary>
        RangeNum<Num, LoopOutOfRange> epsilon{ 0, TWO_PI };
 
        Radian()
        {
            epsilon = ANGLE_RADIAN_EPSILON<Num>::E_LOOSE;
        }
 
        /// <summary>
        /// コンストラクタ
        /// </summary>
        /// <param name="_num">ラジアン値</param>
        Radian(Num _num)
        {
            angle = _num;
            epsilon = ANGLE_RADIAN_EPSILON<Num>::E_LOOSE;
        }
 
        /// <summary>
        /// 0～360度の度数法に変換したものを返します
        /// </summary>
        /// <returns>度数法に変換した値</returns>
        Degree<Num> ToDegree() const;
 
        template<typename T>
        Radian<Num>& operator +=(T _add)
        {
            angle += _add;
 
            return *this;
        }
 
        operator Num () const
        {
            return angle;
        }
 
        /********************************************************
        *
        *  比較演算子
        *
        ********************************************************/
 
        bool operator==(const Degree<Num>& _degree) const
        {
            return EpsilonIf(_degree, epsilon);
        }
 
        bool operator==(const Radian<Num>& _radian) const
        {
            return EpsilonIf(_radian, epsilon);
        }
 
        bool operator==(const Num& _angle) const
        {
            return EpsilonIf(_angle, epsilon);
        }
 
        /// <summary>
        /// 差が許容範囲内か調べる
        /// </summary>
        /// <param name="_degree">度数法の角度</param>
        /// <param name="_epsilon">許容範囲</param>
        /// <returns>許容範囲か否か</returns>
        bool EpsilonIf(const Degree<Num>& _degree, const Num& _epsilon) const
        {
            return Kisaragi_Lib::EpsilonIf((Num)angle, (Num)_degree.ToRadian(), (Num)_epsilon);
        }
 
        /// <summary>
        /// 差が許容範囲内か調べる
        /// </summary>
        /// <param name="_degree">弧度法の角度</param>
        /// <param name="_epsilon">許容範囲</param>
        /// <returns>許容範囲か否か</returns>
        bool EpsilonIf(const Radian<Num>& _radian, const Num& _epsilon) const
        {
            return Kisaragi_Lib::EpsilonIf((Num)angle, (Num)_radian.angle, (Num)_epsilon);
        }
 
        /// <summary>
        /// 差が許容範囲内か調べる
        /// </summary>
        /// <param name="_degree">弧度法の角度</param>
        /// <param name="_epsilon">許容範囲</param>
        /// <returns>許容範囲か否か</returns>
        bool EpsilonIf(const Num& _angle, const Num& _epsilon) const
        {
            return Kisaragi_Lib::EpsilonIf((Num)angle, (Num)_angle, (Num)_epsilon);
        }
    };
 
 
 
 
 
    template<typename Num>
    Radian<Num> Degree<Num>::ToRadian()const
    {
        return Radian<Num>{ (Num)angle * (Num)PI / (Num)DEGREES_HALF };
    }
 
    template<typename Num>
    Degree<Num> Radian<Num>::ToDegree()const
    {
        return Degree<Num>{ (Num)angle * (Num)DEGREES_HALF / (Num)PI };
    }
}