scalar_precision.hpp

Go to the documentation of this file.

#pragma once
 
#include "types.hpp"
 
#include <uni20/config.hpp>
 
#include <array>
#include <optional>
#include <span>
#include <stdexcept>
#include <string_view>
#include <utility>
 
namespace uni20
{
 
enum class ScalarPrecision
{
  fp32,
  fp64,
  fp80,
  fp128
};
 
inline constexpr bool has_float80 = UNI20_HAS_FLOAT80 != 0;
 
inline constexpr bool has_float128 = UNI20_HAS_FLOAT128 != 0;
 
[[nodiscard]] constexpr std::string_view scalar_precision_name(ScalarPrecision precision)
{
  switch (precision)
  {
    case ScalarPrecision::fp32:
      return "fp32";
    case ScalarPrecision::fp64:
      return "fp64";
    case ScalarPrecision::fp80:
      return "fp80";
    case ScalarPrecision::fp128:
      return "fp128";
  }
  return "unknown";
}
 
[[nodiscard]] constexpr std::optional<ScalarPrecision> parse_scalar_precision(std::string_view name)
{
  if (name == "fp32") return ScalarPrecision::fp32;
  if (name == "fp64") return ScalarPrecision::fp64;
  if (name == "fp80") return ScalarPrecision::fp80;
  if (name == "fp128") return ScalarPrecision::fp128;
  return std::nullopt;
}
 
[[nodiscard]] constexpr bool scalar_precision_is_available(ScalarPrecision precision)
{
  switch (precision)
  {
    case ScalarPrecision::fp32:
    case ScalarPrecision::fp64:
      return true;
    case ScalarPrecision::fp80:
      return has_float80;
    case ScalarPrecision::fp128:
      return has_float128;
  }
  return false;
}
 
namespace detail
{
inline constexpr std::array configured_scalar_precisions{
    ScalarPrecision::fp32,
    ScalarPrecision::fp64,
#if UNI20_HAS_FLOAT80
    ScalarPrecision::fp80,
#endif
#if UNI20_HAS_FLOAT128
    ScalarPrecision::fp128,
#endif
};
} // namespace detail
 
[[nodiscard]] constexpr std::span<ScalarPrecision const> configured_scalar_precisions()
{
  return detail::configured_scalar_precisions;
}
 
[[nodiscard]] constexpr std::string_view configured_scalar_precision_choices()
{
  return "fp32|fp64"
#if UNI20_HAS_FLOAT80
         "|fp80"
#endif
#if UNI20_HAS_FLOAT128
         "|fp128"
#endif
      ;
}
 
template <class Function> decltype(auto) visit_scalar_precision(ScalarPrecision precision, Function&& function)
{
  switch (precision)
  {
    case ScalarPrecision::fp32:
      return std::forward<Function>(function).template operator()<float32>();
    case ScalarPrecision::fp64:
      return std::forward<Function>(function).template operator()<float64>();
    case ScalarPrecision::fp80:
#if UNI20_HAS_FLOAT80
      return std::forward<Function>(function).template operator()<float80>();
#else
      throw std::invalid_argument("fp80 is not available in this Uni20 build");
#endif
    case ScalarPrecision::fp128:
#if UNI20_HAS_FLOAT128
      return std::forward<Function>(function).template operator()<float128>();
#else
      throw std::invalid_argument("fp128 is not available in this Uni20 build");
#endif
  }
  throw std::invalid_argument("invalid Uni20 scalar precision");
}
 
} // namespace uni20