quantity.h

Go to the documentation of this file.

 
#pragma once
 
#include "./concepts.h"
 
#include <cmath>
#include <functional>
#include <limits>
#include <ratio>
#include <string>
#include <type_traits>
 
#ifdef EMLABCPP_USE_NLOHMANN_JSON
#include <nlohmann/json.hpp>
#endif
 
namespace emlabcpp
{
 
template < typename Derived, typename ValueType = float >
class quantity
{
        ValueType value_;
 
        [[nodiscard]] Derived& impl()
        {
                return static_cast< Derived& >( *this );
        }
 
        [[nodiscard]] Derived const& impl() const
        {
                return static_cast< Derived const& >( *this );
        }
 
public:
        using value_type = ValueType;
 
        constexpr quantity() noexcept
          : value_( 0 )
        {
        }
 
        template < typename Value >
        constexpr explicit quantity( Value val ) noexcept
          : value_( static_cast< ValueType >( val ) )
        {
        }
 
        constexpr ValueType operator*() const noexcept
        {
                return value_;
        }
 
        constexpr Derived& operator+=( quantity const other ) noexcept
        {
                value_ += *other;
                return impl();
        }
 
        constexpr Derived& operator-=( quantity const other ) noexcept
        {
                value_ -= *other;
                return impl();
        }
 
        constexpr Derived& operator/=( arithmetic auto const val ) noexcept
        {
                value_ /= val;
                return impl();
        }
 
        constexpr Derived& operator*=( arithmetic auto const val ) noexcept
        {
                value_ *= val;
                return impl();
        }
 
        template < typename U >
        constexpr explicit operator U() const noexcept
        {
                return U( value_ );
        }
 
        static std::string get_unit()
        {
                return "";
        }
 
        friend constexpr auto operator<=>( quantity const&, quantity const& ) = default;
};
 
namespace detail
{
        template < typename Derived, typename ValueType >
        constexpr bool quantity_derived_test( quantity< Derived, ValueType > const& )
        {
                return true;
        }
}  // namespace detail
 
template < typename T >
concept quantity_derived = requires( T val ) { detail::quantity_derived_test( val ); };
 
template < typename Tag, typename ValueType = float >
class tagged_quantity : public quantity< tagged_quantity< Tag, ValueType >, ValueType >
{
public:
        using tag = Tag;
        using quantity< tagged_quantity< Tag, ValueType >, ValueType >::quantity;
};
 
template < typename Derived, typename ValueType >
constexpr Derived
operator+( quantity< Derived, ValueType > lhs, quantity< Derived, ValueType > const rhs )
{
        return lhs += rhs;
}
 
template < typename Derived, typename ValueType >
constexpr Derived
operator-( quantity< Derived, ValueType > lhs, quantity< Derived, ValueType > const rhs )
{
        return lhs -= rhs;
}
 
template < typename Derived, typename ValueType >
constexpr Derived operator-( quantity< Derived, ValueType > const val )
{
        return Derived{ -*val };
}
 
template < typename Derived, typename ValueType, arithmetic_like RhValueType >
constexpr bool operator<( quantity< Derived, ValueType > const lhs, RhValueType const rhs )
{
        return *lhs < rhs;
}
 
template < typename Derived, typename ValueType, arithmetic_like LhValueType >
constexpr bool operator<( LhValueType const lhs, quantity< Derived, ValueType > const rhs )
{
        return lhs < *rhs;
}
 
template < typename Derived, typename ValueType >
constexpr Derived operator*( quantity< Derived, ValueType > q, arithmetic auto const val )
{
        return q *= val;
}
 
template < typename Derived, typename ValueType >
constexpr Derived operator/( quantity< Derived, ValueType > q, arithmetic auto const val )
{
        return q /= val;
}
 
template < typename Derived, typename ValueType >
constexpr Derived abs( quantity< Derived, ValueType > const q )
{
        return Derived( std::abs( *q ) );
}
 
template < typename Derived, typename ValueType >
constexpr auto cos( quantity< Derived, ValueType > const u )
{
        return std::cos( *u );
}
 
template < typename Derived, typename ValueType >
constexpr auto sin( quantity< Derived, ValueType > const u )
{
        return std::sin( *u );
}
 
template < typename Derived, typename ValueType >
constexpr Derived
max( quantity< Derived, ValueType > const lh, quantity< Derived, ValueType > const rh )
{
        return Derived( std::max( *lh, *rh ) );
}
 
template < typename Derived, typename ValueType >
constexpr Derived
min( quantity< Derived, ValueType > const lh, quantity< Derived, ValueType > const rh )
{
        return Derived( std::min( *lh, *rh ) );
}
 
//---------------------------------------------------------------------------
 
template < typename Derived, typename ValueType >
constexpr Derived operator*( ValueType const val, quantity< Derived, ValueType > const q )
{
        return q * val;
}
 
template < typename Derived, typename ValueType >
constexpr ValueType operator/( ValueType const val, quantity< Derived, ValueType > const q )
{
        return val / *q;
}
 
#ifdef EMLABCPP_USE_OSTREAM
template < typename T, typename ValueType >
std::ostream& operator<<( std::ostream& os, quantity< T, ValueType > const& q )
{
        return os << *q << T::get_unit();
}
#endif
 
}  // namespace emlabcpp
 
template < emlabcpp::quantity_derived T >
struct std::numeric_limits< T >
{
        using value_type = typename T::value_type;
 
        constexpr static T lowest()
        {
                return T{ std::numeric_limits< value_type >::lowest() };
        }
 
        constexpr static T min()
        {
                return T{ std::numeric_limits< value_type >::min() };
        }
 
        constexpr static T max()
        {
                return T{ std::numeric_limits< value_type >::max() };
        }
};
 
template < emlabcpp::quantity_derived T >
struct std::hash< T >
{
        std::size_t operator()( T q ) const
        {
                std::string const unit = T::get_unit();
                return std::hash< typename T::value_type >()( *q ) ^
                       std::hash< std::string >()( unit );
        }
};
 
#ifdef EMLABCPP_USE_NLOHMANN_JSON
 
template < emlabcpp::quantity_derived T >
struct nlohmann::adl_serializer< T >
{
        static void to_json( nlohmann::json& j, T const q )
        {
                if ( T::get_unit().empty() )
                        j = *q;
                else
                        j[T::get_unit()] = *q;
        }
 
        static T from_json( nlohmann::json const& j )
        {
                using value_type = typename T::value_type;
 
                if ( T::get_unit().empty() )
                        return T{ j.get< value_type >() };
                return T{ j[T::get_unit()].template get< value_type >() };
        }
};
 
#endif