angle.h

Go to the documentation of this file.

 
#pragma once
 
#include "detail/number_parser.h"
#include "detail/unit.h"
#include "detail/unit_symbol.h"
 
namespace SI {
template <typename _type, typename _ratio>
using angle_t = detail::unit_t<'r', std::ratio<1>, _type, _ratio>;
 
template <typename _type> using atto_radian_t = angle_t<_type, std::atto>;
template <typename _type> using femto_radian_t = angle_t<_type, std::femto>;
template <typename _type> using pico_radian_t = angle_t<_type, std::pico>;
template <typename _type> using nano_radian_t = angle_t<_type, std::nano>;
template <typename _type> using micro_radian_t = angle_t<_type, std::micro>;
template <typename _type> using milli_radian_t = angle_t<_type, std::milli>;
template <typename _type> using radian_t = angle_t<_type, std::ratio<1>>;
 
template <typename _type>
using micro_degree_t = angle_t<_type, std::ratio<100000000, 5729577951308232>>;
template <typename _type>
using milli_degree_t =
    angle_t<_type, std::ratio<100000000000, 5729577951308232>>;
template <typename _type>
using degree_t = angle_t<_type, std::ratio<100000000000000, 5729577951308232>>;
 
// specialize unit_symbol for usage with stream operators
template <>
struct unit_symbol<'r', std::ratio<1>>
    : SI::detail::unit_symbol_impl<'r', 'a', 'd'> {};
 
template <>
struct unit_symbol<'r', std::ratio<100000000, 5729577951308232>>
    : SI::detail::unit_symbol_impl<'u', 'd', 'e', 'g'> {};
 
template <>
struct unit_symbol<'r', std::ratio<100000000000, 5729577951308232>>
    : SI::detail::unit_symbol_impl<'m', 'd', 'e', 'g'> {};
 
template <>
struct unit_symbol<'r', std::ratio<100000000000000, 5729577951308232>>
    : SI::detail::unit_symbol_impl<'d', 'e', 'g'> {};
 
template <typename _ratio>
struct unit_symbol<'r', _ratio>
    : SI::detail::unit_symbol_impl<SI::detail::ratio_prefix<_ratio>::value, 'r',
                                   'a', 'd'> {
  static_assert(std::ratio_less_equal<_ratio, std::ratio<1>>::value,
                "Generic streaming only implemented for ratios <=1");
};
 
inline namespace literals {
 
template <char... _digits> constexpr atto_radian_t<int64_t> operator""_arad() {
  return atto_radian_t<int64_t>{SI::detail::parsing::Number<_digits...>::value};
}
 
template <char... _digits> constexpr femto_radian_t<int64_t> operator""_frad() {
  return femto_radian_t<int64_t>{
      SI::detail::parsing::Number<_digits...>::value};
}
 
template <char... _digits> constexpr pico_radian_t<int64_t> operator""_prad() {
  return pico_radian_t<int64_t>{SI::detail::parsing::Number<_digits...>::value};
}
 
template <char... _digits> constexpr nano_radian_t<int64_t> operator""_nrad() {
  return nano_radian_t<int64_t>{SI::detail::parsing::Number<_digits...>::value};
}
 
template <char... _digits> constexpr micro_radian_t<int64_t> operator""_urad() {
  return micro_radian_t<int64_t>{
      SI::detail::parsing::Number<_digits...>::value};
}
 
template <char... _digits> constexpr milli_radian_t<int64_t> operator""_mrad() {
  return milli_radian_t<int64_t>{
      SI::detail::parsing::Number<_digits...>::value};
}
 
template <char... _digits> constexpr radian_t<int64_t> operator""_rad() {
  return radian_t<int64_t>{SI::detail::parsing::Number<_digits...>::value};
}
 
constexpr atto_radian_t<long double> operator""_arad(long double value) {
  return atto_radian_t<long double>{value};
}
 
constexpr femto_radian_t<long double> operator""_frad(long double value) {
  return femto_radian_t<long double>{value};
}
 
constexpr pico_radian_t<long double> operator""_prad(long double value) {
  return pico_radian_t<long double>{value};
}
 
constexpr nano_radian_t<long double> operator""_nrad(long double value) {
  return nano_radian_t<long double>{value};
}
 
constexpr micro_radian_t<long double> operator""_urad(long double value) {
  return micro_radian_t<long double>{value};
}
 
constexpr milli_radian_t<long double> operator""_mrad(long double value) {
  return milli_radian_t<long double>{value};
}
 
constexpr radian_t<long double> operator""_rad(long double value) {
  return radian_t<long double>{value};
}
 
template <char... _digits> constexpr micro_degree_t<int64_t> operator""_udeg() {
  return micro_degree_t<int64_t>{
      SI::detail::parsing::Number<_digits...>::value};
}
 
template <char... _digits> constexpr milli_degree_t<int64_t> operator""_mdeg() {
  return milli_degree_t<int64_t>{
      SI::detail::parsing::Number<_digits...>::value};
}
 
template <char... _digits> constexpr degree_t<int64_t> operator""_deg() {
  return degree_t<int64_t>{SI::detail::parsing::Number<_digits...>::value};
}
 
constexpr micro_degree_t<long double> operator""_udeg(long double value) {
  return micro_degree_t<long double>{value};
}
 
constexpr milli_degree_t<long double> operator""_mdeg(long double value) {
  return milli_degree_t<long double>{value};
}
 
constexpr degree_t<long double> operator""_deg(long double value) {
  return degree_t<long double>{value};
}
 
} // namespace literals
 
} // namespace SI