Numeric.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2026 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 */
/*                                                                           */
/* Numeric constant definitions.                                             */
/*---------------------------------------------------------------------------*/
#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