glibc/math/s_catan.c
Joseph Myers a84e78c8b3 Fix catan, catanh, __ieee754_logf in round-downward mode (bug 16799, bug 16800).
This patch fixes incorrect results from catan and catanh of certain
special inputs in round-downward mode (bug 16799), and incorrect
results of __ieee754_logf (+/-0) in round-downward mode (bug 16800)
that show up through catan/catanh when tested in all rounding modes,
but not directly in the testing for logf because the bug gets hidden
by the wrappers.

Both bugs involve a zero that should be +0 being -0 instead: one
computed as (1-x)*(1+x) in the catan/catanh case, and one as (x-x) in
the logf case.  The fixes ensure positive zero is used.  Testing of
catan and catanh in all rounding modes is duly enabled.

I expect there are various other bugs in special cases in __ieee754_*
functions that are normally hidden by the wrappers but would show up
for testing with -lieee (or in future with -fno-math-errno if we
replace -lieee and _LIB_VERSION with compile-time redirection to new
*_noerrno symbol names).

Tested x86_64 and x86 and ulps updated accordingly.

	[BZ #16799]
	[BZ #16800]
	* math/s_catan.c (__catan): Avoid passing -0 denominator to atan2
	with 0 numerator.
	* math/s_catanf.c (__catanf): Likewise.
	* math/s_catanh.c (__catanh): Likewise.
	* math/s_catanhf.c (__catanhf): Likewise.
	* math/s_catanhl.c (__catanhl): Likewise.
	* math/s_catanl.c (__catanl): Likewise.
	* sysdeps/ieee754/flt-32/e_logf.c (__ieee754_logf): Always divide
	by positive zero when computing -Inf result.
	* math/libm-test.inc (catan_test): Use ALL_RM_TEST.
	(catanh_test): Likewise.
	* sysdeps/i386/fpu/libm-test-ulps: Update.
	* sysdeps/x86_64/fpu/libm-test-ulps: Likewise.
2014-04-02 17:41:02 +00:00

153 lines
3.9 KiB
C

/* Return arc tangent of complex double value.
Copyright (C) 1997-2014 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
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/>. */
#include <complex.h>
#include <math.h>
#include <math_private.h>
#include <float.h>
__complex__ double
__catan (__complex__ double x)
{
__complex__ double res;
int rcls = fpclassify (__real__ x);
int icls = fpclassify (__imag__ x);
if (__glibc_unlikely (rcls <= FP_INFINITE || icls <= FP_INFINITE))
{
if (rcls == FP_INFINITE)
{
__real__ res = __copysign (M_PI_2, __real__ x);
__imag__ res = __copysign (0.0, __imag__ x);
}
else if (icls == FP_INFINITE)
{
if (rcls >= FP_ZERO)
__real__ res = __copysign (M_PI_2, __real__ x);
else
__real__ res = __nan ("");
__imag__ res = __copysign (0.0, __imag__ x);
}
else if (icls == FP_ZERO || icls == FP_INFINITE)
{
__real__ res = __nan ("");
__imag__ res = __copysign (0.0, __imag__ x);
}
else
{
__real__ res = __nan ("");
__imag__ res = __nan ("");
}
}
else if (__glibc_unlikely (rcls == FP_ZERO && icls == FP_ZERO))
{
res = x;
}
else
{
if (fabs (__real__ x) >= 16.0 / DBL_EPSILON
|| fabs (__imag__ x) >= 16.0 / DBL_EPSILON)
{
__real__ res = __copysign (M_PI_2, __real__ x);
if (fabs (__real__ x) <= 1.0)
__imag__ res = 1.0 / __imag__ x;
else if (fabs (__imag__ x) <= 1.0)
__imag__ res = __imag__ x / __real__ x / __real__ x;
else
{
double h = __ieee754_hypot (__real__ x / 2.0, __imag__ x / 2.0);
__imag__ res = __imag__ x / h / h / 4.0;
}
}
else
{
double den, absx, absy;
absx = fabs (__real__ x);
absy = fabs (__imag__ x);
if (absx < absy)
{
double t = absx;
absx = absy;
absy = t;
}
if (absy < DBL_EPSILON / 2.0)
{
den = (1.0 - absx) * (1.0 + absx);
if (den == -0.0)
den = 0.0;
}
else if (absx >= 1.0)
den = (1.0 - absx) * (1.0 + absx) - absy * absy;
else if (absx >= 0.75 || absy >= 0.5)
den = -__x2y2m1 (absx, absy);
else
den = (1.0 - absx) * (1.0 + absx) - absy * absy;
__real__ res = 0.5 * __ieee754_atan2 (2.0 * __real__ x, den);
if (fabs (__imag__ x) == 1.0
&& fabs (__real__ x) < DBL_EPSILON * DBL_EPSILON)
__imag__ res = (__copysign (0.5, __imag__ x)
* (M_LN2 - __ieee754_log (fabs (__real__ x))));
else
{
double r2 = 0.0, num, f;
if (fabs (__real__ x) >= DBL_EPSILON * DBL_EPSILON)
r2 = __real__ x * __real__ x;
num = __imag__ x + 1.0;
num = r2 + num * num;
den = __imag__ x - 1.0;
den = r2 + den * den;
f = num / den;
if (f < 0.5)
__imag__ res = 0.25 * __ieee754_log (f);
else
{
num = 4.0 * __imag__ x;
__imag__ res = 0.25 * __log1p (num / den);
}
}
}
if (fabs (__real__ res) < DBL_MIN)
{
volatile double force_underflow = __real__ res * __real__ res;
(void) force_underflow;
}
if (fabs (__imag__ res) < DBL_MIN)
{
volatile double force_underflow = __imag__ res * __imag__ res;
(void) force_underflow;
}
}
return res;
}
weak_alias (__catan, catan)
#ifdef NO_LONG_DOUBLE
strong_alias (__catan, __catanl)
weak_alias (__catan, catanl)
#endif