scalar_traits.h

#ifndef LINEARALGEBRA_SRC_MOLPRO_LINALG_SCALAR_TRAITS_H_
#define LINEARALGEBRA_SRC_MOLPRO_LINALG_SCALAR_TRAITS_H_
 
#include <complex>
#include <limits>
#include <type_traits>
 
namespace molpro::linalg {
 
template <typename T>
struct is_complex : std::false_type {};
 
template <typename T>
struct is_complex<std::complex<T>> : std::true_type {};
 
template <typename T>
struct real_type {
  using type = T;
};
 
template <typename T>
struct real_type<std::complex<T>> {
  using type = T;
};
 
template <typename T>
using real_type_t = typename real_type<T>::type;
 
template <typename T>
T conjugate(const T& x) {
  if constexpr (is_complex<T>{}) {
    using std::conj;
    return conj(x);
  } else {
    return x;
  }
}
 
template <typename T>
real_type_t<T> real_part(const T& x) {
  if constexpr (is_complex<T>{}) {
    return x.real();
  } else {
    return x;
  }
}
 
template <typename T>
real_type_t<T> imaginary_part(const T& x) {
  if constexpr (is_complex<T>{}) {
    return x.imag();
  } else {
    return real_type_t<T>{};
  }
}
 
template <typename value_type>
real_type_t<value_type> precision_scaled(double tolerance_for_double) {
  using real_t = real_type_t<value_type>;
  if constexpr (std::is_same_v<real_t, double>) {
    return tolerance_for_double;
  } else {
    return real_t(tolerance_for_double) *
           (std::numeric_limits<real_t>::epsilon() / real_t(std::numeric_limits<double>::epsilon()));
  }
}
 
} // namespace molpro::linalg
 
#endif // LINEARALGEBRA_SRC_MOLPRO_LINALG_SCALAR_TRAITS_H_