2013-11-29 17:27:55 +01:00
|
|
|
/* Generate expected output for libm tests with MPFR and MPC.
|
2015-01-02 17:28:19 +01:00
|
|
|
Copyright (C) 2013-2015 Free Software Foundation, Inc.
|
2013-11-29 17:27:55 +01:00
|
|
|
This file is part of the GNU C Library.
|
|
|
|
|
|
|
|
The GNU C Library is free software; you can redistribute it and/or
|
|
|
|
modify it under the terms of the GNU Lesser General Public
|
|
|
|
License as published by the Free Software Foundation; either
|
|
|
|
version 2.1 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
|
|
|
|
Lesser General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
|
|
License along with the GNU C Library; if not, see
|
|
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
|
|
|
|
/* Compile this program as:
|
|
|
|
|
|
|
|
gcc -std=gnu99 -O2 -Wall -Wextra gen-auto-libm-tests.c -lmpc -lmpfr -lgmp \
|
|
|
|
-o gen-auto-libm-tests
|
|
|
|
|
|
|
|
(use of current MPC and MPFR versions recommended) and run it as:
|
|
|
|
|
|
|
|
gen-auto-libm-tests auto-libm-test-in auto-libm-test-out
|
|
|
|
|
|
|
|
The input file auto-libm-test-in contains three kinds of lines:
|
|
|
|
|
|
|
|
Lines beginning with "#" are comments, and are ignored, as are
|
|
|
|
empty lines.
|
|
|
|
|
|
|
|
Other lines are test lines, of the form "function input1 input2
|
|
|
|
... [flag1 flag2 ...]". Inputs are either finite real numbers or
|
|
|
|
integers, depending on the function under test. Real numbers may
|
|
|
|
be in any form acceptable to mpfr_strtofr (base 0); integers in any
|
|
|
|
form acceptable to mpz_set_str (base 0). In addition, real numbers
|
|
|
|
may be certain special strings such as "pi", as listed in the
|
|
|
|
special_real_inputs array.
|
|
|
|
|
|
|
|
Each flag is a flag name possibly followed by a series of
|
|
|
|
":condition". Conditions may be any of the names of floating-point
|
|
|
|
formats in the floating_point_formats array, "long32" and "long64"
|
|
|
|
to indicate the number of bits in the "long" type, or other strings
|
|
|
|
for which libm-test.inc defines a TEST_COND_<condition> macro (with
|
|
|
|
"-"- changed to "_" in the condition name) evaluating to nonzero
|
|
|
|
when the condition is true and zero when the condition is false.
|
|
|
|
The meaning is that the flag applies to the test if all the listed
|
|
|
|
conditions are true. "flag:cond1:cond2 flag:cond3:cond4" means the
|
|
|
|
flag applies if ((cond1 && cond2) || (cond3 && cond4)).
|
|
|
|
|
|
|
|
A real number specified as an input is considered to represent the
|
|
|
|
set of real numbers arising from rounding the given number in any
|
|
|
|
direction for any supported floating-point format; any roundings
|
|
|
|
that give infinity are ignored. Each input on a test line has all
|
|
|
|
the possible roundings considered independently. Each resulting
|
|
|
|
choice of the tuple of inputs to the function is ignored if the
|
|
|
|
mathematical result of the function involves a NaN or an exact
|
|
|
|
infinity, and is otherwise considered for each floating-point
|
|
|
|
format for which all those inputs are exactly representable. Thus
|
|
|
|
tests may result in "overflow", "underflow" and "inexact"
|
|
|
|
exceptions; "invalid" may arise only when the final result type is
|
|
|
|
an integer type and it is the conversion of a mathematically
|
|
|
|
defined finite result to integer type that results in that
|
|
|
|
exception.
|
|
|
|
|
|
|
|
By default, it is assumed that "overflow" and "underflow"
|
|
|
|
exceptions should be correct, but that "inexact" exceptions should
|
|
|
|
only be correct for functions listed as exactly determined. For
|
|
|
|
such functions, "underflow" exceptions should respect whether the
|
|
|
|
machine has before-rounding or after-rounding tininess detection.
|
|
|
|
For other functions, it is considered that if the exact result is
|
|
|
|
somewhere between the greatest magnitude subnormal of a given sign
|
|
|
|
(exclusive) and the least magnitude normal of that sign
|
|
|
|
(inclusive), underflow exceptions are permitted but optional on all
|
|
|
|
machines, and they are also permitted but optional for smaller
|
|
|
|
subnormal exact results for functions that are not exactly
|
|
|
|
determined. errno setting is expected for overflow to infinity and
|
|
|
|
underflow to zero (for real functions), and for out-of-range
|
|
|
|
conversion of a finite result to integer type, and is considered
|
|
|
|
permitted but optional for all other cases where overflow
|
|
|
|
exceptions occur, and where underflow exceptions occur or are
|
|
|
|
permitted. In other cases (where no overflow or underflow is
|
|
|
|
permitted), errno is expected to be left unchanged.
|
|
|
|
|
|
|
|
The flag "no-test-inline" indicates a test is disabled for inline
|
2014-06-23 22:15:14 +02:00
|
|
|
function testing; "ignore-zero-inf-sign" indicates the the signs of
|
|
|
|
zero and infinite results should be ignored; "xfail" indicates the
|
|
|
|
test is disabled as expected to produce incorrect results,
|
|
|
|
"xfail-rounding" indicates the test is disabled only in rounding
|
|
|
|
modes other than round-to-nearest. Otherwise, test flags are of
|
|
|
|
the form "spurious-<exception>" and "missing-<exception>", for any
|
|
|
|
exception ("overflow", "underflow", "inexact", "invalid",
|
|
|
|
"divbyzero"), "spurious-errno" and "missing-errno", to indicate
|
|
|
|
when tests are expected to deviate from the exception and errno
|
|
|
|
settings corresponding to the mathematical results. "xfail",
|
2013-12-03 17:22:49 +01:00
|
|
|
"xfail-rounding", "spurious-" and "missing-" flags should be
|
|
|
|
accompanied by a comment referring to an open bug in glibc
|
|
|
|
Bugzilla.
|
2013-11-29 17:27:55 +01:00
|
|
|
|
|
|
|
The output file auto-libm-test-out contains the test lines from
|
|
|
|
auto-libm-test-in, and, after the line for a given test, some
|
|
|
|
number of output test lines. An output test line is of the form "=
|
|
|
|
function rounding-mode format input1 input2 ... : output1 output2
|
|
|
|
... : flags". rounding-mode is "tonearest", "towardzero", "upward"
|
|
|
|
or "downward". format is a name from the floating_point_formats
|
|
|
|
array, possibly followed by a sequence of ":flag" for flags from
|
2014-03-06 15:11:19 +01:00
|
|
|
"long32" and "long64". Inputs and outputs are specified as hex
|
|
|
|
floats with the required suffix for the floating-point type, or
|
|
|
|
plus_infty or minus_infty for infinite expected results, or as
|
|
|
|
integer constant expressions (not necessarily with the right type)
|
|
|
|
or IGNORE for integer inputs and outputs. Flags are
|
2014-06-23 22:15:14 +02:00
|
|
|
"no-test-inline", "ignore-zero-info-sign", "xfail", "<exception>",
|
|
|
|
"<exception>-ok", "errno-<value>", "errno-<value>-ok", which may be
|
|
|
|
unconditional or conditional. "<exception>" indicates that a
|
|
|
|
correct result means the given exception should be raised.
|
|
|
|
"errno-<value>" indicates that a correct result means errno should
|
|
|
|
be set to the given value. "-ok" means not to test for the given
|
|
|
|
exception or errno value (whether because it was marked as possibly
|
|
|
|
missing or spurious, or because the calculation of correct results
|
|
|
|
indicated it was optional). Conditions "before-rounding" and
|
|
|
|
"after-rounding" indicate tests where expectations for underflow
|
|
|
|
exceptions depend on how the architecture detects tininess. */
|
2013-11-29 17:27:55 +01:00
|
|
|
|
|
|
|
#define _GNU_SOURCE
|
|
|
|
|
|
|
|
#include <assert.h>
|
|
|
|
#include <ctype.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <error.h>
|
|
|
|
#include <stdbool.h>
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
#include <gmp.h>
|
|
|
|
#include <mpfr.h>
|
|
|
|
#include <mpc.h>
|
|
|
|
|
|
|
|
#define ARRAY_SIZE(A) (sizeof (A) / sizeof ((A)[0]))
|
|
|
|
|
|
|
|
/* The supported floating-point formats. */
|
|
|
|
typedef enum
|
|
|
|
{
|
|
|
|
fp_flt_32,
|
|
|
|
fp_dbl_64,
|
|
|
|
fp_ldbl_96_intel,
|
|
|
|
fp_ldbl_96_m68k,
|
|
|
|
fp_ldbl_128,
|
|
|
|
fp_ldbl_128ibm,
|
|
|
|
fp_num_formats,
|
|
|
|
fp_first_format = 0
|
|
|
|
} fp_format;
|
|
|
|
|
|
|
|
/* Structure describing a single floating-point format. */
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
/* The name of the format. */
|
|
|
|
const char *name;
|
|
|
|
/* The suffix to use on floating-point constants with this
|
|
|
|
format. */
|
|
|
|
const char *suffix;
|
|
|
|
/* A string for the largest normal value, or NULL for IEEE formats
|
|
|
|
where this can be determined automatically. */
|
|
|
|
const char *max_string;
|
|
|
|
/* The number of mantissa bits. */
|
|
|
|
int mant_dig;
|
|
|
|
/* The least N such that 2^N overflows. */
|
|
|
|
int max_exp;
|
|
|
|
/* One more than the least N such that 2^N is normal. */
|
|
|
|
int min_exp;
|
|
|
|
/* The largest normal value. */
|
|
|
|
mpfr_t max;
|
Relax gen-auto-libm-tests may-underflow rules, test log1p in all rounding modes.
gen-auto-libm-tests presently allows but does not require underflow
exceptions for results with magnitude in the range (greatest
subnormal, least normal].
In some cases, the magnitude of the exact result is very slightly
above the least normal, but rounding in the implementation results in
it effectively computing an infinite-precision result that is slightly
below the least normal, so raising an underflow exception. This is in
accordance with the documented accuracy goals, but results in
testsuite failures.
This patch changes the logic to allow underflows when the mathematical
result is up to 0.5ulp above the least normal (so in any case where
the round-to-nearest result is the least normal). Ideally underflows
in all these cases would be accepted only when an underflow with the
actual result is consistent with the rounding mode (in FE_TOWARDZERO
mode, a return value of the least normal implies that the
infinite-precision result did not underflow so there should be no
underflow exception, for example), so as to match the documented goals
more precisely - whereas at present the tests for exceptions are
completely independent of the tests of the returned values. (The same
applies to overflow exceptions as well - they too should be checked
for consistency with the result, as in FE_TOWARDZERO mode a result
1ulp below the largest finite value should be inconsistent with an
overflow exception and cause a failure with overflow rather than
simply being considered a 1ulp error when overflow is expected.) But
the present patch at least deals with the cases causing spurious
failures so that (a) certain existing tests no longer need to be
marked as having spurious exceptions (such markings in
auto-libm-test-in end up applying to more cases than just those they
are needed for) and (b) log1p can be tested in all rounding modes
without introducing more such failures. This patch duly moves tests
of log1p to ALL_RM_TEST.
Tested x86_64 and x86 and ulps updated accordingly.
[BZ #16357]
[BZ #16599]
* math/gen-auto-libm-tests.c (fp_format_desc): Add field
min_plus_half.
(fp_formats): Update initializers.
(init_fp_formats): Initialize new field.
(output_for_one_input_case): Allow underflow for results up to
min_plus_half.
* math/libm-test.inc (log1p_test): Use ALL_RM_TEST.
* math/auto-libm-test-in: Don't mark some underflows from asin and
atanh as spurious.
* math/auto-libm-test-out: Regenerated.
* sysdeps/i386/fpu/libm-test-ulps: Update.
* sysdeps/x86_64/fpu/libm-test-ulps: Likewise.
2014-03-25 13:26:06 +01:00
|
|
|
/* The value 0.5ulp above the least positive normal value. */
|
|
|
|
mpfr_t min_plus_half;
|
2013-11-29 17:27:55 +01:00
|
|
|
/* The least positive normal value, 2^(MIN_EXP-1). */
|
|
|
|
mpfr_t min;
|
|
|
|
/* The greatest positive subnormal value. */
|
|
|
|
mpfr_t subnorm_max;
|
|
|
|
/* The least positive subnormal value, 2^(MIN_EXP-MANT_DIG). */
|
|
|
|
mpfr_t subnorm_min;
|
|
|
|
} fp_format_desc;
|
|
|
|
|
|
|
|
/* List of floating-point formats, in the same order as the fp_format
|
|
|
|
enumeration. */
|
|
|
|
static fp_format_desc fp_formats[fp_num_formats] =
|
|
|
|
{
|
Relax gen-auto-libm-tests may-underflow rules, test log1p in all rounding modes.
gen-auto-libm-tests presently allows but does not require underflow
exceptions for results with magnitude in the range (greatest
subnormal, least normal].
In some cases, the magnitude of the exact result is very slightly
above the least normal, but rounding in the implementation results in
it effectively computing an infinite-precision result that is slightly
below the least normal, so raising an underflow exception. This is in
accordance with the documented accuracy goals, but results in
testsuite failures.
This patch changes the logic to allow underflows when the mathematical
result is up to 0.5ulp above the least normal (so in any case where
the round-to-nearest result is the least normal). Ideally underflows
in all these cases would be accepted only when an underflow with the
actual result is consistent with the rounding mode (in FE_TOWARDZERO
mode, a return value of the least normal implies that the
infinite-precision result did not underflow so there should be no
underflow exception, for example), so as to match the documented goals
more precisely - whereas at present the tests for exceptions are
completely independent of the tests of the returned values. (The same
applies to overflow exceptions as well - they too should be checked
for consistency with the result, as in FE_TOWARDZERO mode a result
1ulp below the largest finite value should be inconsistent with an
overflow exception and cause a failure with overflow rather than
simply being considered a 1ulp error when overflow is expected.) But
the present patch at least deals with the cases causing spurious
failures so that (a) certain existing tests no longer need to be
marked as having spurious exceptions (such markings in
auto-libm-test-in end up applying to more cases than just those they
are needed for) and (b) log1p can be tested in all rounding modes
without introducing more such failures. This patch duly moves tests
of log1p to ALL_RM_TEST.
Tested x86_64 and x86 and ulps updated accordingly.
[BZ #16357]
[BZ #16599]
* math/gen-auto-libm-tests.c (fp_format_desc): Add field
min_plus_half.
(fp_formats): Update initializers.
(init_fp_formats): Initialize new field.
(output_for_one_input_case): Allow underflow for results up to
min_plus_half.
* math/libm-test.inc (log1p_test): Use ALL_RM_TEST.
* math/auto-libm-test-in: Don't mark some underflows from asin and
atanh as spurious.
* math/auto-libm-test-out: Regenerated.
* sysdeps/i386/fpu/libm-test-ulps: Update.
* sysdeps/x86_64/fpu/libm-test-ulps: Likewise.
2014-03-25 13:26:06 +01:00
|
|
|
{ "flt-32", "f", NULL, 24, 128, -125, {}, {}, {}, {}, {} },
|
|
|
|
{ "dbl-64", "", NULL, 53, 1024, -1021, {}, {}, {}, {}, {} },
|
|
|
|
{ "ldbl-96-intel", "L", NULL, 64, 16384, -16381, {}, {}, {}, {}, {} },
|
|
|
|
{ "ldbl-96-m68k", "L", NULL, 64, 16384, -16382, {}, {}, {}, {}, {} },
|
|
|
|
{ "ldbl-128", "L", NULL, 113, 16384, -16381, {}, {}, {}, {}, {} },
|
2013-11-29 17:27:55 +01:00
|
|
|
{ "ldbl-128ibm", "L", "0x1.fffffffffffff7ffffffffffff8p+1023",
|
Relax gen-auto-libm-tests may-underflow rules, test log1p in all rounding modes.
gen-auto-libm-tests presently allows but does not require underflow
exceptions for results with magnitude in the range (greatest
subnormal, least normal].
In some cases, the magnitude of the exact result is very slightly
above the least normal, but rounding in the implementation results in
it effectively computing an infinite-precision result that is slightly
below the least normal, so raising an underflow exception. This is in
accordance with the documented accuracy goals, but results in
testsuite failures.
This patch changes the logic to allow underflows when the mathematical
result is up to 0.5ulp above the least normal (so in any case where
the round-to-nearest result is the least normal). Ideally underflows
in all these cases would be accepted only when an underflow with the
actual result is consistent with the rounding mode (in FE_TOWARDZERO
mode, a return value of the least normal implies that the
infinite-precision result did not underflow so there should be no
underflow exception, for example), so as to match the documented goals
more precisely - whereas at present the tests for exceptions are
completely independent of the tests of the returned values. (The same
applies to overflow exceptions as well - they too should be checked
for consistency with the result, as in FE_TOWARDZERO mode a result
1ulp below the largest finite value should be inconsistent with an
overflow exception and cause a failure with overflow rather than
simply being considered a 1ulp error when overflow is expected.) But
the present patch at least deals with the cases causing spurious
failures so that (a) certain existing tests no longer need to be
marked as having spurious exceptions (such markings in
auto-libm-test-in end up applying to more cases than just those they
are needed for) and (b) log1p can be tested in all rounding modes
without introducing more such failures. This patch duly moves tests
of log1p to ALL_RM_TEST.
Tested x86_64 and x86 and ulps updated accordingly.
[BZ #16357]
[BZ #16599]
* math/gen-auto-libm-tests.c (fp_format_desc): Add field
min_plus_half.
(fp_formats): Update initializers.
(init_fp_formats): Initialize new field.
(output_for_one_input_case): Allow underflow for results up to
min_plus_half.
* math/libm-test.inc (log1p_test): Use ALL_RM_TEST.
* math/auto-libm-test-in: Don't mark some underflows from asin and
atanh as spurious.
* math/auto-libm-test-out: Regenerated.
* sysdeps/i386/fpu/libm-test-ulps: Update.
* sysdeps/x86_64/fpu/libm-test-ulps: Likewise.
2014-03-25 13:26:06 +01:00
|
|
|
106, 1024, -968, {}, {}, {}, {}, {} },
|
2013-11-29 17:27:55 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
/* The supported rounding modes. */
|
|
|
|
typedef enum
|
|
|
|
{
|
|
|
|
rm_downward,
|
|
|
|
rm_tonearest,
|
|
|
|
rm_towardzero,
|
|
|
|
rm_upward,
|
|
|
|
rm_num_modes,
|
|
|
|
rm_first_mode = 0
|
|
|
|
} rounding_mode;
|
|
|
|
|
|
|
|
/* Structure describing a single rounding mode. */
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
/* The name of the rounding mode. */
|
|
|
|
const char *name;
|
|
|
|
/* The MPFR rounding mode. */
|
|
|
|
mpfr_rnd_t mpfr_mode;
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
/* The MPC rounding mode. */
|
|
|
|
mpc_rnd_t mpc_mode;
|
2013-11-29 17:27:55 +01:00
|
|
|
} rounding_mode_desc;
|
|
|
|
|
|
|
|
/* List of rounding modes, in the same order as the rounding_mode
|
|
|
|
enumeration. */
|
|
|
|
static const rounding_mode_desc rounding_modes[rm_num_modes] =
|
|
|
|
{
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
{ "downward", MPFR_RNDD, MPC_RNDDD },
|
|
|
|
{ "tonearest", MPFR_RNDN, MPC_RNDNN },
|
|
|
|
{ "towardzero", MPFR_RNDZ, MPC_RNDZZ },
|
|
|
|
{ "upward", MPFR_RNDU, MPC_RNDUU },
|
2013-11-29 17:27:55 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
/* The supported exceptions. */
|
|
|
|
typedef enum
|
|
|
|
{
|
|
|
|
exc_divbyzero,
|
|
|
|
exc_inexact,
|
|
|
|
exc_invalid,
|
|
|
|
exc_overflow,
|
|
|
|
exc_underflow,
|
|
|
|
exc_num_exceptions,
|
|
|
|
exc_first_exception = 0
|
|
|
|
} fp_exception;
|
|
|
|
|
|
|
|
/* List of exceptions, in the same order as the fp_exception
|
|
|
|
enumeration. */
|
|
|
|
static const char *const exceptions[exc_num_exceptions] =
|
|
|
|
{
|
|
|
|
"divbyzero",
|
|
|
|
"inexact",
|
|
|
|
"invalid",
|
|
|
|
"overflow",
|
|
|
|
"underflow",
|
|
|
|
};
|
|
|
|
|
|
|
|
/* The internal precision to use for most MPFR calculations, which
|
|
|
|
must be at least 2 more than the greatest precision of any
|
|
|
|
supported floating-point format. */
|
|
|
|
static int internal_precision;
|
|
|
|
|
|
|
|
/* A value that overflows all supported floating-point formats. */
|
|
|
|
static mpfr_t global_max;
|
|
|
|
|
|
|
|
/* A value that is at most half the least subnormal in any
|
|
|
|
floating-point format and so is rounded the same way as all
|
|
|
|
sufficiently small positive values. */
|
|
|
|
static mpfr_t global_min;
|
|
|
|
|
|
|
|
/* The maximum number of (real or integer) arguments to a function
|
|
|
|
handled by this program (complex arguments count as two real
|
|
|
|
arguments). */
|
|
|
|
#define MAX_NARGS 4
|
|
|
|
|
|
|
|
/* The maximum number of (real or integer) return values from a
|
|
|
|
function handled by this program. */
|
|
|
|
#define MAX_NRET 2
|
|
|
|
|
|
|
|
/* A type of a function argument or return value. */
|
|
|
|
typedef enum
|
|
|
|
{
|
|
|
|
/* No type (not a valid argument or return value). */
|
|
|
|
type_none,
|
|
|
|
/* A floating-point value with the type corresponding to that of
|
|
|
|
the function. */
|
|
|
|
type_fp,
|
|
|
|
/* An integer value of type int. */
|
|
|
|
type_int,
|
|
|
|
/* An integer value of type long. */
|
|
|
|
type_long,
|
|
|
|
/* An integer value of type long long. */
|
|
|
|
type_long_long,
|
|
|
|
} arg_ret_type;
|
|
|
|
|
|
|
|
/* A type of a generic real or integer value. */
|
|
|
|
typedef enum
|
|
|
|
{
|
|
|
|
/* No type. */
|
|
|
|
gtype_none,
|
|
|
|
/* Floating-point (represented with MPFR). */
|
|
|
|
gtype_fp,
|
|
|
|
/* Integer (represented with GMP). */
|
|
|
|
gtype_int,
|
|
|
|
} generic_value_type;
|
|
|
|
|
|
|
|
/* A generic value (argument or result). */
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
/* The type of this value. */
|
|
|
|
generic_value_type type;
|
|
|
|
/* Its value. */
|
|
|
|
union
|
|
|
|
{
|
|
|
|
mpfr_t f;
|
|
|
|
mpz_t i;
|
|
|
|
} value;
|
|
|
|
} generic_value;
|
|
|
|
|
|
|
|
/* A type of input flag. */
|
|
|
|
typedef enum
|
|
|
|
{
|
|
|
|
flag_no_test_inline,
|
2014-06-23 22:15:14 +02:00
|
|
|
flag_ignore_zero_inf_sign,
|
2013-11-29 17:27:55 +01:00
|
|
|
flag_xfail,
|
2013-12-03 17:22:49 +01:00
|
|
|
flag_xfail_rounding,
|
2013-11-29 17:27:55 +01:00
|
|
|
/* The "spurious" and "missing" flags must be in the same order as
|
|
|
|
the fp_exception enumeration. */
|
|
|
|
flag_spurious_divbyzero,
|
|
|
|
flag_spurious_inexact,
|
|
|
|
flag_spurious_invalid,
|
|
|
|
flag_spurious_overflow,
|
|
|
|
flag_spurious_underflow,
|
|
|
|
flag_spurious_errno,
|
|
|
|
flag_missing_divbyzero,
|
|
|
|
flag_missing_inexact,
|
|
|
|
flag_missing_invalid,
|
|
|
|
flag_missing_overflow,
|
|
|
|
flag_missing_underflow,
|
|
|
|
flag_missing_errno,
|
|
|
|
num_input_flag_types,
|
|
|
|
flag_first_flag = 0,
|
|
|
|
flag_spurious_first = flag_spurious_divbyzero,
|
|
|
|
flag_missing_first = flag_missing_divbyzero
|
|
|
|
} input_flag_type;
|
|
|
|
|
|
|
|
/* List of flags, in the same order as the input_flag_type
|
|
|
|
enumeration. */
|
|
|
|
static const char *const input_flags[num_input_flag_types] =
|
|
|
|
{
|
|
|
|
"no-test-inline",
|
2014-06-23 22:15:14 +02:00
|
|
|
"ignore-zero-inf-sign",
|
2013-11-29 17:27:55 +01:00
|
|
|
"xfail",
|
2013-12-03 17:22:49 +01:00
|
|
|
"xfail-rounding",
|
2013-11-29 17:27:55 +01:00
|
|
|
"spurious-divbyzero",
|
|
|
|
"spurious-inexact",
|
|
|
|
"spurious-invalid",
|
|
|
|
"spurious-overflow",
|
|
|
|
"spurious-underflow",
|
|
|
|
"spurious-errno",
|
|
|
|
"missing-divbyzero",
|
|
|
|
"missing-inexact",
|
|
|
|
"missing-invalid",
|
|
|
|
"missing-overflow",
|
|
|
|
"missing-underflow",
|
|
|
|
"missing-errno",
|
|
|
|
};
|
|
|
|
|
|
|
|
/* An input flag, possibly conditional. */
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
/* The type of this flag. */
|
|
|
|
input_flag_type type;
|
|
|
|
/* The conditions on this flag, as a string ":cond1:cond2..." or
|
|
|
|
NULL. */
|
|
|
|
const char *cond;
|
|
|
|
} input_flag;
|
|
|
|
|
|
|
|
/* Structure describing a single test from the input file (which may
|
|
|
|
expand into many tests in the output). The choice of function,
|
|
|
|
which implies the numbers and types of arguments and results, is
|
|
|
|
implicit rather than stored in this structure (except as part of
|
|
|
|
the source line). */
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
/* The text of the input line describing the test, including the
|
|
|
|
trailing newline. */
|
|
|
|
const char *line;
|
|
|
|
/* The number of combinations of interpretations of input values for
|
|
|
|
different floating-point formats and rounding modes. */
|
|
|
|
size_t num_input_cases;
|
|
|
|
/* The corresponding lists of inputs. */
|
|
|
|
generic_value **inputs;
|
|
|
|
/* The number of flags for this test. */
|
|
|
|
size_t num_flags;
|
|
|
|
/* The corresponding list of flags. */
|
|
|
|
input_flag *flags;
|
|
|
|
/* The old output for this test. */
|
|
|
|
const char *old_output;
|
|
|
|
} input_test;
|
|
|
|
|
|
|
|
/* Ways to calculate a function. */
|
|
|
|
typedef enum
|
|
|
|
{
|
|
|
|
/* MPFR function with a single argument and result. */
|
|
|
|
mpfr_f_f,
|
2013-12-16 22:18:07 +01:00
|
|
|
/* MPFR function with two arguments and one result. */
|
|
|
|
mpfr_ff_f,
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
/* MPFR function with three arguments and one result. */
|
|
|
|
mpfr_fff_f,
|
2013-12-09 00:56:28 +01:00
|
|
|
/* MPFR function with a single argument and floating-point and
|
|
|
|
integer results. */
|
|
|
|
mpfr_f_f1,
|
2013-12-18 18:59:29 +01:00
|
|
|
/* MPFR function with integer and floating-point arguments and one
|
|
|
|
result. */
|
|
|
|
mpfr_if_f,
|
2013-12-19 18:21:01 +01:00
|
|
|
/* MPFR function with a single argument and two floating-point
|
|
|
|
results. */
|
|
|
|
mpfr_f_11,
|
2013-12-19 22:28:30 +01:00
|
|
|
/* MPC function with a single complex argument and one real
|
|
|
|
result. */
|
|
|
|
mpc_c_f,
|
Move various TEST_c_c tests from libm-test.inc to auto-libm-test-inc.
This patch moves tests of ccos, ccosh, cexp, clog, csqrt, ctan and
ctanh to auto-libm-test-in, adding the required support to
gen-auto-libm-tests. Other TEST_c_c functions aren't moved for now
(although the relevant table entries are put in gen-auto-libm-tests
for it to know how to handle them): clog10 because of a known MPC bug
causing it to hang for at least some pure imaginary inputs (fixed in
SVN, but I'd rather not rely on unreleased versions of MPFR or MPC
even if relying on very recent releases); the inverse trig and
hyperbolic functions because of known slowness in special cases; and
csin / csinh because of observed slowness that I need to investigate
and report to the MPC maintainers. Slowness can be bypassed by moving
to incremental generation (only for new / changed tests) rather than
regenerating the whole of auto-libm-test-out every time, but that
needs implementing. (This patch takes the time for running
gen-auto-libm-tests from about one second to seven, on my system,
which I think is reasonable. The slow functions would make it take
several minutes at least, which seems unreasonable.)
Tested x86_64 and x86 and ulps updated accordingly.
* math/auto-libm-test-in: Add tests of ccos, ccosh, cexp, clog,
csqrt, ctan and ctanh.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (TEST_COND_x86_64): New macro.
(TEST_COND_x86): Likewise.
(ccos_test_data): Use AUTO_TESTS_c_c.
(ccosh_test_data): Likewise.
(cexp_test_data): Likewise.
(clog_test_data): Likewise.
(csqrt_test_data): Likewise.
(ctan_test_data): Likewise.
(ctan_tonearest_test_data): Likewise.
(ctan_towardzero_test_data): Likewise.
(ctan_downward_test_data): Likewise.
(ctan_upward_test_data): Likewise.
(ctanh_test_data): Likewise.
(ctanh_tonearest_test_data): Likewise.
(ctanh_towardzero_test_data): Likewise.
(ctanh_downward_test_data): Likewise.
(ctanh_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (func_calc_method): Add value
mpc_c_c.
(func_calc_desc): Add mpc_c_c union field.
(FUNC_mpc_c_c): New macro.
(test_functions): Add cacos, cacosh, casin, casinh, catan, catanh,
ccos, ccosh, cexp, clog, clog10, csin, csinh, csqrt, ctan and
ctanh.
(special_fill_min_subnorm_p120): New function.
(special_real_inputs): Add min_subnorm_p120.
(calc_generic_results): Handle mpc_c_c.
* sysdeps/i386/fpu/libm-test-ulps: Update.
* sysdeps/x86_64/fpu/libm-test-ulps: Likewise.
2013-12-20 13:32:44 +01:00
|
|
|
/* MPC function with a single complex argument and one complex
|
|
|
|
result. */
|
|
|
|
mpc_c_c,
|
2013-12-20 13:35:10 +01:00
|
|
|
/* MPC function with two complex arguments and one complex
|
|
|
|
result. */
|
|
|
|
mpc_cc_c,
|
2013-11-29 17:27:55 +01:00
|
|
|
} func_calc_method;
|
|
|
|
|
|
|
|
/* Description of how to calculate a function. */
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
/* Which method is used to calculate the function. */
|
|
|
|
func_calc_method method;
|
|
|
|
/* The specific function called. */
|
|
|
|
union
|
|
|
|
{
|
|
|
|
int (*mpfr_f_f) (mpfr_t, const mpfr_t, mpfr_rnd_t);
|
2013-12-16 22:18:07 +01:00
|
|
|
int (*mpfr_ff_f) (mpfr_t, const mpfr_t, const mpfr_t, mpfr_rnd_t);
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
int (*mpfr_fff_f) (mpfr_t, const mpfr_t, const mpfr_t, const mpfr_t,
|
|
|
|
mpfr_rnd_t);
|
2013-12-09 00:56:28 +01:00
|
|
|
int (*mpfr_f_f1) (mpfr_t, int *, const mpfr_t, mpfr_rnd_t);
|
2013-12-18 18:59:29 +01:00
|
|
|
int (*mpfr_if_f) (mpfr_t, long, const mpfr_t, mpfr_rnd_t);
|
2013-12-19 18:21:01 +01:00
|
|
|
int (*mpfr_f_11) (mpfr_t, mpfr_t, const mpfr_t, mpfr_rnd_t);
|
2013-12-19 22:28:30 +01:00
|
|
|
int (*mpc_c_f) (mpfr_t, const mpc_t, mpfr_rnd_t);
|
Move various TEST_c_c tests from libm-test.inc to auto-libm-test-inc.
This patch moves tests of ccos, ccosh, cexp, clog, csqrt, ctan and
ctanh to auto-libm-test-in, adding the required support to
gen-auto-libm-tests. Other TEST_c_c functions aren't moved for now
(although the relevant table entries are put in gen-auto-libm-tests
for it to know how to handle them): clog10 because of a known MPC bug
causing it to hang for at least some pure imaginary inputs (fixed in
SVN, but I'd rather not rely on unreleased versions of MPFR or MPC
even if relying on very recent releases); the inverse trig and
hyperbolic functions because of known slowness in special cases; and
csin / csinh because of observed slowness that I need to investigate
and report to the MPC maintainers. Slowness can be bypassed by moving
to incremental generation (only for new / changed tests) rather than
regenerating the whole of auto-libm-test-out every time, but that
needs implementing. (This patch takes the time for running
gen-auto-libm-tests from about one second to seven, on my system,
which I think is reasonable. The slow functions would make it take
several minutes at least, which seems unreasonable.)
Tested x86_64 and x86 and ulps updated accordingly.
* math/auto-libm-test-in: Add tests of ccos, ccosh, cexp, clog,
csqrt, ctan and ctanh.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (TEST_COND_x86_64): New macro.
(TEST_COND_x86): Likewise.
(ccos_test_data): Use AUTO_TESTS_c_c.
(ccosh_test_data): Likewise.
(cexp_test_data): Likewise.
(clog_test_data): Likewise.
(csqrt_test_data): Likewise.
(ctan_test_data): Likewise.
(ctan_tonearest_test_data): Likewise.
(ctan_towardzero_test_data): Likewise.
(ctan_downward_test_data): Likewise.
(ctan_upward_test_data): Likewise.
(ctanh_test_data): Likewise.
(ctanh_tonearest_test_data): Likewise.
(ctanh_towardzero_test_data): Likewise.
(ctanh_downward_test_data): Likewise.
(ctanh_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (func_calc_method): Add value
mpc_c_c.
(func_calc_desc): Add mpc_c_c union field.
(FUNC_mpc_c_c): New macro.
(test_functions): Add cacos, cacosh, casin, casinh, catan, catanh,
ccos, ccosh, cexp, clog, clog10, csin, csinh, csqrt, ctan and
ctanh.
(special_fill_min_subnorm_p120): New function.
(special_real_inputs): Add min_subnorm_p120.
(calc_generic_results): Handle mpc_c_c.
* sysdeps/i386/fpu/libm-test-ulps: Update.
* sysdeps/x86_64/fpu/libm-test-ulps: Likewise.
2013-12-20 13:32:44 +01:00
|
|
|
int (*mpc_c_c) (mpc_t, const mpc_t, mpc_rnd_t);
|
2013-12-20 13:35:10 +01:00
|
|
|
int (*mpc_cc_c) (mpc_t, const mpc_t, const mpc_t, mpc_rnd_t);
|
2013-11-29 17:27:55 +01:00
|
|
|
} func;
|
|
|
|
} func_calc_desc;
|
|
|
|
|
|
|
|
/* Structure describing a function handled by this program. */
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
/* The name of the function. */
|
|
|
|
const char *name;
|
|
|
|
/* The number of arguments. */
|
|
|
|
size_t num_args;
|
|
|
|
/* The types of the arguments. */
|
|
|
|
arg_ret_type arg_types[MAX_NARGS];
|
|
|
|
/* The number of return values. */
|
|
|
|
size_t num_ret;
|
|
|
|
/* The types of the return values. */
|
|
|
|
arg_ret_type ret_types[MAX_NRET];
|
|
|
|
/* Whether the function has exactly determined results and
|
|
|
|
exceptions. */
|
|
|
|
bool exact;
|
|
|
|
/* Whether the function is a complex function, so errno setting is
|
|
|
|
optional. */
|
|
|
|
bool complex_fn;
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
/* Whether to treat arguments given as floating-point constants as
|
|
|
|
exact only, rather than rounding them up and down to all
|
|
|
|
formats. */
|
|
|
|
bool exact_args;
|
2013-11-29 17:27:55 +01:00
|
|
|
/* How to calculate this function. */
|
|
|
|
func_calc_desc calc;
|
|
|
|
/* The number of tests allocated for this function. */
|
|
|
|
size_t num_tests_alloc;
|
|
|
|
/* The number of tests for this function. */
|
|
|
|
size_t num_tests;
|
|
|
|
/* The tests themselves. */
|
|
|
|
input_test *tests;
|
|
|
|
} test_function;
|
|
|
|
|
2013-12-09 00:56:28 +01:00
|
|
|
#define ARGS1(T1) 1, { T1 }
|
|
|
|
#define ARGS2(T1, T2) 2, { T1, T2 }
|
|
|
|
#define ARGS3(T1, T2, T3) 3, { T1, T2, T3 }
|
|
|
|
#define ARGS4(T1, T2, T3, T4) 4, { T1, T2, T3, T4 }
|
|
|
|
#define RET1(T1) 1, { T1 }
|
|
|
|
#define RET2(T1, T2) 2, { T1, T2 }
|
|
|
|
#define CALC(TYPE, FN) { TYPE, { .TYPE = FN } }
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
#define FUNC(NAME, ARGS, RET, EXACT, COMPLEX_FN, EXACT_ARGS, CALC) \
|
|
|
|
{ \
|
|
|
|
NAME, ARGS, RET, EXACT, COMPLEX_FN, EXACT_ARGS, CALC, 0, 0, NULL \
|
2013-11-29 17:27:55 +01:00
|
|
|
}
|
|
|
|
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
#define FUNC_mpfr_f_f(NAME, MPFR_FUNC, EXACT) \
|
|
|
|
FUNC (NAME, ARGS1 (type_fp), RET1 (type_fp), EXACT, false, false, \
|
2013-12-09 00:56:28 +01:00
|
|
|
CALC (mpfr_f_f, MPFR_FUNC))
|
2013-12-16 22:18:07 +01:00
|
|
|
#define FUNC_mpfr_ff_f(NAME, MPFR_FUNC, EXACT) \
|
|
|
|
FUNC (NAME, ARGS2 (type_fp, type_fp), RET1 (type_fp), EXACT, false, \
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
false, CALC (mpfr_ff_f, MPFR_FUNC))
|
2013-12-18 18:59:29 +01:00
|
|
|
#define FUNC_mpfr_if_f(NAME, MPFR_FUNC, EXACT) \
|
|
|
|
FUNC (NAME, ARGS2 (type_int, type_fp), RET1 (type_fp), EXACT, false, \
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
false, CALC (mpfr_if_f, MPFR_FUNC))
|
2013-12-19 22:28:30 +01:00
|
|
|
#define FUNC_mpc_c_f(NAME, MPFR_FUNC, EXACT) \
|
|
|
|
FUNC (NAME, ARGS2 (type_fp, type_fp), RET1 (type_fp), EXACT, true, \
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
false, CALC (mpc_c_f, MPFR_FUNC))
|
Move various TEST_c_c tests from libm-test.inc to auto-libm-test-inc.
This patch moves tests of ccos, ccosh, cexp, clog, csqrt, ctan and
ctanh to auto-libm-test-in, adding the required support to
gen-auto-libm-tests. Other TEST_c_c functions aren't moved for now
(although the relevant table entries are put in gen-auto-libm-tests
for it to know how to handle them): clog10 because of a known MPC bug
causing it to hang for at least some pure imaginary inputs (fixed in
SVN, but I'd rather not rely on unreleased versions of MPFR or MPC
even if relying on very recent releases); the inverse trig and
hyperbolic functions because of known slowness in special cases; and
csin / csinh because of observed slowness that I need to investigate
and report to the MPC maintainers. Slowness can be bypassed by moving
to incremental generation (only for new / changed tests) rather than
regenerating the whole of auto-libm-test-out every time, but that
needs implementing. (This patch takes the time for running
gen-auto-libm-tests from about one second to seven, on my system,
which I think is reasonable. The slow functions would make it take
several minutes at least, which seems unreasonable.)
Tested x86_64 and x86 and ulps updated accordingly.
* math/auto-libm-test-in: Add tests of ccos, ccosh, cexp, clog,
csqrt, ctan and ctanh.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (TEST_COND_x86_64): New macro.
(TEST_COND_x86): Likewise.
(ccos_test_data): Use AUTO_TESTS_c_c.
(ccosh_test_data): Likewise.
(cexp_test_data): Likewise.
(clog_test_data): Likewise.
(csqrt_test_data): Likewise.
(ctan_test_data): Likewise.
(ctan_tonearest_test_data): Likewise.
(ctan_towardzero_test_data): Likewise.
(ctan_downward_test_data): Likewise.
(ctan_upward_test_data): Likewise.
(ctanh_test_data): Likewise.
(ctanh_tonearest_test_data): Likewise.
(ctanh_towardzero_test_data): Likewise.
(ctanh_downward_test_data): Likewise.
(ctanh_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (func_calc_method): Add value
mpc_c_c.
(func_calc_desc): Add mpc_c_c union field.
(FUNC_mpc_c_c): New macro.
(test_functions): Add cacos, cacosh, casin, casinh, catan, catanh,
ccos, ccosh, cexp, clog, clog10, csin, csinh, csqrt, ctan and
ctanh.
(special_fill_min_subnorm_p120): New function.
(special_real_inputs): Add min_subnorm_p120.
(calc_generic_results): Handle mpc_c_c.
* sysdeps/i386/fpu/libm-test-ulps: Update.
* sysdeps/x86_64/fpu/libm-test-ulps: Likewise.
2013-12-20 13:32:44 +01:00
|
|
|
#define FUNC_mpc_c_c(NAME, MPFR_FUNC, EXACT) \
|
|
|
|
FUNC (NAME, ARGS2 (type_fp, type_fp), RET2 (type_fp, type_fp), EXACT, \
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
true, false, CALC (mpc_c_c, MPFR_FUNC))
|
2013-12-09 00:56:28 +01:00
|
|
|
|
2013-11-29 17:27:55 +01:00
|
|
|
/* List of functions handled by this program. */
|
|
|
|
static test_function test_functions[] =
|
|
|
|
{
|
2013-11-30 23:04:13 +01:00
|
|
|
FUNC_mpfr_f_f ("acos", mpfr_acos, false),
|
|
|
|
FUNC_mpfr_f_f ("acosh", mpfr_acosh, false),
|
|
|
|
FUNC_mpfr_f_f ("asin", mpfr_asin, false),
|
|
|
|
FUNC_mpfr_f_f ("asinh", mpfr_asinh, false),
|
|
|
|
FUNC_mpfr_f_f ("atan", mpfr_atan, false),
|
2013-12-16 22:18:07 +01:00
|
|
|
FUNC_mpfr_ff_f ("atan2", mpfr_atan2, false),
|
2013-11-30 23:04:13 +01:00
|
|
|
FUNC_mpfr_f_f ("atanh", mpfr_atanh, false),
|
2013-12-19 22:28:30 +01:00
|
|
|
FUNC_mpc_c_f ("cabs", mpc_abs, false),
|
Move various TEST_c_c tests from libm-test.inc to auto-libm-test-inc.
This patch moves tests of ccos, ccosh, cexp, clog, csqrt, ctan and
ctanh to auto-libm-test-in, adding the required support to
gen-auto-libm-tests. Other TEST_c_c functions aren't moved for now
(although the relevant table entries are put in gen-auto-libm-tests
for it to know how to handle them): clog10 because of a known MPC bug
causing it to hang for at least some pure imaginary inputs (fixed in
SVN, but I'd rather not rely on unreleased versions of MPFR or MPC
even if relying on very recent releases); the inverse trig and
hyperbolic functions because of known slowness in special cases; and
csin / csinh because of observed slowness that I need to investigate
and report to the MPC maintainers. Slowness can be bypassed by moving
to incremental generation (only for new / changed tests) rather than
regenerating the whole of auto-libm-test-out every time, but that
needs implementing. (This patch takes the time for running
gen-auto-libm-tests from about one second to seven, on my system,
which I think is reasonable. The slow functions would make it take
several minutes at least, which seems unreasonable.)
Tested x86_64 and x86 and ulps updated accordingly.
* math/auto-libm-test-in: Add tests of ccos, ccosh, cexp, clog,
csqrt, ctan and ctanh.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (TEST_COND_x86_64): New macro.
(TEST_COND_x86): Likewise.
(ccos_test_data): Use AUTO_TESTS_c_c.
(ccosh_test_data): Likewise.
(cexp_test_data): Likewise.
(clog_test_data): Likewise.
(csqrt_test_data): Likewise.
(ctan_test_data): Likewise.
(ctan_tonearest_test_data): Likewise.
(ctan_towardzero_test_data): Likewise.
(ctan_downward_test_data): Likewise.
(ctan_upward_test_data): Likewise.
(ctanh_test_data): Likewise.
(ctanh_tonearest_test_data): Likewise.
(ctanh_towardzero_test_data): Likewise.
(ctanh_downward_test_data): Likewise.
(ctanh_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (func_calc_method): Add value
mpc_c_c.
(func_calc_desc): Add mpc_c_c union field.
(FUNC_mpc_c_c): New macro.
(test_functions): Add cacos, cacosh, casin, casinh, catan, catanh,
ccos, ccosh, cexp, clog, clog10, csin, csinh, csqrt, ctan and
ctanh.
(special_fill_min_subnorm_p120): New function.
(special_real_inputs): Add min_subnorm_p120.
(calc_generic_results): Handle mpc_c_c.
* sysdeps/i386/fpu/libm-test-ulps: Update.
* sysdeps/x86_64/fpu/libm-test-ulps: Likewise.
2013-12-20 13:32:44 +01:00
|
|
|
FUNC_mpc_c_c ("cacos", mpc_acos, false),
|
|
|
|
FUNC_mpc_c_c ("cacosh", mpc_acosh, false),
|
2013-12-19 22:28:30 +01:00
|
|
|
FUNC_mpc_c_f ("carg", mpc_arg, false),
|
Move various TEST_c_c tests from libm-test.inc to auto-libm-test-inc.
This patch moves tests of ccos, ccosh, cexp, clog, csqrt, ctan and
ctanh to auto-libm-test-in, adding the required support to
gen-auto-libm-tests. Other TEST_c_c functions aren't moved for now
(although the relevant table entries are put in gen-auto-libm-tests
for it to know how to handle them): clog10 because of a known MPC bug
causing it to hang for at least some pure imaginary inputs (fixed in
SVN, but I'd rather not rely on unreleased versions of MPFR or MPC
even if relying on very recent releases); the inverse trig and
hyperbolic functions because of known slowness in special cases; and
csin / csinh because of observed slowness that I need to investigate
and report to the MPC maintainers. Slowness can be bypassed by moving
to incremental generation (only for new / changed tests) rather than
regenerating the whole of auto-libm-test-out every time, but that
needs implementing. (This patch takes the time for running
gen-auto-libm-tests from about one second to seven, on my system,
which I think is reasonable. The slow functions would make it take
several minutes at least, which seems unreasonable.)
Tested x86_64 and x86 and ulps updated accordingly.
* math/auto-libm-test-in: Add tests of ccos, ccosh, cexp, clog,
csqrt, ctan and ctanh.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (TEST_COND_x86_64): New macro.
(TEST_COND_x86): Likewise.
(ccos_test_data): Use AUTO_TESTS_c_c.
(ccosh_test_data): Likewise.
(cexp_test_data): Likewise.
(clog_test_data): Likewise.
(csqrt_test_data): Likewise.
(ctan_test_data): Likewise.
(ctan_tonearest_test_data): Likewise.
(ctan_towardzero_test_data): Likewise.
(ctan_downward_test_data): Likewise.
(ctan_upward_test_data): Likewise.
(ctanh_test_data): Likewise.
(ctanh_tonearest_test_data): Likewise.
(ctanh_towardzero_test_data): Likewise.
(ctanh_downward_test_data): Likewise.
(ctanh_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (func_calc_method): Add value
mpc_c_c.
(func_calc_desc): Add mpc_c_c union field.
(FUNC_mpc_c_c): New macro.
(test_functions): Add cacos, cacosh, casin, casinh, catan, catanh,
ccos, ccosh, cexp, clog, clog10, csin, csinh, csqrt, ctan and
ctanh.
(special_fill_min_subnorm_p120): New function.
(special_real_inputs): Add min_subnorm_p120.
(calc_generic_results): Handle mpc_c_c.
* sysdeps/i386/fpu/libm-test-ulps: Update.
* sysdeps/x86_64/fpu/libm-test-ulps: Likewise.
2013-12-20 13:32:44 +01:00
|
|
|
FUNC_mpc_c_c ("casin", mpc_asin, false),
|
|
|
|
FUNC_mpc_c_c ("casinh", mpc_asinh, false),
|
|
|
|
FUNC_mpc_c_c ("catan", mpc_atan, false),
|
|
|
|
FUNC_mpc_c_c ("catanh", mpc_atanh, false),
|
2013-11-30 23:04:13 +01:00
|
|
|
FUNC_mpfr_f_f ("cbrt", mpfr_cbrt, false),
|
Move various TEST_c_c tests from libm-test.inc to auto-libm-test-inc.
This patch moves tests of ccos, ccosh, cexp, clog, csqrt, ctan and
ctanh to auto-libm-test-in, adding the required support to
gen-auto-libm-tests. Other TEST_c_c functions aren't moved for now
(although the relevant table entries are put in gen-auto-libm-tests
for it to know how to handle them): clog10 because of a known MPC bug
causing it to hang for at least some pure imaginary inputs (fixed in
SVN, but I'd rather not rely on unreleased versions of MPFR or MPC
even if relying on very recent releases); the inverse trig and
hyperbolic functions because of known slowness in special cases; and
csin / csinh because of observed slowness that I need to investigate
and report to the MPC maintainers. Slowness can be bypassed by moving
to incremental generation (only for new / changed tests) rather than
regenerating the whole of auto-libm-test-out every time, but that
needs implementing. (This patch takes the time for running
gen-auto-libm-tests from about one second to seven, on my system,
which I think is reasonable. The slow functions would make it take
several minutes at least, which seems unreasonable.)
Tested x86_64 and x86 and ulps updated accordingly.
* math/auto-libm-test-in: Add tests of ccos, ccosh, cexp, clog,
csqrt, ctan and ctanh.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (TEST_COND_x86_64): New macro.
(TEST_COND_x86): Likewise.
(ccos_test_data): Use AUTO_TESTS_c_c.
(ccosh_test_data): Likewise.
(cexp_test_data): Likewise.
(clog_test_data): Likewise.
(csqrt_test_data): Likewise.
(ctan_test_data): Likewise.
(ctan_tonearest_test_data): Likewise.
(ctan_towardzero_test_data): Likewise.
(ctan_downward_test_data): Likewise.
(ctan_upward_test_data): Likewise.
(ctanh_test_data): Likewise.
(ctanh_tonearest_test_data): Likewise.
(ctanh_towardzero_test_data): Likewise.
(ctanh_downward_test_data): Likewise.
(ctanh_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (func_calc_method): Add value
mpc_c_c.
(func_calc_desc): Add mpc_c_c union field.
(FUNC_mpc_c_c): New macro.
(test_functions): Add cacos, cacosh, casin, casinh, catan, catanh,
ccos, ccosh, cexp, clog, clog10, csin, csinh, csqrt, ctan and
ctanh.
(special_fill_min_subnorm_p120): New function.
(special_real_inputs): Add min_subnorm_p120.
(calc_generic_results): Handle mpc_c_c.
* sysdeps/i386/fpu/libm-test-ulps: Update.
* sysdeps/x86_64/fpu/libm-test-ulps: Likewise.
2013-12-20 13:32:44 +01:00
|
|
|
FUNC_mpc_c_c ("ccos", mpc_cos, false),
|
|
|
|
FUNC_mpc_c_c ("ccosh", mpc_cosh, false),
|
|
|
|
FUNC_mpc_c_c ("cexp", mpc_exp, false),
|
|
|
|
FUNC_mpc_c_c ("clog", mpc_log, false),
|
|
|
|
FUNC_mpc_c_c ("clog10", mpc_log10, false),
|
2013-11-30 23:04:13 +01:00
|
|
|
FUNC_mpfr_f_f ("cos", mpfr_cos, false),
|
|
|
|
FUNC_mpfr_f_f ("cosh", mpfr_cosh, false),
|
2013-12-20 13:35:10 +01:00
|
|
|
FUNC ("cpow", ARGS4 (type_fp, type_fp, type_fp, type_fp),
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
RET2 (type_fp, type_fp), false, true, false,
|
|
|
|
CALC (mpc_cc_c, mpc_pow)),
|
Move various TEST_c_c tests from libm-test.inc to auto-libm-test-inc.
This patch moves tests of ccos, ccosh, cexp, clog, csqrt, ctan and
ctanh to auto-libm-test-in, adding the required support to
gen-auto-libm-tests. Other TEST_c_c functions aren't moved for now
(although the relevant table entries are put in gen-auto-libm-tests
for it to know how to handle them): clog10 because of a known MPC bug
causing it to hang for at least some pure imaginary inputs (fixed in
SVN, but I'd rather not rely on unreleased versions of MPFR or MPC
even if relying on very recent releases); the inverse trig and
hyperbolic functions because of known slowness in special cases; and
csin / csinh because of observed slowness that I need to investigate
and report to the MPC maintainers. Slowness can be bypassed by moving
to incremental generation (only for new / changed tests) rather than
regenerating the whole of auto-libm-test-out every time, but that
needs implementing. (This patch takes the time for running
gen-auto-libm-tests from about one second to seven, on my system,
which I think is reasonable. The slow functions would make it take
several minutes at least, which seems unreasonable.)
Tested x86_64 and x86 and ulps updated accordingly.
* math/auto-libm-test-in: Add tests of ccos, ccosh, cexp, clog,
csqrt, ctan and ctanh.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (TEST_COND_x86_64): New macro.
(TEST_COND_x86): Likewise.
(ccos_test_data): Use AUTO_TESTS_c_c.
(ccosh_test_data): Likewise.
(cexp_test_data): Likewise.
(clog_test_data): Likewise.
(csqrt_test_data): Likewise.
(ctan_test_data): Likewise.
(ctan_tonearest_test_data): Likewise.
(ctan_towardzero_test_data): Likewise.
(ctan_downward_test_data): Likewise.
(ctan_upward_test_data): Likewise.
(ctanh_test_data): Likewise.
(ctanh_tonearest_test_data): Likewise.
(ctanh_towardzero_test_data): Likewise.
(ctanh_downward_test_data): Likewise.
(ctanh_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (func_calc_method): Add value
mpc_c_c.
(func_calc_desc): Add mpc_c_c union field.
(FUNC_mpc_c_c): New macro.
(test_functions): Add cacos, cacosh, casin, casinh, catan, catanh,
ccos, ccosh, cexp, clog, clog10, csin, csinh, csqrt, ctan and
ctanh.
(special_fill_min_subnorm_p120): New function.
(special_real_inputs): Add min_subnorm_p120.
(calc_generic_results): Handle mpc_c_c.
* sysdeps/i386/fpu/libm-test-ulps: Update.
* sysdeps/x86_64/fpu/libm-test-ulps: Likewise.
2013-12-20 13:32:44 +01:00
|
|
|
FUNC_mpc_c_c ("csin", mpc_sin, false),
|
|
|
|
FUNC_mpc_c_c ("csinh", mpc_sinh, false),
|
|
|
|
FUNC_mpc_c_c ("csqrt", mpc_sqrt, false),
|
|
|
|
FUNC_mpc_c_c ("ctan", mpc_tan, false),
|
|
|
|
FUNC_mpc_c_c ("ctanh", mpc_tanh, false),
|
2013-11-30 23:04:13 +01:00
|
|
|
FUNC_mpfr_f_f ("erf", mpfr_erf, false),
|
|
|
|
FUNC_mpfr_f_f ("erfc", mpfr_erfc, false),
|
|
|
|
FUNC_mpfr_f_f ("exp", mpfr_exp, false),
|
|
|
|
FUNC_mpfr_f_f ("exp10", mpfr_exp10, false),
|
|
|
|
FUNC_mpfr_f_f ("exp2", mpfr_exp2, false),
|
|
|
|
FUNC_mpfr_f_f ("expm1", mpfr_expm1, false),
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
FUNC ("fma", ARGS3 (type_fp, type_fp, type_fp), RET1 (type_fp),
|
|
|
|
true, false, true, CALC (mpfr_fff_f, mpfr_fma)),
|
2013-12-16 22:18:07 +01:00
|
|
|
FUNC_mpfr_ff_f ("hypot", mpfr_hypot, false),
|
2013-11-30 23:04:13 +01:00
|
|
|
FUNC_mpfr_f_f ("j0", mpfr_j0, false),
|
|
|
|
FUNC_mpfr_f_f ("j1", mpfr_j1, false),
|
2013-12-18 18:59:29 +01:00
|
|
|
FUNC_mpfr_if_f ("jn", mpfr_jn, false),
|
2013-12-09 00:56:28 +01:00
|
|
|
FUNC ("lgamma", ARGS1 (type_fp), RET2 (type_fp, type_int), false, false,
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
false, CALC (mpfr_f_f1, mpfr_lgamma)),
|
2013-11-30 23:04:13 +01:00
|
|
|
FUNC_mpfr_f_f ("log", mpfr_log, false),
|
|
|
|
FUNC_mpfr_f_f ("log10", mpfr_log10, false),
|
|
|
|
FUNC_mpfr_f_f ("log1p", mpfr_log1p, false),
|
|
|
|
FUNC_mpfr_f_f ("log2", mpfr_log2, false),
|
2013-12-16 22:18:07 +01:00
|
|
|
FUNC_mpfr_ff_f ("pow", mpfr_pow, false),
|
2013-11-30 23:04:13 +01:00
|
|
|
FUNC_mpfr_f_f ("sin", mpfr_sin, false),
|
2013-12-19 18:21:01 +01:00
|
|
|
FUNC ("sincos", ARGS1 (type_fp), RET2 (type_fp, type_fp), false, false,
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
false, CALC (mpfr_f_11, mpfr_sin_cos)),
|
2013-11-30 23:04:13 +01:00
|
|
|
FUNC_mpfr_f_f ("sinh", mpfr_sinh, false),
|
2013-11-29 17:27:55 +01:00
|
|
|
FUNC_mpfr_f_f ("sqrt", mpfr_sqrt, true),
|
2013-11-30 23:04:13 +01:00
|
|
|
FUNC_mpfr_f_f ("tan", mpfr_tan, false),
|
|
|
|
FUNC_mpfr_f_f ("tanh", mpfr_tanh, false),
|
|
|
|
FUNC_mpfr_f_f ("tgamma", mpfr_gamma, false),
|
|
|
|
FUNC_mpfr_f_f ("y0", mpfr_y0, false),
|
|
|
|
FUNC_mpfr_f_f ("y1", mpfr_y1, false),
|
2013-12-18 18:59:29 +01:00
|
|
|
FUNC_mpfr_if_f ("yn", mpfr_yn, false),
|
2013-11-29 17:27:55 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Allocate memory, with error checking. */
|
|
|
|
|
|
|
|
static void *
|
|
|
|
xmalloc (size_t n)
|
|
|
|
{
|
|
|
|
void *p = malloc (n);
|
|
|
|
if (p == NULL)
|
|
|
|
error (EXIT_FAILURE, errno, "xmalloc failed");
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *
|
|
|
|
xrealloc (void *p, size_t n)
|
|
|
|
{
|
|
|
|
p = realloc (p, n);
|
|
|
|
if (p == NULL)
|
|
|
|
error (EXIT_FAILURE, errno, "xrealloc failed");
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
|
|
|
xstrdup (const char *s)
|
|
|
|
{
|
|
|
|
char *p = strdup (s);
|
|
|
|
if (p == NULL)
|
|
|
|
error (EXIT_FAILURE, errno, "xstrdup failed");
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Assert that the result of an MPFR operation was exact; that is,
|
|
|
|
that the returned ternary value was 0. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
assert_exact (int i)
|
|
|
|
{
|
|
|
|
assert (i == 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return the generic type of an argument or return value type T. */
|
|
|
|
|
|
|
|
static generic_value_type
|
|
|
|
generic_arg_ret_type (arg_ret_type t)
|
|
|
|
{
|
|
|
|
switch (t)
|
|
|
|
{
|
|
|
|
case type_fp:
|
|
|
|
return gtype_fp;
|
|
|
|
|
|
|
|
case type_int:
|
|
|
|
case type_long:
|
|
|
|
case type_long_long:
|
|
|
|
return gtype_int;
|
|
|
|
|
|
|
|
default:
|
|
|
|
abort ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Free a generic_value *V. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
generic_value_free (generic_value *v)
|
|
|
|
{
|
|
|
|
switch (v->type)
|
|
|
|
{
|
|
|
|
case gtype_fp:
|
|
|
|
mpfr_clear (v->value.f);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case gtype_int:
|
|
|
|
mpz_clear (v->value.i);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
abort ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Copy a generic_value *SRC to *DEST. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
generic_value_copy (generic_value *dest, const generic_value *src)
|
|
|
|
{
|
|
|
|
dest->type = src->type;
|
|
|
|
switch (src->type)
|
|
|
|
{
|
|
|
|
case gtype_fp:
|
|
|
|
mpfr_init (dest->value.f);
|
|
|
|
assert_exact (mpfr_set (dest->value.f, src->value.f, MPFR_RNDN));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case gtype_int:
|
|
|
|
mpz_init (dest->value.i);
|
|
|
|
mpz_set (dest->value.i, src->value.i);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
abort ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize data for floating-point formats. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
init_fp_formats ()
|
|
|
|
{
|
|
|
|
int global_max_exp = 0, global_min_subnorm_exp = 0;
|
|
|
|
for (fp_format f = fp_first_format; f < fp_num_formats; f++)
|
|
|
|
{
|
|
|
|
if (fp_formats[f].mant_dig + 2 > internal_precision)
|
|
|
|
internal_precision = fp_formats[f].mant_dig + 2;
|
|
|
|
if (fp_formats[f].max_exp > global_max_exp)
|
|
|
|
global_max_exp = fp_formats[f].max_exp;
|
|
|
|
int min_subnorm_exp = fp_formats[f].min_exp - fp_formats[f].mant_dig;
|
|
|
|
if (min_subnorm_exp < global_min_subnorm_exp)
|
|
|
|
global_min_subnorm_exp = min_subnorm_exp;
|
|
|
|
mpfr_init2 (fp_formats[f].max, fp_formats[f].mant_dig);
|
|
|
|
if (fp_formats[f].max_string != NULL)
|
|
|
|
{
|
|
|
|
char *ep = NULL;
|
|
|
|
assert_exact (mpfr_strtofr (fp_formats[f].max,
|
|
|
|
fp_formats[f].max_string,
|
|
|
|
&ep, 0, MPFR_RNDN));
|
|
|
|
assert (*ep == 0);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
assert_exact (mpfr_set_ui_2exp (fp_formats[f].max, 1,
|
|
|
|
fp_formats[f].max_exp,
|
|
|
|
MPFR_RNDN));
|
|
|
|
mpfr_nextbelow (fp_formats[f].max);
|
|
|
|
}
|
|
|
|
mpfr_init2 (fp_formats[f].min, fp_formats[f].mant_dig);
|
|
|
|
assert_exact (mpfr_set_ui_2exp (fp_formats[f].min, 1,
|
|
|
|
fp_formats[f].min_exp - 1,
|
|
|
|
MPFR_RNDN));
|
Relax gen-auto-libm-tests may-underflow rules, test log1p in all rounding modes.
gen-auto-libm-tests presently allows but does not require underflow
exceptions for results with magnitude in the range (greatest
subnormal, least normal].
In some cases, the magnitude of the exact result is very slightly
above the least normal, but rounding in the implementation results in
it effectively computing an infinite-precision result that is slightly
below the least normal, so raising an underflow exception. This is in
accordance with the documented accuracy goals, but results in
testsuite failures.
This patch changes the logic to allow underflows when the mathematical
result is up to 0.5ulp above the least normal (so in any case where
the round-to-nearest result is the least normal). Ideally underflows
in all these cases would be accepted only when an underflow with the
actual result is consistent with the rounding mode (in FE_TOWARDZERO
mode, a return value of the least normal implies that the
infinite-precision result did not underflow so there should be no
underflow exception, for example), so as to match the documented goals
more precisely - whereas at present the tests for exceptions are
completely independent of the tests of the returned values. (The same
applies to overflow exceptions as well - they too should be checked
for consistency with the result, as in FE_TOWARDZERO mode a result
1ulp below the largest finite value should be inconsistent with an
overflow exception and cause a failure with overflow rather than
simply being considered a 1ulp error when overflow is expected.) But
the present patch at least deals with the cases causing spurious
failures so that (a) certain existing tests no longer need to be
marked as having spurious exceptions (such markings in
auto-libm-test-in end up applying to more cases than just those they
are needed for) and (b) log1p can be tested in all rounding modes
without introducing more such failures. This patch duly moves tests
of log1p to ALL_RM_TEST.
Tested x86_64 and x86 and ulps updated accordingly.
[BZ #16357]
[BZ #16599]
* math/gen-auto-libm-tests.c (fp_format_desc): Add field
min_plus_half.
(fp_formats): Update initializers.
(init_fp_formats): Initialize new field.
(output_for_one_input_case): Allow underflow for results up to
min_plus_half.
* math/libm-test.inc (log1p_test): Use ALL_RM_TEST.
* math/auto-libm-test-in: Don't mark some underflows from asin and
atanh as spurious.
* math/auto-libm-test-out: Regenerated.
* sysdeps/i386/fpu/libm-test-ulps: Update.
* sysdeps/x86_64/fpu/libm-test-ulps: Likewise.
2014-03-25 13:26:06 +01:00
|
|
|
mpfr_init2 (fp_formats[f].min_plus_half, fp_formats[f].mant_dig + 1);
|
|
|
|
assert_exact (mpfr_set (fp_formats[f].min_plus_half,
|
|
|
|
fp_formats[f].min, MPFR_RNDN));
|
|
|
|
mpfr_nextabove (fp_formats[f].min_plus_half);
|
2013-11-29 17:27:55 +01:00
|
|
|
mpfr_init2 (fp_formats[f].subnorm_max, fp_formats[f].mant_dig);
|
|
|
|
assert_exact (mpfr_set (fp_formats[f].subnorm_max, fp_formats[f].min,
|
|
|
|
MPFR_RNDN));
|
|
|
|
mpfr_nextbelow (fp_formats[f].subnorm_max);
|
|
|
|
mpfr_nextbelow (fp_formats[f].subnorm_max);
|
|
|
|
mpfr_init2 (fp_formats[f].subnorm_min, fp_formats[f].mant_dig);
|
|
|
|
assert_exact (mpfr_set_ui_2exp (fp_formats[f].subnorm_min, 1,
|
|
|
|
min_subnorm_exp, MPFR_RNDN));
|
|
|
|
}
|
|
|
|
mpfr_set_default_prec (internal_precision);
|
|
|
|
mpfr_init (global_max);
|
|
|
|
assert_exact (mpfr_set_ui_2exp (global_max, 1, global_max_exp, MPFR_RNDN));
|
|
|
|
mpfr_init (global_min);
|
|
|
|
assert_exact (mpfr_set_ui_2exp (global_min, 1, global_min_subnorm_exp - 1,
|
|
|
|
MPFR_RNDN));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Fill in mpfr_t values for special strings in input arguments. */
|
|
|
|
|
|
|
|
static size_t
|
|
|
|
special_fill_max (mpfr_t res0, mpfr_t res1 __attribute__ ((unused)),
|
|
|
|
fp_format format)
|
|
|
|
{
|
|
|
|
mpfr_init2 (res0, fp_formats[format].mant_dig);
|
|
|
|
assert_exact (mpfr_set (res0, fp_formats[format].max, MPFR_RNDN));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t
|
|
|
|
special_fill_minus_max (mpfr_t res0, mpfr_t res1 __attribute__ ((unused)),
|
|
|
|
fp_format format)
|
|
|
|
{
|
|
|
|
mpfr_init2 (res0, fp_formats[format].mant_dig);
|
|
|
|
assert_exact (mpfr_neg (res0, fp_formats[format].max, MPFR_RNDN));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-12-16 22:18:07 +01:00
|
|
|
static size_t
|
|
|
|
special_fill_min (mpfr_t res0, mpfr_t res1 __attribute__ ((unused)),
|
|
|
|
fp_format format)
|
|
|
|
{
|
|
|
|
mpfr_init2 (res0, fp_formats[format].mant_dig);
|
|
|
|
assert_exact (mpfr_set (res0, fp_formats[format].min, MPFR_RNDN));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t
|
|
|
|
special_fill_minus_min (mpfr_t res0, mpfr_t res1 __attribute__ ((unused)),
|
|
|
|
fp_format format)
|
|
|
|
{
|
|
|
|
mpfr_init2 (res0, fp_formats[format].mant_dig);
|
|
|
|
assert_exact (mpfr_neg (res0, fp_formats[format].min, MPFR_RNDN));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t
|
|
|
|
special_fill_min_subnorm (mpfr_t res0, mpfr_t res1 __attribute__ ((unused)),
|
|
|
|
fp_format format)
|
|
|
|
{
|
|
|
|
mpfr_init2 (res0, fp_formats[format].mant_dig);
|
|
|
|
assert_exact (mpfr_set (res0, fp_formats[format].subnorm_min, MPFR_RNDN));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t
|
|
|
|
special_fill_minus_min_subnorm (mpfr_t res0,
|
|
|
|
mpfr_t res1 __attribute__ ((unused)),
|
|
|
|
fp_format format)
|
|
|
|
{
|
|
|
|
mpfr_init2 (res0, fp_formats[format].mant_dig);
|
|
|
|
assert_exact (mpfr_neg (res0, fp_formats[format].subnorm_min, MPFR_RNDN));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
Move various TEST_c_c tests from libm-test.inc to auto-libm-test-inc.
This patch moves tests of ccos, ccosh, cexp, clog, csqrt, ctan and
ctanh to auto-libm-test-in, adding the required support to
gen-auto-libm-tests. Other TEST_c_c functions aren't moved for now
(although the relevant table entries are put in gen-auto-libm-tests
for it to know how to handle them): clog10 because of a known MPC bug
causing it to hang for at least some pure imaginary inputs (fixed in
SVN, but I'd rather not rely on unreleased versions of MPFR or MPC
even if relying on very recent releases); the inverse trig and
hyperbolic functions because of known slowness in special cases; and
csin / csinh because of observed slowness that I need to investigate
and report to the MPC maintainers. Slowness can be bypassed by moving
to incremental generation (only for new / changed tests) rather than
regenerating the whole of auto-libm-test-out every time, but that
needs implementing. (This patch takes the time for running
gen-auto-libm-tests from about one second to seven, on my system,
which I think is reasonable. The slow functions would make it take
several minutes at least, which seems unreasonable.)
Tested x86_64 and x86 and ulps updated accordingly.
* math/auto-libm-test-in: Add tests of ccos, ccosh, cexp, clog,
csqrt, ctan and ctanh.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (TEST_COND_x86_64): New macro.
(TEST_COND_x86): Likewise.
(ccos_test_data): Use AUTO_TESTS_c_c.
(ccosh_test_data): Likewise.
(cexp_test_data): Likewise.
(clog_test_data): Likewise.
(csqrt_test_data): Likewise.
(ctan_test_data): Likewise.
(ctan_tonearest_test_data): Likewise.
(ctan_towardzero_test_data): Likewise.
(ctan_downward_test_data): Likewise.
(ctan_upward_test_data): Likewise.
(ctanh_test_data): Likewise.
(ctanh_tonearest_test_data): Likewise.
(ctanh_towardzero_test_data): Likewise.
(ctanh_downward_test_data): Likewise.
(ctanh_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (func_calc_method): Add value
mpc_c_c.
(func_calc_desc): Add mpc_c_c union field.
(FUNC_mpc_c_c): New macro.
(test_functions): Add cacos, cacosh, casin, casinh, catan, catanh,
ccos, ccosh, cexp, clog, clog10, csin, csinh, csqrt, ctan and
ctanh.
(special_fill_min_subnorm_p120): New function.
(special_real_inputs): Add min_subnorm_p120.
(calc_generic_results): Handle mpc_c_c.
* sysdeps/i386/fpu/libm-test-ulps: Update.
* sysdeps/x86_64/fpu/libm-test-ulps: Likewise.
2013-12-20 13:32:44 +01:00
|
|
|
static size_t
|
|
|
|
special_fill_min_subnorm_p120 (mpfr_t res0,
|
|
|
|
mpfr_t res1 __attribute__ ((unused)),
|
|
|
|
fp_format format)
|
|
|
|
{
|
|
|
|
mpfr_init2 (res0, fp_formats[format].mant_dig);
|
|
|
|
assert_exact (mpfr_mul_2ui (res0, fp_formats[format].subnorm_min,
|
|
|
|
120, MPFR_RNDN));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-11-29 17:27:55 +01:00
|
|
|
static size_t
|
|
|
|
special_fill_pi (mpfr_t res0, mpfr_t res1, fp_format format)
|
|
|
|
{
|
|
|
|
mpfr_init2 (res0, fp_formats[format].mant_dig);
|
|
|
|
mpfr_const_pi (res0, MPFR_RNDU);
|
|
|
|
mpfr_init2 (res1, fp_formats[format].mant_dig);
|
|
|
|
mpfr_const_pi (res1, MPFR_RNDD);
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t
|
|
|
|
special_fill_minus_pi (mpfr_t res0, mpfr_t res1, fp_format format)
|
|
|
|
{
|
|
|
|
mpfr_init2 (res0, fp_formats[format].mant_dig);
|
|
|
|
mpfr_const_pi (res0, MPFR_RNDU);
|
|
|
|
assert_exact (mpfr_neg (res0, res0, MPFR_RNDN));
|
|
|
|
mpfr_init2 (res1, fp_formats[format].mant_dig);
|
|
|
|
mpfr_const_pi (res1, MPFR_RNDD);
|
|
|
|
assert_exact (mpfr_neg (res1, res1, MPFR_RNDN));
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
2013-11-30 23:04:13 +01:00
|
|
|
static size_t
|
|
|
|
special_fill_pi_2 (mpfr_t res0, mpfr_t res1, fp_format format)
|
|
|
|
{
|
|
|
|
mpfr_init2 (res0, fp_formats[format].mant_dig);
|
|
|
|
mpfr_const_pi (res0, MPFR_RNDU);
|
|
|
|
assert_exact (mpfr_div_ui (res0, res0, 2, MPFR_RNDN));
|
|
|
|
mpfr_init2 (res1, fp_formats[format].mant_dig);
|
|
|
|
mpfr_const_pi (res1, MPFR_RNDD);
|
|
|
|
assert_exact (mpfr_div_ui (res1, res1, 2, MPFR_RNDN));
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t
|
|
|
|
special_fill_minus_pi_2 (mpfr_t res0, mpfr_t res1, fp_format format)
|
|
|
|
{
|
|
|
|
mpfr_init2 (res0, fp_formats[format].mant_dig);
|
|
|
|
mpfr_const_pi (res0, MPFR_RNDU);
|
|
|
|
assert_exact (mpfr_div_ui (res0, res0, 2, MPFR_RNDN));
|
|
|
|
assert_exact (mpfr_neg (res0, res0, MPFR_RNDN));
|
|
|
|
mpfr_init2 (res1, fp_formats[format].mant_dig);
|
|
|
|
mpfr_const_pi (res1, MPFR_RNDD);
|
|
|
|
assert_exact (mpfr_div_ui (res1, res1, 2, MPFR_RNDN));
|
|
|
|
assert_exact (mpfr_neg (res1, res1, MPFR_RNDN));
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
2013-12-05 14:54:50 +01:00
|
|
|
static size_t
|
|
|
|
special_fill_pi_4 (mpfr_t res0, mpfr_t res1, fp_format format)
|
|
|
|
{
|
|
|
|
mpfr_init2 (res0, fp_formats[format].mant_dig);
|
|
|
|
assert_exact (mpfr_set_si (res0, 1, MPFR_RNDN));
|
|
|
|
mpfr_atan (res0, res0, MPFR_RNDU);
|
|
|
|
mpfr_init2 (res1, fp_formats[format].mant_dig);
|
|
|
|
assert_exact (mpfr_set_si (res1, 1, MPFR_RNDN));
|
|
|
|
mpfr_atan (res1, res1, MPFR_RNDD);
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
2013-11-30 23:04:13 +01:00
|
|
|
static size_t
|
|
|
|
special_fill_pi_6 (mpfr_t res0, mpfr_t res1, fp_format format)
|
|
|
|
{
|
|
|
|
mpfr_init2 (res0, fp_formats[format].mant_dig);
|
|
|
|
assert_exact (mpfr_set_si_2exp (res0, 1, -1, MPFR_RNDN));
|
|
|
|
mpfr_asin (res0, res0, MPFR_RNDU);
|
|
|
|
mpfr_init2 (res1, fp_formats[format].mant_dig);
|
|
|
|
assert_exact (mpfr_set_si_2exp (res1, 1, -1, MPFR_RNDN));
|
|
|
|
mpfr_asin (res1, res1, MPFR_RNDD);
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t
|
|
|
|
special_fill_minus_pi_6 (mpfr_t res0, mpfr_t res1, fp_format format)
|
|
|
|
{
|
|
|
|
mpfr_init2 (res0, fp_formats[format].mant_dig);
|
|
|
|
assert_exact (mpfr_set_si_2exp (res0, -1, -1, MPFR_RNDN));
|
|
|
|
mpfr_asin (res0, res0, MPFR_RNDU);
|
|
|
|
mpfr_init2 (res1, fp_formats[format].mant_dig);
|
|
|
|
assert_exact (mpfr_set_si_2exp (res1, -1, -1, MPFR_RNDN));
|
|
|
|
mpfr_asin (res1, res1, MPFR_RNDD);
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t
|
|
|
|
special_fill_pi_3 (mpfr_t res0, mpfr_t res1, fp_format format)
|
|
|
|
{
|
|
|
|
mpfr_init2 (res0, fp_formats[format].mant_dig);
|
|
|
|
assert_exact (mpfr_set_si_2exp (res0, 1, -1, MPFR_RNDN));
|
|
|
|
mpfr_acos (res0, res0, MPFR_RNDU);
|
|
|
|
mpfr_init2 (res1, fp_formats[format].mant_dig);
|
|
|
|
assert_exact (mpfr_set_si_2exp (res1, 1, -1, MPFR_RNDN));
|
|
|
|
mpfr_acos (res1, res1, MPFR_RNDD);
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t
|
|
|
|
special_fill_2pi_3 (mpfr_t res0, mpfr_t res1, fp_format format)
|
|
|
|
{
|
|
|
|
mpfr_init2 (res0, fp_formats[format].mant_dig);
|
|
|
|
assert_exact (mpfr_set_si_2exp (res0, -1, -1, MPFR_RNDN));
|
|
|
|
mpfr_acos (res0, res0, MPFR_RNDU);
|
|
|
|
mpfr_init2 (res1, fp_formats[format].mant_dig);
|
|
|
|
assert_exact (mpfr_set_si_2exp (res1, -1, -1, MPFR_RNDN));
|
|
|
|
mpfr_acos (res1, res1, MPFR_RNDD);
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
2013-12-20 13:35:10 +01:00
|
|
|
static size_t
|
|
|
|
special_fill_2pi (mpfr_t res0, mpfr_t res1, fp_format format)
|
|
|
|
{
|
|
|
|
mpfr_init2 (res0, fp_formats[format].mant_dig);
|
|
|
|
mpfr_const_pi (res0, MPFR_RNDU);
|
|
|
|
assert_exact (mpfr_mul_ui (res0, res0, 2, MPFR_RNDN));
|
|
|
|
mpfr_init2 (res1, fp_formats[format].mant_dig);
|
|
|
|
mpfr_const_pi (res1, MPFR_RNDD);
|
|
|
|
assert_exact (mpfr_mul_ui (res1, res1, 2, MPFR_RNDN));
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
2013-11-30 23:04:13 +01:00
|
|
|
static size_t
|
|
|
|
special_fill_e (mpfr_t res0, mpfr_t res1, fp_format format)
|
|
|
|
{
|
|
|
|
mpfr_init2 (res0, fp_formats[format].mant_dig);
|
|
|
|
assert_exact (mpfr_set_si (res0, 1, MPFR_RNDN));
|
|
|
|
mpfr_exp (res0, res0, MPFR_RNDU);
|
|
|
|
mpfr_init2 (res1, fp_formats[format].mant_dig);
|
|
|
|
assert_exact (mpfr_set_si (res1, 1, MPFR_RNDN));
|
|
|
|
mpfr_exp (res1, res1, MPFR_RNDD);
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t
|
|
|
|
special_fill_1_e (mpfr_t res0, mpfr_t res1, fp_format format)
|
|
|
|
{
|
|
|
|
mpfr_init2 (res0, fp_formats[format].mant_dig);
|
|
|
|
assert_exact (mpfr_set_si (res0, -1, MPFR_RNDN));
|
|
|
|
mpfr_exp (res0, res0, MPFR_RNDU);
|
|
|
|
mpfr_init2 (res1, fp_formats[format].mant_dig);
|
|
|
|
assert_exact (mpfr_set_si (res1, -1, MPFR_RNDN));
|
|
|
|
mpfr_exp (res1, res1, MPFR_RNDD);
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t
|
|
|
|
special_fill_e_minus_1 (mpfr_t res0, mpfr_t res1, fp_format format)
|
|
|
|
{
|
|
|
|
mpfr_init2 (res0, fp_formats[format].mant_dig);
|
|
|
|
assert_exact (mpfr_set_si (res0, 1, MPFR_RNDN));
|
|
|
|
mpfr_expm1 (res0, res0, MPFR_RNDU);
|
|
|
|
mpfr_init2 (res1, fp_formats[format].mant_dig);
|
|
|
|
assert_exact (mpfr_set_si (res1, 1, MPFR_RNDN));
|
|
|
|
mpfr_expm1 (res1, res1, MPFR_RNDD);
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
2013-11-29 17:27:55 +01:00
|
|
|
/* A special string accepted in input arguments. */
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
/* The string. */
|
|
|
|
const char *str;
|
|
|
|
/* The function that interprets it for a given floating-point
|
|
|
|
format, filling in up to two mpfr_t values and returning the
|
|
|
|
number of values filled. */
|
|
|
|
size_t (*func) (mpfr_t, mpfr_t, fp_format);
|
|
|
|
} special_real_input;
|
|
|
|
|
|
|
|
/* List of special strings accepted in input arguments. */
|
|
|
|
|
|
|
|
static const special_real_input special_real_inputs[] =
|
|
|
|
{
|
|
|
|
{ "max", special_fill_max },
|
|
|
|
{ "-max", special_fill_minus_max },
|
2013-12-16 22:18:07 +01:00
|
|
|
{ "min", special_fill_min },
|
|
|
|
{ "-min", special_fill_minus_min },
|
|
|
|
{ "min_subnorm", special_fill_min_subnorm },
|
|
|
|
{ "-min_subnorm", special_fill_minus_min_subnorm },
|
Move various TEST_c_c tests from libm-test.inc to auto-libm-test-inc.
This patch moves tests of ccos, ccosh, cexp, clog, csqrt, ctan and
ctanh to auto-libm-test-in, adding the required support to
gen-auto-libm-tests. Other TEST_c_c functions aren't moved for now
(although the relevant table entries are put in gen-auto-libm-tests
for it to know how to handle them): clog10 because of a known MPC bug
causing it to hang for at least some pure imaginary inputs (fixed in
SVN, but I'd rather not rely on unreleased versions of MPFR or MPC
even if relying on very recent releases); the inverse trig and
hyperbolic functions because of known slowness in special cases; and
csin / csinh because of observed slowness that I need to investigate
and report to the MPC maintainers. Slowness can be bypassed by moving
to incremental generation (only for new / changed tests) rather than
regenerating the whole of auto-libm-test-out every time, but that
needs implementing. (This patch takes the time for running
gen-auto-libm-tests from about one second to seven, on my system,
which I think is reasonable. The slow functions would make it take
several minutes at least, which seems unreasonable.)
Tested x86_64 and x86 and ulps updated accordingly.
* math/auto-libm-test-in: Add tests of ccos, ccosh, cexp, clog,
csqrt, ctan and ctanh.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (TEST_COND_x86_64): New macro.
(TEST_COND_x86): Likewise.
(ccos_test_data): Use AUTO_TESTS_c_c.
(ccosh_test_data): Likewise.
(cexp_test_data): Likewise.
(clog_test_data): Likewise.
(csqrt_test_data): Likewise.
(ctan_test_data): Likewise.
(ctan_tonearest_test_data): Likewise.
(ctan_towardzero_test_data): Likewise.
(ctan_downward_test_data): Likewise.
(ctan_upward_test_data): Likewise.
(ctanh_test_data): Likewise.
(ctanh_tonearest_test_data): Likewise.
(ctanh_towardzero_test_data): Likewise.
(ctanh_downward_test_data): Likewise.
(ctanh_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (func_calc_method): Add value
mpc_c_c.
(func_calc_desc): Add mpc_c_c union field.
(FUNC_mpc_c_c): New macro.
(test_functions): Add cacos, cacosh, casin, casinh, catan, catanh,
ccos, ccosh, cexp, clog, clog10, csin, csinh, csqrt, ctan and
ctanh.
(special_fill_min_subnorm_p120): New function.
(special_real_inputs): Add min_subnorm_p120.
(calc_generic_results): Handle mpc_c_c.
* sysdeps/i386/fpu/libm-test-ulps: Update.
* sysdeps/x86_64/fpu/libm-test-ulps: Likewise.
2013-12-20 13:32:44 +01:00
|
|
|
{ "min_subnorm_p120", special_fill_min_subnorm_p120 },
|
2013-11-29 17:27:55 +01:00
|
|
|
{ "pi", special_fill_pi },
|
|
|
|
{ "-pi", special_fill_minus_pi },
|
2013-11-30 23:04:13 +01:00
|
|
|
{ "pi/2", special_fill_pi_2 },
|
|
|
|
{ "-pi/2", special_fill_minus_pi_2 },
|
2013-12-05 14:54:50 +01:00
|
|
|
{ "pi/4", special_fill_pi_4 },
|
2013-11-30 23:04:13 +01:00
|
|
|
{ "pi/6", special_fill_pi_6 },
|
|
|
|
{ "-pi/6", special_fill_minus_pi_6 },
|
|
|
|
{ "pi/3", special_fill_pi_3 },
|
|
|
|
{ "2pi/3", special_fill_2pi_3 },
|
2013-12-20 13:35:10 +01:00
|
|
|
{ "2pi", special_fill_2pi },
|
2013-11-30 23:04:13 +01:00
|
|
|
{ "e", special_fill_e },
|
|
|
|
{ "1/e", special_fill_1_e },
|
|
|
|
{ "e-1", special_fill_e_minus_1 },
|
2013-11-29 17:27:55 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Given a real number R computed in round-to-zero mode, set the
|
|
|
|
lowest bit as a sticky bit if INEXACT, and saturate the exponent
|
|
|
|
range for very large or small values. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
adjust_real (mpfr_t r, bool inexact)
|
|
|
|
{
|
|
|
|
if (!inexact)
|
|
|
|
return;
|
|
|
|
/* NaNs are exact, as are infinities in round-to-zero mode. */
|
2013-12-03 17:22:49 +01:00
|
|
|
assert (mpfr_number_p (r));
|
2013-11-29 17:27:55 +01:00
|
|
|
if (mpfr_cmpabs (r, global_min) < 0)
|
|
|
|
assert_exact (mpfr_copysign (r, global_min, r, MPFR_RNDN));
|
|
|
|
else if (mpfr_cmpabs (r, global_max) > 0)
|
|
|
|
assert_exact (mpfr_copysign (r, global_max, r, MPFR_RNDN));
|
|
|
|
else
|
|
|
|
{
|
|
|
|
mpz_t tmp;
|
|
|
|
mpz_init (tmp);
|
|
|
|
mpfr_exp_t e = mpfr_get_z_2exp (tmp, r);
|
2014-02-18 15:45:41 +01:00
|
|
|
if (mpz_sgn (tmp) < 0)
|
|
|
|
{
|
|
|
|
mpz_neg (tmp, tmp);
|
|
|
|
mpz_setbit (tmp, 0);
|
|
|
|
mpz_neg (tmp, tmp);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
mpz_setbit (tmp, 0);
|
2013-11-29 17:27:55 +01:00
|
|
|
assert_exact (mpfr_set_z_2exp (r, tmp, e, MPFR_RNDN));
|
|
|
|
mpz_clear (tmp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Given a finite real number R with sticky bit, compute the roundings
|
|
|
|
to FORMAT in each rounding mode, storing the results in RES, the
|
|
|
|
before-rounding exceptions in EXC_BEFORE and the after-rounding
|
|
|
|
exceptions in EXC_AFTER. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
round_real (mpfr_t res[rm_num_modes],
|
|
|
|
unsigned int exc_before[rm_num_modes],
|
|
|
|
unsigned int exc_after[rm_num_modes],
|
|
|
|
mpfr_t r, fp_format format)
|
|
|
|
{
|
|
|
|
assert (mpfr_number_p (r));
|
|
|
|
for (rounding_mode m = rm_first_mode; m < rm_num_modes; m++)
|
|
|
|
{
|
|
|
|
mpfr_init2 (res[m], fp_formats[format].mant_dig);
|
|
|
|
exc_before[m] = exc_after[m] = 0;
|
|
|
|
bool inexact = mpfr_set (res[m], r, rounding_modes[m].mpfr_mode);
|
|
|
|
if (mpfr_cmpabs (res[m], fp_formats[format].max) > 0)
|
|
|
|
{
|
|
|
|
inexact = true;
|
|
|
|
exc_before[m] |= 1U << exc_overflow;
|
|
|
|
exc_after[m] |= 1U << exc_overflow;
|
|
|
|
bool overflow_inf;
|
|
|
|
switch (m)
|
|
|
|
{
|
|
|
|
case rm_tonearest:
|
|
|
|
overflow_inf = true;
|
|
|
|
break;
|
|
|
|
case rm_towardzero:
|
|
|
|
overflow_inf = false;
|
|
|
|
break;
|
|
|
|
case rm_downward:
|
|
|
|
overflow_inf = mpfr_signbit (res[m]);
|
|
|
|
break;
|
|
|
|
case rm_upward:
|
|
|
|
overflow_inf = !mpfr_signbit (res[m]);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
abort ();
|
|
|
|
}
|
|
|
|
if (overflow_inf)
|
|
|
|
mpfr_set_inf (res[m], mpfr_signbit (res[m]) ? -1 : 1);
|
|
|
|
else
|
|
|
|
assert_exact (mpfr_copysign (res[m], fp_formats[format].max,
|
|
|
|
res[m], MPFR_RNDN));
|
|
|
|
}
|
|
|
|
if (mpfr_cmpabs (r, fp_formats[format].min) < 0)
|
|
|
|
{
|
|
|
|
/* Tiny before rounding; may or may not be tiny after
|
|
|
|
rounding, and underflow applies only if also inexact
|
|
|
|
around rounding to a possibly subnormal value. */
|
|
|
|
bool tiny_after_rounding
|
|
|
|
= mpfr_cmpabs (res[m], fp_formats[format].min) < 0;
|
|
|
|
/* To round to a possibly subnormal value, and determine
|
|
|
|
inexactness as a subnormal in the process, scale up and
|
|
|
|
round to integer, then scale back down. */
|
|
|
|
mpfr_t tmp;
|
|
|
|
mpfr_init (tmp);
|
|
|
|
assert_exact (mpfr_mul_2si (tmp, r, (fp_formats[format].mant_dig
|
|
|
|
- fp_formats[format].min_exp),
|
|
|
|
MPFR_RNDN));
|
|
|
|
int rint_res = mpfr_rint (tmp, tmp, rounding_modes[m].mpfr_mode);
|
|
|
|
/* The integer must be representable. */
|
|
|
|
assert (rint_res == 0 || rint_res == 2 || rint_res == -2);
|
|
|
|
/* If rounding to full precision was inexact, so must
|
|
|
|
rounding to subnormal precision be inexact. */
|
|
|
|
if (inexact)
|
|
|
|
assert (rint_res != 0);
|
|
|
|
else
|
|
|
|
inexact = rint_res != 0;
|
|
|
|
assert_exact (mpfr_mul_2si (res[m], tmp,
|
|
|
|
(fp_formats[format].min_exp
|
|
|
|
- fp_formats[format].mant_dig),
|
|
|
|
MPFR_RNDN));
|
|
|
|
mpfr_clear (tmp);
|
|
|
|
if (inexact)
|
|
|
|
{
|
|
|
|
exc_before[m] |= 1U << exc_underflow;
|
|
|
|
if (tiny_after_rounding)
|
|
|
|
exc_after[m] |= 1U << exc_underflow;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (inexact)
|
|
|
|
{
|
|
|
|
exc_before[m] |= 1U << exc_inexact;
|
|
|
|
exc_after[m] |= 1U << exc_inexact;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Handle the input argument at ARG (NUL-terminated), updating the
|
|
|
|
lists of test inputs in IT accordingly. NUM_PREV_ARGS arguments
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
are already in those lists. If EXACT_ARGS, interpret a value given
|
|
|
|
as a floating-point constant exactly (it must be exact for some
|
|
|
|
supported format) rather than rounding up and down. The argument,
|
|
|
|
of type GTYPE, comes from file FILENAME, line LINENO. */
|
2013-11-29 17:27:55 +01:00
|
|
|
|
|
|
|
static void
|
|
|
|
handle_input_arg (const char *arg, input_test *it, size_t num_prev_args,
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
generic_value_type gtype, bool exact_args,
|
2013-11-29 17:27:55 +01:00
|
|
|
const char *filename, unsigned int lineno)
|
|
|
|
{
|
|
|
|
size_t num_values = 0;
|
|
|
|
generic_value values[2 * fp_num_formats];
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
bool check_empty_list = false;
|
2013-11-29 17:27:55 +01:00
|
|
|
switch (gtype)
|
|
|
|
{
|
|
|
|
case gtype_fp:
|
|
|
|
for (fp_format f = fp_first_format; f < fp_num_formats; f++)
|
|
|
|
{
|
|
|
|
mpfr_t extra_values[2];
|
|
|
|
size_t num_extra_values = 0;
|
|
|
|
for (size_t i = 0; i < ARRAY_SIZE (special_real_inputs); i++)
|
|
|
|
{
|
|
|
|
if (strcmp (arg, special_real_inputs[i].str) == 0)
|
|
|
|
{
|
|
|
|
num_extra_values
|
|
|
|
= special_real_inputs[i].func (extra_values[0],
|
|
|
|
extra_values[1], f);
|
|
|
|
assert (num_extra_values > 0
|
|
|
|
&& num_extra_values <= ARRAY_SIZE (extra_values));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (num_extra_values == 0)
|
|
|
|
{
|
|
|
|
mpfr_t tmp;
|
|
|
|
char *ep;
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
if (exact_args)
|
|
|
|
check_empty_list = true;
|
2013-11-29 17:27:55 +01:00
|
|
|
mpfr_init (tmp);
|
|
|
|
bool inexact = mpfr_strtofr (tmp, arg, &ep, 0, MPFR_RNDZ);
|
|
|
|
if (*ep != 0 || !mpfr_number_p (tmp))
|
|
|
|
error_at_line (EXIT_FAILURE, 0, filename, lineno,
|
|
|
|
"bad floating-point argument: '%s'", arg);
|
|
|
|
adjust_real (tmp, inexact);
|
|
|
|
mpfr_t rounded[rm_num_modes];
|
|
|
|
unsigned int exc_before[rm_num_modes];
|
|
|
|
unsigned int exc_after[rm_num_modes];
|
|
|
|
round_real (rounded, exc_before, exc_after, tmp, f);
|
|
|
|
mpfr_clear (tmp);
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
if (mpfr_number_p (rounded[rm_upward])
|
|
|
|
&& (!exact_args || mpfr_equal_p (rounded[rm_upward],
|
|
|
|
rounded[rm_downward])))
|
2013-11-29 17:27:55 +01:00
|
|
|
{
|
|
|
|
mpfr_init2 (extra_values[num_extra_values],
|
|
|
|
fp_formats[f].mant_dig);
|
|
|
|
assert_exact (mpfr_set (extra_values[num_extra_values],
|
|
|
|
rounded[rm_upward], MPFR_RNDN));
|
|
|
|
num_extra_values++;
|
|
|
|
}
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
if (mpfr_number_p (rounded[rm_downward]) && !exact_args)
|
2013-11-29 17:27:55 +01:00
|
|
|
{
|
|
|
|
mpfr_init2 (extra_values[num_extra_values],
|
|
|
|
fp_formats[f].mant_dig);
|
|
|
|
assert_exact (mpfr_set (extra_values[num_extra_values],
|
|
|
|
rounded[rm_downward], MPFR_RNDN));
|
|
|
|
num_extra_values++;
|
|
|
|
}
|
|
|
|
for (rounding_mode m = rm_first_mode; m < rm_num_modes; m++)
|
|
|
|
mpfr_clear (rounded[m]);
|
|
|
|
}
|
|
|
|
for (size_t i = 0; i < num_extra_values; i++)
|
|
|
|
{
|
|
|
|
bool found = false;
|
|
|
|
for (size_t j = 0; j < num_values; j++)
|
|
|
|
{
|
|
|
|
if (mpfr_equal_p (values[j].value.f, extra_values[i])
|
|
|
|
&& ((mpfr_signbit (values[j].value.f) != 0)
|
|
|
|
== (mpfr_signbit (extra_values[i]) != 0)))
|
|
|
|
{
|
|
|
|
found = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!found)
|
|
|
|
{
|
|
|
|
assert (num_values < ARRAY_SIZE (values));
|
|
|
|
values[num_values].type = gtype_fp;
|
|
|
|
mpfr_init2 (values[num_values].value.f,
|
|
|
|
fp_formats[f].mant_dig);
|
|
|
|
assert_exact (mpfr_set (values[num_values].value.f,
|
|
|
|
extra_values[i], MPFR_RNDN));
|
|
|
|
num_values++;
|
|
|
|
}
|
|
|
|
mpfr_clear (extra_values[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case gtype_int:
|
|
|
|
num_values = 1;
|
|
|
|
values[0].type = gtype_int;
|
|
|
|
int ret = mpz_init_set_str (values[0].value.i, arg, 0);
|
|
|
|
if (ret != 0)
|
|
|
|
error_at_line (EXIT_FAILURE, 0, filename, lineno,
|
|
|
|
"bad integer argument: '%s'", arg);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
abort ();
|
|
|
|
}
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
if (check_empty_list && num_values == 0)
|
|
|
|
error_at_line (EXIT_FAILURE, 0, filename, lineno,
|
|
|
|
"floating-point argument not exact for any format: '%s'",
|
|
|
|
arg);
|
2013-11-29 17:27:55 +01:00
|
|
|
assert (num_values > 0 && num_values <= ARRAY_SIZE (values));
|
|
|
|
if (it->num_input_cases >= SIZE_MAX / num_values)
|
|
|
|
error_at_line (EXIT_FAILURE, 0, filename, lineno, "too many input cases");
|
|
|
|
generic_value **old_inputs = it->inputs;
|
|
|
|
size_t new_num_input_cases = it->num_input_cases * num_values;
|
|
|
|
generic_value **new_inputs = xmalloc (new_num_input_cases
|
|
|
|
* sizeof (new_inputs[0]));
|
|
|
|
for (size_t i = 0; i < it->num_input_cases; i++)
|
|
|
|
{
|
|
|
|
for (size_t j = 0; j < num_values; j++)
|
|
|
|
{
|
|
|
|
size_t idx = i * num_values + j;
|
|
|
|
new_inputs[idx] = xmalloc ((num_prev_args + 1)
|
|
|
|
* sizeof (new_inputs[idx][0]));
|
|
|
|
for (size_t k = 0; k < num_prev_args; k++)
|
|
|
|
generic_value_copy (&new_inputs[idx][k], &old_inputs[i][k]);
|
|
|
|
generic_value_copy (&new_inputs[idx][num_prev_args], &values[j]);
|
|
|
|
}
|
|
|
|
for (size_t j = 0; j < num_prev_args; j++)
|
|
|
|
generic_value_free (&old_inputs[i][j]);
|
|
|
|
free (old_inputs[i]);
|
|
|
|
}
|
|
|
|
free (old_inputs);
|
|
|
|
for (size_t i = 0; i < num_values; i++)
|
|
|
|
generic_value_free (&values[i]);
|
|
|
|
it->inputs = new_inputs;
|
|
|
|
it->num_input_cases = new_num_input_cases;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Handle the input flag ARG (NUL-terminated), storing it in *FLAG.
|
|
|
|
The flag comes from file FILENAME, line LINENO. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
handle_input_flag (char *arg, input_flag *flag,
|
|
|
|
const char *filename, unsigned int lineno)
|
|
|
|
{
|
|
|
|
char *ep = strchr (arg, ':');
|
|
|
|
if (ep == NULL)
|
|
|
|
{
|
|
|
|
ep = strchr (arg, 0);
|
|
|
|
assert (ep != NULL);
|
|
|
|
}
|
|
|
|
char c = *ep;
|
|
|
|
*ep = 0;
|
|
|
|
bool found = false;
|
|
|
|
for (input_flag_type i = flag_first_flag; i <= num_input_flag_types; i++)
|
|
|
|
{
|
|
|
|
if (strcmp (arg, input_flags[i]) == 0)
|
|
|
|
{
|
|
|
|
found = true;
|
|
|
|
flag->type = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!found)
|
|
|
|
error_at_line (EXIT_FAILURE, 0, filename, lineno, "unknown flag: '%s'",
|
|
|
|
arg);
|
|
|
|
*ep = c;
|
|
|
|
if (c == 0)
|
|
|
|
flag->cond = NULL;
|
|
|
|
else
|
|
|
|
flag->cond = xstrdup (ep);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Add the test LINE (file FILENAME, line LINENO) to the test
|
|
|
|
data. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
add_test (char *line, const char *filename, unsigned int lineno)
|
|
|
|
{
|
|
|
|
size_t num_tokens = 1;
|
|
|
|
char *p = line;
|
|
|
|
while ((p = strchr (p, ' ')) != NULL)
|
|
|
|
{
|
|
|
|
num_tokens++;
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
if (num_tokens < 2)
|
|
|
|
error_at_line (EXIT_FAILURE, 0, filename, lineno,
|
|
|
|
"line too short: '%s'", line);
|
|
|
|
p = strchr (line, ' ');
|
|
|
|
size_t func_name_len = p - line;
|
|
|
|
for (size_t i = 0; i < ARRAY_SIZE (test_functions); i++)
|
|
|
|
{
|
|
|
|
if (func_name_len == strlen (test_functions[i].name)
|
|
|
|
&& strncmp (line, test_functions[i].name, func_name_len) == 0)
|
|
|
|
{
|
|
|
|
test_function *tf = &test_functions[i];
|
|
|
|
if (num_tokens < 1 + tf->num_args)
|
|
|
|
error_at_line (EXIT_FAILURE, 0, filename, lineno,
|
|
|
|
"line too short: '%s'", line);
|
|
|
|
if (tf->num_tests == tf->num_tests_alloc)
|
|
|
|
{
|
|
|
|
tf->num_tests_alloc = 2 * tf->num_tests_alloc + 16;
|
|
|
|
tf->tests
|
|
|
|
= xrealloc (tf->tests,
|
|
|
|
tf->num_tests_alloc * sizeof (tf->tests[0]));
|
|
|
|
}
|
|
|
|
input_test *it = &tf->tests[tf->num_tests];
|
|
|
|
it->line = line;
|
|
|
|
it->num_input_cases = 1;
|
|
|
|
it->inputs = xmalloc (sizeof (it->inputs[0]));
|
|
|
|
it->inputs[0] = NULL;
|
|
|
|
it->old_output = NULL;
|
|
|
|
p++;
|
|
|
|
for (size_t j = 0; j < tf->num_args; j++)
|
|
|
|
{
|
|
|
|
char *ep = strchr (p, ' ');
|
|
|
|
if (ep == NULL)
|
|
|
|
{
|
|
|
|
ep = strchr (p, '\n');
|
|
|
|
assert (ep != NULL);
|
|
|
|
}
|
|
|
|
if (ep == p)
|
|
|
|
error_at_line (EXIT_FAILURE, 0, filename, lineno,
|
|
|
|
"empty token in line: '%s'", line);
|
|
|
|
for (char *t = p; t < ep; t++)
|
|
|
|
if (isspace ((unsigned char) *t))
|
|
|
|
error_at_line (EXIT_FAILURE, 0, filename, lineno,
|
|
|
|
"whitespace in token in line: '%s'", line);
|
|
|
|
char c = *ep;
|
|
|
|
*ep = 0;
|
|
|
|
handle_input_arg (p, it, j,
|
|
|
|
generic_arg_ret_type (tf->arg_types[j]),
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
tf->exact_args, filename, lineno);
|
2013-11-29 17:27:55 +01:00
|
|
|
*ep = c;
|
|
|
|
p = ep + 1;
|
|
|
|
}
|
|
|
|
it->num_flags = num_tokens - 1 - tf->num_args;
|
|
|
|
it->flags = xmalloc (it->num_flags * sizeof (it->flags[0]));
|
|
|
|
for (size_t j = 0; j < it->num_flags; j++)
|
|
|
|
{
|
|
|
|
char *ep = strchr (p, ' ');
|
|
|
|
if (ep == NULL)
|
|
|
|
{
|
|
|
|
ep = strchr (p, '\n');
|
|
|
|
assert (ep != NULL);
|
|
|
|
}
|
|
|
|
if (ep == p)
|
|
|
|
error_at_line (EXIT_FAILURE, 0, filename, lineno,
|
|
|
|
"empty token in line: '%s'", line);
|
|
|
|
for (char *t = p; t < ep; t++)
|
|
|
|
if (isspace ((unsigned char) *t))
|
|
|
|
error_at_line (EXIT_FAILURE, 0, filename, lineno,
|
|
|
|
"whitespace in token in line: '%s'", line);
|
|
|
|
char c = *ep;
|
|
|
|
*ep = 0;
|
|
|
|
handle_input_flag (p, &it->flags[j], filename, lineno);
|
|
|
|
*ep = c;
|
|
|
|
p = ep + 1;
|
|
|
|
}
|
|
|
|
assert (*p == 0);
|
|
|
|
tf->num_tests++;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
error_at_line (EXIT_FAILURE, 0, filename, lineno,
|
|
|
|
"unknown function in line: '%s'", line);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Read in the test input data from FILENAME. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
read_input (const char *filename)
|
|
|
|
{
|
|
|
|
FILE *fp = fopen (filename, "r");
|
|
|
|
if (fp == NULL)
|
|
|
|
error (EXIT_FAILURE, errno, "open '%s'", filename);
|
|
|
|
unsigned int lineno = 0;
|
|
|
|
for (;;)
|
|
|
|
{
|
|
|
|
size_t size = 0;
|
|
|
|
char *line = NULL;
|
|
|
|
ssize_t ret = getline (&line, &size, fp);
|
|
|
|
if (ret == -1)
|
|
|
|
break;
|
|
|
|
lineno++;
|
|
|
|
if (line[0] == '#' || line[0] == '\n')
|
|
|
|
continue;
|
|
|
|
add_test (line, filename, lineno);
|
|
|
|
}
|
|
|
|
if (ferror (fp))
|
|
|
|
error (EXIT_FAILURE, errno, "read from '%s'", filename);
|
|
|
|
if (fclose (fp) != 0)
|
|
|
|
error (EXIT_FAILURE, errno, "close '%s'", filename);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Calculate the generic results (round-to-zero with sticky bit) for
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
the function described by CALC, with inputs INPUTS, if MODE is
|
|
|
|
rm_towardzero; for other modes, calculate results in that mode,
|
|
|
|
which must be exact zero results. */
|
2013-11-29 17:27:55 +01:00
|
|
|
|
|
|
|
static void
|
|
|
|
calc_generic_results (generic_value *outputs, generic_value *inputs,
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
const func_calc_desc *calc, rounding_mode mode)
|
2013-11-29 17:27:55 +01:00
|
|
|
{
|
|
|
|
bool inexact;
|
2013-12-20 13:35:10 +01:00
|
|
|
int mpc_ternary;
|
|
|
|
mpc_t ci1, ci2, co;
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
mpfr_rnd_t mode_mpfr = rounding_modes[mode].mpfr_mode;
|
|
|
|
mpc_rnd_t mode_mpc = rounding_modes[mode].mpc_mode;
|
2013-12-20 13:35:10 +01:00
|
|
|
|
2013-11-29 17:27:55 +01:00
|
|
|
switch (calc->method)
|
|
|
|
{
|
|
|
|
case mpfr_f_f:
|
|
|
|
assert (inputs[0].type == gtype_fp);
|
|
|
|
outputs[0].type = gtype_fp;
|
|
|
|
mpfr_init (outputs[0].value.f);
|
|
|
|
inexact = calc->func.mpfr_f_f (outputs[0].value.f, inputs[0].value.f,
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
mode_mpfr);
|
|
|
|
if (mode != rm_towardzero)
|
|
|
|
assert (!inexact && mpfr_zero_p (outputs[0].value.f));
|
2013-11-29 17:27:55 +01:00
|
|
|
adjust_real (outputs[0].value.f, inexact);
|
|
|
|
break;
|
|
|
|
|
2013-12-16 22:18:07 +01:00
|
|
|
case mpfr_ff_f:
|
|
|
|
assert (inputs[0].type == gtype_fp);
|
2013-12-18 18:59:29 +01:00
|
|
|
assert (inputs[1].type == gtype_fp);
|
2013-12-16 22:18:07 +01:00
|
|
|
outputs[0].type = gtype_fp;
|
|
|
|
mpfr_init (outputs[0].value.f);
|
|
|
|
inexact = calc->func.mpfr_ff_f (outputs[0].value.f, inputs[0].value.f,
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
inputs[1].value.f, mode_mpfr);
|
|
|
|
if (mode != rm_towardzero)
|
|
|
|
assert (!inexact && mpfr_zero_p (outputs[0].value.f));
|
|
|
|
adjust_real (outputs[0].value.f, inexact);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case mpfr_fff_f:
|
|
|
|
assert (inputs[0].type == gtype_fp);
|
|
|
|
assert (inputs[1].type == gtype_fp);
|
|
|
|
assert (inputs[2].type == gtype_fp);
|
|
|
|
outputs[0].type = gtype_fp;
|
|
|
|
mpfr_init (outputs[0].value.f);
|
|
|
|
inexact = calc->func.mpfr_fff_f (outputs[0].value.f, inputs[0].value.f,
|
|
|
|
inputs[1].value.f, inputs[2].value.f,
|
|
|
|
mode_mpfr);
|
|
|
|
if (mode != rm_towardzero)
|
|
|
|
assert (!inexact && mpfr_zero_p (outputs[0].value.f));
|
2013-12-16 22:18:07 +01:00
|
|
|
adjust_real (outputs[0].value.f, inexact);
|
|
|
|
break;
|
|
|
|
|
2013-12-09 00:56:28 +01:00
|
|
|
case mpfr_f_f1:
|
|
|
|
assert (inputs[0].type == gtype_fp);
|
|
|
|
outputs[0].type = gtype_fp;
|
|
|
|
outputs[1].type = gtype_int;
|
|
|
|
mpfr_init (outputs[0].value.f);
|
|
|
|
int i = 0;
|
|
|
|
inexact = calc->func.mpfr_f_f1 (outputs[0].value.f, &i,
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
inputs[0].value.f, mode_mpfr);
|
|
|
|
if (mode != rm_towardzero)
|
|
|
|
assert (!inexact && mpfr_zero_p (outputs[0].value.f));
|
2013-12-09 00:56:28 +01:00
|
|
|
adjust_real (outputs[0].value.f, inexact);
|
|
|
|
mpz_init_set_si (outputs[1].value.i, i);
|
|
|
|
break;
|
|
|
|
|
2013-12-18 18:59:29 +01:00
|
|
|
case mpfr_if_f:
|
|
|
|
assert (inputs[0].type == gtype_int);
|
|
|
|
assert (inputs[1].type == gtype_fp);
|
|
|
|
outputs[0].type = gtype_fp;
|
|
|
|
mpfr_init (outputs[0].value.f);
|
|
|
|
assert (mpz_fits_slong_p (inputs[0].value.i));
|
|
|
|
long l = mpz_get_si (inputs[0].value.i);
|
|
|
|
inexact = calc->func.mpfr_if_f (outputs[0].value.f, l,
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
inputs[1].value.f, mode_mpfr);
|
|
|
|
if (mode != rm_towardzero)
|
|
|
|
assert (!inexact && mpfr_zero_p (outputs[0].value.f));
|
2013-12-18 18:59:29 +01:00
|
|
|
adjust_real (outputs[0].value.f, inexact);
|
|
|
|
break;
|
|
|
|
|
2013-12-19 18:21:01 +01:00
|
|
|
case mpfr_f_11:
|
|
|
|
assert (inputs[0].type == gtype_fp);
|
|
|
|
outputs[0].type = gtype_fp;
|
|
|
|
mpfr_init (outputs[0].value.f);
|
|
|
|
outputs[1].type = gtype_fp;
|
|
|
|
mpfr_init (outputs[1].value.f);
|
|
|
|
int comb_ternary = calc->func.mpfr_f_11 (outputs[0].value.f,
|
|
|
|
outputs[1].value.f,
|
|
|
|
inputs[0].value.f,
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
mode_mpfr);
|
|
|
|
if (mode != rm_towardzero)
|
|
|
|
assert (((comb_ternary & 0x3) == 0
|
|
|
|
&& mpfr_zero_p (outputs[0].value.f))
|
|
|
|
|| ((comb_ternary & 0xc) == 0
|
|
|
|
&& mpfr_zero_p (outputs[1].value.f)));
|
2013-12-19 18:21:01 +01:00
|
|
|
adjust_real (outputs[0].value.f, (comb_ternary & 0x3) != 0);
|
|
|
|
adjust_real (outputs[1].value.f, (comb_ternary & 0xc) != 0);
|
|
|
|
break;
|
|
|
|
|
2013-12-19 22:28:30 +01:00
|
|
|
case mpc_c_f:
|
|
|
|
assert (inputs[0].type == gtype_fp);
|
|
|
|
assert (inputs[1].type == gtype_fp);
|
|
|
|
outputs[0].type = gtype_fp;
|
|
|
|
mpfr_init (outputs[0].value.f);
|
2013-12-20 13:35:10 +01:00
|
|
|
mpc_init2 (ci1, internal_precision);
|
|
|
|
assert_exact (mpc_set_fr_fr (ci1, inputs[0].value.f, inputs[1].value.f,
|
2013-12-19 22:28:30 +01:00
|
|
|
MPC_RNDNN));
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
inexact = calc->func.mpc_c_f (outputs[0].value.f, ci1, mode_mpfr);
|
|
|
|
if (mode != rm_towardzero)
|
|
|
|
assert (!inexact && mpfr_zero_p (outputs[0].value.f));
|
2013-12-19 22:28:30 +01:00
|
|
|
adjust_real (outputs[0].value.f, inexact);
|
2013-12-20 13:35:10 +01:00
|
|
|
mpc_clear (ci1);
|
2013-12-19 22:28:30 +01:00
|
|
|
break;
|
|
|
|
|
Move various TEST_c_c tests from libm-test.inc to auto-libm-test-inc.
This patch moves tests of ccos, ccosh, cexp, clog, csqrt, ctan and
ctanh to auto-libm-test-in, adding the required support to
gen-auto-libm-tests. Other TEST_c_c functions aren't moved for now
(although the relevant table entries are put in gen-auto-libm-tests
for it to know how to handle them): clog10 because of a known MPC bug
causing it to hang for at least some pure imaginary inputs (fixed in
SVN, but I'd rather not rely on unreleased versions of MPFR or MPC
even if relying on very recent releases); the inverse trig and
hyperbolic functions because of known slowness in special cases; and
csin / csinh because of observed slowness that I need to investigate
and report to the MPC maintainers. Slowness can be bypassed by moving
to incremental generation (only for new / changed tests) rather than
regenerating the whole of auto-libm-test-out every time, but that
needs implementing. (This patch takes the time for running
gen-auto-libm-tests from about one second to seven, on my system,
which I think is reasonable. The slow functions would make it take
several minutes at least, which seems unreasonable.)
Tested x86_64 and x86 and ulps updated accordingly.
* math/auto-libm-test-in: Add tests of ccos, ccosh, cexp, clog,
csqrt, ctan and ctanh.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (TEST_COND_x86_64): New macro.
(TEST_COND_x86): Likewise.
(ccos_test_data): Use AUTO_TESTS_c_c.
(ccosh_test_data): Likewise.
(cexp_test_data): Likewise.
(clog_test_data): Likewise.
(csqrt_test_data): Likewise.
(ctan_test_data): Likewise.
(ctan_tonearest_test_data): Likewise.
(ctan_towardzero_test_data): Likewise.
(ctan_downward_test_data): Likewise.
(ctan_upward_test_data): Likewise.
(ctanh_test_data): Likewise.
(ctanh_tonearest_test_data): Likewise.
(ctanh_towardzero_test_data): Likewise.
(ctanh_downward_test_data): Likewise.
(ctanh_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (func_calc_method): Add value
mpc_c_c.
(func_calc_desc): Add mpc_c_c union field.
(FUNC_mpc_c_c): New macro.
(test_functions): Add cacos, cacosh, casin, casinh, catan, catanh,
ccos, ccosh, cexp, clog, clog10, csin, csinh, csqrt, ctan and
ctanh.
(special_fill_min_subnorm_p120): New function.
(special_real_inputs): Add min_subnorm_p120.
(calc_generic_results): Handle mpc_c_c.
* sysdeps/i386/fpu/libm-test-ulps: Update.
* sysdeps/x86_64/fpu/libm-test-ulps: Likewise.
2013-12-20 13:32:44 +01:00
|
|
|
case mpc_c_c:
|
|
|
|
assert (inputs[0].type == gtype_fp);
|
|
|
|
assert (inputs[1].type == gtype_fp);
|
|
|
|
outputs[0].type = gtype_fp;
|
|
|
|
mpfr_init (outputs[0].value.f);
|
|
|
|
outputs[1].type = gtype_fp;
|
|
|
|
mpfr_init (outputs[1].value.f);
|
2013-12-20 13:35:10 +01:00
|
|
|
mpc_init2 (ci1, internal_precision);
|
Move various TEST_c_c tests from libm-test.inc to auto-libm-test-inc.
This patch moves tests of ccos, ccosh, cexp, clog, csqrt, ctan and
ctanh to auto-libm-test-in, adding the required support to
gen-auto-libm-tests. Other TEST_c_c functions aren't moved for now
(although the relevant table entries are put in gen-auto-libm-tests
for it to know how to handle them): clog10 because of a known MPC bug
causing it to hang for at least some pure imaginary inputs (fixed in
SVN, but I'd rather not rely on unreleased versions of MPFR or MPC
even if relying on very recent releases); the inverse trig and
hyperbolic functions because of known slowness in special cases; and
csin / csinh because of observed slowness that I need to investigate
and report to the MPC maintainers. Slowness can be bypassed by moving
to incremental generation (only for new / changed tests) rather than
regenerating the whole of auto-libm-test-out every time, but that
needs implementing. (This patch takes the time for running
gen-auto-libm-tests from about one second to seven, on my system,
which I think is reasonable. The slow functions would make it take
several minutes at least, which seems unreasonable.)
Tested x86_64 and x86 and ulps updated accordingly.
* math/auto-libm-test-in: Add tests of ccos, ccosh, cexp, clog,
csqrt, ctan and ctanh.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (TEST_COND_x86_64): New macro.
(TEST_COND_x86): Likewise.
(ccos_test_data): Use AUTO_TESTS_c_c.
(ccosh_test_data): Likewise.
(cexp_test_data): Likewise.
(clog_test_data): Likewise.
(csqrt_test_data): Likewise.
(ctan_test_data): Likewise.
(ctan_tonearest_test_data): Likewise.
(ctan_towardzero_test_data): Likewise.
(ctan_downward_test_data): Likewise.
(ctan_upward_test_data): Likewise.
(ctanh_test_data): Likewise.
(ctanh_tonearest_test_data): Likewise.
(ctanh_towardzero_test_data): Likewise.
(ctanh_downward_test_data): Likewise.
(ctanh_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (func_calc_method): Add value
mpc_c_c.
(func_calc_desc): Add mpc_c_c union field.
(FUNC_mpc_c_c): New macro.
(test_functions): Add cacos, cacosh, casin, casinh, catan, catanh,
ccos, ccosh, cexp, clog, clog10, csin, csinh, csqrt, ctan and
ctanh.
(special_fill_min_subnorm_p120): New function.
(special_real_inputs): Add min_subnorm_p120.
(calc_generic_results): Handle mpc_c_c.
* sysdeps/i386/fpu/libm-test-ulps: Update.
* sysdeps/x86_64/fpu/libm-test-ulps: Likewise.
2013-12-20 13:32:44 +01:00
|
|
|
mpc_init2 (co, internal_precision);
|
2013-12-20 13:35:10 +01:00
|
|
|
assert_exact (mpc_set_fr_fr (ci1, inputs[0].value.f, inputs[1].value.f,
|
|
|
|
MPC_RNDNN));
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
mpc_ternary = calc->func.mpc_c_c (co, ci1, mode_mpc);
|
|
|
|
if (mode != rm_towardzero)
|
|
|
|
assert ((!MPC_INEX_RE (mpc_ternary)
|
|
|
|
&& mpfr_zero_p (mpc_realref (co)))
|
|
|
|
|| (!MPC_INEX_IM (mpc_ternary)
|
|
|
|
&& mpfr_zero_p (mpc_imagref (co))));
|
2013-12-20 13:35:10 +01:00
|
|
|
assert_exact (mpfr_set (outputs[0].value.f, mpc_realref (co),
|
|
|
|
MPFR_RNDN));
|
|
|
|
assert_exact (mpfr_set (outputs[1].value.f, mpc_imagref (co),
|
|
|
|
MPFR_RNDN));
|
|
|
|
adjust_real (outputs[0].value.f, MPC_INEX_RE (mpc_ternary));
|
|
|
|
adjust_real (outputs[1].value.f, MPC_INEX_IM (mpc_ternary));
|
|
|
|
mpc_clear (ci1);
|
|
|
|
mpc_clear (co);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case mpc_cc_c:
|
|
|
|
assert (inputs[0].type == gtype_fp);
|
|
|
|
assert (inputs[1].type == gtype_fp);
|
|
|
|
assert (inputs[2].type == gtype_fp);
|
|
|
|
assert (inputs[3].type == gtype_fp);
|
|
|
|
outputs[0].type = gtype_fp;
|
|
|
|
mpfr_init (outputs[0].value.f);
|
|
|
|
outputs[1].type = gtype_fp;
|
|
|
|
mpfr_init (outputs[1].value.f);
|
|
|
|
mpc_init2 (ci1, internal_precision);
|
|
|
|
mpc_init2 (ci2, internal_precision);
|
|
|
|
mpc_init2 (co, internal_precision);
|
|
|
|
assert_exact (mpc_set_fr_fr (ci1, inputs[0].value.f, inputs[1].value.f,
|
|
|
|
MPC_RNDNN));
|
|
|
|
assert_exact (mpc_set_fr_fr (ci2, inputs[2].value.f, inputs[3].value.f,
|
Move various TEST_c_c tests from libm-test.inc to auto-libm-test-inc.
This patch moves tests of ccos, ccosh, cexp, clog, csqrt, ctan and
ctanh to auto-libm-test-in, adding the required support to
gen-auto-libm-tests. Other TEST_c_c functions aren't moved for now
(although the relevant table entries are put in gen-auto-libm-tests
for it to know how to handle them): clog10 because of a known MPC bug
causing it to hang for at least some pure imaginary inputs (fixed in
SVN, but I'd rather not rely on unreleased versions of MPFR or MPC
even if relying on very recent releases); the inverse trig and
hyperbolic functions because of known slowness in special cases; and
csin / csinh because of observed slowness that I need to investigate
and report to the MPC maintainers. Slowness can be bypassed by moving
to incremental generation (only for new / changed tests) rather than
regenerating the whole of auto-libm-test-out every time, but that
needs implementing. (This patch takes the time for running
gen-auto-libm-tests from about one second to seven, on my system,
which I think is reasonable. The slow functions would make it take
several minutes at least, which seems unreasonable.)
Tested x86_64 and x86 and ulps updated accordingly.
* math/auto-libm-test-in: Add tests of ccos, ccosh, cexp, clog,
csqrt, ctan and ctanh.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (TEST_COND_x86_64): New macro.
(TEST_COND_x86): Likewise.
(ccos_test_data): Use AUTO_TESTS_c_c.
(ccosh_test_data): Likewise.
(cexp_test_data): Likewise.
(clog_test_data): Likewise.
(csqrt_test_data): Likewise.
(ctan_test_data): Likewise.
(ctan_tonearest_test_data): Likewise.
(ctan_towardzero_test_data): Likewise.
(ctan_downward_test_data): Likewise.
(ctan_upward_test_data): Likewise.
(ctanh_test_data): Likewise.
(ctanh_tonearest_test_data): Likewise.
(ctanh_towardzero_test_data): Likewise.
(ctanh_downward_test_data): Likewise.
(ctanh_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (func_calc_method): Add value
mpc_c_c.
(func_calc_desc): Add mpc_c_c union field.
(FUNC_mpc_c_c): New macro.
(test_functions): Add cacos, cacosh, casin, casinh, catan, catanh,
ccos, ccosh, cexp, clog, clog10, csin, csinh, csqrt, ctan and
ctanh.
(special_fill_min_subnorm_p120): New function.
(special_real_inputs): Add min_subnorm_p120.
(calc_generic_results): Handle mpc_c_c.
* sysdeps/i386/fpu/libm-test-ulps: Update.
* sysdeps/x86_64/fpu/libm-test-ulps: Likewise.
2013-12-20 13:32:44 +01:00
|
|
|
MPC_RNDNN));
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
mpc_ternary = calc->func.mpc_cc_c (co, ci1, ci2, mode_mpc);
|
|
|
|
if (mode != rm_towardzero)
|
|
|
|
assert ((!MPC_INEX_RE (mpc_ternary)
|
|
|
|
&& mpfr_zero_p (mpc_realref (co)))
|
|
|
|
|| (!MPC_INEX_IM (mpc_ternary)
|
|
|
|
&& mpfr_zero_p (mpc_imagref (co))));
|
Move various TEST_c_c tests from libm-test.inc to auto-libm-test-inc.
This patch moves tests of ccos, ccosh, cexp, clog, csqrt, ctan and
ctanh to auto-libm-test-in, adding the required support to
gen-auto-libm-tests. Other TEST_c_c functions aren't moved for now
(although the relevant table entries are put in gen-auto-libm-tests
for it to know how to handle them): clog10 because of a known MPC bug
causing it to hang for at least some pure imaginary inputs (fixed in
SVN, but I'd rather not rely on unreleased versions of MPFR or MPC
even if relying on very recent releases); the inverse trig and
hyperbolic functions because of known slowness in special cases; and
csin / csinh because of observed slowness that I need to investigate
and report to the MPC maintainers. Slowness can be bypassed by moving
to incremental generation (only for new / changed tests) rather than
regenerating the whole of auto-libm-test-out every time, but that
needs implementing. (This patch takes the time for running
gen-auto-libm-tests from about one second to seven, on my system,
which I think is reasonable. The slow functions would make it take
several minutes at least, which seems unreasonable.)
Tested x86_64 and x86 and ulps updated accordingly.
* math/auto-libm-test-in: Add tests of ccos, ccosh, cexp, clog,
csqrt, ctan and ctanh.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (TEST_COND_x86_64): New macro.
(TEST_COND_x86): Likewise.
(ccos_test_data): Use AUTO_TESTS_c_c.
(ccosh_test_data): Likewise.
(cexp_test_data): Likewise.
(clog_test_data): Likewise.
(csqrt_test_data): Likewise.
(ctan_test_data): Likewise.
(ctan_tonearest_test_data): Likewise.
(ctan_towardzero_test_data): Likewise.
(ctan_downward_test_data): Likewise.
(ctan_upward_test_data): Likewise.
(ctanh_test_data): Likewise.
(ctanh_tonearest_test_data): Likewise.
(ctanh_towardzero_test_data): Likewise.
(ctanh_downward_test_data): Likewise.
(ctanh_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (func_calc_method): Add value
mpc_c_c.
(func_calc_desc): Add mpc_c_c union field.
(FUNC_mpc_c_c): New macro.
(test_functions): Add cacos, cacosh, casin, casinh, catan, catanh,
ccos, ccosh, cexp, clog, clog10, csin, csinh, csqrt, ctan and
ctanh.
(special_fill_min_subnorm_p120): New function.
(special_real_inputs): Add min_subnorm_p120.
(calc_generic_results): Handle mpc_c_c.
* sysdeps/i386/fpu/libm-test-ulps: Update.
* sysdeps/x86_64/fpu/libm-test-ulps: Likewise.
2013-12-20 13:32:44 +01:00
|
|
|
assert_exact (mpfr_set (outputs[0].value.f, mpc_realref (co),
|
|
|
|
MPFR_RNDN));
|
|
|
|
assert_exact (mpfr_set (outputs[1].value.f, mpc_imagref (co),
|
|
|
|
MPFR_RNDN));
|
|
|
|
adjust_real (outputs[0].value.f, MPC_INEX_RE (mpc_ternary));
|
|
|
|
adjust_real (outputs[1].value.f, MPC_INEX_IM (mpc_ternary));
|
2013-12-20 13:35:10 +01:00
|
|
|
mpc_clear (ci1);
|
|
|
|
mpc_clear (ci2);
|
Move various TEST_c_c tests from libm-test.inc to auto-libm-test-inc.
This patch moves tests of ccos, ccosh, cexp, clog, csqrt, ctan and
ctanh to auto-libm-test-in, adding the required support to
gen-auto-libm-tests. Other TEST_c_c functions aren't moved for now
(although the relevant table entries are put in gen-auto-libm-tests
for it to know how to handle them): clog10 because of a known MPC bug
causing it to hang for at least some pure imaginary inputs (fixed in
SVN, but I'd rather not rely on unreleased versions of MPFR or MPC
even if relying on very recent releases); the inverse trig and
hyperbolic functions because of known slowness in special cases; and
csin / csinh because of observed slowness that I need to investigate
and report to the MPC maintainers. Slowness can be bypassed by moving
to incremental generation (only for new / changed tests) rather than
regenerating the whole of auto-libm-test-out every time, but that
needs implementing. (This patch takes the time for running
gen-auto-libm-tests from about one second to seven, on my system,
which I think is reasonable. The slow functions would make it take
several minutes at least, which seems unreasonable.)
Tested x86_64 and x86 and ulps updated accordingly.
* math/auto-libm-test-in: Add tests of ccos, ccosh, cexp, clog,
csqrt, ctan and ctanh.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (TEST_COND_x86_64): New macro.
(TEST_COND_x86): Likewise.
(ccos_test_data): Use AUTO_TESTS_c_c.
(ccosh_test_data): Likewise.
(cexp_test_data): Likewise.
(clog_test_data): Likewise.
(csqrt_test_data): Likewise.
(ctan_test_data): Likewise.
(ctan_tonearest_test_data): Likewise.
(ctan_towardzero_test_data): Likewise.
(ctan_downward_test_data): Likewise.
(ctan_upward_test_data): Likewise.
(ctanh_test_data): Likewise.
(ctanh_tonearest_test_data): Likewise.
(ctanh_towardzero_test_data): Likewise.
(ctanh_downward_test_data): Likewise.
(ctanh_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (func_calc_method): Add value
mpc_c_c.
(func_calc_desc): Add mpc_c_c union field.
(FUNC_mpc_c_c): New macro.
(test_functions): Add cacos, cacosh, casin, casinh, catan, catanh,
ccos, ccosh, cexp, clog, clog10, csin, csinh, csqrt, ctan and
ctanh.
(special_fill_min_subnorm_p120): New function.
(special_real_inputs): Add min_subnorm_p120.
(calc_generic_results): Handle mpc_c_c.
* sysdeps/i386/fpu/libm-test-ulps: Update.
* sysdeps/x86_64/fpu/libm-test-ulps: Likewise.
2013-12-20 13:32:44 +01:00
|
|
|
mpc_clear (co);
|
|
|
|
break;
|
|
|
|
|
2013-11-29 17:27:55 +01:00
|
|
|
default:
|
|
|
|
abort ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return the number of bits for integer type TYPE, where "long" has
|
|
|
|
LONG_BITS bits (32 or 64). */
|
|
|
|
|
|
|
|
static int
|
|
|
|
int_type_bits (arg_ret_type type, int long_bits)
|
|
|
|
{
|
|
|
|
assert (long_bits == 32 || long_bits == 64);
|
|
|
|
switch (type)
|
|
|
|
{
|
|
|
|
case type_int:
|
|
|
|
return 32;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case type_long:
|
|
|
|
return long_bits;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case type_long_long:
|
|
|
|
return 64;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
abort ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check whether an integer Z fits a given type TYPE, where "long" has
|
|
|
|
LONG_BITS bits (32 or 64). */
|
|
|
|
|
|
|
|
static bool
|
|
|
|
int_fits_type (mpz_t z, arg_ret_type type, int long_bits)
|
|
|
|
{
|
|
|
|
int bits = int_type_bits (type, long_bits);
|
|
|
|
bool ret = true;
|
|
|
|
mpz_t t;
|
|
|
|
mpz_init (t);
|
|
|
|
mpz_ui_pow_ui (t, 2, bits - 1);
|
|
|
|
if (mpz_cmp (z, t) >= 0)
|
|
|
|
ret = false;
|
|
|
|
mpz_neg (t, t);
|
|
|
|
if (mpz_cmp (z, t) < 0)
|
|
|
|
ret = false;
|
|
|
|
mpz_clear (t);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Print a generic value V to FP (name FILENAME), preceded by a space,
|
|
|
|
for type TYPE, floating-point format FORMAT, LONG_BITS bits per
|
|
|
|
long, printing " IGNORE" instead if IGNORE. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
output_generic_value (FILE *fp, const char *filename, const generic_value *v,
|
|
|
|
bool ignore, arg_ret_type type, fp_format format,
|
|
|
|
int long_bits)
|
|
|
|
{
|
|
|
|
if (ignore)
|
|
|
|
{
|
|
|
|
if (fputs (" IGNORE", fp) < 0)
|
|
|
|
error (EXIT_FAILURE, errno, "write to '%s'", filename);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
assert (v->type == generic_arg_ret_type (type));
|
|
|
|
const char *suffix;
|
|
|
|
switch (type)
|
|
|
|
{
|
|
|
|
case type_fp:
|
|
|
|
suffix = fp_formats[format].suffix;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case type_int:
|
|
|
|
suffix = "";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case type_long:
|
|
|
|
suffix = "L";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case type_long_long:
|
|
|
|
suffix = "LL";
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
abort ();
|
|
|
|
}
|
|
|
|
switch (v->type)
|
|
|
|
{
|
|
|
|
case gtype_fp:
|
|
|
|
if (mpfr_inf_p (v->value.f))
|
|
|
|
{
|
|
|
|
if (fputs ((mpfr_signbit (v->value.f)
|
|
|
|
? " minus_infty" : " plus_infty"), fp) < 0)
|
|
|
|
error (EXIT_FAILURE, errno, "write to '%s'", filename);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
assert (mpfr_number_p (v->value.f));
|
|
|
|
if (mpfr_fprintf (fp, " %Ra%s", v->value.f, suffix) < 0)
|
|
|
|
error (EXIT_FAILURE, errno, "mpfr_fprintf to '%s'", filename);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case gtype_int: ;
|
|
|
|
int bits = int_type_bits (type, long_bits);
|
|
|
|
mpz_t tmp;
|
|
|
|
mpz_init (tmp);
|
|
|
|
mpz_ui_pow_ui (tmp, 2, bits - 1);
|
|
|
|
mpz_neg (tmp, tmp);
|
|
|
|
if (mpz_cmp (v->value.i, tmp) == 0)
|
|
|
|
{
|
|
|
|
mpz_add_ui (tmp, tmp, 1);
|
|
|
|
if (mpfr_fprintf (fp, " (%Zd%s-1)", tmp, suffix) < 0)
|
|
|
|
error (EXIT_FAILURE, errno, "mpfr_fprintf to '%s'", filename);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (mpfr_fprintf (fp, " %Zd%s", v->value.i, suffix) < 0)
|
|
|
|
error (EXIT_FAILURE, errno, "mpfr_fprintf to '%s'", filename);
|
|
|
|
}
|
|
|
|
mpz_clear (tmp);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
abort ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Generate test output to FP (name FILENAME) for test function TF,
|
|
|
|
input test IT, choice of input values INPUTS. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
output_for_one_input_case (FILE *fp, const char *filename, test_function *tf,
|
|
|
|
input_test *it, generic_value *inputs)
|
|
|
|
{
|
|
|
|
bool long_bits_matters = false;
|
|
|
|
bool fits_long32 = true;
|
|
|
|
for (size_t i = 0; i < tf->num_args; i++)
|
|
|
|
{
|
|
|
|
generic_value_type gtype = generic_arg_ret_type (tf->arg_types[i]);
|
|
|
|
assert (inputs[i].type == gtype);
|
|
|
|
if (gtype == gtype_int)
|
|
|
|
{
|
|
|
|
bool fits_64 = int_fits_type (inputs[i].value.i, tf->arg_types[i],
|
|
|
|
64);
|
|
|
|
if (!fits_64)
|
|
|
|
return;
|
|
|
|
if (tf->arg_types[i] == type_long
|
|
|
|
&& !int_fits_type (inputs[i].value.i, tf->arg_types[i], 32))
|
|
|
|
{
|
|
|
|
long_bits_matters = true;
|
|
|
|
fits_long32 = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
generic_value generic_outputs[MAX_NRET];
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
calc_generic_results (generic_outputs, inputs, &tf->calc, rm_towardzero);
|
2013-11-29 17:27:55 +01:00
|
|
|
bool ignore_output_long32[MAX_NRET] = { false };
|
|
|
|
bool ignore_output_long64[MAX_NRET] = { false };
|
|
|
|
for (size_t i = 0; i < tf->num_ret; i++)
|
|
|
|
{
|
|
|
|
assert (generic_outputs[i].type
|
|
|
|
== generic_arg_ret_type (tf->ret_types[i]));
|
|
|
|
switch (generic_outputs[i].type)
|
|
|
|
{
|
|
|
|
case gtype_fp:
|
|
|
|
if (!mpfr_number_p (generic_outputs[i].value.f))
|
|
|
|
goto out; /* Result is NaN or exact infinity. */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case gtype_int:
|
|
|
|
ignore_output_long32[i] = !int_fits_type (generic_outputs[i].value.i,
|
|
|
|
tf->ret_types[i], 32);
|
|
|
|
ignore_output_long64[i] = !int_fits_type (generic_outputs[i].value.i,
|
|
|
|
tf->ret_types[i], 64);
|
|
|
|
if (ignore_output_long32[i] != ignore_output_long64[i])
|
|
|
|
long_bits_matters = true;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
abort ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Iterate over relevant sizes of long and floating-point formats. */
|
|
|
|
for (int long_bits = 32; long_bits <= 64; long_bits += 32)
|
|
|
|
{
|
|
|
|
if (long_bits == 32 && !fits_long32)
|
|
|
|
continue;
|
|
|
|
if (long_bits == 64 && !long_bits_matters)
|
|
|
|
continue;
|
|
|
|
const char *long_cond;
|
|
|
|
if (long_bits_matters)
|
|
|
|
long_cond = (long_bits == 32 ? ":long32" : ":long64");
|
|
|
|
else
|
|
|
|
long_cond = "";
|
|
|
|
bool *ignore_output = (long_bits == 32
|
|
|
|
? ignore_output_long32
|
|
|
|
: ignore_output_long64);
|
|
|
|
for (fp_format f = fp_first_format; f < fp_num_formats; f++)
|
|
|
|
{
|
|
|
|
bool fits = true;
|
|
|
|
mpfr_t res[rm_num_modes];
|
|
|
|
unsigned int exc_before[rm_num_modes];
|
|
|
|
unsigned int exc_after[rm_num_modes];
|
|
|
|
for (size_t i = 0; i < tf->num_args; i++)
|
|
|
|
{
|
|
|
|
if (inputs[i].type == gtype_fp)
|
2013-12-18 18:59:29 +01:00
|
|
|
{
|
|
|
|
round_real (res, exc_before, exc_after, inputs[i].value.f,
|
|
|
|
f);
|
|
|
|
if (!mpfr_equal_p (res[rm_tonearest], inputs[i].value.f))
|
|
|
|
fits = false;
|
|
|
|
for (rounding_mode m = rm_first_mode; m < rm_num_modes; m++)
|
|
|
|
mpfr_clear (res[m]);
|
|
|
|
if (!fits)
|
|
|
|
break;
|
|
|
|
}
|
2013-11-29 17:27:55 +01:00
|
|
|
}
|
|
|
|
if (!fits)
|
|
|
|
continue;
|
|
|
|
/* The inputs fit this type, so compute the ideal outputs
|
|
|
|
and exceptions. */
|
|
|
|
mpfr_t all_res[MAX_NRET][rm_num_modes];
|
|
|
|
unsigned int all_exc_before[MAX_NRET][rm_num_modes];
|
|
|
|
unsigned int all_exc_after[MAX_NRET][rm_num_modes];
|
|
|
|
unsigned int merged_exc_before[rm_num_modes] = { 0 };
|
|
|
|
unsigned int merged_exc_after[rm_num_modes] = { 0 };
|
|
|
|
/* For functions not exactly determined, track whether
|
|
|
|
underflow is required (some result is inexact, and
|
|
|
|
magnitude does not exceed the greatest magnitude
|
|
|
|
subnormal), and permitted (not an exact zero, and
|
|
|
|
magnitude does not exceed the least magnitude
|
|
|
|
normal). */
|
|
|
|
bool must_underflow = false;
|
|
|
|
bool may_underflow = false;
|
|
|
|
for (size_t i = 0; i < tf->num_ret; i++)
|
|
|
|
{
|
|
|
|
switch (generic_outputs[i].type)
|
|
|
|
{
|
|
|
|
case gtype_fp:
|
|
|
|
round_real (all_res[i], all_exc_before[i], all_exc_after[i],
|
|
|
|
generic_outputs[i].value.f, f);
|
|
|
|
for (rounding_mode m = rm_first_mode; m < rm_num_modes; m++)
|
|
|
|
{
|
|
|
|
merged_exc_before[m] |= all_exc_before[i][m];
|
|
|
|
merged_exc_after[m] |= all_exc_after[i][m];
|
|
|
|
if (!tf->exact)
|
|
|
|
{
|
|
|
|
must_underflow
|
|
|
|
|= ((all_exc_before[i][m]
|
|
|
|
& (1U << exc_inexact)) != 0
|
|
|
|
&& (mpfr_cmpabs (generic_outputs[i].value.f,
|
|
|
|
fp_formats[f].subnorm_max)
|
|
|
|
<= 0));
|
|
|
|
may_underflow
|
|
|
|
|= (!mpfr_zero_p (generic_outputs[i].value.f)
|
Relax gen-auto-libm-tests may-underflow rules, test log1p in all rounding modes.
gen-auto-libm-tests presently allows but does not require underflow
exceptions for results with magnitude in the range (greatest
subnormal, least normal].
In some cases, the magnitude of the exact result is very slightly
above the least normal, but rounding in the implementation results in
it effectively computing an infinite-precision result that is slightly
below the least normal, so raising an underflow exception. This is in
accordance with the documented accuracy goals, but results in
testsuite failures.
This patch changes the logic to allow underflows when the mathematical
result is up to 0.5ulp above the least normal (so in any case where
the round-to-nearest result is the least normal). Ideally underflows
in all these cases would be accepted only when an underflow with the
actual result is consistent with the rounding mode (in FE_TOWARDZERO
mode, a return value of the least normal implies that the
infinite-precision result did not underflow so there should be no
underflow exception, for example), so as to match the documented goals
more precisely - whereas at present the tests for exceptions are
completely independent of the tests of the returned values. (The same
applies to overflow exceptions as well - they too should be checked
for consistency with the result, as in FE_TOWARDZERO mode a result
1ulp below the largest finite value should be inconsistent with an
overflow exception and cause a failure with overflow rather than
simply being considered a 1ulp error when overflow is expected.) But
the present patch at least deals with the cases causing spurious
failures so that (a) certain existing tests no longer need to be
marked as having spurious exceptions (such markings in
auto-libm-test-in end up applying to more cases than just those they
are needed for) and (b) log1p can be tested in all rounding modes
without introducing more such failures. This patch duly moves tests
of log1p to ALL_RM_TEST.
Tested x86_64 and x86 and ulps updated accordingly.
[BZ #16357]
[BZ #16599]
* math/gen-auto-libm-tests.c (fp_format_desc): Add field
min_plus_half.
(fp_formats): Update initializers.
(init_fp_formats): Initialize new field.
(output_for_one_input_case): Allow underflow for results up to
min_plus_half.
* math/libm-test.inc (log1p_test): Use ALL_RM_TEST.
* math/auto-libm-test-in: Don't mark some underflows from asin and
atanh as spurious.
* math/auto-libm-test-out: Regenerated.
* sysdeps/i386/fpu/libm-test-ulps: Update.
* sysdeps/x86_64/fpu/libm-test-ulps: Likewise.
2014-03-25 13:26:06 +01:00
|
|
|
&& (mpfr_cmpabs (generic_outputs[i].value.f,
|
|
|
|
fp_formats[f].min_plus_half)
|
|
|
|
<= 0));
|
2013-11-29 17:27:55 +01:00
|
|
|
}
|
Move tests of fma from libm-test.inc to auto-libm-test-in.
This patch moves tests of fma to auto-libm-test-in, adding the
required support to gen-auto-libm-tests.
Because fma can have exact zero results depending on the rounding
mode, results of fma cannot always be determined from a single value
computed in higher precision with a sticky bit. Thus, this patch adds
support for recomputing results with the original MPFR/MPC function in
the case where an exact zero is involved. (This also affects some
results for cpow; when we start testing cpow in all rounding modes, I
think it will be most appropriate to make those tests use
IGNORE_ZERO_INF_SIGN, since ISO C does not attempt to determine signs
of zero results, or special caes in general, for cpow, and I think
signs of zero for cpow are beyond the scope of glibc's accuracy
goals.)
Simply treating the existing test inputs for fma like those for other
functions (i.e., as representing the given value rounded up or down to
any of the supported floating-point formats) increases the size of
auto-libm-test-out by about 16MB (i.e., about half the file is fma
test data). While rounded versions of tests are perfectly reasonable
test inputs for fma, in this case having them seems excessive, so this
patch allows functions to specify in gen-auto-libm-tests that the
given test inputs are only to be interpreted exactly, not as
corresponding to values rounded up and down. This reduces the size of
the generated test data for fma to a more reasonable 2MB.
A consequence of this patch is that fma is now tested for correct
presence or absence of "inexact" exceptions, where previously this
wasn't tested because I didn't want to try to add that test coverage
manually to all the existing tests. As far as I know, the existing
fma implementations are already correct in this regard.
This patch provides the first cases where the gen-auto-libm-tests
support for distinguishing before-rounding/after-rounding underflow
actually produces separate entries in auto-libm-test-out (for
functions without exactly determined results, the affected cases are
all considered underflow-optional, so this only affects functions like
fma with exactly determined results). I didn't see any signs of
problems with this logic in the output.
Tested x86_64 and x86.
* math/auto-libm-test-in: Add tests of fma.
* math/auto-libm-test-out: Regenerated.
* math/libm-test.inc (fma_test_data): Use AUTO_TESTS_fff_f.
(fma_towardzero_test_data): Likewise.
(fma_downward_test_data): Likewise.
(fma_upward_test_data): Likewise.
* math/gen-auto-libm-tests.c (rounding_mode_desc): Add field
mpc_mode.
(rounding_modes): Add values for new field.
(func_calc_method): Add value mpfr_fff_f.
(func_calc_desc): Add mpfr_fff_f union field.
(test_function): Add field exact_args.
(FUNC): Add macro argument EXACT_ARGS.
(FUNC_mpfr_f_f): Update call to FUNC.
(FUNC_mpfr_f_f): Likewise.
(FUNC_mpfr_ff_f): Likewise.
(FUNC_mpfr_if_f): Likewise.
(FUNC_mpc_c_f): Likewise.
(FUNC_mpc_c_c): Likewise.
(test_functions): Add fma. Update calls to FUNC.
(handle_input_arg): Add argument exact_args.
(add_test): Update call to handle_input_arg.
(calc_generic_results): Add argument mode. Handle mpfr_fff_f.
(output_for_one_input_case): Update call to calc_generic_results.
Recalculate exact zero results in each rounding mode.
2014-02-18 22:48:51 +01:00
|
|
|
/* If the result is an exact zero, the sign may
|
|
|
|
depend on the rounding mode, so recompute it
|
|
|
|
directly in that mode. */
|
|
|
|
if (mpfr_zero_p (all_res[i][m])
|
|
|
|
&& (all_exc_before[i][m] & (1U << exc_inexact)) == 0)
|
|
|
|
{
|
|
|
|
generic_value outputs_rm[MAX_NRET];
|
|
|
|
calc_generic_results (outputs_rm, inputs,
|
|
|
|
&tf->calc, m);
|
|
|
|
assert_exact (mpfr_set (all_res[i][m],
|
|
|
|
outputs_rm[i].value.f,
|
|
|
|
MPFR_RNDN));
|
|
|
|
for (size_t j = 0; j < tf->num_ret; j++)
|
|
|
|
generic_value_free (&outputs_rm[j]);
|
|
|
|
}
|
2013-11-29 17:27:55 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case gtype_int:
|
|
|
|
if (ignore_output[i])
|
|
|
|
for (rounding_mode m = rm_first_mode;
|
|
|
|
m < rm_num_modes;
|
|
|
|
m++)
|
|
|
|
{
|
|
|
|
merged_exc_before[m] |= 1U << exc_invalid;
|
|
|
|
merged_exc_after[m] |= 1U << exc_invalid;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
abort ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
assert (may_underflow || !must_underflow);
|
|
|
|
for (rounding_mode m = rm_first_mode; m < rm_num_modes; m++)
|
|
|
|
{
|
|
|
|
bool before_after_matters
|
|
|
|
= tf->exact && merged_exc_before[m] != merged_exc_after[m];
|
2014-03-06 15:11:19 +01:00
|
|
|
if (before_after_matters)
|
2013-11-29 17:27:55 +01:00
|
|
|
{
|
2014-03-06 15:11:19 +01:00
|
|
|
assert ((merged_exc_before[m] ^ merged_exc_after[m])
|
|
|
|
== (1U << exc_underflow));
|
|
|
|
assert ((merged_exc_before[m] & (1U << exc_underflow)) != 0);
|
|
|
|
}
|
|
|
|
unsigned int merged_exc = merged_exc_before[m];
|
|
|
|
if (fprintf (fp, "= %s %s %s%s", tf->name,
|
|
|
|
rounding_modes[m].name, fp_formats[f].name,
|
|
|
|
long_cond) < 0)
|
|
|
|
error (EXIT_FAILURE, errno, "write to '%s'", filename);
|
|
|
|
/* Print inputs. */
|
|
|
|
for (size_t i = 0; i < tf->num_args; i++)
|
|
|
|
output_generic_value (fp, filename, &inputs[i], false,
|
|
|
|
tf->arg_types[i], f, long_bits);
|
|
|
|
if (fputs (" :", fp) < 0)
|
|
|
|
error (EXIT_FAILURE, errno, "write to '%s'", filename);
|
|
|
|
/* Print outputs. */
|
|
|
|
bool must_erange = false;
|
|
|
|
for (size_t i = 0; i < tf->num_ret; i++)
|
|
|
|
{
|
|
|
|
generic_value g;
|
|
|
|
g.type = generic_outputs[i].type;
|
|
|
|
switch (g.type)
|
2013-11-29 17:27:55 +01:00
|
|
|
{
|
2014-03-06 15:11:19 +01:00
|
|
|
case gtype_fp:
|
|
|
|
if (mpfr_inf_p (all_res[i][m])
|
|
|
|
&& (all_exc_before[i][m]
|
|
|
|
& (1U << exc_overflow)) != 0)
|
|
|
|
must_erange = true;
|
|
|
|
if (mpfr_zero_p (all_res[i][m])
|
|
|
|
&& (tf->exact
|
|
|
|
|| mpfr_zero_p (all_res[i][rm_tonearest]))
|
|
|
|
&& (all_exc_before[i][m]
|
|
|
|
& (1U << exc_underflow)) != 0)
|
|
|
|
must_erange = true;
|
|
|
|
mpfr_init2 (g.value.f, fp_formats[f].mant_dig);
|
|
|
|
assert_exact (mpfr_set (g.value.f, all_res[i][m],
|
|
|
|
MPFR_RNDN));
|
|
|
|
break;
|
2013-11-29 17:27:55 +01:00
|
|
|
|
2014-03-06 15:11:19 +01:00
|
|
|
case gtype_int:
|
|
|
|
mpz_init (g.value.i);
|
|
|
|
mpz_set (g.value.i, generic_outputs[i].value.i);
|
|
|
|
break;
|
2013-11-29 17:27:55 +01:00
|
|
|
|
2014-03-06 15:11:19 +01:00
|
|
|
default:
|
|
|
|
abort ();
|
2013-11-29 17:27:55 +01:00
|
|
|
}
|
2014-03-06 15:11:19 +01:00
|
|
|
output_generic_value (fp, filename, &g, ignore_output[i],
|
|
|
|
tf->ret_types[i], f, long_bits);
|
|
|
|
generic_value_free (&g);
|
|
|
|
}
|
|
|
|
if (fputs (" :", fp) < 0)
|
|
|
|
error (EXIT_FAILURE, errno, "write to '%s'", filename);
|
|
|
|
/* Print miscellaneous flags (passed through from
|
|
|
|
input). */
|
|
|
|
for (size_t i = 0; i < it->num_flags; i++)
|
|
|
|
switch (it->flags[i].type)
|
|
|
|
{
|
|
|
|
case flag_no_test_inline:
|
2014-06-23 22:15:14 +02:00
|
|
|
case flag_ignore_zero_inf_sign:
|
2014-03-06 15:11:19 +01:00
|
|
|
case flag_xfail:
|
|
|
|
if (fprintf (fp, " %s%s",
|
|
|
|
input_flags[it->flags[i].type],
|
|
|
|
(it->flags[i].cond
|
|
|
|
? it->flags[i].cond
|
|
|
|
: "")) < 0)
|
|
|
|
error (EXIT_FAILURE, errno, "write to '%s'",
|
|
|
|
filename);
|
|
|
|
break;
|
|
|
|
case flag_xfail_rounding:
|
|
|
|
if (m != rm_tonearest)
|
|
|
|
if (fprintf (fp, " xfail%s",
|
|
|
|
(it->flags[i].cond
|
|
|
|
? it->flags[i].cond
|
|
|
|
: "")) < 0)
|
|
|
|
error (EXIT_FAILURE, errno, "write to '%s'",
|
|
|
|
filename);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* Print exception flags and compute errno
|
|
|
|
expectations where not already computed. */
|
|
|
|
bool may_edom = false;
|
|
|
|
bool must_edom = false;
|
|
|
|
bool may_erange = must_erange || may_underflow;
|
|
|
|
for (fp_exception e = exc_first_exception;
|
|
|
|
e < exc_num_exceptions;
|
|
|
|
e++)
|
|
|
|
{
|
|
|
|
bool expect_e = (merged_exc & (1U << e)) != 0;
|
|
|
|
bool e_optional = false;
|
|
|
|
switch (e)
|
|
|
|
{
|
|
|
|
case exc_divbyzero:
|
|
|
|
if (expect_e)
|
|
|
|
may_erange = must_erange = true;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case exc_inexact:
|
|
|
|
if (!tf->exact)
|
|
|
|
e_optional = true;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case exc_invalid:
|
|
|
|
if (expect_e)
|
|
|
|
may_edom = must_edom = true;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case exc_overflow:
|
|
|
|
if (expect_e)
|
|
|
|
may_erange = true;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case exc_underflow:
|
|
|
|
if (expect_e)
|
|
|
|
may_erange = true;
|
|
|
|
if (must_underflow)
|
|
|
|
assert (expect_e);
|
|
|
|
if (may_underflow && !must_underflow)
|
|
|
|
e_optional = true;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
abort ();
|
|
|
|
}
|
|
|
|
if (e_optional)
|
|
|
|
{
|
|
|
|
assert (!before_after_matters);
|
|
|
|
if (fprintf (fp, " %s-ok", exceptions[e]) < 0)
|
|
|
|
error (EXIT_FAILURE, errno, "write to '%s'",
|
|
|
|
filename);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (expect_e)
|
|
|
|
if (fprintf (fp, " %s", exceptions[e]) < 0)
|
2013-11-29 17:27:55 +01:00
|
|
|
error (EXIT_FAILURE, errno, "write to '%s'",
|
|
|
|
filename);
|
2014-03-06 15:11:19 +01:00
|
|
|
if (before_after_matters && e == exc_underflow)
|
|
|
|
if (fputs (":before-rounding", fp) < 0)
|
|
|
|
error (EXIT_FAILURE, errno, "write to '%s'",
|
|
|
|
filename);
|
|
|
|
for (int after = 0; after <= 1; after++)
|
2013-11-29 17:27:55 +01:00
|
|
|
{
|
2014-03-06 15:11:19 +01:00
|
|
|
bool expect_e_here = expect_e;
|
|
|
|
if (after == 1 && (!before_after_matters
|
|
|
|
|| e != exc_underflow))
|
|
|
|
continue;
|
|
|
|
const char *after_cond;
|
|
|
|
if (before_after_matters && e == exc_underflow)
|
|
|
|
{
|
|
|
|
after_cond = (after
|
|
|
|
? ":after-rounding"
|
|
|
|
: ":before-rounding");
|
|
|
|
expect_e_here = !after;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
after_cond = "";
|
2013-11-29 17:27:55 +01:00
|
|
|
input_flag_type okflag;
|
2014-03-06 15:11:19 +01:00
|
|
|
okflag = (expect_e_here
|
2013-11-29 17:27:55 +01:00
|
|
|
? flag_missing_first
|
|
|
|
: flag_spurious_first) + e;
|
|
|
|
for (size_t i = 0; i < it->num_flags; i++)
|
|
|
|
if (it->flags[i].type == okflag)
|
2014-03-06 15:11:19 +01:00
|
|
|
if (fprintf (fp, " %s-ok%s%s",
|
2013-11-29 17:27:55 +01:00
|
|
|
exceptions[e],
|
|
|
|
(it->flags[i].cond
|
|
|
|
? it->flags[i].cond
|
2014-03-06 15:11:19 +01:00
|
|
|
: ""), after_cond) < 0)
|
2013-11-29 17:27:55 +01:00
|
|
|
error (EXIT_FAILURE, errno, "write to '%s'",
|
|
|
|
filename);
|
|
|
|
}
|
|
|
|
}
|
2014-03-06 15:11:19 +01:00
|
|
|
}
|
|
|
|
/* Print errno expectations. */
|
|
|
|
if (tf->complex_fn)
|
|
|
|
{
|
|
|
|
must_edom = false;
|
|
|
|
must_erange = false;
|
|
|
|
}
|
|
|
|
if (may_edom && !must_edom)
|
|
|
|
{
|
|
|
|
if (fputs (" errno-edom-ok", fp) < 0)
|
|
|
|
error (EXIT_FAILURE, errno, "write to '%s'",
|
|
|
|
filename);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (must_edom)
|
|
|
|
if (fputs (" errno-edom", fp) < 0)
|
|
|
|
error (EXIT_FAILURE, errno, "write to '%s'",
|
|
|
|
filename);
|
|
|
|
input_flag_type okflag = (must_edom
|
|
|
|
? flag_missing_errno
|
|
|
|
: flag_spurious_errno);
|
|
|
|
for (size_t i = 0; i < it->num_flags; i++)
|
|
|
|
if (it->flags[i].type == okflag)
|
|
|
|
if (fprintf (fp, " errno-edom-ok%s",
|
|
|
|
(it->flags[i].cond
|
|
|
|
? it->flags[i].cond
|
|
|
|
: "")) < 0)
|
2013-11-29 17:27:55 +01:00
|
|
|
error (EXIT_FAILURE, errno, "write to '%s'",
|
|
|
|
filename);
|
2014-03-06 15:11:19 +01:00
|
|
|
}
|
|
|
|
if (before_after_matters)
|
|
|
|
assert (may_erange && !must_erange);
|
|
|
|
if (may_erange && !must_erange)
|
|
|
|
{
|
|
|
|
if (fprintf (fp, " errno-erange-ok%s",
|
|
|
|
(before_after_matters
|
|
|
|
? ":before-rounding"
|
|
|
|
: "")) < 0)
|
|
|
|
error (EXIT_FAILURE, errno, "write to '%s'",
|
|
|
|
filename);
|
|
|
|
}
|
|
|
|
if (before_after_matters || !(may_erange && !must_erange))
|
|
|
|
{
|
|
|
|
if (must_erange)
|
|
|
|
if (fputs (" errno-erange", fp) < 0)
|
|
|
|
error (EXIT_FAILURE, errno, "write to '%s'",
|
|
|
|
filename);
|
|
|
|
input_flag_type okflag = (must_erange
|
|
|
|
? flag_missing_errno
|
|
|
|
: flag_spurious_errno);
|
|
|
|
for (size_t i = 0; i < it->num_flags; i++)
|
|
|
|
if (it->flags[i].type == okflag)
|
|
|
|
if (fprintf (fp, " errno-erange-ok%s%s",
|
|
|
|
(it->flags[i].cond
|
|
|
|
? it->flags[i].cond
|
|
|
|
: ""),
|
|
|
|
(before_after_matters
|
|
|
|
? ":after-rounding"
|
|
|
|
: "")) < 0)
|
2013-11-29 17:27:55 +01:00
|
|
|
error (EXIT_FAILURE, errno, "write to '%s'",
|
|
|
|
filename);
|
|
|
|
}
|
2014-03-06 15:11:19 +01:00
|
|
|
if (putc ('\n', fp) < 0)
|
|
|
|
error (EXIT_FAILURE, errno, "write to '%s'", filename);
|
2013-11-29 17:27:55 +01:00
|
|
|
}
|
|
|
|
for (size_t i = 0; i < tf->num_ret; i++)
|
|
|
|
{
|
|
|
|
if (generic_outputs[i].type == gtype_fp)
|
|
|
|
for (rounding_mode m = rm_first_mode; m < rm_num_modes; m++)
|
|
|
|
mpfr_clear (all_res[i][m]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
for (size_t i = 0; i < tf->num_ret; i++)
|
|
|
|
generic_value_free (&generic_outputs[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Generate test output data to FILENAME. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
generate_output (const char *filename)
|
|
|
|
{
|
|
|
|
FILE *fp = fopen (filename, "w");
|
|
|
|
if (fp == NULL)
|
|
|
|
error (EXIT_FAILURE, errno, "open '%s'", filename);
|
|
|
|
for (size_t i = 0; i < ARRAY_SIZE (test_functions); i++)
|
|
|
|
{
|
|
|
|
test_function *tf = &test_functions[i];
|
|
|
|
for (size_t j = 0; j < tf->num_tests; j++)
|
|
|
|
{
|
|
|
|
input_test *it = &tf->tests[j];
|
|
|
|
if (fputs (it->line, fp) < 0)
|
|
|
|
error (EXIT_FAILURE, errno, "write to '%s'", filename);
|
|
|
|
for (size_t k = 0; k < it->num_input_cases; k++)
|
|
|
|
output_for_one_input_case (fp, filename, tf, it, it->inputs[k]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (fclose (fp) != 0)
|
|
|
|
error (EXIT_FAILURE, errno, "close '%s'", filename);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
main (int argc, char **argv)
|
|
|
|
{
|
|
|
|
if (argc != 3)
|
|
|
|
error (EXIT_FAILURE, 0, "usage: gen-auto-libm-tests <input> <output>");
|
|
|
|
const char *input_filename = argv[1];
|
|
|
|
const char *output_filename = argv[2];
|
|
|
|
init_fp_formats ();
|
|
|
|
read_input (input_filename);
|
|
|
|
generate_output (output_filename);
|
|
|
|
exit (EXIT_SUCCESS);
|
|
|
|
}
|