scalar_traits.hpp

Go to the documentation of this file.

#pragma once
 
#include "numeric_limits.hpp"
#include "types.hpp"
#include <complex>
#include <type_traits>
 
namespace uni20
{
 
template <typename T>
struct is_integer_t : std::bool_constant<std::integral<T> && !std::same_as<T, bool> && !std::same_as<T, char> &&
                                         !std::same_as<T, signed char> && !std::same_as<T, unsigned char>>
{};
 
template <typename T> inline constexpr bool is_integer_v = is_integer_t<std::remove_cvref_t<T>>::value;
 
template <typename T> struct is_real_t : std::false_type
{};
 
template <> struct is_real_t<float> : std::true_type
{};
 
template <> struct is_real_t<double> : std::true_type
{};
 
template <> struct is_real_t<long double> : std::true_type
{};
 
#if UNI20_HAS_MPREAL
template <> struct is_real_t<mpreal> : std::true_type
{};
#endif
 
#if UNI20_HAS_FLOAT128
template <> struct is_real_t<uni20::float128> : std::true_type
{};
#endif
 
template <typename T> inline constexpr bool is_real_v = is_real_t<std::remove_cvref_t<T>>::value;
 
template <typename T> struct is_complex_t : std::false_type
{};
 
template <typename T> struct is_complex_t<detail::standard_complex<T>> : std::true_type
{};
#if UNI20_HAS_MPREAL
template <> struct is_complex_t<mpcomplex> : std::true_type
{};
#endif
 
template <typename T> inline constexpr bool is_complex_v = is_complex_t<std::remove_cvref_t<T>>::value;
 
template <typename T> inline constexpr bool is_scalar_v = is_real_v<T> || is_complex_v<T> || is_integer_v<T>;
 
template <typename T> inline constexpr bool is_real_or_complex_v = is_real_v<T> || is_complex_v<T>;
 
template <typename T> struct scalar_type
{
    using type = void;
};
 
template <typename T>
  requires is_scalar_v<T>
struct scalar_type<T>
{
    using type = T;
};
 
template <typename T>
  requires requires { typename T::value_type; } && (!is_scalar_v<T>) &&
           requires { typename scalar_type<typename T::value_type>::type; }
struct scalar_type<T> : scalar_type<typename T::value_type>
{};
 
template <typename T> using scalar_t = typename scalar_type<std::remove_cvref_t<T>>::type;
 
template <typename T> inline constexpr bool is_scalar_valued_v = !std::same_as<scalar_t<T>, void>;
 
template <typename T>
inline constexpr bool is_integer_scalar_valued_v = is_scalar_valued_v<T> && is_integer_v<scalar_t<T>>;
 
template <typename T> inline constexpr bool is_real_scalar_valued_v = is_scalar_valued_v<T> && is_real_v<scalar_t<T>>;
 
template <typename T>
inline constexpr bool is_complex_scalar_valued_v = is_scalar_valued_v<T> && is_complex_v<scalar_t<T>>;
 
template <typename T>
inline constexpr bool is_real_or_complex_scalar_valued_v = is_scalar_valued_v<T> && is_real_or_complex_v<scalar_t<T>>;
 
template <typename T> struct make_real;
 
template <typename T>
  requires is_real_scalar_valued_v<T>
struct make_real<T>
{
    using type = T;
};
 
template <typename T>
  requires is_complex_v<T>
struct make_real<T>
{
    using type = typename T::value_type;
};
 
template <typename T> using make_real_t = typename make_real<T>::type;
 
template <typename T> struct make_complex;
 
template <typename T>
  requires is_real_v<T>
struct make_complex<T>
{
    using type = uni20::complex<T>;
};
 
template <typename T>
  requires is_complex_scalar_valued_v<T>
struct make_complex<T>
{
    using type = T;
};
 
template <typename T> using make_complex_t = typename make_complex<T>::type;
 
} // namespace uni20