lossless_type.hpp

Go to the documentation of this file.

# /*
#  * Created by YongGyu Lee on 2020/12/08.
#  */
#
# ifndef VCCC_TYPE_TRAITS_LOSSLESS_TYPE_HPP
# define VCCC_TYPE_TRAITS_LOSSLESS_TYPE_HPP
#
# include "vccc/__type_traits/bigger_type.hpp"
# include "vccc/__type_traits/conjunction.hpp"
# include "vccc/__type_traits/detail/lossless_type_int_division.hpp"
 
namespace vccc {
 
 
 
// TODO: change double to biggest among input floating_point type
template<typename ...Types>
using decay_if_float_t = typename std::conditional_t<conjunction<std::is_same<Types, float>...>::value, float, double>;
 
 
template<typename...>struct lossless_type_add;
 
template<typename ...Ts>
using lossless_type_add_t = typename lossless_type_add<Ts...>::type;
 
 
template<typename T>
struct lossless_type_add<T> {
  static_assert(std::is_arithmetic<T>::value, "Invalid type in lossless_type_add<>");
  using type = T;
};
 
template<typename T1, typename T2>
struct lossless_type_add<T1, T2> {
  using type = decltype(static_cast<lossless_type_add_t<T1>>(0) +
                        static_cast<lossless_type_add_t<T2>>(0));
};
 
template<typename T1, typename T2, typename ...Ts>
struct lossless_type_add<T1, T2, Ts...> {
  using type = decltype(static_cast<lossless_type_add_t<T1, T2>>(0) +
                        static_cast<lossless_type_add_t<Ts...>>(0));
};
 
 
 
template<typename...>struct lossless_type_mul;
 
template<typename ...Ts>
using lossless_type_mul_t = typename lossless_type_mul<Ts...>::type;
 
template<typename T>
struct lossless_type_mul<T> {
  static_assert(std::is_arithmetic<T>::value, "Invalid type in lossless_type_mul<>");
  using type = T;
};
 
template<typename T1, typename T2>
struct lossless_type_mul<T1, T2> {
  using type =
      decltype(static_cast<lossless_type_mul_t<T1>>(0) *
               static_cast<lossless_type_mul_t<T2>>(0));
};
 
template<typename T1, typename T2, typename ...Ts>
struct lossless_type_mul<T1, T2, Ts...> {
  using type =
      decltype(static_cast<lossless_type_mul_t<T1, T2>>(0) *
               static_cast<lossless_type_mul_t<Ts...>>(0));
};
 
 
 
template<typename...> struct lossless_type_div;
 
template<typename ...Ts>
using lossless_type_div_t = typename lossless_type_div<Ts...>::type;
 
 
template<typename T>
struct lossless_type_div<T> {
  static_assert(std::is_arithmetic<T>::value, "Invalid type in lossless_type_div<>");
  using type = T;
};
 
template<typename T1, typename T2>
struct lossless_type_div<T1, T2> {
  using type =
      std::conditional_t<are_integral<T1, T2>::value,
          internal::lossless_type_int_division_t<T1, T2>,
          decltype(static_cast<lossless_type_div_t<T1>>(0) /
                   static_cast<lossless_type_div_t<T2>>(0))>;
};
 
template<typename T1, typename T2, typename ...Ts>
struct lossless_type_div<T1, T2, Ts...> {
  using type =
      decltype(static_cast<lossless_type_div_t<T1, T2>>(0) /
               static_cast<lossless_type_div_t<Ts...>>(0));
};
 
 
 
} // namespace vccc
 
# endif // VCCC_TYPE_TRAITS_LOSSLESS_TYPE_HPP