diff options
Diffstat (limited to 'math/libm-test.c')
| -rw-r--r-- | math/libm-test.c | 1520 |
1 files changed, 1520 insertions, 0 deletions
diff --git a/math/libm-test.c b/math/libm-test.c new file mode 100644 index 0000000000..98e3cbad5d --- /dev/null +++ b/math/libm-test.c @@ -0,0 +1,1520 @@ +/* Copyright (C) 1997 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Andreas Jaeger <aj@arthur.pfalz.de>, 1997. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + The GNU C Library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with the GNU C Library; see the file COPYING.LIB. If not, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + + +/* + Part of testsuite for libm. + + This file has to be included by a master file that defines: + + Makros: + FUNC(function): converts general function name (like cos) to + name with correct suffix (e.g. cosl or cosf) + MATHCONST(x): like FUNC but for constants (e.g convert 0.0 to 0.0L) + MATHTYPE: floating point type to test + TEST_MSG: informal message to be displayed + CHOOSE(Clongdouble,Cdouble,Cfloat): + chooses one of the parameters as epsilon for testing + equality + PRINTF_EXPR Floating point conversion specification to print a variable + of type MATHTYPE with printf. PRINTF_EXPR just contains + the specifier, not the percent and width arguments, + e.g. "f" + */ + +/* This program isn't finished yet. + It has tests for acos, acosh, asin, asinh, atan, atan2, atanh, + cbrt, ceil, cos, cosh, exp, exp2, expm1, fabs, floor, fpclassify, + frexp, ldexp, + log, log10, log1p, log2, logb, + pow, sin, sinh, tan, tanh, fabs, hypot. + Tests for the other libm-functions will come later. + + The routines using random variables are still under construction. I don't + like it the way it's working now and will change it. + + Exception handling has not been implemented so far so don't get fooled + that these tests pass. + + Parameter handling is primitive in the moment: + --verbose=[0..3] for different levels of output: + 0: only error count + 1: basic report on failed tests + 2: full report on failed tests + 3: full report on failed and passed tests (default) + -v for full output (equals --verbose=3) + -s,--silent outputs only the error count (equals --verbose=0) + */ + +/* Define if the following ISO C 9X functions are implemented: exp2, + log2. */ +#undef ISO_9X_IMPLEMENTED + +#define _GNU_SOURCE + +#include <math.h> +#include <float.h> + +#include <errno.h> +#include <stdlib.h> +#include <stdio.h> +#include <time.h> +#include <getopt.h> + +/* TEST_EXCEPTION: tests if an exception as occured */ +/* for the moment: does nothing */ +/* Possible exceptions */ +#define NO_EXCEPTION 0x0 +#define INVALID_EXCEPTION 0x1 +#define DIVIDE_BY_ZERO_EXCEPTION 0x2 + +#define PRINT 1 +#define NO_PRINT 0 + +#define TEST_EXCEPTION(test) do {} while (0); +/* As long as no exception code is available prevent warnings. */ +#define UNUSED __attribute__ ((unused)) + +static int noErrors; + +static int verbose = 3; +static MATHTYPE minus_zero, plus_zero; +static MATHTYPE plus_infty, minus_infty, nan_value; + +typedef MATHTYPE (*mathfunc) (MATHTYPE); + + +#define ISINF(x) \ +(sizeof (x) == sizeof (float) ? \ + isinff (x) \ + : sizeof (x) == sizeof (double) ? \ + isinf (x) : isinfl (x)) + + + /* + Test if Floating-Point stack hasn't changed + */ +static void +fpstack_test (const char *test_name) +{ +#ifdef i386 + static int old_stack; + int sw; +asm ("fnstsw":"=a" (sw)); + sw >>= 11; + sw &= 7; + if (sw != old_stack) + { + printf ("FP-Stack wrong after test %s\n", test_name); + if (verbose > 2) + printf ("=======> stack = %d\n", sw); + ++noErrors; + old_stack = sw; + } +#endif +} + + +/* + Call to an external function so that floating point registers + get moved to memory + */ +static void +this_does_nothing (void) +{ + clock_t dummy; + + dummy = clock (); +} + +/* + Get a random value x with min_value < x < max_value + and min_value, max_value finite, + max_value and min_value shouldn't be too close together + */ +static MATHTYPE +random_value (MATHTYPE min_value, MATHTYPE max_value) +{ + int r; + MATHTYPE x; + + r = rand (); + + x = (max_value - min_value) / RAND_MAX * (MATHTYPE) r + min_value; + + if ((x <= min_value) || (x >= max_value) || !isfinite (x)) + x = (max_value - min_value) / 2 + min_value; + + return x; +} + +/* Get a random value x with x > min_value. */ +static MATHTYPE +random_greater (MATHTYPE min_value) +{ + return random_value (min_value, 1e6); /* CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX) */ +} + +/* Get a random value x with x < max_value. */ +static MATHTYPE +random_less (MATHTYPE max_value) +{ + return random_value (-1e6, max_value); +} + + +/* Test if two floating point numbers are equal. */ +static int +check_equal (MATHTYPE computed, MATHTYPE supplied, MATHTYPE eps, MATHTYPE * diff) +{ + /* Both plus Infinity or both minus infinity. */ + if (ISINF (computed) && (ISINF (computed) == ISINF (supplied))) + return 1; + + if (isnan (computed) && isnan (supplied)) /* isnan works for all types */ + return 1; + + *diff = FUNC(fabs) (computed - supplied); + + if (*diff <= eps || signbit (computed) != signbit (supplied)) + return 1; + + return 0; +} + + +static void +output_result_bool (const char *test_name, int result) +{ + if (result) + { + if (verbose > 2) + printf ("Pass: %s\n", test_name); + } + else + { + if (verbose) + printf ("Fail: %s\n", test_name); + noErrors++; + } + + fpstack_test (test_name); +} + + +static void +output_isvalue (const char *test_name, int result, + MATHTYPE value) +{ + if (result) + { + if (verbose > 2) + printf ("Pass: %s\n", test_name); + } + else + { + if (verbose) + printf ("Fail: %s\n", test_name); + if (verbose > 1) + printf (" Value: %.20" PRINTF_EXPR "\n", value); + noErrors++; + } + + fpstack_test (test_name); +} + + +static void +output_isvalue_ext (const char *test_name, int result, + MATHTYPE value, MATHTYPE parameter) +{ + if (result) + { + if (verbose > 2) + printf ("Pass: %s\n", test_name); + } + else + { + if (verbose) + printf ("Fail: %s\n", test_name); + if (verbose > 1) + { + printf (" Value: %.20" PRINTF_EXPR "\n", value); + printf (" Parameter: %.20" PRINTF_EXPR "\n", parameter); + } + noErrors++; + } + + fpstack_test (test_name); +} + + +static void +output_result (const char *test_name, int result, + MATHTYPE computed, MATHTYPE expected, + MATHTYPE difference, + int print_values, int print_diff) +{ + if (result) + { + if (verbose > 2) + printf ("Pass: %s\n", test_name); + } + else + { + if (verbose) + printf ("Fail: %s\n", test_name); + if (verbose > 1 && print_values) + { + printf ("Result:\n"); + printf (" is: %.20" PRINTF_EXPR "\n", computed); + printf (" should be: %.20" PRINTF_EXPR "\n", expected); + if (print_diff) + printf (" difference: %.20" PRINTF_EXPR "\n", difference); + } + noErrors++; + } + + fpstack_test (test_name); +} + + +static void +output_result_ext (const char *test_name, int result, + MATHTYPE computed, MATHTYPE expected, + MATHTYPE difference, + MATHTYPE parameter, + int print_values, int print_diff) +{ + if (result) + { + if (verbose > 2) + printf ("Pass: %s\n", test_name); + } + else + { + if (verbose) + printf ("Fail: %s\n", test_name); + if (verbose > 1 && print_values) + { + printf ("Result:\n"); + printf (" is: %.20" PRINTF_EXPR "\n", computed); + printf (" should be: %.20" PRINTF_EXPR "\n", expected); + if (print_diff) + printf (" difference: %.20" PRINTF_EXPR "\n", difference); + printf ("Parameter: %.20" PRINTF_EXPR "\n", parameter); + } + noErrors++; + } + + fpstack_test (test_name); +} + + +static void +check (const char *test_name, MATHTYPE computed, MATHTYPE expected) +{ + MATHTYPE diff; + int result; + + result = check_equal (computed, expected, 0, &diff); + output_result (test_name, result, + computed, expected, diff, PRINT, PRINT); +} + + +static void +check_ext (const char *test_name, MATHTYPE computed, MATHTYPE expected, + MATHTYPE parameter) +{ + MATHTYPE diff; + int result; + + result = check_equal (computed, expected, 0, &diff); + output_result_ext (test_name, result, + computed, expected, diff, parameter, PRINT, PRINT); +} + + +static void +check_eps (const char *test_name, MATHTYPE computed, MATHTYPE expected, + MATHTYPE epsilon) +{ + MATHTYPE diff; + int result; + + result = check_equal (computed, expected, epsilon, &diff); + output_result (test_name, result, + computed, expected, diff, PRINT, PRINT); +} + + +static void +check_bool (const char *test_name, int computed) +{ + output_result_bool (test_name, computed); +} + + +static void +check_isnan (const char *test_name, MATHTYPE computed) +{ + output_isvalue (test_name, isnan (computed), computed); +} + + +static void +check_isnan_exc (const char *test_name, MATHTYPE computed, + short exception UNUSED) +{ + output_isvalue (test_name, isnan (computed), computed); +} + + +static void +check_isnan_ext (const char *test_name, MATHTYPE computed, + MATHTYPE parameter) +{ + output_isvalue_ext (test_name, isnan (computed), computed, parameter); +} + + +/* Tests if computed is +Inf */ +static void +check_isinfp (const char *test_name, MATHTYPE computed) +{ + output_isvalue (test_name, (ISINF (computed) == +1), computed); +} + + +static void +check_isinfp_ext (const char *test_name, MATHTYPE computed, + MATHTYPE parameter) +{ + output_isvalue_ext (test_name, (ISINF (computed) == +1), computed, parameter); +} + + +/* Tests if computed is +Inf */ +static void +check_isinfp_exc (const char *test_name, MATHTYPE computed, + int exception UNUSED) +{ + output_isvalue (test_name, (ISINF (computed) == +1), computed); +} + +/* Tests if computed is -Inf */ +static void +check_isinfn (const char *test_name, MATHTYPE computed) +{ + output_isvalue (test_name, (ISINF (computed) == -1), computed); +} + + +static void +check_isinfn_ext (const char *test_name, MATHTYPE computed, + MATHTYPE parameter) +{ + output_isvalue_ext (test_name, (ISINF (computed) == -1), computed, parameter); +} + + +/* Tests if computed is -Inf */ +static void +check_isinfn_exc (const char *test_name, MATHTYPE computed, + int exception UNUSED) +{ + output_isvalue (test_name, (ISINF (computed) == -1), computed); +} + + +/**************************************************************************** + Test for single functions of libm +****************************************************************************/ + +static void +acos_test (void) +{ + MATHTYPE x; + + check ("acos (1) == 0", FUNC(acos) (1), 0); + + x = random_greater (1); + check_isnan_exc ("acos (x) == NaN + invalid exception for |x| > 1", + FUNC(acos) (x), + INVALID_EXCEPTION); +} + +static void +acosh_test (void) +{ + MATHTYPE x; + + check ("acosh(1) == 0", FUNC(acosh) (1), 0); + check_isinfp ("acosh(+inf) == +inf", FUNC(acosh) (plus_infty)); + + x = random_less (1); + check_isnan_exc ("acosh(x) == NaN plus invalid exception if x < 1", + FUNC(acosh) (x), INVALID_EXCEPTION); +} + + +static void +asin_test (void) +{ + MATHTYPE x; + check ("asin (0) == 0", FUNC(asin) (0), 0); + + x = random_greater (1); + check_isnan_exc ("asin x == NaN + invalid exception for |x| > 1", + FUNC(asin) (x), + INVALID_EXCEPTION); +} + +static void +asinh_test (void) +{ + + check ("asinh(+0) == +0", FUNC(asinh) (0), 0); + check ("asinh(-0) == -0", FUNC(asinh) (minus_zero), minus_zero); +} + + +static void +atan_test (void) +{ + check ("atan (0) == 0", FUNC(atan) (0), 0); + check ("atan (-0) == -0", FUNC(atan) (minus_zero), minus_zero); + + check ("atan (+inf) == pi/2", FUNC(atan) (plus_infty), M_PI_2); + check ("atan (-inf) == -pi/2", FUNC(atan) (minus_infty), -M_PI_2); + +} + +static void +atan2_test (void) +{ + MATHTYPE x; + + x = random_greater (0); + check ("atan2 (0,x) == 0 for x > 0", + FUNC(atan2) (0, x), 0); + x = random_greater (0); + check ("atan2 (-0,x) == -0 for x > 0", + FUNC(atan2) (minus_zero, x), minus_zero); + + check ("atan2 (+0,+0) == +0", FUNC(atan2) (0, 0), 0); + check ("atan2 (-0,+0) == -0", FUNC(atan2) (minus_zero, 0), minus_zero); + + x = -random_greater (0); + check ("atan2 (+0,x) == +pi for x < 0", FUNC(atan2) (0, x), M_PI); + + x = -random_greater (0); + check ("atan2 (-0,x) == -pi for x < 0", FUNC(atan2) (minus_zero, x), -M_PI); + + check ("atan2 (+0,-0) == +pi", FUNC(atan2) (0, minus_zero), M_PI); + check ("atan2 (-0,-0) == -pi", FUNC(atan2) (minus_zero, minus_zero), -M_PI); + + x = random_greater (0); + check ("atan2 (y,+0) == pi/2 for y > 0", FUNC(atan2) (x, 0), M_PI_2); + + x = random_greater (0); + check ("atan2 (y,-0) == pi/2 for y > 0", FUNC(atan2) (x, minus_zero), M_PI_2); + + x = random_greater (0); + check ("atan2 (y,-inf) == +pi for finite y > 0", + FUNC(atan2) (x, minus_infty), M_PI); + + x = -random_greater (0); + check ("atan2 (y,-inf) == -pi for finite y < 0", + FUNC(atan2) (x, minus_infty), -M_PI); + + check ("atan2 (+inf,+inf) == +pi/4", + FUNC(atan2) (plus_infty, plus_infty), M_PI_4); + + check ("atan2 (-inf,+inf) == -pi/4", + FUNC(atan2) (minus_infty, plus_infty), -M_PI_4); + + check ("atan2 (+inf,-inf) == +3*pi/4", + FUNC(atan2) (plus_infty, minus_infty), 3 * M_PI_4); + + check ("atan2 (-inf,-inf) == -3*pi/4", + FUNC(atan2) (minus_infty, minus_infty), -3 * M_PI_4); +} + + +static void +atanh_test (void) +{ + + check ("atanh(+0) == +0", FUNC(atanh) (0), 0); + check ("atanh(-0) == -0", FUNC(atanh) (minus_zero), minus_zero); + check_isinfp_exc ("atanh(+1) == +inf plus divide-by-zero exception", + FUNC(atanh) (1), DIVIDE_BY_ZERO_EXCEPTION); + check_isinfn_exc ("atanh(-1) == -inf plus divide-by-zero exception", + FUNC(atanh) (-1), DIVIDE_BY_ZERO_EXCEPTION); +} + + +static void +cbrt_test (void) +{ + check ("cbrt (+0) == +0", FUNC(cbrt) (0.0), 0.0); + check ("cbrt (-0) == -0", FUNC(cbrt) (minus_zero), minus_zero); + + check ("cbrt (8) == 2", FUNC(cbrt) (8), 2); + check ("cbrt (-27) == -3", FUNC(cbrt) (-27.0), -3.0); +} + + +static void +ceil_test (void) +{ + check ("ceil (+0) == +0", FUNC(ceil) (0.0), 0.0); + check ("ceil (-0) == -0", FUNC(ceil) (minus_zero), minus_zero); + check_isinfp ("ceil (+inf) == +inf", FUNC(ceil) (plus_infty)); + check_isinfn ("ceil (-inf) == -inf", FUNC(ceil) (minus_infty)); + + check ("ceil (pi) == 4", FUNC(ceil) (M_PI), 4.0); + check ("ceil (-pi) == -3", FUNC(ceil) (-M_PI), 3.0); +} + + +static void +cos_test (void) +{ + + check ("cos (+0) == 1", FUNC(cos) (0), 1); + check ("cos (-0) == 1", FUNC(cos) (minus_zero), 1); + check_isnan_exc ("cos (+inf) == NaN plus invalid exception", + FUNC(cos) (plus_infty), + INVALID_EXCEPTION); + check_isnan_exc ("cos (-inf) == NaN plus invalid exception", + FUNC(cos) (minus_infty), + INVALID_EXCEPTION); + + check_eps ("cos (pi/3) == 0.5", FUNC(cos) (M_PI / 3.0), + 0.5, CHOOSE (0, 1e-15L, 1e-7L)); + check_eps ("cos (pi/2) == 0.5", FUNC(cos) (M_PI_2), + 0, CHOOSE (1e-19L, 1e-16L, 1e-7L)); + +} + +static void +cosh_test (void) +{ + check ("cosh (+0) == 1", FUNC(cosh) (0), 1); + check ("cosh (-0) == 1", FUNC(cosh) (minus_zero), 1); + + check_isinfp ("cosh (+inf) == +inf", FUNC(cosh) (plus_infty)); + check_isinfp ("cosh (-inf) == +inf", FUNC(cosh) (minus_infty)); +} + + +static void +exp_test (void) +{ + check ("exp (+0) == 1", FUNC(exp) (0), 1); + check ("exp (-0) == 1", FUNC(exp) (minus_zero), 1); + + check_isinfp ("exp (+inf) == +inf", FUNC(exp) (plus_infty)); + check ("exp (-inf) == 0", FUNC(exp) (minus_infty), 0); + + check ("exp (1) == e", FUNC(exp) (1), M_E); +} + + +#ifdef ISO_9X_IMPLEMENTED +static void +exp2_test (void) +{ + check ("exp2 (+0) == 1", FUNC(exp2) (0), 1); + check ("exp2 (-0) == 1", FUNC(exp2) (minus_zero), 1); + + check_isinfp ("exp2 (+inf) == +inf", FUNC(exp2) (plus_infty)); + check ("exp2 (-inf) == 0", FUNC(exp2) (minus_infty), 0); + check ("exp2 (10) == 1024", FUNC(exp2) (10), 1024); +} +#endif + + +static void +expm1_test (void) +{ + check ("expm1 (+0) == 0", FUNC(expm1) (0), 0); + check ("expm1 (-0) == -0", FUNC(expm1) (minus_zero), minus_zero); + + check_isinfp ("expm1 (+inf) == +inf", FUNC(expm1) (plus_infty)); + check ("expm1 (-inf) == -1", FUNC(expm1) (minus_infty), -1); + + check ("expm1 (1) == e-1", FUNC(expm1) (1), M_E - 1.0); +} + + + + +static void +check_frexp (const char *test_name, MATHTYPE computed, MATHTYPE expected, + int comp_int, int exp_int) +{ + MATHTYPE diff; + int result; + + result = (check_equal (computed, expected, 0, &diff) + && (comp_int == exp_int)); + + if (result) + { + if (verbose > 2) + printf ("Pass: %s\n", test_name); + } + else + { + if (verbose) + printf ("Fail: %s\n", test_name); + if (verbose > 1) + { + printf ("Result:\n"); + printf (" is: %.20" PRINTF_EXPR " *2^%d\n", computed, comp_int); + printf (" should be: %.20" PRINTF_EXPR " *2^%d\n", expected, exp_int); + printf (" difference: %.20" PRINTF_EXPR "\n", diff); + } + noErrors++; + } + fpstack_test (test_name); + output_result (test_name, result, + computed, expected, diff, PRINT, PRINT); +} + + +static void +frexp_test (void) +{ + int x_int; + MATHTYPE result; + + result = FUNC(frexp) (plus_infty, &x_int); + check_isinfp ("frexp (+inf, expr) == +inf", result); + + result = FUNC(frexp) (minus_infty, &x_int); + check_isinfn ("frexp (-inf, expr) == -inf", result); + + result = FUNC(frexp) (nan_value, &x_int); + check_isnan ("frexp (Nan, expr) == NaN", result); + + result = FUNC(frexp) (0, &x_int); + check_frexp ("frexp: +0 == 0 * 2^0", result, 0, x_int, 0); + + result = FUNC(frexp) (minus_zero, &x_int); + check_frexp ("frexp: -0 == -0 * 2^0", result, minus_zero, x_int, 0); + + result = FUNC(frexp) (12.8L, &x_int); + check_frexp ("frexp: 12.8 == 0.8 * 2^4", result, 0.8L, x_int, 4); + + result = FUNC(frexp) (-27.34L, &x_int); + check_frexp ("frexp: -27.34 == -0.854375 * 2^5", result, -0.854375L, x_int, 5); + +} + + +#if __GLIBC__ < 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ < 1) +/* All floating-point numbers can be put in one of these categories. */ +enum +{ + FP_NAN, +#define FP_NAN FP_NAN + FP_INFINITE, +#define FP_INFINITE FP_INFINITE + FP_ZERO, +#define FP_ZERO FP_ZERO + FP_SUBNORMAL, +#define FP_SUBNORMAL FP_SUBNORMAL + FP_NORMAL +#define FP_NORMAL FP_NORMAL +}; +#endif + + +static void +fpclassify_test (void) +{ + MATHTYPE x; + + /* fpclassify is a macro, don't give it constants as parameter */ + check_bool ("fpclassify (NaN) == FP_NAN", fpclassify (nan_value) == FP_NAN); + check_bool ("fpclassify (+inf) == FP_INFINITE", + fpclassify (plus_infty) == FP_INFINITE); + check_bool ("fpclassify (-inf) == FP_INFINITE", + fpclassify (minus_infty) == FP_INFINITE); + check_bool ("fpclassify (+0) == FP_ZERO", + fpclassify (plus_zero) == FP_ZERO); + check_bool ("fpclassify (-0) == FP_ZERO", + fpclassify (minus_zero) == FP_ZERO); + + x = 1000.0; + check_bool ("fpclassify (1000) == FP_NORMAL", + fpclassify (x) == FP_NORMAL); +} + + +static void +ldexp_test (void) +{ + check ("ldexp (0, 0) == 0", FUNC(ldexp) (0, 0), 0); + + check_isinfp ("ldexp (+inf, 1) == +inf", FUNC(ldexp) (plus_infty, 1)); + check_isinfn ("ldexp (-inf, 1) == -inf", FUNC(ldexp) (minus_infty, 1)); + check_isnan ("ldexp (NaN, 1) == NaN", FUNC(ldexp) (nan_value, 1)); + + check ("ldexp (0.8, 4) == 12.8", FUNC(ldexp) (0.8L, 4), 12.8L); + check ("ldexp (-0.854375, 5) == -27.34", FUNC(ldexp) (-0.854375L, 5), -27.34L); +} + + +static void +log_test (void) +{ + check_isinfn_exc ("log (+0) == -inf", FUNC(log) (0), + DIVIDE_BY_ZERO_EXCEPTION); + check_isinfn_exc ("log (-0) == -inf", FUNC(log) (minus_zero), + DIVIDE_BY_ZERO_EXCEPTION); + + check ("log (1) == 0", FUNC(log) (1), 0); + + check_isnan_exc ("log (x) == NaN plus divide-by-zero exception if x < 0", + FUNC(log) (-1), INVALID_EXCEPTION); + check_isinfp ("log (+inf) == +inf", FUNC(log) (plus_infty)); + + check_eps ("log (e) == 1", FUNC(log) (M_E), 1, CHOOSE (0, 0, 9e-8L)); + check ("log (1/e) == -1", FUNC(log) (1.0 / M_E), 1); + check ("log (2) == M_LN2", FUNC(log) (2), M_LN2); + check ("log (10) == M_LN10", FUNC(log) (10), M_LN10); +} + + +static void +log10_test (void) +{ + check_isinfn_exc ("log10 (+0) == -inf", FUNC(log10) (0), + DIVIDE_BY_ZERO_EXCEPTION); + check_isinfn_exc ("log10 (-0) == -inf", FUNC(log10) (minus_zero), + DIVIDE_BY_ZERO_EXCEPTION); + + check ("log10 (1) == +0", FUNC(log10) (1), 0); + + check_isnan_exc ("log10 (x) == NaN plus divide-by-zero exception if x < 0", + FUNC(log10) (-1), INVALID_EXCEPTION); + + check_isinfp ("log10 (+inf) == +inf", FUNC(log10) (plus_infty)); + + check ("log10 (0.1) == -1", FUNC(log10) (0.1L), -1); + check ("log10 (10) == 1", FUNC(log10) (10.0), 1); + check ("log10 (100) == 2", FUNC(log10) (100.0), 2); + check ("log10 (10000) == 4", FUNC(log10) (10000.0), 4); + check_eps ("log10 (e) == M_LOG10E", FUNC(log10) (M_E), M_LOG10E, + CHOOSE (0, 0, 9e-8)); +} + + +static void +log1p_test (void) +{ + check ("log1p (+0) == +0" |