types.hpp

Go to the documentation of this file.

#pragma once
 
#include <uni20/config.hpp>
#if UNI20_HAS_FLOAT128 && UNI20_FLOAT128_PROVIDER_MPLAPACK
#include <mplapack_config.h>
#endif
#include <complex>
#include <concepts>
#include <limits>
 
namespace uni20
{
 
// Fundamental types used throughout the library
 
using size_type = std::ptrdiff_t;
using index_type = std::ptrdiff_t;
 
// Type aliases for explicit precision and complex values
using float32 = float;
using float64 = double;
 
#if UNI20_HAS_MPREAL
class mpreal;
class mpcomplex;
#endif
 
namespace detail
{
// Preserve deduction where code specifically adapts the standard-library family.
template <typename Real> using standard_complex = std::complex<Real>;
template <typename Real> struct complex_type
{
    using type = standard_complex<Real>;
};
#if UNI20_HAS_MPREAL
template <> struct complex_type<mpreal>
{
    using type = mpcomplex;
};
#endif
} // namespace detail
 
#if UNI20_HAS_FLOAT80
using float80 = long double;
static_assert(std::numeric_limits<float80>::is_iec559 && std::numeric_limits<float80>::radix == 2 &&
                  std::numeric_limits<float80>::digits == 64 && std::numeric_limits<float80>::min_exponent == -16381 &&
                  std::numeric_limits<float80>::max_exponent == 16384 &&
                  std::numeric_limits<float80>::denorm_min() > 0 &&
                  std::numeric_limits<float80>::denorm_min() < std::numeric_limits<float80>::min(),
              "Uni20's configured fp80 format must match the consuming compiler's long double");
#endif
 
template <typename Real> using complex = typename detail::complex_type<Real>::type;
 
using complex64 = complex<float>;
using complex128 = complex<double>;
#if UNI20_HAS_FLOAT80
using complex160 = complex<float80>;
#endif
 
using cfloat = complex<float>;
using cdouble = complex<double>;
 
#if UNI20_HAS_FLOAT128 && UNI20_FLOAT128_PROVIDER_MPLAPACK
using float128 = mplapack_binary128_t;
 
using complex256 = complex<float128>;
 
using cfloat128 = complex256;
#endif
 
template <typename R> struct remove_proxy_reference : std::remove_reference<R>
{};
 
template <typename R>
constexpr bool is_proxy_reference_v =
    !std::is_same_v<typename remove_proxy_reference<std::remove_cvref_t<R>>::type, std::remove_cvref_t<R>>;
 
template <typename R>
using remove_proxy_reference_t =
    std::conditional_t<is_proxy_reference_v<R>, typename remove_proxy_reference<std::remove_cvref_t<R>>::type,
                       std::remove_reference_t<R>>;
 
template <typename Value> struct logical_value
{
    using type = std::remove_cvref_t<Value>;
};
 
template <typename Value> using logical_value_t = typename logical_value<std::remove_cvref_t<Value>>::type;
 
} // namespace uni20