summary refs log tree commit diff
path: root/math
diff options
context:
space:
mode:
Diffstat (limited to 'math')
-rw-r--r--math/Makefile11
-rw-r--r--math/atest-exp.c191
-rw-r--r--math/atest-sincos.c275
-rw-r--r--math/libm-test.c14
4 files changed, 480 insertions, 11 deletions
diff --git a/math/Makefile b/math/Makefile
index 3b1ff4332b..62619111c9 100644
--- a/math/Makefile
+++ b/math/Makefile
@@ -77,14 +77,15 @@ distribute += $(long-c-yes:=.c)
 
 # Rules for the test suite.
 tests = test-float test-double $(test-longdouble-$(long-double-fcts)) \
-	test-ifloat test-idouble test-matherr test-fenv
+	test-ifloat test-idouble test-matherr test-fenv \
+	atest-exp atest-sincos
 # We do the `long double' tests only if this data type is available and
 # distrinct from `double'.
 test-longdouble-yes = test-ldouble test-ildoubl
 
-CFLAGS-test-float.c = -fno-inline
-CFLAGS-test-double.c = -fno-inline
-CFLAGS-test-ldouble.c = -fno-inline
+CFLAGS-test-float.c = -fno-inline -ffloat-store
+CFLAGS-test-double.c = -fno-inline -ffloat-store
+CFLAGS-test-ldouble.c = -fno-inline -ffloat-store
 LDLIBS-test-ifloat = math/libm
 LDLIBS-test-idouble = math/libm
 LDLIBS-test-ildoubl = math/libm
@@ -92,6 +93,8 @@ LDLIBS-test-float = math/libm
 LDLIBS-test-double = math/libm
 LDLIBS-test-ldouble = math/libm
 LDLIBS-test-matherr = math/libm
+LDLIBS-atest-exp = math/libm
+LDLIBS-atest-sincos = math/libm
 
 distribute += libm-test.c
 
diff --git a/math/atest-exp.c b/math/atest-exp.c
new file mode 100644
index 0000000000..28e572c444
--- /dev/null
+++ b/math/atest-exp.c
@@ -0,0 +1,191 @@
+/* Copyright (C) 1997 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Geoffrey Keating <Geoff.Keating@anu.edu.au>, 1997.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public
+   License along with the GNU C Library; see the file COPYING.LIB.  If not,
+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include <stdio.h>
+#include <math.h>
+#include <stdlib/gmp.h>
+#include <string.h>
+#include <limits.h>
+#include <assert.h>
+
+#define PRINT_ERRORS 0
+
+#define TOL 80
+#define N2 17
+#define FRAC (32*4)
+
+#define mpbpl (CHAR_BIT * sizeof (mp_limb_t))
+#define SZ (FRAC / mpbpl + 1)
+typedef mp_limb_t mp1[SZ], mp2[SZ * 2];
+
+/* This string has 101 hex digits.  */
+static const char exp1[102] = "2" /* point */
+"b7e151628aed2a6abf7158809cf4f3c762e7160f38b4da56a7"
+"84d9045190cfef324e7738926cfbe5f4bf8d8d8c31d763da07";
+static const char hexdig[] = "0123456789abcdef";
+
+void
+print_mpn_hex (const mp_limb_t *x, unsigned size)
+{
+   char value[size + 1];
+   unsigned i;
+   const unsigned final = (size * 4 > SZ * mpbpl) ? SZ * mpbpl / 4 : size;
+
+   memset (value, '0', size);
+
+   for (i = 0; i < final ; i++)
+     value[size - 1 - i] = hexdig[x[i * 4 / mpbpl] >> (i * 4) % mpbpl & 0xf];
+
+   value[size] = '\0';
+   fputs (value, stdout);
+}
+
+void
+exp_mpn (mp1 ex, mp1 x)
+{
+   unsigned n;
+   mp1 xp;
+   mp2 tmp;
+   mp_limb_t chk, round;
+   mp1 tol;
+
+   memset (xp, 0, sizeof (mp1));
+   memset (ex, 0, sizeof (mp1));
+   xp[FRAC / mpbpl] = 1 << FRAC % mpbpl;
+   memset (tol,0, sizeof (mp1));
+   tol[(FRAC - TOL) / mpbpl] = 1 << (FRAC - TOL) % mpbpl;
+
+   n = 0;
+
+   do
+     {
+       /* Calculate sum(x^n/n!) until the next term is sufficiently small.  */
+
+       mpn_mul_n (tmp, xp, x, SZ);
+       assert (tmp[SZ * 2 - 1] == 0);
+       if (n > 0)
+	 round = mpn_divmod_1 (xp, tmp + FRAC / mpbpl, SZ, n);
+       chk = mpn_add_n (ex, ex, xp, SZ);
+       assert (chk == 0);
+       n++;
+       assert (n < 80); /* Catch too-high TOL.  */
+     }
+   while (n < 10 || mpn_cmp (xp, tol, SZ) >= 0);
+}
+
+static int
+mpn_bitsize(const mp_limb_t *SRC_PTR, mp_size_t SIZE)
+{
+   int i, j;
+   for (i = SIZE - 1; i > 0; i--)
+     if (SRC_PTR[i] != 0)
+       break;
+   for (j = mpbpl - 1; j > 0; j--)
+     if ((SRC_PTR[i] & 1 << j) != 0)
+       break;
+
+   return i * 32 + j;
+}
+
+int
+main (void)
+{
+   mp1 ex, x, xt, e2, e3;
+   int i;
+   int errors = 0;
+   int failures = 0;
+   mp1 maxerror;
+   int maxerror_s = 0;
+   const double sf = pow (2, mpbpl);
+
+   /* assert (mpbpl == mp_bits_per_limb); */
+   assert (FRAC / mpbpl * mpbpl == FRAC);
+
+   memset (maxerror, 0, sizeof (mp1));
+   memset (xt, 0, sizeof (mp1));
+   xt[(FRAC - N2) / mpbpl] = 1 << (FRAC - N2) % mpbpl;
+
+   for (i = 0; i < 1 << N2; i++)
+   {
+      int e2s, e3s, j;
+      double de2;
+
+      mpn_mul_1 (x,xt,SZ,i);
+      exp_mpn (ex, x);
+      de2 = exp (i / (double) (1 << N2));
+      for (j = SZ-1; j >= 0; j--)
+	{
+	  e2[j] = (mp_limb_t) de2;
+	  de2 = (de2 - e2[j]) * sf;
+	}
+      if (mpn_cmp (ex,e2,SZ) >= 0)
+	mpn_sub_n (e3,ex,e2,SZ);
+      else
+	mpn_sub_n (e3,e2,ex,SZ);
+
+      e2s = mpn_bitsize (e2,SZ);
+      e3s = mpn_bitsize (e3,SZ);
+      if (e3s > 1 && e2s - e3s < 54)
+	{
+#if PRINT_ERRORS
+	  printf ("%06x ", i * (0x100000 / (1 << N2)));
+	  print_mpn_hex (ex, (FRAC / 4) + 1);
+	  fputs ("\n       ",stdout);
+	  print_mpn_hex (e2, (FRAC / 4) + 1);
+	  printf ("\n %c     ",
+		  e2s - e3s < 54 ? e2s - e3s == 53 ? 'e' : 'F' : 'P');
+	  print_mpn_hex (e3, (FRAC / 4) + 1);
+	  putchar ('\n');
+#endif
+	 errors += (e2s - e3s == 53);
+	 failures += (e2s - e3s < 53);
+	}
+      if (e3s >= maxerror_s
+	  && mpn_cmp (e3, maxerror, SZ) > 0)
+	{
+	  memcpy (maxerror, e3, sizeof (mp1));
+	  maxerror_s = e3s;
+	}
+   }
+
+   /* Check exp_mpn against precomputed value of exp(1).  */
+   memset (x, '\0', sizeof (mp1));
+   x[FRAC / mpbpl] = 1 << FRAC % mpbpl;
+   exp_mpn (ex, x);
+
+   memset (e2, '\0', sizeof (mp1));
+   for (i = -1; i < 100 && i < FRAC / 4; i++)
+     e2[(FRAC - i * 4 - 4) / mpbpl] |= (strchr (hexdig, exp1[i + 1]) - hexdig
+					<< (FRAC - i * 4 - 4) % mpbpl);
+
+   if (mpn_cmp (ex, e2, SZ) >= 0)
+     mpn_sub_n (e3, ex, e2, SZ);
+   else
+     mpn_sub_n (e3, e2, ex, SZ);
+
+   printf ("%d failures; %d errors; error rate %0.2f%%\n", failures, errors,
+	   errors * 100.0 / (double) (1 << N2));
+   fputs ("maximum error:   ", stdout);
+   print_mpn_hex (maxerror, (FRAC / 4) + 1);
+   fputs ("\nerror in exp(1): ", stdout);
+   print_mpn_hex (e3, (FRAC / 4) + 1);
+   putchar ('\n');
+
+   return failures == 0 ? 0 : 1;
+}
diff --git a/math/atest-sincos.c b/math/atest-sincos.c
new file mode 100644
index 0000000000..98f1e719b1
--- /dev/null
+++ b/math/atest-sincos.c
@@ -0,0 +1,275 @@
+/* Copyright (C) 1997 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Geoffrey Keating <Geoff.Keating@anu.edu.au>, 1997.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public
+   License along with the GNU C Library; see the file COPYING.LIB.  If not,
+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include <stdio.h>
+#include <math.h>
+#include <stdlib/gmp.h>
+#include <string.h>
+#include <limits.h>
+#include <assert.h>
+
+#define PRINT_ERRORS 0
+
+#define N 0
+#define N2 20
+#define FRAC (32 * 4)
+
+#define mpbpl (CHAR_BIT * sizeof (mp_limb_t))
+#define SZ (FRAC / mpbpl + 1)
+typedef mp_limb_t mp1[SZ], mp2[SZ * 2];
+
+/* These strings have exactly 100 hex digits in them.  */
+static const char sin1[101] =
+"d76aa47848677020c6e9e909c50f3c3289e511132f518b4def"
+"b6ca5fd6c649bdfb0bd9ff1edcd4577655b5826a3d3b50c264";
+static const char cos1[101] =
+"8a51407da8345c91c2466d976871bd29a2373a894f96c3b7f2"
+"300240b760e6fa96a94430a52d0e9e43f3450e3b8ff99bc934";
+static const char hexdig[] = "0123456789abcdef";
+
+void
+print_mpn_hex (const mp_limb_t *x, unsigned size)
+{
+   char value[size + 1];
+   unsigned i;
+   const unsigned final = (size * 4 > SZ * mpbpl) ? SZ * mpbpl / 4 : size;
+
+   memset (value, '0', size);
+
+   for (i = 0; i < final ; i++)
+     value[size-1-i] = hexdig[x[i * 4 / mpbpl] >> (i * 4) % mpbpl & 0xf];
+
+   value[size] = '\0';
+   fputs (value, stdout);
+}
+
+void
+sincosx_mpn (mp1 si, mp1 co, mp1 xx, mp1 ix)
+{
+   int i;
+   mp2 s[4], c[4];
+   mp1 tmp, x;
+   mp_limb_t chk, round;
+
+   if (ix == NULL)
+     {
+       memset (si, 0, sizeof (mp1));
+       memset (co, 0, sizeof (mp1));
+       co[SZ-1] = 1;
+       memcpy (x, xx, sizeof (mp1));
+     }
+   else
+      mpn_sub_n (x, xx, ix, SZ);
+
+   for (i = 0; i < 1 << N; i++)
+     {
+#define add_shift_mulh(d,x,s1,s2,sh,n) \
+       /* d = (n ? -1 : 1) * (s1 + (s2>>sh)) * x / (1>>N); */		      \
+      do { 								      \
+	 if (s2 != NULL) {						      \
+	    if (sh > 0) {						      \
+	       assert (sh < mpbpl);					      \
+	       mpn_lshift (tmp, s1, SZ, sh);				      \
+	       chk = (n ? mpn_sub_n : mpn_add_n)(tmp,tmp,s2+FRAC/mpbpl,SZ);   \
+	    } else							      \
+	       chk = (n ? mpn_sub_n : mpn_add_n)(tmp,s1,s2+FRAC/mpbpl,SZ);    \
+	    /* assert(chk == 0); */					      \
+	    mpn_mul_n(d,tmp,x,SZ);					      \
+	 } else 							      \
+	    mpn_mul_n(d,s1,x,SZ);					      \
+	 /* assert(d[SZ*2-1] == 0); */					      \
+	 assert(N+sh < mpbpl);						      \
+	 if (N+sh > 0) mpn_rshift(d,d,2*SZ,N+sh);			      \
+      } while(0)
+#define summ(d,ss,s,n) \
+      /* d = ss +/- (s[0]+2*s[1]+2*s[2]+s[3])/6; */			      \
+      do { 								      \
+	 chk = mpn_add_n(tmp,s[1]+FRAC/mpbpl,s[2]+FRAC/mpbpl,SZ);	      \
+	 mpn_lshift(tmp,tmp,SZ,1);					      \
+	 chk |= mpn_add_n(tmp,tmp,s[0]+FRAC/mpbpl,SZ);			      \
+	 chk |= mpn_add_n(tmp,tmp,s[3]+FRAC/mpbpl,SZ);			      \
+	 round = mpn_divmod_1(tmp,tmp,SZ,6);				      \
+	 /* chk |= mpn_add_1(tmp,tmp,SZ, (round > 3) ); */		      \
+         chk |= (n ? mpn_sub_n : mpn_add_n)(d,ss,tmp,SZ);		      \
+	 /* assert(chk == 0); */					      \
+      } while (0)
+
+      add_shift_mulh (s[0], x, co, NULL, 0, 0); /* s0 = h * c; */
+      add_shift_mulh (c[0], x, si, NULL, 0, 0); /* c0 = h * s; */
+      add_shift_mulh (s[1], x, co, c[0], 1, 1); /* s1 = h * (c - c0/2); */
+      add_shift_mulh (c[1], x, si, s[0], 1, 0); /* c1 = h * (s + s0/2); */
+      add_shift_mulh (s[2], x, co, c[1], 1, 1); /* s2 = h * (c - c1/2); */
+      add_shift_mulh (c[2], x, si, s[1], 1, 0); /* c2 = h * (s + s1/2); */
+      add_shift_mulh (s[3], x, co, c[2], 0, 1); /* s3 = h * (c - c2); */
+      add_shift_mulh (c[3], x, si, s[2], 0, 0); /* c3 = h * (s + s2); */
+      summ (si, si, s, 0);        /* s = s + (s0+2*s1+2*s2+s3)/6; */
+      summ (co, co, c, 1);        /* c = c - (c0+2*c1+2*c2+c3)/6; */
+   }
+#undef add_shift_mulh
+#undef summ
+}
+
+static int
+mpn_bitsize (const mp_limb_t *SRC_PTR, mp_size_t SIZE)
+{
+   int i, j;
+   for (i = SIZE - 1; i > 0; i--)
+     if (SRC_PTR[i] != 0)
+       break;
+   for (j = mpbpl - 1; j > 0; j--)
+     if ((SRC_PTR[i] & 1 << j) != 0)
+       break;
+
+   return i * 32 + j;
+}
+
+int
+main (void)
+{
+  mp1 si, co, x, ox, xt, s2, c2, s3, c3;
+  int i;
+  int sin_errors = 0, cos_errors = 0;
+  int sin_failures = 0, cos_failures = 0;
+  mp1 sin_maxerror, cos_maxerror;
+  int sin_maxerror_s = 0, cos_maxerror_s = 0;
+  const double sf = pow (2, mpbpl);
+
+  /* assert(mpbpl == mp_bits_per_limb);  */
+  assert(FRAC / mpbpl * mpbpl == FRAC);
+
+  memset (sin_maxerror, 0, sizeof (mp1));
+  memset (cos_maxerror, 0, sizeof (mp1));
+  memset (xt, 0, sizeof (mp1));
+  xt[(FRAC - N2) / mpbpl] = 1 << (FRAC - N2) % mpbpl;
+
+  for (i = 0; i < 1 << N2; i++)
+    {
+      int s2s, s3s, c2s, c3s, j;
+      double ds2,dc2;
+
+      mpn_mul_1 (x, xt, SZ, i);
+      sincosx_mpn (si, co, x, i == 0 ? NULL : ox);
+      memcpy (ox, x, sizeof (mp1));
+      ds2 = sin (i / (double) (1 << N2));
+      dc2 = cos (i / (double) (1 << N2));
+      for (j = SZ-1; j >= 0; j--)
+	{
+	  s2[j] = (mp_limb_t) ds2;
+	  ds2 = (ds2 - s2[j]) * sf;
+	  c2[j] = (mp_limb_t) dc2;
+	  dc2 = (dc2 - c2[j]) * sf;
+	}
+      if (mpn_cmp (si, s2, SZ) >= 0)
+	mpn_sub_n (s3, si, s2, SZ);
+      else
+	mpn_sub_n (s3, s2, si, SZ);
+      if (mpn_cmp (co, c2, SZ) >= 0)
+	mpn_sub_n (c3, co, c2, SZ);
+      else
+	mpn_sub_n (c3, c2, co, SZ);
+
+      s2s = mpn_bitsize (s2, SZ);
+      s3s = mpn_bitsize (s3, SZ);
+      c2s = mpn_bitsize (c2, SZ);
+      c3s = mpn_bitsize (c3, SZ);
+      if (s3s > 1 && s2s - s3s < 54
+	  || c3s > 1 && c2s - c3s < 54
+	  || 0)
+	{
+#if PRINT_ERRORS
+	  printf ("%06x ", i * (0x100000 / (1 << N2)));
+	  print_mpn_hex(si, (FRAC / 4) + 1);
+	  putchar (' ');
+	  print_mpn_hex (co, (FRAC / 4) + 1);
+	  putchar ('\n');
+	  fputs ("       ", stdout);
+	  print_mpn_hex (s2, (FRAC / 4) + 1);
+	  putchar (' ');
+	  print_mpn_hex (c2, (FRAC / 4) + 1);
+	  putchar ('\n');
+	  printf (" %c%c    ",
+		  s2s-s3s < 54 ? s2s - s3s == 53 ? 'e' : 'F' : 'P',
+		  c2s-c3s < 54 ? c2s - c3s == 53 ? 'e' : 'F' : 'P');
+	  print_mpn_hex (s3, (FRAC / 4) + 1);
+	  putchar (' ');
+	  print_mpn_hex (c3, (FRAC / 4) + 1);
+	  putchar ('\n');
+#endif
+	  sin_errors += s2s - s3s == 53;
+	  cos_errors += c2s - c3s == 53;
+	  sin_failures += s2s - s3s < 53;
+	  cos_failures += c2s - c3s < 53;
+	}
+      if (s3s >= sin_maxerror_s
+	  && mpn_cmp (s3, sin_maxerror, SZ) > 0)
+	{
+	  memcpy (sin_maxerror, s3, sizeof (mp1));
+	  sin_maxerror_s = s3s;
+	}
+      if (c3s >= cos_maxerror_s
+	  && mpn_cmp (c3, cos_maxerror, SZ) > 0)
+	{
+	  memcpy (cos_maxerror, c3, sizeof (mp1));
+	  cos_maxerror_s = c3s;
+	}
+    }
+
+   /* Check Range-Kutta against precomputed values of sin(1) and cos(1).  */
+   memset (x, 0, sizeof (mp1));
+   x[FRAC / mpbpl] = 1 << FRAC % mpbpl;
+   sincosx_mpn (si, co, x, ox);
+
+   memset (s2, 0, sizeof (mp1));
+   memset (c2, 0, sizeof (mp1));
+   for (i = 0; i < 100 && i < FRAC / 4; i++)
+     {
+       s2[(FRAC - i * 4 - 4) / mpbpl] |= (strchr (hexdig, sin1[i]) - hexdig
+					  << (FRAC - i * 4 - 4) % mpbpl);
+       c2[(FRAC - i * 4 - 4) / mpbpl] |= (strchr (hexdig, cos1[i]) - hexdig
+					  << (FRAC - i * 4 - 4) % mpbpl);
+     }
+
+   if (mpn_cmp (si, s2, SZ) >= 0)
+     mpn_sub_n (s3, si, s2, SZ);
+   else
+     mpn_sub_n (s3, s2, si, SZ);
+   if (mpn_cmp (co, c2, SZ) >= 0)
+      mpn_sub_n (c3, co, c2, SZ);
+   else
+     mpn_sub_n (c3, c2, co, SZ);
+
+   printf ("sin:\n");
+   printf ("%d failures; %d errors; error rate %0.2f%%\n",
+	   sin_failures, sin_errors, sin_errors * 100.0 / (double) (1 << N2));
+   fputs ("maximum error:   ", stdout);
+   print_mpn_hex (sin_maxerror, (FRAC / 4) + 1);
+   fputs ("\nerror in sin(1): ", stdout);
+   print_mpn_hex (s3, (FRAC / 4) + 1);
+
+   fputs ("\n\ncos:\n", stdout);
+   printf ("%d failures; %d errors; error rate %0.2f%%\n",
+	   cos_failures, cos_errors, cos_errors * 100.0 / (double) (1 << N2));
+   fputs ("maximum error:   ", stdout);
+   print_mpn_hex (cos_maxerror, (FRAC / 4) + 1);
+   fputs ("\nerror in cos(1): ", stdout);
+   print_mpn_hex (c3, (FRAC / 4) + 1);
+   putchar ('\n');
+
+   return (sin_failures == 0 && cos_failures == 0) ? 0 : 1;
+}
diff --git a/math/libm-test.c b/math/libm-test.c
index a173a09631..da1de8385f 100644
--- a/math/libm-test.c
+++ b/math/libm-test.c
@@ -1003,7 +1003,7 @@ cbrt_test (void)
 	     CHOOSE (5e-18L, 0, 0));
   check_eps ("cbrt (8) == 2", FUNC(cbrt) (8), 2, CHOOSE (5e-17L, 0, 0));
   check_eps ("cbrt (-27) == -3", FUNC(cbrt) (-27.0), -3.0,
-	     CHOOSE (3e-16L, 0, 0));
+	     CHOOSE (3e-16L, 5e-16, 0));
 }
 
 
@@ -1095,7 +1095,7 @@ exp_test (void)
   check_isinfp ("exp (+inf) == +inf", FUNC(exp) (plus_infty));
   check ("exp (-inf) == 0", FUNC(exp) (minus_infty), 0);
 #endif
-  check_eps ("exp (1) == e", FUNC(exp) (1), M_E, CHOOSE (4e-18L, 0, 0));
+  check_eps ("exp (1) == e", FUNC(exp) (1), M_E, CHOOSE (4e-18L, 5e-16, 0));
 }
 
 
@@ -1129,7 +1129,7 @@ expm1_test (void)
 #endif
 
   check_eps ("expm1 (1) == e-1", FUNC(expm1) (1), M_E - 1.0,
-	     CHOOSE (4e-18L, 0, 0));
+	     CHOOSE (4e-18L, 0, 2e-7));
 }
 
 
@@ -4600,7 +4600,7 @@ static void
 inverse_functions (void)
 {
   inverse_func_pair_test ("asin(sin(x)) == x",
-			FUNC(sin), FUNC(asin), 1.0, CHOOSE (2e-18L, 0, 1e-7L));
+			FUNC(sin), FUNC(asin), 1.0, CHOOSE (2e-18L, 0, 3e-7L));
   inverse_func_pair_test ("sin(asin(x)) == x",
 			  FUNC(asin), FUNC(sin), 1.0, 0.0);
 
@@ -4706,14 +4706,14 @@ identities (void)
   identities1_test (-1, CHOOSE (1e-18L, 0, 1e-7));
 
   identities2_test (0.2L, CHOOSE (1e-19L, 1e-16, 0));
-  identities2_test (0.9L, CHOOSE (0, 1e-15, 0));
+  identities2_test (0.9L, CHOOSE (0, 1e-15, 2e-7));
   identities2_test (0, 0);
-  identities2_test (-1, CHOOSE (1e-18L, 1e-15, 0));
+  identities2_test (-1, CHOOSE (1e-18L, 1e-15, 2e-7));
 
   identities3_test (0.2L, CHOOSE (1e-18L, 0, 1e-7));
   identities3_test (0.9L, CHOOSE (1e-18L, 1e-15, 1e-6));
   identities3_test (0, CHOOSE (0, 0, 1e-6));
-  identities3_test (-1, CHOOSE (1e-18L, 0, 1e-6));
+  identities3_test (-1, CHOOSE (1e-18L, 7e-16, 1e-6));
 }