Math.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2024 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* Math.h                                                      (C) 2000-2024 */
/*                                                                           */
/* Fonctions mathématiques diverses.                                         */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_UTILS_MATH_H
#define ARCANE_UTILS_MATH_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/UtilsTypes.h"
#include "arcane/utils/Convert.h"
 
#include <cmath>
#include <cstdlib>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
namespace Arcane::math
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
ARCCORE_HOST_DEVICE inline double
log(double v)
{
#ifdef ARCANE_CHECK_MATH
  if (v==0.0 || v<0.0)
    arcaneMathError(v,"log");
#endif
  return std::log(v);
}
 
ARCCORE_HOST_DEVICE inline long double
log(long double v)
{
#ifdef ARCANE_CHECK_MATH
  if (v==0.0 || v<0.0)
    arcaneMathError(v,"log");
#endif
  return std::log(v);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
ARCCORE_HOST_DEVICE inline double
log10(double v)
{
#ifdef ARCANE_CHECK_MATH
  if (v==0.0 || v<0.0)
    arcaneMathError(v,"log");
#endif
  return std::log10(v);
}
 
ARCCORE_HOST_DEVICE inline long double
log10(long double v)
{
#ifdef ARCANE_CHECK_MATH
  if (v==0.0 || v<0.0)
    arcaneMathError(v,"log");
#endif
  return std::log10(v);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
ARCCORE_HOST_DEVICE inline double
floor(double v)
{
  return std::floor(v);
}
 
ARCCORE_HOST_DEVICE inline long double
floor(long double v)
{
  return std::floor(v);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
ARCCORE_HOST_DEVICE inline double
exp(double v)
{
  return std::exp(v);
}
ARCCORE_HOST_DEVICE inline long double
exp(long double v)
{
  return std::exp(v);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
ARCCORE_HOST_DEVICE inline double
sqrt(double v)
{
#ifdef ARCANE_CHECK_MATH
  if (v<0.)
    arcaneMathError(v,"sqrt");
#endif
  return std::sqrt(v);
}
ARCCORE_HOST_DEVICE inline long double
sqrt(long double v)
{
#ifdef ARCANE_CHECK_MATH
  if (v<0.)
    arcaneMathError(v,"sqrt");
#endif
  return std::sqrt(v);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
ARCCORE_HOST_DEVICE inline double
pow(double x,double y)
{
#ifdef ARCANE_CHECK_MATH
  // Arguments invalides si x est négatif et y non entier
  if (x<0.0 && ::floor(y)!=y)
    arcaneMathError(x,y,"pow");
#endif
  return std::pow(x,y);
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
ARCCORE_HOST_DEVICE inline long double
pow(long double x,long double y)
{
#ifdef ARCANE_CHECK_MATH
  // Arguments invalides si x est négatif et y non entier
  if (x<0.0 && ::floorl(y)!=y)
    arcaneMathError(x,y,"pow");
#endif
  return std::pow(x,y);
}
ARCCORE_HOST_DEVICE inline long double
pow(double x,long double y)
{
#ifdef ARCANE_CHECK_MATH
  // Arguments invalides si x est négatif et y non entier
  if (x<0.0 && ::floorl(y)!=y)
    arcaneMathError(x,y,"pow");
#endif
  return std::pow(x,y);
}
ARCCORE_HOST_DEVICE inline long double
pow(long double x,double y)
{
#ifdef ARCANE_CHECK_MATH
  // Arguments invalides si x est négatif et y non entier
  if (x<0.0 && ::floor(y)!=y)
    arcaneMathError(x,y,"pow");
#endif
  return std::pow(x,y);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<class T> ARCCORE_HOST_DEVICE inline T
min(const T& a,const T& b)
{
  return ( (a<b) ? a : b );
}
ARCCORE_HOST_DEVICE inline long double
min(long double a,long double b)
{
  return ( (a<b) ? a : b );
}
ARCCORE_HOST_DEVICE inline long double
min(double a,long double b)
{
  return ( (a<b) ? a : b );
}
ARCCORE_HOST_DEVICE inline long double
min(long double a,double b)
{
  return ( (a<b) ? a : b );
}
ARCCORE_HOST_DEVICE inline double
min(double a,double b)
{
  return ( (a<b) ? a : b );
}
ARCCORE_HOST_DEVICE inline float
min(float a,float b)
{
  return ( (a<b) ? a : b );
}
ARCCORE_HOST_DEVICE inline int
min(int a,int b)
{
  return ( (a<b) ? a : b );
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<class T> ARCCORE_HOST_DEVICE inline T
max(const T& a,const T& b)
{
  return ( (a<b) ? b : a );
}
ARCCORE_HOST_DEVICE inline long double
max(long double a,long double b)
{
  return ( (a<b) ? b : a );
}
ARCCORE_HOST_DEVICE inline long double
max(double a,long double b)
{
  return ( (a<b) ? b : a );
}
ARCCORE_HOST_DEVICE inline long double
max(long double a,double b)
{
  return ( (a<b) ? b : a );
}
ARCCORE_HOST_DEVICE inline unsigned long
max(unsigned long a,unsigned long b)
{
  return ( (a<b) ? b : a );
}
ARCCORE_HOST_DEVICE inline double
max(double a,double b)
{
  return ( (a<b) ? b : a );
}
ARCCORE_HOST_DEVICE inline float
max(float a,float b)
{
  return ( (a<b) ? b : a );
}
ARCCORE_HOST_DEVICE inline Int16
max(Int16 a,Int16 b)
{
  return ( (a<b) ? b : a );
}
ARCCORE_HOST_DEVICE inline Int32
max(Int32 a,Int32 b)
{
  return ( (a<b) ? b : a );
}
ARCCORE_HOST_DEVICE inline Int64
max(Int32 a,Int64 b)
{
  return ( (a<b) ? b : a );
}
ARCCORE_HOST_DEVICE inline Int64
max(Int64 a,Int32 b)
{
  return ( (a<b) ? b : a );
}
ARCCORE_HOST_DEVICE inline Int64
max(Int64 a,Int64 b)
{
  return ( (a<b) ? b : a );
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
ARCCORE_HOST_DEVICE inline long double
abs(long double a)
{
  return std::abs(a);
}
ARCCORE_HOST_DEVICE inline double
abs(double a)
{
  return std::abs(a);
}
ARCCORE_HOST_DEVICE inline float
abs(float a)
{
  return std::abs(a);
}
 
ARCCORE_HOST_DEVICE inline short
abs(short a)
{
  return (a>0) ? a : (short)(-a);
}
 
ARCCORE_HOST_DEVICE inline int
abs(int a)
{
  return (a>0) ? a : (-a);
}
 
ARCCORE_HOST_DEVICE inline long
abs(long a)
{
  return (a>0L) ? a : (-a);
}
 
ARCCORE_HOST_DEVICE inline long long
abs(long long a)
{
  return (a>0LL) ? a : (-a);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
extern ARCANE_UTILS_EXPORT double
truncateDouble(double v,Integer nb_digit);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
extern ARCANE_UTILS_EXPORT void
truncateDouble(ArrayView<double> values,Integer nb_digit);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane::math
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#ifdef ARCANE_REAL_USE_APFLOAT
#include "arcane/utils/MathApfloat.h"
#endif
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif