[bpt/guile.git] / m4 / mathfunc.m4

# mathfunc.m4 serial 11
dnl Copyright (C) 2010-2013 Free Software Foundation, Inc.
dnl This file is free software; the Free Software Foundation
dnl gives unlimited permission to copy and/or distribute it,
dnl with or without modifications, as long as this notice is preserved.

# gl_MATHFUNC(FUNC, RETTYPE, PARAMTYPES [, INCLUDES] [, EXTRA-CODE])
# ------------------------------------------------------------------
# tests whether the function FUNC is available in libc or libm.
# RETTYPE is the return type. PARAMTYPES is a parameter list, with parentheses.
# It sets FUNC_LIBM to empty or "-lm" accordingly.

AC_DEFUN([gl_MATHFUNC],
[
  dnl We need the RETTYPE and PARAMTYPES in order to force linking with the
  dnl function.
  dnl 1) With gcc >= 4.3 on glibc/x86_64, calls to the 'fabs' function
  dnl    are inlined by the compiler, therefore linking of these calls does
  dnl    not require -lm, but taking the function pointer of 'fabs' does.
  dnl 2) On MSVC 9, many math functions exist only as macros with arguments,
  dnl    whereas the function pointer is undefined.
  dnl On the other hand, taking just the function pointer is not enough.
  dnl 1) On AIX 7.1, when 'long double' is 128 bit large ("xlc -qldbl128" or
  dnl    "xlc -qlongdouble" or "gcc -mlong-double-128") many math functions
  dnl    exist as macros with arguments, that may reference libm or even
  dnl    completely undefined functions such as __rint128.
  dnl 2) In AIX 7.1 with gcc 4.2, when optimization is turned on, calls to
  dnl    rint() with simple arguments are turned into rintf() calls by the
  dnl    compiler. But while rint() is resides in libc, rintf() is in libm.
  m4_pushdef([func], [$1])
  m4_pushdef([FUNC], [m4_translit([$1],[abcdefghijklmnopqrstuvwxyz],
                                       [ABCDEFGHIJKLMNOPQRSTUVWXYZ])])
  m4_pushdef([ARGS], [m4_bpatsubst(
                        [m4_bpatsubst(
                           [m4_bpatsubst(
                              [m4_bpatsubst(
                                 [m4_bpatsubst(
                                    [m4_bpatsubst(
                                       [m4_bpatsubst(
                                          [m4_bpatsubst(
                                             [m4_bpatsubst(
                                                [$3],
                                                [int \*], [&i_ret])],
                                             [float \*], [&f_ret])],
                                          [double \*], [&d_ret])],
                                       [long double \*], [&l_ret])],
                                    [int], [2])],
                                 [float], [1.618034f])],
                              [long double], [1.618033988749894848L])],
                           [double], [1.6180339887])],
                        [void], [])])
  FUNC[]_LIBM=
  AC_CACHE_CHECK([whether func() can be used without linking with libm],
    [gl_cv_func_]func[_no_libm],
    [
      AC_LINK_IFELSE(
        [AC_LANG_PROGRAM(
           [[#ifndef __NO_MATH_INLINES
             # define __NO_MATH_INLINES 1 /* for glibc */
             #endif
             #include <math.h>
             $4
             $2 (*funcptr) $3 = ]func[;
             int i_ret;
             float f_ret;
             double d_ret;
             long double l_ret;]],
           [[$2 y = funcptr ]ARGS[ + ]func[ ]ARGS[;
             $5
             return y < 0.3 || y > 1.7;
           ]])],
        [gl_cv_func_]func[_no_libm=yes],
        [gl_cv_func_]func[_no_libm=no])
    ])
  if test $gl_cv_func_[]func[]_no_libm = no; then
    AC_CACHE_CHECK([whether func() can be used with libm],
      [gl_cv_func_]func[_in_libm],
      [
        save_LIBS="$LIBS"
        LIBS="$LIBS -lm"
        AC_LINK_IFELSE(
          [AC_LANG_PROGRAM(
             [[#ifndef __NO_MATH_INLINES
               # define __NO_MATH_INLINES 1 /* for glibc */
               #endif
               #include <math.h>
               $4
               $2 (*funcptr) $3 = ]func[;
               int i_ret;
               float f_ret;
               double d_ret;
               long double l_ret;]],
             [[$2 y = funcptr ]ARGS[ + ]func[ ]ARGS[;
               $5
               return y < 0.3 || y > 1.7;
             ]])],
          [gl_cv_func_]func[_in_libm=yes],
          [gl_cv_func_]func[_in_libm=no])
        LIBS="$save_LIBS"
      ])
    if test $gl_cv_func_[]func[]_in_libm = yes; then
      FUNC[]_LIBM=-lm
    fi
  fi
  AC_SUBST(FUNC[_LIBM])
  m4_popdef([ARGS])
  m4_popdef([FUNC])
  m4_popdef([func])
])

# gl_COMMON_DOUBLE_MATHFUNC(FUNC)
# -------------------------------
# tests whether the function FUNC is available in libc or libm.
# It sets FUNC_LIBM to empty or "-lm" accordingly.
# FUNC must be one of the following functions, that are present on all systems
# and provided by libm on all systems except Mac OS X, BeOS, Haiku:
#   acos asin atan atan2 cbrt cos cosh erf erfc exp fmod hypot j0 j1 jn lgamma
#   log log10 log1p pow remainder sin sinh sqrt tan tanh y0 y1 yn

AC_DEFUN([gl_COMMON_DOUBLE_MATHFUNC],
[
  AC_REQUIRE([gl_COMMON_DOUBLE_MATHFUNC_TEST])
  m4_pushdef([FUNC], [m4_translit([$1],[abcdefghijklmnopqrstuvwxyz],
                                       [ABCDEFGHIJKLMNOPQRSTUVWXYZ])])
  FUNC[]_LIBM="$POW_LIBM"
  AC_SUBST(FUNC[_LIBM])
  m4_popdef([FUNC])
])

AC_DEFUN([gl_COMMON_DOUBLE_MATHFUNC_TEST],
[
  dnl We could use any of the following:
  dnl gl_MATHFUNC([acos], [double], [(double)])
  dnl gl_MATHFUNC([asin], [double], [(double)])
  dnl gl_MATHFUNC([atan], [double], [(double)])
  dnl gl_MATHFUNC([atan2], [double], [(double, double)])
  dnl gl_MATHFUNC([cbrt], [double], [(double)])
  dnl gl_MATHFUNC([cos], [double], [(double)])
  dnl gl_MATHFUNC([cosh], [double], [(double)])
  dnl gl_MATHFUNC([erf], [double], [(double)])
  dnl gl_MATHFUNC([erfc], [double], [(double)])
  dnl gl_MATHFUNC([exp], [double], [(double)])
  dnl gl_MATHFUNC([fmod], [double], [(double, double)])
  dnl gl_MATHFUNC([hypot], [double], [(double, double)])
  dnl gl_MATHFUNC([j0], [double], [(double)])
  dnl gl_MATHFUNC([j1], [double], [(double)])
  dnl gl_MATHFUNC([jn], [double], [(int, double)])
  dnl gl_MATHFUNC([lgamma], [double], [(double)])
  dnl gl_MATHFUNC([log], [double], [(double)])
  dnl gl_MATHFUNC([log10], [double], [(double)])
  dnl gl_MATHFUNC([log1p], [double], [(double)])
  dnl gl_MATHFUNC([pow], [double], [(double, double)])
  dnl gl_MATHFUNC([remainder], [double], [(double, double)])
  dnl gl_MATHFUNC([sin], [double], [(double)])
  dnl gl_MATHFUNC([sinh], [double], [(double)])
  dnl gl_MATHFUNC([sqrt], [double], [(double)])
  dnl gl_MATHFUNC([tan], [double], [(double)])
  dnl gl_MATHFUNC([tanh], [double], [(double)])
  dnl gl_MATHFUNC([y0], [double], [(double)])
  dnl gl_MATHFUNC([y1], [double], [(double)])
  dnl gl_MATHFUNC([yn], [double], [(int, double)])
  gl_MATHFUNC([pow], [double], [(double, double)])
])
Commit	Line	Data
005de2e8	1	# mathfunc.m4 serial 11
af07e104	2	dnl Copyright (C) 2010-2013 Free Software Foundation, Inc.
b81eb646 LC	3	dnl This file is free software; the Free Software Foundation
	4	dnl gives unlimited permission to copy and/or distribute it,
	5	dnl with or without modifications, as long as this notice is preserved.
	6
7f1ea859 LC	7	# gl_MATHFUNC(FUNC, RETTYPE, PARAMTYPES [, INCLUDES] [, EXTRA-CODE])
7f1ea859 LC	8	# ------------------------------------------------------------------
b81eb646 LC	9	# tests whether the function FUNC is available in libc or libm.
	10	# RETTYPE is the return type. PARAMTYPES is a parameter list, with parentheses.
	11	# It sets FUNC_LIBM to empty or "-lm" accordingly.
	12
	13	AC_DEFUN([gl_MATHFUNC],
	14	[
	15	dnl We need the RETTYPE and PARAMTYPES in order to force linking with the
35428fb6 LC	16	dnl function.
	17	dnl 1) With gcc >= 4.3 on glibc/x86_64, calls to the 'fabs' function
	18	dnl are inlined by the compiler, therefore linking of these calls does
	19	dnl not require -lm, but taking the function pointer of 'fabs' does.
	20	dnl 2) On MSVC 9, many math functions exist only as macros with arguments,
	21	dnl whereas the function pointer is undefined.
	22	dnl On the other hand, taking just the function pointer is not enough.
	23	dnl 1) On AIX 7.1, when 'long double' is 128 bit large ("xlc -qldbl128" or
	24	dnl "xlc -qlongdouble" or "gcc -mlong-double-128") many math functions
	25	dnl exist as macros with arguments, that may reference libm or even
	26	dnl completely undefined functions such as __rint128.
	27	dnl 2) In AIX 7.1 with gcc 4.2, when optimization is turned on, calls to
	28	dnl rint() with simple arguments are turned into rintf() calls by the
	29	dnl compiler. But while rint() is resides in libc, rintf() is in libm.
b81eb646 LC	30	m4_pushdef([func], [$1])
	31	m4_pushdef([FUNC], [m4_translit([$1],[abcdefghijklmnopqrstuvwxyz],
	32	[ABCDEFGHIJKLMNOPQRSTUVWXYZ])])
35428fb6 LC	33	m4_pushdef([ARGS], [m4_bpatsubst(
	34	[m4_bpatsubst(
	35	[m4_bpatsubst(
	36	[m4_bpatsubst(
	37	[m4_bpatsubst(
	38	[m4_bpatsubst(
	39	[m4_bpatsubst(
	40	[m4_bpatsubst(
7f1ea859 LC	41	[m4_bpatsubst(
	42	[$3],
	43	[int \*], [&i_ret])],
	44	[float \*], [&f_ret])],
	45	[double \*], [&d_ret])],
	46	[long double \*], [&l_ret])],
	47	[int], [2])],
	48	[float], [1.618034f])],
	49	[long double], [1.618033988749894848L])],
	50	[double], [1.6180339887])],
	51	[void], [])])
b81eb646 LC	52	FUNC[]_LIBM=
	53	AC_CACHE_CHECK([whether func() can be used without linking with libm],
	54	[gl_cv_func_]func[_no_libm],
	55	[
	56	AC_LINK_IFELSE(
	57	[AC_LANG_PROGRAM(
	58	[[#ifndef __NO_MATH_INLINES
	59	# define __NO_MATH_INLINES 1 /* for glibc */
	60	#endif
	61	#include <math.h>
7f1ea859	62	$4
b81eb646	63	$2 (*funcptr) $3 = ]func[;
35428fb6 LC	64	int i_ret;
	65	float f_ret;
	66	double d_ret;
	67	long double l_ret;]],
	68	[[$2 y = funcptr ]ARGS[ + ]func[ ]ARGS[;
7f1ea859	69	$5
b81eb646 LC	70	return y < 0.3 \|\| y > 1.7;
	71	]])],
	72	[gl_cv_func_]func[_no_libm=yes],
	73	[gl_cv_func_]func[_no_libm=no])
	74	])
	75	if test $gl_cv_func_[]func[]_no_libm = no; then
	76	AC_CACHE_CHECK([whether func() can be used with libm],
	77	[gl_cv_func_]func[_in_libm],
	78	[
	79	save_LIBS="$LIBS"
	80	LIBS="$LIBS -lm"
	81	AC_LINK_IFELSE(
	82	[AC_LANG_PROGRAM(
	83	[[#ifndef __NO_MATH_INLINES
	84	# define __NO_MATH_INLINES 1 /* for glibc */
	85	#endif
	86	#include <math.h>
7f1ea859	87	$4
b81eb646	88	$2 (*funcptr) $3 = ]func[;
35428fb6 LC	89	int i_ret;
	90	float f_ret;
	91	double d_ret;
	92	long double l_ret;]],
	93	[[$2 y = funcptr ]ARGS[ + ]func[ ]ARGS[;
7f1ea859	94	$5
b81eb646 LC	95	return y < 0.3 \|\| y > 1.7;
	96	]])],
	97	[gl_cv_func_]func[_in_libm=yes],
	98	[gl_cv_func_]func[_in_libm=no])
	99	LIBS="$save_LIBS"
	100	])
	101	if test $gl_cv_func_[]func[]_in_libm = yes; then
	102	FUNC[]_LIBM=-lm
	103	fi
	104	fi
	105	AC_SUBST(FUNC[_LIBM])
35428fb6	106	m4_popdef([ARGS])
b81eb646 LC	107	m4_popdef([FUNC])
	108	m4_popdef([func])
	109	])
	110
	111	# gl_COMMON_DOUBLE_MATHFUNC(FUNC)
	112	# -------------------------------
	113	# tests whether the function FUNC is available in libc or libm.
	114	# It sets FUNC_LIBM to empty or "-lm" accordingly.
	115	# FUNC must be one of the following functions, that are present on all systems
005de2e8	116	# and provided by libm on all systems except Mac OS X, BeOS, Haiku:
b81eb646 LC	117	# acos asin atan atan2 cbrt cos cosh erf erfc exp fmod hypot j0 j1 jn lgamma
	118	# log log10 log1p pow remainder sin sinh sqrt tan tanh y0 y1 yn
	119
	120	AC_DEFUN([gl_COMMON_DOUBLE_MATHFUNC],
	121	[
	122	AC_REQUIRE([gl_COMMON_DOUBLE_MATHFUNC_TEST])
	123	m4_pushdef([FUNC], [m4_translit([$1],[abcdefghijklmnopqrstuvwxyz],
	124	[ABCDEFGHIJKLMNOPQRSTUVWXYZ])])
	125	FUNC[]_LIBM="$POW_LIBM"
	126	AC_SUBST(FUNC[_LIBM])
	127	m4_popdef([FUNC])
	128	])
	129
	130	AC_DEFUN([gl_COMMON_DOUBLE_MATHFUNC_TEST],
	131	[
	132	dnl We could use any of the following:
	133	dnl gl_MATHFUNC([acos], [double], [(double)])
	134	dnl gl_MATHFUNC([asin], [double], [(double)])
	135	dnl gl_MATHFUNC([atan], [double], [(double)])
	136	dnl gl_MATHFUNC([atan2], [double], [(double, double)])
	137	dnl gl_MATHFUNC([cbrt], [double], [(double)])
	138	dnl gl_MATHFUNC([cos], [double], [(double)])
	139	dnl gl_MATHFUNC([cosh], [double], [(double)])
	140	dnl gl_MATHFUNC([erf], [double], [(double)])
	141	dnl gl_MATHFUNC([erfc], [double], [(double)])
	142	dnl gl_MATHFUNC([exp], [double], [(double)])
	143	dnl gl_MATHFUNC([fmod], [double], [(double, double)])
	144	dnl gl_MATHFUNC([hypot], [double], [(double, double)])
	145	dnl gl_MATHFUNC([j0], [double], [(double)])
	146	dnl gl_MATHFUNC([j1], [double], [(double)])
	147	dnl gl_MATHFUNC([jn], [double], [(int, double)])
	148	dnl gl_MATHFUNC([lgamma], [double], [(double)])
	149	dnl gl_MATHFUNC([log], [double], [(double)])
	150	dnl gl_MATHFUNC([log10], [double], [(double)])
	151	dnl gl_MATHFUNC([log1p], [double], [(double)])
	152	dnl gl_MATHFUNC([pow], [double], [(double, double)])
	153	dnl gl_MATHFUNC([remainder], [double], [(double, double)])
	154	dnl gl_MATHFUNC([sin], [double], [(double)])
	155	dnl gl_MATHFUNC([sinh], [double], [(double)])
	156	dnl gl_MATHFUNC([sqrt], [double], [(double)])
	157	dnl gl_MATHFUNC([tan], [double], [(double)])
	158	dnl gl_MATHFUNC([tanh], [double], [(double)])
	159	dnl gl_MATHFUNC([y0], [double], [(double)])
	160	dnl gl_MATHFUNC([y1], [double], [(double)])
	161	dnl gl_MATHFUNC([yn], [double], [(int, double)])
	162	gl_MATHFUNC([pow], [double], [(double, double)])
	163	])