limits.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2021, 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>

#if defined( LVARRAY_USE_CUDA )
  #include <cuda_fp16.h>
#endif

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();
};

#if defined( LVARRAY_USE_CUDA )

template<>
struct NumericLimits< __half >
{
  static constexpr float min = 1.0 / 16384;
  static constexpr float lowest = -65504;
  static constexpr float max = 65504;
  static constexpr float epsilon = 1.0 / 1024;
  static constexpr float denorm_min = 1.0 / 16777216;
};

template<>
struct NumericLimits< __half2 > : public NumericLimits< __half >
{};

#endif

template< typename T >
struct NumericLimitsNC
{
  T const min = NumericLimits< T >::min;
  T const lowest = NumericLimits< T >::lowest;
  T const max = NumericLimits< T >::max;
  T const epsilon = NumericLimits< T >::epsilon;
  T const denorm_min = NumericLimits< 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 };
  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_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 );
}

}