DimensionalAnalysis.hpp

Go to the documentation of this file.

#ifndef CPP_UTILITIES_DIMENSIONALANALYSIS_HPP
#define CPP_UTILITIES_DIMENSIONALANALYSIS_HPP
 
#include <tuple>
#include <ratio>
#include <cmath>
#include "../Common.h"
 
UTILITIES_NAMESPACE_BEGIN
 
namespace Dimensional {
template<int length, int mass, int time, int current, int temperature, int amountOfSubstance, int luminousIntensity>
struct Unit
{
    using type = Unit<length, mass, time, current, temperature, amountOfSubstance, luminousIntensity>;
#if __cplusplus >= 201402L
    static constexpr std::tuple<int, int, int, int, int, int, int> factors{
        length, mass, time, current, temperature, amountOfSubstance, luminousIntensity
    };
#else
    static const std::tuple<int, int, int, int, int, int, int> factors;
#endif
    static constexpr int factorLength               = length;
    static constexpr int factorMass                 = mass;
    static constexpr int factorTime                 = time;
    static constexpr int factorCurrent              = current;
    static constexpr int factorTemperature          = temperature;
    static constexpr int factorAmountOfSubstance    = amountOfSubstance;
    static constexpr int factorLuminousIntensity    = luminousIntensity;
};
#if __cplusplus < 201703L // Definition of static constexpr member is deprecated since C++17.
#if __cplusplus >= 201402L
template<int length, int mass, int time, int current, int temperature, int amountOfSubstance, int luminousIntensity>
constexpr std::tuple<int, int, int, int, int, int, int> Unit<length, mass, time, current, temperature, amountOfSubstance, luminousIntensity>::factors;
#else
template<int length, int mass, int time, int current, int temperature, int amountOfSubstance, int luminousIntensity>
const std::tuple<int, int, int, int, int, int, int> Unit<length, mass, time, current, temperature, amountOfSubstance, luminousIntensity>::factors{
    length, mass, time, current, temperature, amountOfSubstance, luminousIntensity
};
#endif
template<int length, int mass, int time, int current, int temperature, int amountOfSubstance, int luminousIntensity>
constexpr int Unit<length, mass, time, current, temperature, amountOfSubstance, luminousIntensity>::factorLength;
template<int length, int mass, int time, int current, int temperature, int amountOfSubstance, int luminousIntensity>
constexpr int Unit<length, mass, time, current, temperature, amountOfSubstance, luminousIntensity>::factorMass;
template<int length, int mass, int time, int current, int temperature, int amountOfSubstance, int luminousIntensity>
constexpr int Unit<length, mass, time, current, temperature, amountOfSubstance, luminousIntensity>::factorTime;
template<int length, int mass, int time, int current, int temperature, int amountOfSubstance, int luminousIntensity>
constexpr int Unit<length, mass, time, current, temperature, amountOfSubstance, luminousIntensity>::factorCurrent;
template<int length, int mass, int time, int current, int temperature, int amountOfSubstance, int luminousIntensity>
constexpr int Unit<length, mass, time, current, temperature, amountOfSubstance, luminousIntensity>::factorTemperature;
template<int length, int mass, int time, int current, int temperature, int amountOfSubstance, int luminousIntensity>
constexpr int Unit<length, mass, time, current, temperature, amountOfSubstance, luminousIntensity>::factorAmountOfSubstance;
template<int length, int mass, int time, int current, int temperature, int amountOfSubstance, int luminousIntensity>
constexpr int Unit<length, mass, time, current, temperature, amountOfSubstance, luminousIntensity>::factorLuminousIntensity;
#endif
 
template<typename Unit1,  typename Unit2>
using UnitMultiply = Unit<
    Unit1::factorLength             + Unit2::factorLength,
    Unit1::factorMass               + Unit2::factorMass,
    Unit1::factorTime               + Unit2::factorTime,
    Unit1::factorCurrent            + Unit2::factorCurrent,
    Unit1::factorTemperature        + Unit2::factorTemperature,
    Unit1::factorAmountOfSubstance  + Unit2::factorAmountOfSubstance,
    Unit1::factorLuminousIntensity  + Unit2::factorLuminousIntensity
>;
template<typename Unit1,  typename Unit2>
using UnitDivide = Unit<
    Unit1::factorLength             - Unit2::factorLength,
    Unit1::factorMass               - Unit2::factorMass,
    Unit1::factorTime               - Unit2::factorTime,
    Unit1::factorCurrent            - Unit2::factorCurrent,
    Unit1::factorTemperature        - Unit2::factorTemperature,
    Unit1::factorAmountOfSubstance  - Unit2::factorAmountOfSubstance,
    Unit1::factorLuminousIntensity  - Unit2::factorLuminousIntensity
>;
template<typename U, int n>
using UnitPow = Unit<
    U::factorLength             * n,
    U::factorMass               * n,
    U::factorTime               * n,
    U::factorCurrent            * n,
    U::factorTemperature        * n,
    U::factorAmountOfSubstance  * n,
    U::factorLuminousIntensity  * n
>;
template<typename U, int n>
using UnitRoot = Unit<
    U::factorLength             / n,
    U::factorMass               / n,
    U::factorTime               / n,
    U::factorCurrent            / n,
    U::factorTemperature        / n,
    U::factorAmountOfSubstance  / n,
    U::factorLuminousIntensity  / n
>;
typedef Unit<0, 0, 0, 0, 0, 0, 0> Scala;
typedef Unit<1, 0, 0, 0, 0, 0, 0> Length;
typedef Unit<0, 1, 0, 0, 0, 0, 0> Mass;
typedef Unit<0, 0, 1, 0, 0, 0, 0> Time;
typedef Unit<0, 0, 0, 1, 0, 0, 0> Current;
typedef Unit<0, 0, 0, 0, 1, 0, 0> Temperature;
typedef Unit<0, 0, 0, 0, 0, 1, 0> AmountOfSubstance;
typedef Unit<0, 0, 0, 0, 0, 0, 1> LuminousIntensity;
typedef UnitDivide<Length, Time> Speed;
typedef UnitDivide<Speed, Time> Acceleration;
typedef UnitDivide<Scala, Time> Frenquency;
// TODO radian
// TODO steradian
typedef UnitMultiply<Mass, Acceleration> Force;
typedef UnitMultiply<Length, Length> Area;
typedef UnitMultiply<Area, Length> Volume;
typedef UnitDivide<Force, Area> Pressure;
typedef UnitMultiply<Force, Length> Energy;
typedef UnitDivide<Energy, Time> Power;
typedef UnitMultiply<Time, Current> Charge;
typedef UnitDivide<Power, Current> Voltage;
typedef UnitDivide<Charge, Voltage> ElelctricCapacitance;
typedef UnitDivide<Voltage, Current> ElectricResistance;
typedef UnitDivide<Scala, ElectricResistance> ElelctricConductance;
typedef UnitMultiply<Voltage, Time> MagneticFlux;
typedef UnitDivide<MagneticFlux, Area> MagnetFluxDensity;
typedef UnitDivide<MagneticFlux, Current> Inductance;
typedef LuminousIntensity Luminous;
typedef UnitDivide<LuminousIntensity, Area> Illuminance;
typedef UnitDivide<Scala, Time> Radioactivity;
typedef UnitDivide<Energy, Mass> AbsorbedDose;
typedef UnitDivide<Energy, Mass> EquivalentDose;
typedef UnitDivide<AmountOfSubstance, Time> CatalyticActivity;
// Forward declarations
template<typename T, typename Unit, typename Ratio>
class Quantity;
template<typename NewRatio, typename T, typename U, typename Ratio>
Quantity<T, U, NewRatio> quantity_cast(Quantity<T, U, Ratio> x);
 
template<typename T, typename U, typename Ratio = std::ratio<1>>
class Quantity
{
public:
    using type = Quantity<T, U, Ratio>;
    using value_type = T;
    using unit_type = U;
    using ratio_type = Ratio;
 
    inline explicit Quantity(T x = 0)
        : v(x)
    {}
 
    inline Quantity(const Quantity<T, U, Ratio>& other)
        : v(other.v)
    {}
 
    template<typename OtherRatio>
    inline Quantity(const Quantity<T, U, OtherRatio>& other)
        : v(quantity_cast<Ratio>(other).value())
    {}
 
    inline T value() const
    { return v; }
 
    inline void set_value(T value)
    { v = value;; }
 
    inline T standard_value() const
    { return quantity_cast<std::ratio<1>>(*this).value(); }
 
    inline void set_standard_value(T value)
    { v = quantity_cast<Ratio>(Quantity<T, U>(value)).value(); }
 
    template<typename OtherRatio>
    inline Quantity<T, U, Ratio>&
    operator+=(const Quantity<T, U, OtherRatio>& other)
    { v += quantity_cast<Ratio>(other).v; return *this; }
 
    inline Quantity<T, U, Ratio>&
    operator=(const Quantity<T, U, Ratio>& other)
    { v = other.v; return *this; }
 
    template<typename OtherRatio>
    inline Quantity<T, U, Ratio>&
    operator=(const Quantity<T, U, OtherRatio>& other)
    { v = quantity_cast<Ratio>(other).v; return *this; }
 
    template<typename OtherRatio>
    inline bool operator==(const Quantity<T, U, OtherRatio>& other) const
    { return v == quantity_cast<Ratio>(other).v; }
 
    template<typename OtherRatio>
    inline bool operator!=(const Quantity<T, U, OtherRatio>& other) const
    { return !(*this == other); }
 
    template<typename OtherRatio>
    inline bool operator<(const Quantity<T, U, OtherRatio>& other) const
    { return v < quantity_cast<Ratio>(other).v; }
 
    template<typename OtherRatio>
    inline bool operator<=(const Quantity<T, U, OtherRatio>& other) const
    { return (*this < other) || (*this == other); }
 
    template<typename OtherRatio>
    inline bool operator>(const Quantity<T, U, OtherRatio>& other) const
    { return !(*this <= other); }
 
    template<typename OtherRatio>
    inline bool operator>=(const Quantity<T, U, OtherRatio>& other) const
    { return !(*this < other); }
 
private:
    T v;
};
 
template<typename T, typename U, typename Ratio1, typename Ratio2>
inline Quantity<T, U, Ratio1>
operator+(Quantity<T, U, Ratio1> lhs, Quantity<T, U, Ratio2> rhs)
{
    return Quantity<T, U, Ratio1>(lhs.value()
                                  + quantity_cast<Ratio1>(rhs).value());
}
 
template<typename T, typename U, typename Ratio1, typename Ratio2>
inline Quantity<T, U, Ratio1>
operator-(Quantity<T, U, Ratio1>& lhs, Quantity<T, U, Ratio2> rhs)
{
    return Quantity<T, U, Ratio1>(lhs.value()
                                  - quantity_cast<Ratio1>(rhs).value());
}
 
template<typename T, typename Unit1, typename Ratio1, typename Unit2, typename Ratio2>
inline Quantity<T, UnitMultiply<Unit1, Unit2>, Ratio1>
operator*(Quantity<T, Unit1, Ratio1> lhs, Quantity<T, Unit2, Ratio2> rhs)
{
    using dim = UnitMultiply<Unit1, Unit2>;
    return Quantity<T, dim, Ratio1>(lhs.value()
                                    * quantity_cast<Ratio1>(rhs).value());
}
 
template<typename T, typename Unit1, typename Ratio1, typename Unit2, typename Ratio2>
inline Quantity<T, UnitDivide<Unit1, Unit2>, Ratio1>
operator/(Quantity<T, Unit1, Ratio1> lhs, Quantity<T, Unit2, Ratio2> rhs)
{
    using dim = UnitDivide<Unit1, Unit2>;
    return Quantity<T, dim, Ratio1>(lhs.value()
                                    / quantity_cast<Ratio1>(rhs).value());
}
 
template<int factor, typename T, typename U, typename Ratio>
inline Quantity<T, UnitPow<U, factor>, std::ratio<1>>
pow(const Quantity<T, U, Ratio>& x)
{
    return Quantity<
               T,
               UnitPow<U, factor>,
               std::ratio<1>
           >(std::pow(quantity_cast<std::ratio<1>>(x).value(),
                      factor));
}
 
template<int factor, typename T, typename U, typename Ratio>
inline Quantity<T, UnitRoot<U, factor>, std::ratio<1>>
root(const Quantity<T, U, Ratio>& x)
{
    return Quantity<
               T,
               UnitRoot<U, factor>,
               std::ratio<1>
           >(std::pow(quantity_cast<std::ratio<1>>(x).value(),
                      1.0 / factor));
}
 
template<typename NewRatio, typename T, typename U, typename Ratio>
inline Quantity<T, U, NewRatio> quantity_cast(Quantity<T, U, Ratio> x)
{
    using ratio_div = std::ratio_divide<Ratio, NewRatio>;
    T val = x.value()
            * (static_cast<long double>(ratio_div::num) / ratio_div::den);
    return Quantity<T, U, NewRatio>(val);
}
 
typedef std::ratio<80813362, 25723692> ratio_PI;
typedef std::ratio_divide<ratio_PI, std::ratio<180>> ratio_degree;
typedef std::ratio<500, 1> ratio_length_li;
typedef std::ratio_divide<ratio_length_li, std::ratio<15>> ratio_yin;
typedef std::ratio_divide<ratio_yin, std::ratio<10>> ratio_zhang;
typedef std::ratio_divide<ratio_zhang, std::ratio<2>> ratio_xun;
typedef std::ratio_divide<ratio_zhang, std::ratio<10>> ratio_chi;
typedef std::ratio_divide<ratio_chi, std::ratio<10>> ratio_cun;
typedef std::ratio_divide<ratio_cun, std::ratio<10>> ratio_length_fen;
typedef std::ratio_divide<ratio_length_fen, std::ratio<10>> ratio_length_li2;
typedef std::ratio_divide<ratio_length_li2, std::ratio<10>> ratio_length_hao;
typedef std::ratio_divide<ratio_length_hao, std::ratio<10>> ratio_length_si;
typedef std::ratio_divide<ratio_length_si, std::ratio<10>> ratio_length_hu;
typedef std::ratio<200000, 3> ratio_qing;
typedef std::ratio<2000, 3> ratio_mu;
typedef std::ratio_divide<ratio_mu, std::ratio<240>> ratio_gong;
typedef std::ratio<50> ratio_dan;
typedef std::ratio<1, 2> ratio_jin;
typedef std::ratio_divide<ratio_jin, std::ratio<10>> ratio_liang;
typedef std::ratio_divide<ratio_liang, std::ratio<10>> ratio_qian;
typedef std::ratio_divide<ratio_qian, std::ratio<10>> ratio_mass_fen;
typedef std::ratio_divide<ratio_mass_fen, std::ratio<10>> ratio_mass_li;
typedef std::ratio_divide<ratio_mass_li, std::ratio<10>> ratio_mass_hao;
typedef std::ratio_divide<ratio_mass_hao, std::ratio<10>> ratio_mass_si;
typedef std::ratio_divide<ratio_mass_si, std::ratio<10>> ratio_mass_hu;
typedef std::ratio_multiply<std::ratio<1609344ll, 1000000ll>, std::kilo> ratio_mile;
typedef std::ratio_divide<ratio_mile, std::ratio<8>> ratio_furlong;
typedef std::ratio_divide<ratio_furlong, std::ratio<10>> ratio_chain;
typedef std::ratio_divide<ratio_chain, std::ratio<22>> ratio_yard;
typedef std::ratio_divide<ratio_yard, std::ratio<16>> ratio_nail;
typedef std::ratio_divide<ratio_yard, std::ratio<3>> ratio_feet;
typedef std::ratio_divide<ratio_feet, std::ratio<12>> ratio_inch;
typedef std::ratio_divide<ratio_inch, std::ratio<6>> ratio_pica;
typedef std::ratio_divide<ratio_pica, std::ratio<12>> ratio_point;
typedef std::ratio<10160469088, 10000000> ratio_longton;
typedef std::ratio<90718474, 100000> ratio_shortton;
typedef std::ratio<5080234544, 100000000> ratio_long_hundredweight;
typedef std::ratio<45359237, 1000000> ratio_short_hundredweight;
typedef std::ratio<45359237, 100000000> ratio_pound;
typedef std::ratio_divide<ratio_pound, std::ratio<16>> ratio_ounce;
typedef std::ratio_divide<ratio_ounce, std::ratio<16>> ratio_drachm;
typedef std::ratio_multiply<std::ratio<6479891, 100000ll>, std::micro> ratio_grain;
typedef ratio_long_hundredweight ratio_en_hundredweight;
typedef std::ratio_multiply<ratio_pound, std::ratio<28>> ratio_en_quarter;
typedef std::ratio_multiply<ratio_pound, std::ratio<14>> ratio_en_stone;
typedef std::ratio_multiply<std::ratio<35516328125ll, 10000000000ll>, std::micro> ratio_en_fluid_dram;
typedef std::ratio_multiply<ratio_en_fluid_dram, std::ratio<8>> ratio_en_fluid_ounce;
typedef std::ratio_multiply<ratio_en_fluid_ounce, std::ratio<5>> ratio_en_gill;
typedef std::ratio_multiply<ratio_en_gill, std::ratio<2>> ratio_en_cup;
typedef std::ratio_multiply<ratio_en_cup, std::ratio<2>> ratio_en_pint;
typedef std::ratio_multiply<ratio_en_pint, std::ratio<2>> ratio_en_quart;
typedef std::ratio_multiply<ratio_en_quart, std::ratio<4>> ratio_en_gallon;
typedef std::ratio_multiply<ratio_en_gallon, std::ratio<2>> ratio_en_peck;
typedef std::ratio_multiply<ratio_en_peck, std::ratio<4>> ratio_en_bushel;
typedef ratio_short_hundredweight ratio_us_hundredweight;
typedef std::ratio_multiply<std::ratio<36966911953125ll, 10000000000000ll>, std::micro> ratio_us_fluid_dram;
typedef std::ratio_multiply<ratio_us_fluid_dram, std::ratio<8>> ratio_us_fluid_ounce;
typedef std::ratio_divide<ratio_us_fluid_ounce, std::ratio<6>> ratio_us_teaspoons;
typedef std::ratio_divide<ratio_us_fluid_ounce, std::ratio<2>> ratio_us_tablespoons;
typedef std::ratio_multiply<ratio_us_fluid_ounce, std::ratio<4>> ratio_us_gill;
typedef std::ratio_multiply<ratio_us_gill, std::ratio<2>> ratio_us_cup;
typedef std::ratio_multiply<ratio_us_cup, std::ratio<2>> ratio_us_pint;
typedef std::ratio_multiply<ratio_us_pint, std::ratio<2>> ratio_us_quart;
typedef std::ratio_multiply<ratio_us_quart, std::ratio<4>> ratio_us_gallon;
typedef std::ratio_multiply<std::ratio<5506104713575ll, 10000000000000ll>, std::milli> ratio_us_dry_pint;
typedef std::ratio_multiply<ratio_us_dry_pint, std::ratio<2>> ratio_us_dry_quart;
typedef std::ratio_multiply<ratio_us_dry_quart, std::ratio<4>> ratio_us_dry_gallon;
typedef std::ratio_multiply<ratio_us_dry_gallon, std::ratio<2>> ratio_us_dry_peck;
typedef std::ratio_multiply<ratio_us_dry_peck, std::ratio<4>> ratio_us_bushel;
} // namespace Dimensional
UTILITIES_NAMESPACE_END
 
#endif  // CPP_UTILITIES_DIMENSIONALANALYSIS_HPP