limits.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2020, Lawrence Livermore National Security, LLC and LvArray contributors.
 * All rights reserved.
 * See the LICENSE file for details.
 * SPDX-License-Identifier: (BSD-3-Clause)
 */

#pragma once

// Source includes
#include "Macros.hpp"

// System includes
#include <limits>

namespace LvArray
{

template< typename T >
struct NumericLimits : public std::numeric_limits< T >
{
  static constexpr T min = std::numeric_limits< T >::min();
  static constexpr T lowest = std::numeric_limits< T >::lowest();
  static constexpr T max = std::numeric_limits< T >::max();
  static constexpr T epsilon = std::numeric_limits< T >::epsilon();
  static constexpr T round_error = std::numeric_limits< T >::round_error();
  static constexpr T infinity = std::numeric_limits< T >::infinity();
  static constexpr T quiet_NaN = std::numeric_limits< T >::quiet_NaN();
  static constexpr T signaling_NaN = std::numeric_limits< T >::signaling_NaN();
  static constexpr T denorm_min = std::numeric_limits< T >::denorm_min();
};

template< typename T >
struct NumericLimitsNC : public std::numeric_limits< T >
{
  T const min = std::numeric_limits< T >::min();
  T const lowest = std::numeric_limits< T >::lowest();
  T const max = std::numeric_limits< T >::max();
  T const epsilon = std::numeric_limits< T >::epsilon();
  T const round_error = std::numeric_limits< T >::round_error();
  T const infinity = std::numeric_limits< T >::infinity();
  T const quiet_NaN = std::numeric_limits< T >::quiet_NaN();
  T const signaling_NaN = std::numeric_limits< T >::signaling_NaN();
  T const denorm_min = std::numeric_limits< T >::denorm_min();
};

namespace internal
{

template< typename T, typename U >
constexpr bool sameSignedness = ( std::is_signed< T >::value && std::is_signed< U >::value ) ||
                                ( std::is_unsigned< T >::value && std::is_unsigned< U >::value );

template< typename INPUT, typename OUTPUT >
constexpr bool canEasilyConvert = sizeof( INPUT ) < sizeof( OUTPUT ) ||
                                  ( sizeof( INPUT ) == sizeof( OUTPUT ) && sameSignedness< INPUT, OUTPUT > );

} // namespace internal

template< typename OUTPUT, typename INPUT >
std::enable_if_t< internal::canEasilyConvert< INPUT, OUTPUT >, OUTPUT >
inline constexpr LVARRAY_HOST_DEVICE
integerConversion( INPUT input )
{
  static_assert( std::is_integral< INPUT >::value, "INPUT must be an integral type." );
  static_assert( std::is_integral< OUTPUT >::value, "OUTPUT must be an integral type." );

  return OUTPUT{ input };
}

template< typename OUTPUT, typename INPUT >
std::enable_if_t< !internal::canEasilyConvert< INPUT, OUTPUT > &&
                  std::is_unsigned< INPUT >::value,
                  OUTPUT >
inline LVARRAY_HOST_DEVICE
integerConversion( INPUT input )
{
  static_assert( std::is_integral< INPUT >::value, "INPUT must be an integral type." );
  static_assert( std::is_integral< OUTPUT >::value, "OUTPUT must be an integral type." );

  LVARRAY_ERROR_IF_GT( input, NumericLimits< OUTPUT >::max );

  return static_cast< OUTPUT >( input );
}

template< typename OUTPUT, typename INPUT >
std::enable_if_t< !internal::canEasilyConvert< INPUT, OUTPUT > &&
                  !std::is_unsigned< INPUT >::value,
                  OUTPUT >
inline LVARRAY_HOST_DEVICE
integerConversion( INPUT input )
{
  static_assert( std::is_integral< INPUT >::value, "INPUT must be an integral type." );
  static_assert( std::is_integral< OUTPUT >::value, "OUTPUT must be an integral type." );

  LVARRAY_ERROR_IF_LT( input, std::make_signed_t< OUTPUT >{ NumericLimits< OUTPUT >::min } );

  // If OUTPUT is unsigned we convert input to an unsigned type. This is safe because it must be
  // positive due to the check above.
  using ConditionallyUnsigned = std::conditional_t< std::is_unsigned< OUTPUT >::value, std::make_unsigned_t< INPUT >, INPUT >;
  LVARRAY_ERROR_IF_GT( ConditionallyUnsigned( input ), NumericLimits< OUTPUT >::max );

  return static_cast< OUTPUT >( input );
}

}