Unit.hpp

Go to the documentation of this file.

#ifndef PHYTH_UNIT_HPP
#define PHYTH_UNIT_HPP
 
#include <ratio>
 
namespace Phyth {
    template<typename DimT, typename Scale = std::ratio<1>, typename TagT = void>
    struct Unit {
        using DimensionT = DimT;
        using ScaleT = Scale;
 
        static constexpr double scale = static_cast<double>(Scale::num) / Scale::den;
 
        Unit() = default;
    };
 
    template<typename T>
    struct is_unit : std::false_type {
    };
 
    template<typename DimT, typename Scale, typename TagT>
    struct is_unit<Unit<DimT, Scale, TagT> > : std::true_type {
    };
 
    template<typename T>
    inline constexpr bool is_unit_v = is_unit<T>::value;
 
    template<typename U1, typename U2>
    struct UnitMulBin {
        using type = Unit<
            DimMulT<typename U1::DimensionT, typename U2::DimensionT>,
            typename std::ratio_multiply<typename U1::ScaleT, typename U2::ScaleT>::type
        >;
    };
 
    template<typename U1, typename U2>
    struct UnitDivBin {
        using type = Unit<
            DimDivT<typename U1::DimensionT, typename U2::DimensionT>,
            typename std::ratio_divide<typename U1::ScaleT, typename U2::ScaleT>::type
        >;
    };
 
    template<template<typename, typename> class F, typename... Ts>
    struct FoldLeft;
 
    template<template<typename, typename> class F, typename T>
    struct FoldLeft<F, T> {
        using type = T;
    };
 
    template<template<typename, typename> class F,
        typename T1, typename T2, typename... Rest>
    struct FoldLeft<F, T1, T2, Rest...> {
        using type = typename FoldLeft<
            F,
            typename F<T1, T2>::type,
            Rest...
        >::type;
    };
 
    template<template<typename, typename> class F, typename... Ts>
    using FoldLeftT = typename FoldLeft<F, Ts...>::type;
 
    template<typename... Us>
    using UnitMulT = FoldLeftT<UnitMulBin, Us...>;
 
    template<typename... Us>
    using UnitDivT = FoldLeftT<UnitDivBin, Us...>;
 
    template <typename U, typename Ratio>
    struct UnitRec {
        using type = Unit<
            DimDivT<Dimensionless, typename U::DimensionT>,
            std::ratio_multiply<typename U::ScaleT, Ratio>
        >;
    };
 
    template <typename U, typename Ratio = std::ratio<1>>
    using UnitRecT = typename UnitRec<U, Ratio>::type;
}
 
#endif // PHYTH_UNIT_HPP