Numeric.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2022 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* Numeric.h                                                   (C) 2000-2020 */
/*                                                                           */
/* Définitions des constantes numériques.                                    */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_DATATYPE_NUMERIC_H
#define ARCANE_DATATYPE_NUMERIC_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/Limits.h"
#include "arcane/utils/Math.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<class T>
class TypeEqualT
{
 public:
  constexpr ARCCORE_HOST_DEVICE static bool isNearlyZero (const T& a)
  {
    return (a==T());
  }
 
  constexpr ARCCORE_HOST_DEVICE static bool isZero (const T& a)
  {
    return (a==T());
  }
 
  constexpr ARCCORE_HOST_DEVICE static bool isNearlyEqual(const T& a,const T& b)
  {
    return (a==b);
  }
 
  constexpr ARCCORE_HOST_DEVICE static bool isNearlyEqualWithEpsilon(const T& a,const T& b,const T&)
  {
    return (a==b);
  }
 
  constexpr ARCCORE_HOST_DEVICE static bool isEqual(const T& a,const T& b)
  {
    return (a==b);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<class T>
class FloatEqualT
{
 private:
  constexpr ARCCORE_HOST_DEVICE static T nepsilon() { return FloatInfo<T>::nearlyEpsilon(); }
 public:
  constexpr ARCCORE_HOST_DEVICE static bool isNearlyZero(T a)
  {
    return ( (a<0.) ? a>-nepsilon() : a<nepsilon() );
  }
  
  constexpr ARCCORE_HOST_DEVICE static bool isNearlyZeroWithEpsilon(T a,T epsilon)
  {
    return ( (a<0.) ? a>-epsilon : a<epsilon );
  }
  
  ARCCORE_HOST_DEVICE static bool isNearlyZero(T a,T b)
  {
    return ( (a<0.) ? a>-(b*nepsilon()) : a<(b*nepsilon()) );
  }
 
  constexpr ARCCORE_HOST_DEVICE static bool isTrueZero(T a) { return (a==FloatInfo<T>::zero()); }
  constexpr ARCCORE_HOST_DEVICE static bool isZero(T a) { return (a==FloatInfo<T>::zero()); }
  constexpr ARCCORE_HOST_DEVICE static bool isNearlyEqual(T a,T b)
  {
    T s = math::abs(a) + math::abs(b);
    T d = a - b;
    return (d==FloatInfo<T>::zero()) ? true : isNearlyZero(d/s);
  }
  constexpr ARCCORE_HOST_DEVICE static bool isNearlyEqualWithEpsilon(T a,T b,T epsilon)
  {
    T s = math::abs(a) + math::abs(b);
    T d = a - b;
    return (d==FloatInfo<T>::zero()) ? true : isNearlyZeroWithEpsilon(d/s,epsilon);
  }
  constexpr ARCCORE_HOST_DEVICE static bool isEqual(T a,T b)
  {
    return a==b;
  }
};
template<>
class TypeEqualT<float>
: public FloatEqualT<float>
{};
 
template<>
class TypeEqualT<double>
: public FloatEqualT<double>
{};
 
template<>
class TypeEqualT<long double>
: public FloatEqualT<long double>
{};
 
#ifdef ARCANE_REAL_NOT_BUILTIN
template<>
class TypeEqualT<Real>
: public FloatEqualT<Real>
{};
#endif
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace math
{
 
template<class _Type> constexpr ARCCORE_HOST_DEVICE inline bool
isNearlyEqual(const _Type& a,const _Type& b)
{
  return TypeEqualT<_Type>::isNearlyEqual(a,b);
}
 
constexpr ARCCORE_HOST_DEVICE inline bool
isNearlyEqual(Real a,Real b)
{
  return TypeEqualT<Real>::isNearlyEqual(a,b);
}
 
template<class _Type> constexpr ARCCORE_HOST_DEVICE inline bool
isNearlyEqualWithEpsilon(const _Type& a,const _Type& b,const _Type& epsilon)
{
  return TypeEqualT<_Type>::isNearlyEqualWithEpsilon(a,b,epsilon);
}
 
ARCCORE_HOST_DEVICE constexpr inline bool
isNearlyEqualWithEpsilon(Real a,Real b,Real epsilon)
{
  return TypeEqualT<Real>::isNearlyEqualWithEpsilon(a,b,epsilon);
}
 
template<class _Type> constexpr ARCCORE_HOST_DEVICE inline bool
isEqual(const _Type& a,const _Type& b)
{
  return TypeEqualT<_Type>::isEqual(a,b);
}
 
ARCCORE_HOST_DEVICE constexpr inline bool
isEqual(Real a,Real b)
{
  return TypeEqualT<Real>::isEqual(a,b);
}
 
template<class _Type> constexpr ARCCORE_HOST_DEVICE inline bool
isNearlyZeroWithEpsilon(const _Type& a,const _Type& epsilon)
{
  return TypeEqualT<_Type>::isNearlyZeroWithEpsilon(a,epsilon);
}
 
template<class _Type> constexpr ARCCORE_HOST_DEVICE inline bool
isNearlyZero(const _Type& a)
{
  return TypeEqualT<_Type>::isNearlyZero(a);
}
 
template<class _Type> constexpr ARCCORE_HOST_DEVICE inline bool
isZero(const _Type& a)
{
  return TypeEqualT<_Type>::isZero(a);
}
} // namespace math
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif