Math.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* Math.h                                                      (C) 2000-2024 */
/*                                                                           */
/* Diverse mathematical functions.                                           */
/*---------------------------------------------------------------------------*/
#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
  // Invalid arguments if x is negative and y is not an integer
  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
  // Invalid arguments if x is negative and y is not an integer
  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
  // Invalid arguments if x is negative and y is not an integer
  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
  // Invalid arguments if x is negative and y is not an integer
  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