Units.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2017 Louis Langholtz https://github.com/louis-langholtz/PlayRho
 *
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */
 
#ifndef PLAYRHO_COMMON_UNITS_HPP
#define PLAYRHO_COMMON_UNITS_HPP
 
#include <PlayRho/Common/RealConstants.hpp>
#include <PlayRho/Common/Templates.hpp>
#include <type_traits>
#include <cmath>
 
// #define USE_BOOST_UNITS
#if defined(USE_BOOST_UNITS)
#include <boost/units/io.hpp>
#include <boost/units/limits.hpp>
#include <boost/units/cmath.hpp>
#include <boost/units/systems/si/length.hpp>
#include <boost/units/systems/si/time.hpp>
#include <boost/units/systems/si/velocity.hpp>
#include <boost/units/systems/si/acceleration.hpp>
#include <boost/units/systems/si/frequency.hpp>
#include <boost/units/systems/si/velocity.hpp>
#include <boost/units/systems/si/mass.hpp>
#include <boost/units/systems/si/momentum.hpp>
#include <boost/units/systems/si/inverse_mass.hpp>
#include <boost/units/systems/si/area.hpp>
#include <boost/units/systems/si/plane_angle.hpp>
#include <boost/units/systems/si/angular_momentum.hpp>
#include <boost/units/systems/si/angular_velocity.hpp>
#include <boost/units/systems/si/angular_acceleration.hpp>
#include <boost/units/systems/si/second_moment_of_area.hpp>
#include <boost/units/systems/si/surface_density.hpp>
#include <boost/units/systems/si/moment_of_inertia.hpp>
#include <boost/units/systems/si/inverse_moment_of_inertia.hpp>
#include <boost/units/systems/si/force.hpp>
#include <boost/units/systems/si/torque.hpp>
#include <boost/units/systems/angle/degrees.hpp>
#endif // defined(USE_BOOST_UNITS)
 
// Define quantity and unit related macros to abstract away C-preprocessor definitions
#if defined(USE_BOOST_UNITS)
#define PLAYRHO_QUANTITY(BoostDimension) boost::units::quantity<BoostDimension, Real>
#define PLAYRHO_UNIT(Quantity, BoostUnit) Quantity{BoostUnit * Real{1}}
#define PLAYRHO_DERIVED_UNIT(Quantity, BoostUnit, Ratio) Quantity{BoostUnit * Real{Ratio}}
#else // defined(USE_BOOST_UNITS)
#define PLAYRHO_QUANTITY(BoostDimension) Real
#define PLAYRHO_UNIT(Quantity, BoostUnit) Real{1}
#define PLAYRHO_DERIVED_UNIT(Quantity, BoostUnit, Ratio) Real{Ratio}}
#endif // defined(USE_BOOST_UNITS)
 
namespace playrho
{
    
    using Time = PLAYRHO_QUANTITY(boost::units::si::time);
    
    using Frequency = PLAYRHO_QUANTITY(boost::units::si::frequency);
    
    using Length = PLAYRHO_QUANTITY(boost::units::si::length);
    
    using LinearVelocity = PLAYRHO_QUANTITY(boost::units::si::velocity);
    
    using LinearAcceleration = PLAYRHO_QUANTITY(boost::units::si::acceleration);
    
    using Mass = PLAYRHO_QUANTITY(boost::units::si::mass);
    
    using InvMass = PLAYRHO_QUANTITY(boost::units::si::inverse_mass);
    
    using Area = PLAYRHO_QUANTITY(boost::units::si::area);
    
    using AreaDensity = PLAYRHO_QUANTITY(boost::units::si::surface_density);
    
    using Angle = PLAYRHO_QUANTITY(boost::units::si::plane_angle);
    
    using AngularVelocity = PLAYRHO_QUANTITY(boost::units::si::angular_velocity);
    
    using AngularAcceleration = PLAYRHO_QUANTITY(boost::units::si::angular_acceleration);
 
    using Force = PLAYRHO_QUANTITY(boost::units::si::force);
    
    using Torque = PLAYRHO_QUANTITY(boost::units::si::torque);
    
    using SecondMomentOfArea = PLAYRHO_QUANTITY(boost::units::si::second_moment_of_area);
    
    using RotInertia = PLAYRHO_QUANTITY(boost::units::si::moment_of_inertia);
    
    using InvRotInertia = PLAYRHO_QUANTITY(boost::units::si::inverse_moment_of_inertia);
    
    using Momentum = PLAYRHO_QUANTITY(boost::units::si::momentum);
    
    using AngularMomentum = PLAYRHO_QUANTITY(boost::units::si::angular_momentum);
    
 
 
    PLAYRHO_CONSTEXPR const auto Second = PLAYRHO_UNIT(Time, boost::units::si::second);
 
    PLAYRHO_CONSTEXPR const auto SquareSecond = Second * Second;
 
    PLAYRHO_CONSTEXPR const auto Hertz = PLAYRHO_UNIT(Frequency, boost::units::si::hertz);
 
    PLAYRHO_CONSTEXPR const auto Meter = PLAYRHO_UNIT(Length, boost::units::si::meter);
 
    PLAYRHO_CONSTEXPR const auto MeterPerSecond = PLAYRHO_UNIT(LinearVelocity,
        boost::units::si::meter_per_second);
 
    PLAYRHO_CONSTEXPR const auto MeterPerSquareSecond = PLAYRHO_UNIT(LinearAcceleration,
        boost::units::si::meter_per_second_squared);
 
    PLAYRHO_CONSTEXPR const auto Kilogram = PLAYRHO_UNIT(Mass, boost::units::si::kilogram);
 
    PLAYRHO_CONSTEXPR const auto SquareMeter = PLAYRHO_UNIT(Area, boost::units::si::square_meter);
 
    PLAYRHO_CONSTEXPR const auto CubicMeter = Meter * Meter * Meter;
 
    PLAYRHO_CONSTEXPR const auto KilogramPerSquareMeter = PLAYRHO_UNIT(AreaDensity,
        boost::units::si::kilogram_per_square_meter);
 
    PLAYRHO_CONSTEXPR const auto Radian = PLAYRHO_UNIT(Angle, boost::units::si::radian);
    
    PLAYRHO_CONSTEXPR const auto Degree = Angle{Radian * Pi / Real{180}};
    
    PLAYRHO_CONSTEXPR const auto SquareRadian = Radian * Radian;
 
    PLAYRHO_CONSTEXPR const auto RadianPerSecond = PLAYRHO_UNIT(AngularVelocity,
        boost::units::si::radian_per_second);
    
    PLAYRHO_CONSTEXPR const auto DegreePerSecond = AngularVelocity{RadianPerSecond * Degree / Radian};
 
    PLAYRHO_CONSTEXPR const auto RadianPerSquareSecond = Radian / (Second * Second);
 
    PLAYRHO_CONSTEXPR const auto DegreePerSquareSecond = Degree / (Second * Second);
 
    PLAYRHO_CONSTEXPR const auto Newton = PLAYRHO_UNIT(Force, boost::units::si::newton);
 
    PLAYRHO_CONSTEXPR const auto NewtonMeter = PLAYRHO_UNIT(Torque, boost::units::si::newton_meter);
 
    PLAYRHO_CONSTEXPR const auto NewtonSecond = Newton * Second;
    
    PLAYRHO_CONSTEXPR const auto NewtonMeterSecond = NewtonMeter * Second;
    
    PLAYRHO_CONSTEXPR const auto RevolutionsPerMinute = 2 * Pi * Radian / (Real{60} * Second);
    
    
 
    PLAYRHO_CONSTEXPR inline Mass operator"" _g(unsigned long long int v) noexcept
    {
        return static_cast<Real>(v) * (Kilogram / Kilo);
    }
    
    PLAYRHO_CONSTEXPR inline Mass operator"" _g(long double v) noexcept
    {
        return static_cast<Real>(v) * (Kilogram / Kilo);
    }
 
    PLAYRHO_CONSTEXPR inline Mass operator"" _kg(unsigned long long int v) noexcept
    {
        return static_cast<Real>(v) * Kilogram;
    }
    
    PLAYRHO_CONSTEXPR inline Mass operator"" _kg(long double v) noexcept
    {
        return static_cast<Real>(v) * Kilogram;
    }
    
    PLAYRHO_CONSTEXPR inline Mass operator"" _Pg(unsigned long long int v) noexcept
    {
        return static_cast<Real>(v) * Peta * (Kilogram / Kilo);
    }
 
    PLAYRHO_CONSTEXPR inline Mass operator"" _Pg(long double v) noexcept
    {
        return static_cast<Real>(v) * Peta * (Kilogram / Kilo);
    }
 
    PLAYRHO_CONSTEXPR inline Mass operator"" _Yg(unsigned long long int v) noexcept
    {
        return static_cast<Real>(v) * Yotta * (Kilogram / Kilo);
    }
    
    PLAYRHO_CONSTEXPR inline Mass operator"" _Yg(long double v) noexcept
    {
        return static_cast<Real>(v) * Yotta * (Kilogram / Kilo);
    }
    
    PLAYRHO_CONSTEXPR inline Length operator"" _m(unsigned long long int v) noexcept
    {
        return static_cast<Real>(v) * Meter;
    }
    
    PLAYRHO_CONSTEXPR inline Length operator"" _m(long double v) noexcept
    {
        return static_cast<Real>(v) * Meter;
    }
    
    PLAYRHO_CONSTEXPR inline Length operator"" _dm(unsigned long long int v) noexcept
    {
        return static_cast<Real>(v) * Deci * Meter;
    }
    
    PLAYRHO_CONSTEXPR inline Length operator"" _dm(long double v) noexcept
    {
        return static_cast<Real>(v) * Deci * Meter;
    }
    
    PLAYRHO_CONSTEXPR inline Length operator"" _cm(unsigned long long int v) noexcept
    {
        return static_cast<Real>(v) * Centi * Meter;
    }
    
    PLAYRHO_CONSTEXPR inline Length operator"" _cm(long double v) noexcept
    {
        return static_cast<Real>(v) * Centi * Meter;
    }
    
    PLAYRHO_CONSTEXPR inline Length operator"" _Gm (unsigned long long int v) noexcept
    {
        return static_cast<Real>(v) * Giga * Meter;
    }
    
    PLAYRHO_CONSTEXPR inline Length operator"" _Gm (long double v) noexcept
    {
        return static_cast<Real>(v) * Giga * Meter;
    }
    
    PLAYRHO_CONSTEXPR inline Length operator"" _Mm (unsigned long long int v) noexcept
    {
        return static_cast<Real>(v) * Mega * Meter;
    }
 
    PLAYRHO_CONSTEXPR inline Length operator"" _Mm (long double v) noexcept
    {
        return static_cast<Real>(v) * Mega * Meter;
    }
 
    PLAYRHO_CONSTEXPR inline Length operator"" _km (unsigned long long int v) noexcept
    {
        return static_cast<Real>(v) * Kilo * Meter;
    }
    
    PLAYRHO_CONSTEXPR inline Length operator"" _km (long double v) noexcept
    {
        return static_cast<Real>(v) * Kilo * Meter;
    }
    
    PLAYRHO_CONSTEXPR inline Time operator"" _s(unsigned long long int v) noexcept
    {
        return static_cast<Real>(v) * Second;
    }
    
    PLAYRHO_CONSTEXPR inline Time operator"" _s(long double v) noexcept
    {
        return static_cast<Real>(v) * Second;
    }
    
    PLAYRHO_CONSTEXPR inline Time operator"" _min(unsigned long long int v) noexcept
    {
        return static_cast<Real>(v) * 60 * Second;
    }
    
    PLAYRHO_CONSTEXPR inline Time operator"" _min(long double v) noexcept
    {
        return static_cast<Real>(v) * 60 * Second;
    }
    
    PLAYRHO_CONSTEXPR inline Time operator"" _h(unsigned long long int v) noexcept
    {
        return static_cast<Real>(v) * 60 * 60 * Second;
    }
    
    PLAYRHO_CONSTEXPR inline Time operator"" _h(long double v) noexcept
    {
        return static_cast<Real>(v) * 60 * 60 * Second;
    }
    
    PLAYRHO_CONSTEXPR inline Time operator"" _d(unsigned long long int v) noexcept
    {
        return static_cast<Real>(v) * 60 * 60 * 24 * Second;
    }
    
    PLAYRHO_CONSTEXPR inline Time operator"" _d(long double v) noexcept
    {
        return static_cast<Real>(v) * 60 * 60 * 24 * Second;
    }
 
    PLAYRHO_CONSTEXPR inline Angle operator"" _rad(unsigned long long int v) noexcept
    {
        return static_cast<Real>(v) * Radian;
    }
 
    PLAYRHO_CONSTEXPR inline Angle operator"" _rad(long double v) noexcept
    {
        return static_cast<Real>(v) * Radian;
    }
 
    PLAYRHO_CONSTEXPR inline Angle operator"" _deg(unsigned long long int v) noexcept
    {
        return static_cast<Real>(v) * Degree;
    }
    
    PLAYRHO_CONSTEXPR inline Angle operator"" _deg(long double v) noexcept
    {
        return static_cast<Real>(v) * Degree;
    }
 
    PLAYRHO_CONSTEXPR inline Force operator"" _N(unsigned long long int v) noexcept
    {
        return static_cast<Real>(v) * Newton;
    }
    
    PLAYRHO_CONSTEXPR inline Force operator"" _N(long double v) noexcept
    {
        return static_cast<Real>(v) * Newton;
    }
    
    PLAYRHO_CONSTEXPR inline Area operator"" _m2(unsigned long long int v) noexcept
    {
        return static_cast<Real>(v) * SquareMeter;
    }
    
    PLAYRHO_CONSTEXPR inline Area operator"" _m2(long double v) noexcept
    {
        return static_cast<Real>(v) * SquareMeter;
    }
    
    PLAYRHO_CONSTEXPR inline LinearVelocity operator"" _mps(unsigned long long int v) noexcept
    {
        return static_cast<Real>(v) * MeterPerSecond;
    }
 
    PLAYRHO_CONSTEXPR inline LinearVelocity operator"" _mps(long double v) noexcept
    {
        return static_cast<Real>(v) * MeterPerSecond;
    }
    
    PLAYRHO_CONSTEXPR inline LinearVelocity operator"" _kps(unsigned long long int v) noexcept
    {
        return static_cast<Real>(v) * Kilo * MeterPerSecond;
    }
    
    PLAYRHO_CONSTEXPR inline LinearVelocity operator"" _kps(long double v) noexcept
    {
        return static_cast<Real>(v) * Kilo * MeterPerSecond;
    }
    
    PLAYRHO_CONSTEXPR inline LinearAcceleration operator"" _mps2(unsigned long long int v) noexcept
    {
        return static_cast<Real>(v) * MeterPerSquareSecond;
    }
    
    PLAYRHO_CONSTEXPR inline LinearAcceleration operator"" _mps2(long double v) noexcept
    {
        return static_cast<Real>(v) * MeterPerSquareSecond;
    }
    
    PLAYRHO_CONSTEXPR inline Frequency operator"" _Hz(unsigned long long int v) noexcept
    {
        return static_cast<Real>(v) * Hertz;
    }
    
    PLAYRHO_CONSTEXPR inline Frequency operator"" _Hz(long double v) noexcept
    {
        return static_cast<Real>(v) * Hertz;
    }
    
    PLAYRHO_CONSTEXPR inline Torque operator"" _Nm(unsigned long long int v) noexcept
    {
        return static_cast<Real>(v) * NewtonMeter;
    }
    
    PLAYRHO_CONSTEXPR inline Torque operator"" _Nm(long double v) noexcept
    {
        return static_cast<Real>(v) * NewtonMeter;
    }
    
    PLAYRHO_CONSTEXPR inline Momentum operator"" _Ns(unsigned long long int v) noexcept
    {
        return static_cast<Real>(v) * NewtonSecond;
    }
    
    PLAYRHO_CONSTEXPR inline Momentum operator"" _Ns(long double v) noexcept
    {
        return static_cast<Real>(v) * NewtonSecond;
    }
    
    PLAYRHO_CONSTEXPR inline AreaDensity operator"" _kgpm2(unsigned long long int v) noexcept
    {
        return static_cast<Real>(v) * KilogramPerSquareMeter;
    }
    
    PLAYRHO_CONSTEXPR inline AreaDensity operator"" _kgpm2(long double v) noexcept
    {
        return static_cast<Real>(v) * KilogramPerSquareMeter;
    }
 
    PLAYRHO_CONSTEXPR inline AngularVelocity operator"" _rpm(unsigned long long int v) noexcept
    {
        return static_cast<Real>(v) * RevolutionsPerMinute;
    }
 
    PLAYRHO_CONSTEXPR inline AngularVelocity operator"" _rpm(long double v) noexcept
    {
        return static_cast<Real>(v) * RevolutionsPerMinute;
    }
 
    
    PLAYRHO_CONSTEXPR inline Real StripUnit(const Real value)
    {
        return value;
    }
 
 
    PLAYRHO_CONSTEXPR const auto EarthlyLinearAcceleration = Real{-9.8f} * MeterPerSquareSecond;
    
    PLAYRHO_CONSTEXPR const auto BigG = Real{6.67408e-11f} * CubicMeter / (Kilogram * SquareSecond);
    
 
#if defined(USE_BOOST_UNITS)
    using boost::units::isfinite;
    using boost::units::isnormal;
    using boost::units::cos;
    using boost::units::sin;
    
    // Don't use boost's hypot since it does type promotion which is problematic.
    // using boost::units::hypot;
    
    template<class Unit>
    inline auto
    hypot(const boost::units::quantity<Unit,Real>& x, const boost::units::quantity<Unit,Real>& y)
    {
        using std::hypot;
        return boost::units::quantity<Unit,Real>::from_value(hypot(x.value(), y.value()));
    }
    
    template<class Unit>
    inline auto
    sqrt(const boost::units::quantity<Unit,Real>& q)
    {
        using std::sqrt;
        using quantity_type = typename boost::units::root_typeof_helper<
            boost::units::quantity<Unit,Real>,
            boost::units::static_rational<2>
            >::type;
        using unit_type = typename quantity_type::unit_type;
        
        return boost::units::quantity<unit_type, Real>::from_value(sqrt(q.value()));
    }
    
    template <class Y>
    inline auto AlmostZero(const boost::units::quantity<Y, Real> v)
    {
        return abs(v) < std::numeric_limits<boost::units::quantity<Y, Real>>::min();
    }
 
    template<class Unit,class Y>
    PLAYRHO_CONSTEXPR inline auto StripUnit(const boost::units::quantity<Unit, Y> source)
    {
        return source.value();
    }
 
    template <>
    PLAYRHO_CONSTEXPR inline Angle GetInvalid() noexcept
    {
        return GetInvalid<Real>() * Radian;
    }
    
    template <>
    PLAYRHO_CONSTEXPR inline Frequency GetInvalid() noexcept
    {
        return GetInvalid<Real>() * Hertz;
    }
    
    template <>
    PLAYRHO_CONSTEXPR inline AngularVelocity GetInvalid() noexcept
    {
        return GetInvalid<Real>() * RadianPerSecond;
    }
    
    template <>
    PLAYRHO_CONSTEXPR inline Time GetInvalid() noexcept
    {
        return GetInvalid<Real>() * Second;
    }
    
    template <>
    PLAYRHO_CONSTEXPR inline Length GetInvalid() noexcept
    {
        return GetInvalid<Real>() * Meter;
    }
    
    template <>
    PLAYRHO_CONSTEXPR inline Mass GetInvalid() noexcept
    {
        return GetInvalid<Real>() * Kilogram;
    }
    
    template <>
    PLAYRHO_CONSTEXPR inline InvMass GetInvalid() noexcept
    {
        return GetInvalid<Real>() / Kilogram;
    }
    
    template <>
    PLAYRHO_CONSTEXPR inline Momentum GetInvalid() noexcept
    {
        return GetInvalid<Real>() * Kilogram * MeterPerSecond;
    }
    
    template <>
    PLAYRHO_CONSTEXPR inline Force GetInvalid() noexcept
    {
        return GetInvalid<Real>() * Newton;
    }
    
    template <>
    PLAYRHO_CONSTEXPR inline Torque GetInvalid() noexcept
    {
        return GetInvalid<Real>() * NewtonMeter;
    }
    
    template <>
    PLAYRHO_CONSTEXPR inline LinearVelocity GetInvalid() noexcept
    {
        return GetInvalid<Real>() * MeterPerSecond;
    }
    
    template <>
    PLAYRHO_CONSTEXPR inline LinearAcceleration GetInvalid() noexcept
    {
        return GetInvalid<Real>() * MeterPerSquareSecond;
    }
    
    template <>
    PLAYRHO_CONSTEXPR inline AngularAcceleration GetInvalid() noexcept
    {
        return GetInvalid<Real>() * RadianPerSquareSecond;
    }
    
    template <>
    PLAYRHO_CONSTEXPR inline RotInertia GetInvalid() noexcept
    {
        // RotInertia is L^2  M    QP^-2
        return GetInvalid<Real>() * SquareMeter * Kilogram / SquareRadian;
    }
    
#endif // defined(USE_BOOST_UNITS)
 
} // namespace playrho
 
#if defined(USE_BOOST_UNITS)
namespace boost {
namespace units {
 
// Define division and multiplication templated operators in boost::units namespace since
//   boost::units is the consistent namespace of operands for these and this aids with
//   argument dependent lookup (ADL).
//
// Note that while boost::units already defines division and multiplication operator support,
//   that's only for division or multiplication with the same type that the quantity is based
//   on. For example when Real is float, Length{0.0f} * 2.0f is already supported but
//   Length{0.0f} * 2 is not.
 
template <class Dimension, typename X, typename = std::enable_if_t<
    playrho::IsArithmetic<X>::value && !std::is_same<X, playrho::Real>::value &&
    std::is_same<decltype(playrho::Real{} / X{}), playrho::Real>::value >
>
PLAYRHO_CONSTEXPR inline auto operator/ (quantity<Dimension, playrho::Real> lhs, X rhs)
{
    return lhs / playrho::Real(rhs);
}
 
template <class Dimension, typename X, typename = std::enable_if_t<
    playrho::IsArithmetic<X>::value && !std::is_same<X, playrho::Real>::value &&
    std::is_same<decltype(X{} / playrho::Real{}), playrho::Real>::value >
>
PLAYRHO_CONSTEXPR inline auto operator/ (X lhs, quantity<Dimension, playrho::Real> rhs)
{
    return playrho::Real(lhs) / rhs;
}
 
template <class Dimension, typename X, typename = std::enable_if_t<
    playrho::IsArithmetic<X>::value && !std::is_same<X, playrho::Real>::value &&
    std::is_same<decltype(playrho::Real{} * X{}), playrho::Real>::value> >
PLAYRHO_CONSTEXPR inline auto operator* (quantity<Dimension, playrho::Real> lhs, X rhs)
{
    return lhs * playrho::Real(rhs);
}
 
template <class Dimension, typename X, typename = std::enable_if_t<
    playrho::IsArithmetic<X>::value && !std::is_same<X, playrho::Real>::value &&
    std::is_same<decltype(playrho::Real{} * X{}), playrho::Real>::value> >
PLAYRHO_CONSTEXPR inline auto operator* (X lhs, quantity<Dimension, playrho::Real> rhs)
{
    return playrho::Real(lhs) * rhs;
}
 
} // namespace units
} // namespace boost
#endif // defined(USE_BOOST_UNITS)
 
#undef PLAYRHO_QUANTITY
#undef PLAYRHO_UNIT
 
#endif // PLAYRHO_COMMON_UNITS_HPP