NRE_Unit.hpp

Go to the documentation of this file.

     #pragma once

     #include <iostream>
     #include <ratio>

     #include <Utility/String/NRE_String.hpp>
     #include <Utility/Interfaces/Stringable/NRE_Stringable.hpp>

     #include "NRE_Math.hpp"

    namespace NRE {
        namespace Math {

            template <class M, class L, class T, class A>
            class Unit : public Utility::Stringable<Unit<M, L, T, A>> {
                private:    //Fields
                    double value;    
                public:    // Methods
                    //## Constructor ##//
                        constexpr Unit() : value(0.0) {
                        }
                        constexpr Unit(double val) : value(val) {
                        }
                        constexpr Unit(long double val) : value(static_cast <double> (val)) {
                        }

                    //## Getter ##//
                        constexpr double getValue() const {
                            return value;
                        }

                    //## Methods ##//
                        constexpr Unit<std::ratio_divide<M, std::ratio<2>>, std::ratio_divide<L, std::ratio<2>>, std::ratio_divide<T, std::ratio<2>>, std::ratio_divide<A, std::ratio<2>>>
                        sqrt() {
                            return Unit<std::ratio_divide<M, std::ratio<2>>, std::ratio_divide<L, std::ratio<2>>, std::ratio_divide<T, std::ratio<2>>, std::ratio_divide<A, std::ratio<2>>>(value);
                        }

                    //## Shortcut Operator ##//
                        constexpr Unit const& operator+=(Unit const& u) {
                            value += u.value;
                            return *this;
                        }
                        constexpr Unit const& operator-=(Unit const& u) {
                            value -= u.value;
                            return *this;
                        }
                        constexpr Unit operator-() const {
                            return Unit(-value);
                        }

                    //## Arithmetic Operator ##//
                        constexpr Unit operator+(Unit const& u) const {
                            return Unit(*this) += u;
                        }
                        constexpr Unit operator-(Unit const& u) const {
                            return Unit(*this) -= u;
                        }

                    //## Comparison Operator ##//
                        constexpr bool operator==(Unit const& u) const {
                            return Math::almostEqual(value, u.value);
                        }
                        constexpr bool operator!=(Unit const& u) const {
                            return !(*this == u);
                        }
                        constexpr bool operator<=(Unit const& u) const {
                            return value <= u.value;
                        }
                        constexpr bool operator>=(Unit const& u) const {
                            return value >= u.value;
                        }
                        constexpr bool operator<(Unit const& u) const {
                            return value < u.value;
                        }
                        constexpr bool operator>(Unit const& u) const {
                            return value > u.value;
                        }
                        Utility::String toString() const {
                            Utility::String res;
                            res << value;
                            return res;
                        }
            };

            template <class M, class L, class T, class A>
            std::ostream& operator <<(std::ostream& stream, Unit<M, L, T, A> const& o) {
                return stream << o.toString();
            }

            template <class M,  class L,  class T,  class A,
                      class M2, class L2, class T2, class A2>
            constexpr Unit<std::ratio_subtract<M, M2>, std::ratio_subtract<L, L2>, std::ratio_subtract<T, T2>, std::ratio_subtract<A, A2>> operator/(Unit<M, L, T, A> const& u1, Unit<M2, L2, T2, A2> const& u2) {
                return Unit<std::ratio_subtract<M, M2>, std::ratio_subtract<L, L2>, std::ratio_subtract<T, T2>, std::ratio_subtract<A, A2>>(u1.getValue() / u2.getValue());
            }

            template <class M, class L, class T, class A>
            constexpr Unit<std::ratio_subtract<std::ratio<0>, M>, std::ratio_subtract<std::ratio<0>, L>, std::ratio_subtract<std::ratio<0>, T>, std::ratio_subtract<std::ratio<0>, A>> operator/(long double x, Unit<M, L, T, A> const& u) {
                return Unit<std::ratio_subtract<std::ratio<0>, M>, std::ratio_subtract<std::ratio<0>, L>, std::ratio_subtract<std::ratio<0>, T>, std::ratio_subtract<std::ratio<0>, A>>(x / u.getValue());
            }

            template <class M, class L, class T, class A>
            constexpr Unit<M, L, T, A> operator/(Unit<M, L, T, A> const& u, long double x) {
                return Unit<M, L, T, A>(u.getValue() / x);
            }

            template <class M,  class L,  class T,  class A,
                      class M2, class L2, class T2, class A2>
            constexpr Unit<std::ratio_add<M, M2>, std::ratio_add<L, L2>, std::ratio_add<T, T2>, std::ratio_add<A, A2>> operator*(Unit<M, L, T, A> const& u1, Unit<M2, L2, T2, A2> const& u2) {
                return Unit<std::ratio_add<M, M2>, std::ratio_add<L, L2>, std::ratio_add<T, T2>, std::ratio_add<A, A2>>(u1.getValue() * u2.getValue());
            }

            template <class M, class L, class T, class A>
            constexpr Unit<M, L, T, A> operator*(long double x, Unit<M, L, T, A> const& u) {
                return Unit<M, L, T, A>(x * u.getValue());
            }

            template <class M, class L, class T, class A>
            constexpr Unit<M, L, T, A> operator*(Unit<M, L, T, A> const& u, long double x) {
                return Unit<M, L, T, A>(u.getValue() * x);
            }

            #define TYPEDEF_UNIT(M, L, T, A, name) typedef Unit<std::ratio<M>, std::ratio<L>, std::ratio<T>, std::ratio<A>> name

            TYPEDEF_UNIT(1,  0,  0, 0, UMass);
            TYPEDEF_UNIT(0,  1,  0, 0, ULength);
            TYPEDEF_UNIT(0,  2,  0, 0, UArea);
            TYPEDEF_UNIT(0,  3,  0, 0, UVolume);
            TYPEDEF_UNIT(0,  0,  1, 0, UTime);
            TYPEDEF_UNIT(0,  1, -1, 0, USpeed);
            TYPEDEF_UNIT(0,  1, -2, 0, UAcceleration);
            TYPEDEF_UNIT(0,  0, -1, 0, UFrequency);
            TYPEDEF_UNIT(1,  1, -2, 0, UForce);
            TYPEDEF_UNIT(1, -1, -2, 0, UPressure);
            TYPEDEF_UNIT(0,  0,  0, 1, Angle);

            constexpr UMass kilogramme(1.0);                                    
            constexpr UMass gramme   = 0.001 * kilogramme;                      
            constexpr UMass tonne    = 1000 * kilogramme;                       
            constexpr ULength metre(1.0);                                       
            constexpr ULength decimetre  = metre / 10;                          
            constexpr ULength centimetre = metre / 100;                         
            constexpr ULength millimetre = metre / 1000;                        
            constexpr ULength kilometre  = 1000 * metre;                        
            constexpr UArea metre2      = metre * metre;                        
            constexpr UArea decimetre2  = decimetre * decimetre;                
            constexpr UArea centimetre2 = centimetre * centimetre;              
            constexpr UArea millimetre2 = millimetre * millimetre;              
            constexpr UArea kilometre2  = kilometre * kilometre;                
            constexpr UVolume metre3      = metre2 * metre;                     
            constexpr UVolume decimetre3  = decimetre2 * decimetre;             
            constexpr UVolume centimetre3 = centimetre2 * centimetre;           
            constexpr UVolume millimetre3 = millimetre2 * millimetre;           
            constexpr UVolume kilometre3  = kilometre2 * kilometre;             
            constexpr UVolume litre       = decimetre3;                         
            constexpr UTime second(1.0);                                        
            constexpr UTime minute   = 60 * second;                             
            constexpr UTime hour     = 60 * minute;                             
            constexpr UTime day      = 24 * hour;                               
            constexpr UFrequency Hz(1.0);                                       
            constexpr UAcceleration G = 9.80665 * metre / (second * second);    
            constexpr UForce newton(1.0);                                       
            constexpr UPressure pascal(1.0);                                    
            constexpr ULength operator"" _mm(long double x) { return static_cast <double> (x) * millimetre; }
            constexpr ULength operator"" _cm(long double x) { return static_cast <double> (x) * centimetre; }
            constexpr ULength operator""  _m(long double x) { return static_cast <double> (x) * metre; }
            constexpr ULength operator"" _km(long double x) { return static_cast <double> (x) * kilometre; }
            constexpr ULength operator"" _mm(unsigned long long int x) { return static_cast <double> (x) * millimetre; }
            constexpr ULength operator"" _cm(unsigned long long int x) { return static_cast <double> (x) * centimetre; }
            constexpr ULength operator""  _m(unsigned long long int x) { return static_cast <double> (x) * metre; }
            constexpr ULength operator"" _km(unsigned long long int x) { return static_cast <double> (x) * kilometre; }
            constexpr USpeed operator"" _kmph(long double x) { return static_cast <double> (x) * kilometre / hour; }
            constexpr USpeed operator"" _kmph(unsigned long long int x) { return static_cast <double> (x) * kilometre / hour; }
            constexpr UFrequency operator"" _Hz(long double x) { return UFrequency(x); }
            constexpr UFrequency operator"" _Hz(unsigned long long int x) { return UFrequency(static_cast <double> (x)); }
            constexpr UTime operator""   _s(long double x) { return UTime(x); }
            constexpr UTime operator"" _min(long double x) { return static_cast <double> (x) * minute; }
            constexpr UTime operator""   _h(long double x) { return static_cast <double> (x) * hour; }
            constexpr UTime operator"" _day(long double x) { return static_cast <double> (x) * day; }
            constexpr UTime operator""   _s(unsigned long long int x) { return UTime(static_cast <double> (x)); }
            constexpr UTime operator"" _min(unsigned long long int x) { return static_cast <double> (x) * minute; }
            constexpr UTime operator""   _h(unsigned long long int x) { return static_cast <double> (x) * hour; }
            constexpr UTime operator"" _day(unsigned long long int x) { return static_cast <double> (x) * day; }
            constexpr UMass operator"" _kg(long double x) { return UMass(x); }
            constexpr UMass operator""  _g(long double x) { return static_cast <double> (x) * gramme; }
            constexpr UMass operator""  _t(long double x) { return static_cast <double> (x) * tonne; }
            constexpr UMass operator"" _kg(unsigned long long int x) { return UMass(static_cast <double> (x)); }
            constexpr UMass operator""  _g(unsigned long long int x) { return static_cast <double> (x) * gramme; }
            constexpr UMass operator""  _t(unsigned long long int x) { return static_cast <double> (x) * tonne; }
            constexpr UAcceleration operator"" _mps2(long double x) { return UAcceleration(x); }
            constexpr UAcceleration operator"" _mps2(unsigned long long int x) { return UAcceleration(static_cast <double> (x)); }
            constexpr UAcceleration operator"" _G(long double x) { return static_cast <double> (x) * G; }
            constexpr UAcceleration operator"" _G(unsigned long long int x) { return static_cast <double> (x) * G; }
            constexpr UForce operator"" _N(long double x) { return UForce(x); }
            constexpr UForce operator"" _N(unsigned long long int x) { return UForce(static_cast <double> (x)); }
            constexpr UPressure operator"" _Pa(long double x) { return UPressure(x); }
            constexpr UPressure operator"" _Pa(unsigned long long int x) { return UPressure(static_cast <double> (x)); }
            constexpr long double operator"" _pi(long double x) { return static_cast <double> (x) * PI; }
            constexpr long double operator"" _pi(unsigned long long int x) { return static_cast <double> (x) * PI; }

            constexpr Angle radian(1.0);                                        
            constexpr Angle degree = (PI / 180.0f) * radian;                      
            constexpr Angle operator"" _rad(long double x) { return Angle(x); }
            constexpr Angle operator"" _rad(unsigned long long int x) { return Angle(static_cast <double> (x)); }
            constexpr Angle operator"" _deg(long double x) { return static_cast <double> (x) * degree; }
            constexpr Angle operator"" _deg(unsigned long long int x) { return static_cast <double> (x) * degree; }

            inline double sin(Angle const& u) {
                return std::sin(u.getValue());
            }
            inline double cos(Angle const& u) {
                return std::cos(u.getValue());
            }
            inline double tan(Angle const& u) {
                return std::tan(u.getValue());
            }
            inline double asin(Angle const& u) {
                return std::asin(u.getValue());
            }
            inline double acos(Angle const& u) {
                return std::acos(u.getValue());
            }
            inline double atan(Angle const& u) {
                return std::atan(u.getValue());
            }
            
            inline double toRad(Angle const& u) {
                return u.getValue();
            }
        
            inline double toDeg(Angle const& u) {
                return (u / degree).getValue();
            }
        }
    }