/* A GNU-like <math.h>.

   Copyright (C) 2002-2003, 2007-2018 Free Software Foundation, Inc.

   This program is free software: you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */

#ifndef _@GUARD_PREFIX@_MATH_H

#if __GNUC__ >= 3

@PRAGMA_SYSTEM_HEADER@

#endif

@PRAGMA_COLUMNS@

/* The include_next requires a split double-inclusion guard.  */

#@INCLUDE_NEXT_AS_FIRST_DIRECTIVE@ @NEXT_AS_FIRST_DIRECTIVE_MATH_H@

#ifndef _@GUARD_PREFIX@_MATH_H

#define _@GUARD_PREFIX@_MATH_H

/* On OpenVMS, NAN, INFINITY, and HUGEVAL macros are defined in <fp.h>.  */

#if defined __VMS && ! defined NAN

# include <fp.h>

#endif

#ifndef _GL_INLINE_HEADER_BEGIN

 #error "Please include config.h first."

#endif

_GL_INLINE_HEADER_BEGIN

#ifndef _GL_MATH_INLINE

# define _GL_MATH_INLINE _GL_INLINE

#endif

/* The definitions of _GL_FUNCDECL_RPL etc. are copied here.  */

/* The definition of _GL_ARG_NONNULL is copied here.  */

/* The definition of _GL_WARN_ON_USE is copied here.  */

#ifdef __cplusplus

/* Helper macros to define type-generic function FUNC as overloaded functions,

   rather than as macros like in C.  POSIX declares these with an argument of

   real-floating (that is, one of float, double, or long double).  */

# define _GL_MATH_CXX_REAL_FLOATING_DECL_1(func) \

static inline int                                                   \

_gl_cxx_ ## func ## f (float f)                                     \

{                                                                   \

  return func (f);                                                  \

}                                                                   \

static inline int                                                   \

_gl_cxx_ ## func ## d (double d)                                    \

{                                                                   \

  return func (d);                                                  \

}                                                                   \

static inline int                                                   \

_gl_cxx_ ## func ## l (long double l)                               \

{                                                                   \

  return func (l);                                                  \

}

# define _GL_MATH_CXX_REAL_FLOATING_DECL_2(func) \

_GL_BEGIN_NAMESPACE                                                 \

inline int                                                          \

func (float f)                                                      \

{                                                                   \

  return _gl_cxx_ ## func ## f (f);                                 \

}                                                                   \

inline int                                                          \

func (double d)                                                     \

{                                                                   \

  return _gl_cxx_ ## func ## d (d);                                 \

}                                                                   \

inline int                                                          \

func (long double l)                                                \

{                                                                   \

  return _gl_cxx_ ## func ## l (l);                                 \

}                                                                   \

_GL_END_NAMESPACE

#endif

/* Helper macros to define a portability warning for the

   classification macro FUNC called with VALUE.  POSIX declares the

   classification macros with an argument of real-floating (that is,

   one of float, double, or long double).  */

#define _GL_WARN_REAL_FLOATING_DECL(func) \

_GL_MATH_INLINE int                                                 \

rpl_ ## func ## f (float f)                                         \

{                                                                   \

  return func (f);                                                  \

}                                                                   \

_GL_MATH_INLINE int                                                 \

rpl_ ## func ## d (double d)                                        \

{                                                                   \

  return func (d);                                                  \

}                                                                   \

_GL_MATH_INLINE int                                                 \

rpl_ ## func ## l (long double l)                                   \

{                                                                   \

  return func (l);                                                  \

}                                                                   \

_GL_WARN_ON_USE (rpl_ ## func ## f, #func " is unportable - "       \

                 "use gnulib module " #func " for portability");    \

_GL_WARN_ON_USE (rpl_ ## func ## d, #func " is unportable - "       \

                 "use gnulib module " #func " for portability");    \

_GL_WARN_ON_USE (rpl_ ## func ## l, #func " is unportable - "       \

                 "use gnulib module " #func " for portability")

#define _GL_WARN_REAL_FLOATING_IMPL(func, value) \

  (sizeof (value) == sizeof (float) ? rpl_ ## func ## f (value)     \

   : sizeof (value) == sizeof (double) ? rpl_ ## func ## d (value)  \

   : rpl_ ## func ## l (value))

#if @REPLACE_ITOLD@

/* Pull in a function that fixes the 'int' to 'long double' conversion

   of glibc 2.7.  */

_GL_EXTERN_C void _Qp_itoq (long double *, int);

static void (*_gl_math_fix_itold) (long double *, int) = _Qp_itoq;

#endif

/* POSIX allows platforms that don't support NAN.  But all major

   machines in the past 15 years have supported something close to

   IEEE NaN, so we define this unconditionally.  We also must define

   it on platforms like Solaris 10, where NAN is present but defined

   as a function pointer rather than a floating point constant.  */

#if !defined NAN || @REPLACE_NAN@

# if !GNULIB_defined_NAN

#  undef NAN

  /* The Compaq (ex-DEC) C 6.4 compiler and the Microsoft MSVC 9 compiler

     choke on the expression 0.0 / 0.0.  */

#  if defined __DECC || defined _MSC_VER

_GL_MATH_INLINE float

_NaN ()

{

  static float zero = 0.0f;

  return zero / zero;

}

#   define NAN (_NaN())

#  else

#   define NAN (0.0f / 0.0f)

#  endif

#  define GNULIB_defined_NAN 1

# endif

#endif

/* Solaris 10 defines HUGE_VAL, but as a function pointer rather

   than a floating point constant.  */

#if @REPLACE_HUGE_VAL@

# undef HUGE_VALF

# define HUGE_VALF (1.0f / 0.0f)

# undef HUGE_VAL

# define HUGE_VAL (1.0 / 0.0)

# undef HUGE_VALL

# define HUGE_VALL (1.0L / 0.0L)

#endif

/* HUGE_VALF is a 'float' Infinity.  */

#ifndef HUGE_VALF

# if defined _MSC_VER

/* The Microsoft MSVC 9 compiler chokes on the expression 1.0f / 0.0f.  */

#  define HUGE_VALF (1e25f * 1e25f)

# else

#  define HUGE_VALF (1.0f / 0.0f)

# endif

#endif

/* HUGE_VAL is a 'double' Infinity.  */

#ifndef HUGE_VAL

# if defined _MSC_VER

/* The Microsoft MSVC 9 compiler chokes on the expression 1.0 / 0.0.  */

#  define HUGE_VAL (1e250 * 1e250)

# else

#  define HUGE_VAL (1.0 / 0.0)

# endif

#endif

/* HUGE_VALL is a 'long double' Infinity.  */

#ifndef HUGE_VALL

# if defined _MSC_VER

/* The Microsoft MSVC 9 compiler chokes on the expression 1.0L / 0.0L.  */

#  define HUGE_VALL (1e250L * 1e250L)

# else

#  define HUGE_VALL (1.0L / 0.0L)

# endif

#endif

#if defined FP_ILOGB0 && defined FP_ILOGBNAN

 /* Ensure FP_ILOGB0 and FP_ILOGBNAN are correct.  */

# if defined __HAIKU__

  /* Haiku: match what ilogb() does */

#  undef FP_ILOGB0

#  undef FP_ILOGBNAN

#  define FP_ILOGB0   (- 2147483647 - 1) /* INT_MIN */

#  define FP_ILOGBNAN (- 2147483647 - 1) /* INT_MIN */

# endif

#else

 /* Ensure FP_ILOGB0 and FP_ILOGBNAN are defined.  */

# if defined __NetBSD__ || defined __sgi

  /* NetBSD, IRIX 6.5: match what ilogb() does */

#  define FP_ILOGB0   (- 2147483647 - 1) /* INT_MIN */

#  define FP_ILOGBNAN (- 2147483647 - 1) /* INT_MIN */

# elif defined _AIX

  /* AIX 5.1: match what ilogb() does in AIX >= 5.2 */

#  define FP_ILOGB0   (- 2147483647 - 1) /* INT_MIN */

#  define FP_ILOGBNAN 2147483647 /* INT_MAX */

# elif defined __sun

  /* Solaris 9: match what ilogb() does */

#  define FP_ILOGB0   (- 2147483647) /* - INT_MAX */

#  define FP_ILOGBNAN 2147483647 /* INT_MAX */

# else

  /* Gnulib defined values.  */

#  define FP_ILOGB0   (- 2147483647) /* - INT_MAX */

#  define FP_ILOGBNAN (- 2147483647 - 1) /* INT_MIN */

# endif

#endif

#if @GNULIB_ACOSF@

# if @REPLACE_ACOSF@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef acosf

#   define acosf rpl_acosf

#  endif

_GL_FUNCDECL_RPL (acosf, float, (float x));

_GL_CXXALIAS_RPL (acosf, float, (float x));

# else

#  if !@HAVE_ACOSF@

#   undef acosf

_GL_FUNCDECL_SYS (acosf, float, (float x));

#  endif

_GL_CXXALIAS_SYS (acosf, float, (float x));

# endif

_GL_CXXALIASWARN (acosf);

#elif defined GNULIB_POSIXCHECK

# undef acosf

# if HAVE_RAW_DECL_ACOSF

_GL_WARN_ON_USE (acosf, "acosf is unportable - "

                 "use gnulib module acosf for portability");

# endif

#endif

#if @GNULIB_ACOSL@

# if !@HAVE_ACOSL@ || !@HAVE_DECL_ACOSL@

#  undef acosl

_GL_FUNCDECL_SYS (acosl, long double, (long double x));

# endif

_GL_CXXALIAS_SYS (acosl, long double, (long double x));

_GL_CXXALIASWARN (acosl);

#elif defined GNULIB_POSIXCHECK

# undef acosl

# if HAVE_RAW_DECL_ACOSL

_GL_WARN_ON_USE (acosl, "acosl is unportable - "

                 "use gnulib module acosl for portability");

# endif

#endif

#if @GNULIB_ASINF@

# if @REPLACE_ASINF@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef asinf

#   define asinf rpl_asinf

#  endif

_GL_FUNCDECL_RPL (asinf, float, (float x));

_GL_CXXALIAS_RPL (asinf, float, (float x));

# else

#  if !@HAVE_ASINF@

#   undef asinf

_GL_FUNCDECL_SYS (asinf, float, (float x));

#  endif

_GL_CXXALIAS_SYS (asinf, float, (float x));

# endif

_GL_CXXALIASWARN (asinf);

#elif defined GNULIB_POSIXCHECK

# undef asinf

# if HAVE_RAW_DECL_ASINF

_GL_WARN_ON_USE (asinf, "asinf is unportable - "

                 "use gnulib module asinf for portability");

# endif

#endif

#if @GNULIB_ASINL@

# if !@HAVE_ASINL@ || !@HAVE_DECL_ASINL@

#  undef asinl

_GL_FUNCDECL_SYS (asinl, long double, (long double x));

# endif

_GL_CXXALIAS_SYS (asinl, long double, (long double x));

_GL_CXXALIASWARN (asinl);

#elif defined GNULIB_POSIXCHECK

# undef asinl

# if HAVE_RAW_DECL_ASINL

_GL_WARN_ON_USE (asinl, "asinl is unportable - "

                 "use gnulib module asinl for portability");

# endif

#endif

#if @GNULIB_ATANF@

# if @REPLACE_ATANF@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef atanf

#   define atanf rpl_atanf

#  endif

_GL_FUNCDECL_RPL (atanf, float, (float x));

_GL_CXXALIAS_RPL (atanf, float, (float x));

# else

#  if !@HAVE_ATANF@

#   undef atanf

_GL_FUNCDECL_SYS (atanf, float, (float x));

#  endif

_GL_CXXALIAS_SYS (atanf, float, (float x));

# endif

_GL_CXXALIASWARN (atanf);

#elif defined GNULIB_POSIXCHECK

# undef atanf

# if HAVE_RAW_DECL_ATANF

_GL_WARN_ON_USE (atanf, "atanf is unportable - "

                 "use gnulib module atanf for portability");

# endif

#endif

#if @GNULIB_ATANL@

# if !@HAVE_ATANL@ || !@HAVE_DECL_ATANL@

#  undef atanl

_GL_FUNCDECL_SYS (atanl, long double, (long double x));

# endif

_GL_CXXALIAS_SYS (atanl, long double, (long double x));

_GL_CXXALIASWARN (atanl);

#elif defined GNULIB_POSIXCHECK

# undef atanl

# if HAVE_RAW_DECL_ATANL

_GL_WARN_ON_USE (atanl, "atanl is unportable - "

                 "use gnulib module atanl for portability");

# endif

#endif

#if @GNULIB_ATAN2F@

# if @REPLACE_ATAN2F@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef atan2f

#   define atan2f rpl_atan2f

#  endif

_GL_FUNCDECL_RPL (atan2f, float, (float y, float x));

_GL_CXXALIAS_RPL (atan2f, float, (float y, float x));

# else

#  if !@HAVE_ATAN2F@

#   undef atan2f

_GL_FUNCDECL_SYS (atan2f, float, (float y, float x));

#  endif

_GL_CXXALIAS_SYS (atan2f, float, (float y, float x));

# endif

_GL_CXXALIASWARN (atan2f);

#elif defined GNULIB_POSIXCHECK

# undef atan2f

# if HAVE_RAW_DECL_ATAN2F

_GL_WARN_ON_USE (atan2f, "atan2f is unportable - "

                 "use gnulib module atan2f for portability");

# endif

#endif

#if @GNULIB_CBRTF@

# if @REPLACE_CBRTF@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef cbrtf

#   define cbrtf rpl_cbrtf

#  endif

_GL_FUNCDECL_RPL (cbrtf, float, (float x));

_GL_CXXALIAS_RPL (cbrtf, float, (float x));

# else

#  if !@HAVE_DECL_CBRTF@

_GL_FUNCDECL_SYS (cbrtf, float, (float x));

#  endif

_GL_CXXALIAS_SYS (cbrtf, float, (float x));

# endif

_GL_CXXALIASWARN (cbrtf);

#elif defined GNULIB_POSIXCHECK

# undef cbrtf

# if HAVE_RAW_DECL_CBRTF

_GL_WARN_ON_USE (cbrtf, "cbrtf is unportable - "

                 "use gnulib module cbrtf for portability");

# endif

#endif

#if @GNULIB_CBRT@

# if !@HAVE_CBRT@

_GL_FUNCDECL_SYS (cbrt, double, (double x));

# endif

_GL_CXXALIAS_SYS (cbrt, double, (double x));

_GL_CXXALIASWARN (cbrt);

#elif defined GNULIB_POSIXCHECK

# undef cbrt

# if HAVE_RAW_DECL_CBRT

_GL_WARN_ON_USE (cbrt, "cbrt is unportable - "

                 "use gnulib module cbrt for portability");

# endif

#endif

#if @GNULIB_CBRTL@

# if @REPLACE_CBRTL@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef cbrtl

#   define cbrtl rpl_cbrtl

#  endif

_GL_FUNCDECL_RPL (cbrtl, long double, (long double x));

_GL_CXXALIAS_RPL (cbrtl, long double, (long double x));

# else

#  if !@HAVE_DECL_CBRTL@

_GL_FUNCDECL_SYS (cbrtl, long double, (long double x));

#  endif

_GL_CXXALIAS_SYS (cbrtl, long double, (long double x));

# endif

_GL_CXXALIASWARN (cbrtl);

#elif defined GNULIB_POSIXCHECK

# undef cbrtl

# if HAVE_RAW_DECL_CBRTL

_GL_WARN_ON_USE (cbrtl, "cbrtl is unportable - "

                 "use gnulib module cbrtl for portability");

# endif

#endif

#if @GNULIB_CEILF@

# if @REPLACE_CEILF@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef ceilf

#   define ceilf rpl_ceilf

#  endif

_GL_FUNCDECL_RPL (ceilf, float, (float x));

_GL_CXXALIAS_RPL (ceilf, float, (float x));

# else

#  if !@HAVE_DECL_CEILF@

#   undef ceilf

_GL_FUNCDECL_SYS (ceilf, float, (float x));

#  endif

_GL_CXXALIAS_SYS (ceilf, float, (float x));

# endif

_GL_CXXALIASWARN (ceilf);

#elif defined GNULIB_POSIXCHECK

# undef ceilf

# if HAVE_RAW_DECL_CEILF

_GL_WARN_ON_USE (ceilf, "ceilf is unportable - "

                 "use gnulib module ceilf for portability");

# endif

#endif

#if @GNULIB_CEIL@

# if @REPLACE_CEIL@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef ceil

#   define ceil rpl_ceil

#  endif

_GL_FUNCDECL_RPL (ceil, double, (double x));

_GL_CXXALIAS_RPL (ceil, double, (double x));

# else

_GL_CXXALIAS_SYS (ceil, double, (double x));

# endif

_GL_CXXALIASWARN (ceil);

#endif

#if @GNULIB_CEILL@

# if @REPLACE_CEILL@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef ceill

#   define ceill rpl_ceill

#  endif

_GL_FUNCDECL_RPL (ceill, long double, (long double x));

_GL_CXXALIAS_RPL (ceill, long double, (long double x));

# else

#  if !@HAVE_DECL_CEILL@

#   undef ceill

_GL_FUNCDECL_SYS (ceill, long double, (long double x));

#  endif

_GL_CXXALIAS_SYS (ceill, long double, (long double x));

# endif

_GL_CXXALIASWARN (ceill);

#elif defined GNULIB_POSIXCHECK

# undef ceill

# if HAVE_RAW_DECL_CEILL

_GL_WARN_ON_USE (ceill, "ceill is unportable - "

                 "use gnulib module ceill for portability");

# endif

#endif

#if @GNULIB_COPYSIGNF@

# if !@HAVE_DECL_COPYSIGNF@

_GL_FUNCDECL_SYS (copysignf, float, (float x, float y));

# endif

_GL_CXXALIAS_SYS (copysignf, float, (float x, float y));

_GL_CXXALIASWARN (copysignf);

#elif defined GNULIB_POSIXCHECK

# undef copysignf

# if HAVE_RAW_DECL_COPYSIGNF

_GL_WARN_ON_USE (copysignf, "copysignf is unportable - "

                 "use gnulib module copysignf for portability");

# endif

#endif

#if @GNULIB_COPYSIGN@

# if !@HAVE_COPYSIGN@

_GL_FUNCDECL_SYS (copysign, double, (double x, double y));

# endif

_GL_CXXALIAS_SYS (copysign, double, (double x, double y));

_GL_CXXALIASWARN (copysign);

#elif defined GNULIB_POSIXCHECK

# undef copysign

# if HAVE_RAW_DECL_COPYSIGN

_GL_WARN_ON_USE (copysign, "copysign is unportable - "

                 "use gnulib module copysign for portability");

# endif

#endif

#if @GNULIB_COPYSIGNL@

# if !@HAVE_COPYSIGNL@

_GL_FUNCDECL_SYS (copysignl, long double, (long double x, long double y));

# endif

_GL_CXXALIAS_SYS (copysignl, long double, (long double x, long double y));

_GL_CXXALIASWARN (copysignl);

#elif defined GNULIB_POSIXCHECK

# undef copysignl

# if HAVE_RAW_DECL_COPYSIGNL

_GL_WARN_ON_USE (copysign, "copysignl is unportable - "

                 "use gnulib module copysignl for portability");

# endif

#endif

#if @GNULIB_COSF@

# if @REPLACE_COSF@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef cosf

#   define cosf rpl_cosf

#  endif

_GL_FUNCDECL_RPL (cosf, float, (float x));

_GL_CXXALIAS_RPL (cosf, float, (float x));

# else

#  if !@HAVE_COSF@

#   undef cosf

_GL_FUNCDECL_SYS (cosf, float, (float x));

#  endif

_GL_CXXALIAS_SYS (cosf, float, (float x));

# endif

_GL_CXXALIASWARN (cosf);

#elif defined GNULIB_POSIXCHECK

# undef cosf

# if HAVE_RAW_DECL_COSF

_GL_WARN_ON_USE (cosf, "cosf is unportable - "

                 "use gnulib module cosf for portability");

# endif

#endif

#if @GNULIB_COSL@

# if !@HAVE_COSL@ || !@HAVE_DECL_COSL@

#  undef cosl

_GL_FUNCDECL_SYS (cosl, long double, (long double x));

# endif

_GL_CXXALIAS_SYS (cosl, long double, (long double x));

_GL_CXXALIASWARN (cosl);

#elif defined GNULIB_POSIXCHECK

# undef cosl

# if HAVE_RAW_DECL_COSL

_GL_WARN_ON_USE (cosl, "cosl is unportable - "

                 "use gnulib module cosl for portability");

# endif

#endif

#if @GNULIB_COSHF@

# if @REPLACE_COSHF@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef coshf

#   define coshf rpl_coshf

#  endif

_GL_FUNCDECL_RPL (coshf, float, (float x));

_GL_CXXALIAS_RPL (coshf, float, (float x));

# else

#  if !@HAVE_COSHF@

#   undef coshf

_GL_FUNCDECL_SYS (coshf, float, (float x));

#  endif

_GL_CXXALIAS_SYS (coshf, float, (float x));

# endif

_GL_CXXALIASWARN (coshf);

#elif defined GNULIB_POSIXCHECK

# undef coshf

# if HAVE_RAW_DECL_COSHF

_GL_WARN_ON_USE (coshf, "coshf is unportable - "

                 "use gnulib module coshf for portability");

# endif

#endif

#if @GNULIB_EXPF@

# if @REPLACE_EXPF@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef expf

#   define expf rpl_expf

#  endif

_GL_FUNCDECL_RPL (expf, float, (float x));

_GL_CXXALIAS_RPL (expf, float, (float x));

# else

#  if !@HAVE_EXPF@

#   undef expf

_GL_FUNCDECL_SYS (expf, float, (float x));

#  endif

_GL_CXXALIAS_SYS (expf, float, (float x));

# endif

_GL_CXXALIASWARN (expf);

#elif defined GNULIB_POSIXCHECK

# undef expf

# if HAVE_RAW_DECL_EXPF

_GL_WARN_ON_USE (expf, "expf is unportable - "

                 "use gnulib module expf for portability");

# endif

#endif

#if @GNULIB_EXPL@

# if !@HAVE_EXPL@ || !@HAVE_DECL_EXPL@

#  undef expl

_GL_FUNCDECL_SYS (expl, long double, (long double x));

# endif

_GL_CXXALIAS_SYS (expl, long double, (long double x));

_GL_CXXALIASWARN (expl);

#elif defined GNULIB_POSIXCHECK

# undef expl

# if HAVE_RAW_DECL_EXPL

_GL_WARN_ON_USE (expl, "expl is unportable - "

                 "use gnulib module expl for portability");

# endif

#endif

#if @GNULIB_EXP2F@

# if !@HAVE_DECL_EXP2F@

_GL_FUNCDECL_SYS (exp2f, float, (float x));

# endif

_GL_CXXALIAS_SYS (exp2f, float, (float x));

_GL_CXXALIASWARN (exp2f);

#elif defined GNULIB_POSIXCHECK

# undef exp2f

# if HAVE_RAW_DECL_EXP2F

_GL_WARN_ON_USE (exp2f, "exp2f is unportable - "

                 "use gnulib module exp2f for portability");

# endif

#endif

#if @GNULIB_EXP2@

# if @REPLACE_EXP2@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef exp2

#   define exp2 rpl_exp2

#  endif

_GL_FUNCDECL_RPL (exp2, double, (double x));

_GL_CXXALIAS_RPL (exp2, double, (double x));

# else

#  if !@HAVE_DECL_EXP2@

_GL_FUNCDECL_SYS (exp2, double, (double x));

#  endif

_GL_CXXALIAS_SYS (exp2, double, (double x));

# endif

_GL_CXXALIASWARN (exp2);

#elif defined GNULIB_POSIXCHECK

# undef exp2

# if HAVE_RAW_DECL_EXP2

_GL_WARN_ON_USE (exp2, "exp2 is unportable - "

                 "use gnulib module exp2 for portability");

# endif

#endif

#if @GNULIB_EXP2L@

# if @REPLACE_EXP2L@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef exp2l

#   define exp2l rpl_exp2l

#  endif

_GL_FUNCDECL_RPL (exp2l, long double, (long double x));

_GL_CXXALIAS_RPL (exp2l, long double, (long double x));

# else

#  if !@HAVE_DECL_EXP2L@

#   undef exp2l

_GL_FUNCDECL_SYS (exp2l, long double, (long double x));

#  endif

_GL_CXXALIAS_SYS (exp2l, long double, (long double x));

# endif

_GL_CXXALIASWARN (exp2l);

#elif defined GNULIB_POSIXCHECK

# undef exp2l

# if HAVE_RAW_DECL_EXP2L

_GL_WARN_ON_USE (exp2l, "exp2l is unportable - "

                 "use gnulib module exp2l for portability");

# endif

#endif

#if @GNULIB_EXPM1F@

# if @REPLACE_EXPM1F@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef expm1f

#   define expm1f rpl_expm1f

#  endif

_GL_FUNCDECL_RPL (expm1f, float, (float x));

_GL_CXXALIAS_RPL (expm1f, float, (float x));

# else

#  if !@HAVE_EXPM1F@

_GL_FUNCDECL_SYS (expm1f, float, (float x));

#  endif

_GL_CXXALIAS_SYS (expm1f, float, (float x));

# endif

_GL_CXXALIASWARN (expm1f);

#elif defined GNULIB_POSIXCHECK

# undef expm1f

# if HAVE_RAW_DECL_EXPM1F

_GL_WARN_ON_USE (expm1f, "expm1f is unportable - "

                 "use gnulib module expm1f for portability");

# endif

#endif

#if @GNULIB_EXPM1@

# if @REPLACE_EXPM1@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef expm1

#   define expm1 rpl_expm1

#  endif

_GL_FUNCDECL_RPL (expm1, double, (double x));

_GL_CXXALIAS_RPL (expm1, double, (double x));

# else

#  if !@HAVE_EXPM1@

_GL_FUNCDECL_SYS (expm1, double, (double x));

#  endif

_GL_CXXALIAS_SYS (expm1, double, (double x));

# endif

_GL_CXXALIASWARN (expm1);

#elif defined GNULIB_POSIXCHECK

# undef expm1

# if HAVE_RAW_DECL_EXPM1

_GL_WARN_ON_USE (expm1, "expm1 is unportable - "

                 "use gnulib module expm1 for portability");

# endif

#endif

#if @GNULIB_EXPM1L@

# if !@HAVE_DECL_EXPM1L@

#  undef expm1l

_GL_FUNCDECL_SYS (expm1l, long double, (long double x));

# endif

_GL_CXXALIAS_SYS (expm1l, long double, (long double x));

_GL_CXXALIASWARN (expm1l);

#elif defined GNULIB_POSIXCHECK

# undef expm1l

# if HAVE_RAW_DECL_EXPM1L

_GL_WARN_ON_USE (expm1l, "expm1l is unportable - "

                 "use gnulib module expm1l for portability");

# endif

#endif

#if @GNULIB_FABSF@

# if !@HAVE_FABSF@

#  undef fabsf

_GL_FUNCDECL_SYS (fabsf, float, (float x));

# endif

_GL_CXXALIAS_SYS (fabsf, float, (float x));

_GL_CXXALIASWARN (fabsf);

#elif defined GNULIB_POSIXCHECK

# undef fabsf

# if HAVE_RAW_DECL_FABSF

_GL_WARN_ON_USE (fabsf, "fabsf is unportable - "

                 "use gnulib module fabsf for portability");

# endif

#endif

#if @GNULIB_FABSL@

# if @REPLACE_FABSL@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef fabsl

#   define fabsl rpl_fabsl

#  endif

_GL_FUNCDECL_RPL (fabsl, long double, (long double x));

_GL_CXXALIAS_RPL (fabsl, long double, (long double x));

# else

#  if !@HAVE_FABSL@

#   undef fabsl

_GL_FUNCDECL_SYS (fabsl, long double, (long double x));

#  endif

_GL_CXXALIAS_SYS (fabsl, long double, (long double x));

# endif

_GL_CXXALIASWARN (fabsl);

#elif defined GNULIB_POSIXCHECK

# undef fabsl

# if HAVE_RAW_DECL_FABSL

_GL_WARN_ON_USE (fabsl, "fabsl is unportable - "

                 "use gnulib module fabsl for portability");

# endif

#endif

#if @GNULIB_FLOORF@

# if @REPLACE_FLOORF@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef floorf

#   define floorf rpl_floorf

#  endif

_GL_FUNCDECL_RPL (floorf, float, (float x));

_GL_CXXALIAS_RPL (floorf, float, (float x));

# else

#  if !@HAVE_DECL_FLOORF@

#   undef floorf

_GL_FUNCDECL_SYS (floorf, float, (float x));

#  endif

_GL_CXXALIAS_SYS (floorf, float, (float x));

# endif

_GL_CXXALIASWARN (floorf);

#elif defined GNULIB_POSIXCHECK

# undef floorf

# if HAVE_RAW_DECL_FLOORF

_GL_WARN_ON_USE (floorf, "floorf is unportable - "

                 "use gnulib module floorf for portability");

# endif

#endif

#if @GNULIB_FLOOR@

# if @REPLACE_FLOOR@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef floor

#   define floor rpl_floor

#  endif

_GL_FUNCDECL_RPL (floor, double, (double x));

_GL_CXXALIAS_RPL (floor, double, (double x));

# else

_GL_CXXALIAS_SYS (floor, double, (double x));

# endif

_GL_CXXALIASWARN (floor);

#endif

#if @GNULIB_FLOORL@

# if @REPLACE_FLOORL@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef floorl

#   define floorl rpl_floorl

#  endif

_GL_FUNCDECL_RPL (floorl, long double, (long double x));

_GL_CXXALIAS_RPL (floorl, long double, (long double x));

# else

#  if !@HAVE_DECL_FLOORL@

#   undef floorl

_GL_FUNCDECL_SYS (floorl, long double, (long double x));

#  endif

_GL_CXXALIAS_SYS (floorl, long double, (long double x));

# endif

_GL_CXXALIASWARN (floorl);

#elif defined GNULIB_POSIXCHECK

# undef floorl

# if HAVE_RAW_DECL_FLOORL

_GL_WARN_ON_USE (floorl, "floorl is unportable - "

                 "use gnulib module floorl for portability");

# endif

#endif

#if @GNULIB_FMAF@

# if @REPLACE_FMAF@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef fmaf

#   define fmaf rpl_fmaf

#  endif

_GL_FUNCDECL_RPL (fmaf, float, (float x, float y, float z));

_GL_CXXALIAS_RPL (fmaf, float, (float x, float y, float z));

# else