Better distinguish between NaN/qNaN/sNaN.

5 files changed, 600 insertions, 600 deletions

diff --git a/math/basic-test.c b/math/basic-test.c
index f9b9752dea..218c9699fb 100644
--- a/math/basic-test.c
+++ b/math/basic-test.c
@@ -32,40 +32,40 @@ check (const char *testname, int result)
   }
 }
 
-#define TEST_FUNC(NAME, FLOAT, NANFUNC, EPSILON, HUGEVAL) \
+#define TEST_FUNC(NAME, FLOAT, NANFUNC, EPSILON, HUGEVAL)		      \
 static void								      \
 NAME (void)								      \
 {									      \
   /* Variables are declared volatile to forbid some compiler		      \
      optimizations.  */							      \
-  volatile FLOAT Inf_var, NaN_var, zero_var, one_var;			      \
+  volatile FLOAT Inf_var, qNaN_var, zero_var, one_var;			      \
   FLOAT x1, x2;								      \
 									      \
   zero_var = 0.0;							      \
   one_var = 1.0;							      \
-  NaN_var = zero_var / zero_var;					      \
+  qNaN_var = zero_var / zero_var;					      \
   Inf_var = one_var / zero_var;						      \
 									      \
   (void) &zero_var;							      \
   (void) &one_var;							      \
-  (void) &NaN_var;							      \
+  (void) &qNaN_var;							      \
   (void) &Inf_var;							      \
 									      \
 									      \
   check (#FLOAT " isinf (inf) == 1", isinf (Inf_var) == 1);		      \
   check (#FLOAT " isinf (-inf) == -1", isinf (-Inf_var) == -1);		      \
   check (#FLOAT " !isinf (1)", !(isinf (one_var)));			      \
-  check (#FLOAT " !isinf (NaN)", !(isinf (NaN_var)));			      \
+  check (#FLOAT " !isinf (qNaN)", !(isinf (qNaN_var)));			      \
 									      \
-  check (#FLOAT " isnan (NaN)", isnan (NaN_var));			      \
-  check (#FLOAT " isnan (-NaN)", isnan (-NaN_var));			      \
+  check (#FLOAT " isnan (qNaN)", isnan (qNaN_var));			      \
+  check (#FLOAT " isnan (-qNaN)", isnan (-qNaN_var));			      \
   check (#FLOAT " !isnan (1)", !(isnan (one_var)));			      \
   check (#FLOAT " !isnan (inf)", !(isnan (Inf_var)));			      \
 									      \
   check (#FLOAT " inf == inf", Inf_var == Inf_var);			      \
   check (#FLOAT " -inf == -inf", -Inf_var == -Inf_var);			      \
   check (#FLOAT " inf != -inf", Inf_var != -Inf_var);			      \
-  check (#FLOAT " NaN != NaN", NaN_var != NaN_var);			      \
+  check (#FLOAT " qNaN != qNaN", qNaN_var != qNaN_var);			      \
 									      \
   /*									      \
      the same tests but this time with NAN from <bits/nan.h>		      \
@@ -80,11 +80,11 @@ NAME (void)								      \
   /*									      \
      And again with the value returned by the `nan' function.		      \
    */									      \
-  check (#FLOAT " isnan (NAN)", isnan (NANFUNC ("")));			      \
-  check (#FLOAT " isnan (-NAN)", isnan (-NANFUNC ("")));		      \
-  check (#FLOAT " !isinf (NAN)", !(isinf (NANFUNC (""))));		      \
-  check (#FLOAT " !isinf (-NAN)", !(isinf (-NANFUNC (""))));		      \
-  check (#FLOAT " NAN != NAN", NANFUNC ("") != NANFUNC (""));		      \
+  check (#FLOAT " isnan (nan (\"\"))", isnan (NANFUNC ("")));		      \
+  check (#FLOAT " isnan (-nan (\"\"))", isnan (-NANFUNC ("")));		      \
+  check (#FLOAT " !isinf (nan (\"\"))", !(isinf (NANFUNC (""))));	      \
+  check (#FLOAT " !isinf (-nan (\"\"))", !(isinf (-NANFUNC (""))));	      \
+  check (#FLOAT " nan (\"\") != nan (\"\")", NANFUNC ("") != NANFUNC (""));   \
 									      \
   /* test if EPSILON is ok */						      \
   x1 = 1.0;								      \
@@ -106,19 +106,19 @@ NAME (void)								      \
 void									      \
 NAME (void)								      \
 {									      \
-  volatile DOUBLE Inf_var, NaN_var, zero_var, one_var;			      \
+  volatile DOUBLE Inf_var, qNaN_var, zero_var, one_var;			      \
   FLOAT x1, x2;								      \
 									      \
   zero_var = 0.0;							      \
   one_var = 1.0;							      \
-  NaN_var = zero_var / zero_var;					      \
+  qNaN_var = zero_var / zero_var;					      \
   Inf_var = one_var / zero_var;						      \
 									      \
-  (void) &NaN_var;							      \
+  (void) &qNaN_var;							      \
   (void) &Inf_var;							      \
 									      \
-  x1 = (FLOAT) NaN_var;							      \
-  check (" "#FLOAT" x = ("#FLOAT") ("#DOUBLE") NaN", isnan (x1) != 0);	      \
+  x1 = (FLOAT) qNaN_var;						      \
+  check (" "#FLOAT" x = ("#FLOAT") ("#DOUBLE") qNaN", isnan (x1) != 0);	      \
   x2 = (FLOAT) Inf_var;							      \
   check (" "#FLOAT" x = ("#FLOAT") ("#DOUBLE") Inf", isinf (x2) != 0);	      \
 }
diff --git a/math/bits/mathcalls.h b/math/bits/mathcalls.h
index e90a34b0f7..e5af507257 100644
--- a/math/bits/mathcalls.h
+++ b/math/bits/mathcalls.h
@@ -220,7 +220,7 @@ __END_NAMESPACE_C99
 
 #ifdef __USE_ISOC99
 __BEGIN_NAMESPACE_C99
-/* Return representation of NaN for double type.  */
+/* Return representation of qNaN for double type.  */
 __MATHCALLX (nan,, (const char *__tagb), (__const__));
 __END_NAMESPACE_C99
 #endif
diff --git a/math/gen-libm-test.pl b/math/gen-libm-test.pl
index 998a9e5e32..01e0fc20d3 100755
--- a/math/gen-libm-test.pl
+++ b/math/gen-libm-test.pl
@@ -58,7 +58,7 @@ use vars qw ($output_dir $ulps_file);
     "plus_zero" => "+0",
     "minus_infty" => "-inf",
     "plus_infty" => "inf",
-    "nan_value" => "NaN",
+    "qnan_value" => "qNaN",
     "M_El" => "e",
     "M_E2l" => "e^2",
     "M_E3l" => "e^3",
diff --git a/math/libm-test.inc b/math/libm-test.inc
index 1b6111d393..157dd79311 100644
--- a/math/libm-test.inc
+++ b/math/libm-test.inc
@@ -224,7 +224,7 @@ static int output_points;	/* Should the single function results printed?  */
 static int ignore_max_ulp;	/* Should we ignore max_ulp?  */
 
 static FLOAT minus_zero, plus_zero;
-static FLOAT plus_infty, minus_infty, nan_value, max_value, min_value;
+static FLOAT plus_infty, minus_infty, qnan_value, max_value, min_value;
 static FLOAT min_subnorm_value;
 
 static FLOAT max_error, real_max_error, imag_max_error;
@@ -805,15 +805,15 @@ acos_test (void)
 
   START (acos);
 
-  TEST_f_f (acos, plus_infty, nan_value, INVALID_EXCEPTION);
-  TEST_f_f (acos, minus_infty, nan_value, INVALID_EXCEPTION);
-  TEST_f_f (acos, nan_value, nan_value);
+  TEST_f_f (acos, plus_infty, qnan_value, INVALID_EXCEPTION);
+  TEST_f_f (acos, minus_infty, qnan_value, INVALID_EXCEPTION);
+  TEST_f_f (acos, qnan_value, qnan_value);
 
   /* |x| > 1: */
-  TEST_f_f (acos, 1.125L, nan_value, INVALID_EXCEPTION);
-  TEST_f_f (acos, -1.125L, nan_value, INVALID_EXCEPTION);
-  TEST_f_f (acos, max_value, nan_value, INVALID_EXCEPTION);
-  TEST_f_f (acos, -max_value, nan_value, INVALID_EXCEPTION);
+  TEST_f_f (acos, 1.125L, qnan_value, INVALID_EXCEPTION);
+  TEST_f_f (acos, -1.125L, qnan_value, INVALID_EXCEPTION);
+  TEST_f_f (acos, max_value, qnan_value, INVALID_EXCEPTION);
+  TEST_f_f (acos, -max_value, qnan_value, INVALID_EXCEPTION);
 
   TEST_f_f (acos, 0, M_PI_2l);
   TEST_f_f (acos, minus_zero, M_PI_2l);
@@ -971,11 +971,11 @@ acosh_test (void)
   START (acosh);
 
   TEST_f_f (acosh, plus_infty, plus_infty);
-  TEST_f_f (acosh, minus_infty, nan_value, INVALID_EXCEPTION);
+  TEST_f_f (acosh, minus_infty, qnan_value, INVALID_EXCEPTION);
 
   /* x < 1:  */
-  TEST_f_f (acosh, -1.125L, nan_value, INVALID_EXCEPTION);
-  TEST_f_f (acosh, -max_value, nan_value, INVALID_EXCEPTION);
+  TEST_f_f (acosh, -1.125L, qnan_value, INVALID_EXCEPTION);
+  TEST_f_f (acosh, -max_value, qnan_value, INVALID_EXCEPTION);
 
   TEST_f_f (acosh, 1, 0);
   TEST_f_f (acosh, 7, 2.63391579384963341725009269461593689L);
@@ -994,15 +994,15 @@ asin_test (void)
 
   START (asin);
 
-  TEST_f_f (asin, plus_infty, nan_value, INVALID_EXCEPTION);
-  TEST_f_f (asin, minus_infty, nan_value, INVALID_EXCEPTION);
-  TEST_f_f (asin, nan_value, nan_value);
+  TEST_f_f (asin, plus_infty, qnan_value, INVALID_EXCEPTION);
+  TEST_f_f (asin, minus_infty, qnan_value, INVALID_EXCEPTION);
+  TEST_f_f (asin, qnan_value, qnan_value);
 
-  /* asin x == NaN plus invalid exception for |x| > 1.  */
-  TEST_f_f (asin, 1.125L, nan_value, INVALID_EXCEPTION);
-  TEST_f_f (asin, -1.125L, nan_value, INVALID_EXCEPTION);
-  TEST_f_f (asin, max_value, nan_value, INVALID_EXCEPTION);
-  TEST_f_f (asin, -max_value, nan_value, INVALID_EXCEPTION);
+  /* asin x == qNaN plus invalid exception for |x| > 1.  */
+  TEST_f_f (asin, 1.125L, qnan_value, INVALID_EXCEPTION);
+  TEST_f_f (asin, -1.125L, qnan_value, INVALID_EXCEPTION);
+  TEST_f_f (asin, max_value, qnan_value, INVALID_EXCEPTION);
+  TEST_f_f (asin, -max_value, qnan_value, INVALID_EXCEPTION);
 
   TEST_f_f (asin, 0, 0);
   TEST_f_f (asin, minus_zero, minus_zero);
@@ -1164,7 +1164,7 @@ asinh_test (void)
   TEST_f_f (asinh, plus_infty, plus_infty);
   TEST_f_f (asinh, minus_infty, minus_infty);
 #endif
-  TEST_f_f (asinh, nan_value, nan_value);
+  TEST_f_f (asinh, qnan_value, qnan_value);
   TEST_f_f (asinh, 0.75L, 0.693147180559945309417232121458176568L);
 
   END (asinh);
@@ -1186,7 +1186,7 @@ atan_test (void)
 
   TEST_f_f (atan, plus_infty, M_PI_2l);
   TEST_f_f (atan, minus_infty, -M_PI_2l);
-  TEST_f_f (atan, nan_value, nan_value);
+  TEST_f_f (atan, qnan_value, qnan_value);
   TEST_f_f (atan, max_value, M_PI_2l);
   TEST_f_f (atan, -max_value, -M_PI_2l);
 
@@ -1225,13 +1225,13 @@ atanh_test (void)
 
   TEST_f_f (atanh, 1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
   TEST_f_f (atanh, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
-  TEST_f_f (atanh, nan_value, nan_value);
+  TEST_f_f (atanh, qnan_value, qnan_value);
 
-  /* atanh (x) == NaN plus invalid exception if |x| > 1.  */
-  TEST_f_f (atanh, 1.125L, nan_value, INVALID_EXCEPTION);
-  TEST_f_f (atanh, -1.125L, nan_value, INVALID_EXCEPTION);
-  TEST_f_f (atanh, max_value, nan_value, INVALID_EXCEPTION);
-  TEST_f_f (atanh, -max_value, nan_value, INVALID_EXCEPTION);
+  /* atanh (x) == qNaN plus invalid exception if |x| > 1.  */
+  TEST_f_f (atanh, 1.125L, qnan_value, INVALID_EXCEPTION);
+  TEST_f_f (atanh, -1.125L, qnan_value, INVALID_EXCEPTION);
+  TEST_f_f (atanh, max_value, qnan_value, INVALID_EXCEPTION);
+  TEST_f_f (atanh, -max_value, qnan_value, INVALID_EXCEPTION);
 
   TEST_f_f (atanh, 0.75L, 0.972955074527656652552676371721589865L);
 
@@ -1301,7 +1301,7 @@ atan2_test (void)
   TEST_ff_f (atan2, minus_infty, plus_infty, -M_PI_4l);
   TEST_ff_f (atan2, plus_infty, minus_infty, M_PI_34l);
   TEST_ff_f (atan2, minus_infty, minus_infty, -M_PI_34l);
-  TEST_ff_f (atan2, nan_value, nan_value, nan_value);
+  TEST_ff_f (atan2, qnan_value, qnan_value, qnan_value);
 
   TEST_ff_f (atan2, max_value, max_value, M_PI_4l);
 
@@ -1341,10 +1341,10 @@ cabs_test (void)
   /* cabs (-inf + i x) == +inf.  */
   TEST_c_f (cabs, minus_infty, 1.0, plus_infty);
 
-  TEST_c_f (cabs, minus_infty, nan_value, plus_infty);
-  TEST_c_f (cabs, minus_infty, nan_value, plus_infty);
+  TEST_c_f (cabs, minus_infty, qnan_value, plus_infty);
+  TEST_c_f (cabs, minus_infty, qnan_value, plus_infty);
 
-  TEST_c_f (cabs, nan_value, nan_value, nan_value);
+  TEST_c_f (cabs, qnan_value, qnan_value, qnan_value);
 
   /* cabs (x,y) == cabs (y,x).  */
   TEST_c_f (cabs, 0.75L, 12.390625L, 12.4133028598606664302388810868156657L);
@@ -1410,22 +1410,22 @@ cacos_test (void)
   TEST_c_c (cacos, plus_infty, 0.5, 0.0, minus_infty);
   TEST_c_c (cacos, plus_infty, -0.5, 0.0, plus_infty);
 
-  TEST_c_c (cacos, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
-  TEST_c_c (cacos, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
+  TEST_c_c (cacos, plus_infty, qnan_value, qnan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
+  TEST_c_c (cacos, minus_infty, qnan_value, qnan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
 
-  TEST_c_c (cacos, 0, nan_value, M_PI_2l, nan_value);
-  TEST_c_c (cacos, minus_zero, nan_value, M_PI_2l, nan_value);
+  TEST_c_c (cacos, 0, qnan_value, M_PI_2l, qnan_value);
+  TEST_c_c (cacos, minus_zero, qnan_value, M_PI_2l, qnan_value);
 
-  TEST_c_c (cacos, nan_value, plus_infty, nan_value, minus_infty);
-  TEST_c_c (cacos, nan_value, minus_infty, nan_value, plus_infty);
+  TEST_c_c (cacos, qnan_value, plus_infty, qnan_value, minus_infty);
+  TEST_c_c (cacos, qnan_value, minus_infty, qnan_value, plus_infty);
 
-  TEST_c_c (cacos, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
-  TEST_c_c (cacos, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
+  TEST_c_c (cacos, 10.5, qnan_value, qnan_value, qnan_value, INVALID_EXCEPTION_OK);
+  TEST_c_c (cacos, -10.5, qnan_value, qnan_value, qnan_value, INVALID_EXCEPTION_OK);
 
-  TEST_c_c (cacos, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
-  TEST_c_c (cacos, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
+  TEST_c_c (cacos, qnan_value, 0.75, qnan_value, qnan_value, INVALID_EXCEPTION_OK);
+  TEST_c_c (cacos, qnan_value, -0.75, qnan_value, qnan_value, INVALID_EXCEPTION_OK);
 
-  TEST_c_c (cacos, nan_value, nan_value, nan_value, nan_value);
+  TEST_c_c (cacos, qnan_value, qnan_value, qnan_value, qnan_value);
 
   TEST_c_c (cacos, plus_zero, -1.5L, M_PI_2l, 1.194763217287109304111930828519090523536L);
   TEST_c_c (cacos, minus_zero, -1.5L, M_PI_2l, 1.194763217287109304111930828519090523536L);
@@ -1564,22 +1564,22 @@ cacosh_test (void)
   TEST_c_c (cacosh, plus_infty, 0.5, plus_infty, 0.0);
   TEST_c_c (cacosh, plus_infty, -0.5, plus_infty, minus_zero);
 
-  TEST_c_c (cacosh, plus_infty, nan_value, plus_infty, nan_value);
-  TEST_c_c (cacosh, minus_infty, nan_value, plus_infty, nan_value);
+  TEST_c_c (cacosh, plus_infty, qnan_value, plus_infty, qnan_value);
+  TEST_c_c (cacosh, minus_infty, qnan_value, plus_infty, qnan_value);
 
-  TEST_c_c (cacosh, 0, nan_value, nan_value, nan_value);
-  TEST_c_c (cacosh, minus_zero, nan_value, nan_value, nan_value);
+  TEST_c_c (cacosh, 0, qnan_value, qnan_value, qnan_value);
+  TEST_c_c (cacosh, minus_zero, qnan_value, qnan_value, qnan_value);
 
-  TEST_c_c (cacosh, nan_value, plus_infty, plus_infty, nan_value);
-  TEST_c_c (cacosh, nan_value, minus_infty, plus_infty, nan_value);
+  TEST_c_c (cacosh, qnan_value, plus_infty, plus_infty, qnan_value);
+  TEST_c_c (cacosh, qnan_value, minus_infty, plus_infty, qnan_value);
 
-  TEST_c_c (cacosh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
-  TEST_c_c (cacosh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
+  TEST_c_c (cacosh, 10.5, qnan_value, qnan_value, qnan_value, INVALID_EXCEPTION_OK);
+  TEST_c_c (cacosh, -10.5, qnan_value, qnan_value, qnan_value, INVALID_EXCEPTION_OK);
 
-  TEST_c_c (cacosh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
-  TEST_c_c (cacosh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
+  TEST_c_c (cacosh, qnan_value, 0.75, qnan_value, qnan_value, INVALID_EXCEPTION_OK);
+  TEST_c_c (cacosh, qnan_value, -0.75, qnan_value, qnan_value, INVALID_EXCEPTION_OK);
 
-  TEST_c_c (cacosh, nan_value, nan_value, nan_value, nan_value);
+  TEST_c_c (cacosh, qnan_value, qnan_value, qnan_value, qnan_value);
 
   TEST_c_c (cacosh, plus_zero, -1.5L, 1.194763217287109304111930828519090523536L, -M_PI_2l);
   TEST_c_c (cacosh, minus_zero, -1.5L, 1.194763217287109304111930828519090523536L, -M_PI_2l);
@@ -1676,7 +1676,7 @@ carg_test (void)
 
   TEST_c_f (carg, minus_infty, minus_infty, -3 * M_PI_4l);
 
-  TEST_c_f (carg, nan_value, nan_value, nan_value);
+  TEST_c_f (carg, qnan_value, qnan_value, qnan_value);
 
   END (carg);
 }
@@ -1721,22 +1721,22 @@ casin_test (void)
   TEST_c_c (casin, plus_infty, 0.5, M_PI_2l, plus_infty);
   TEST_c_c (casin, plus_infty, -0.5, M_PI_2l, minus_infty);
 
-  TEST_c_c (casin, nan_value, plus_infty, nan_value, plus_infty);
-  TEST_c_c (casin, nan_value, minus_infty, nan_value, minus_infty);
+  TEST_c_c (casin, qnan_value, plus_infty, qnan_value, plus_infty);
+  TEST_c_c (casin, qnan_value, minus_infty, qnan_value, minus_infty);
 
-  TEST_c_c (casin, 0.0, nan_value, 0.0, nan_value);
-  TEST_c_c (casin, minus_zero, nan_value, minus_zero, nan_value);
+  TEST_c_c (casin, 0.0, qnan_value, 0.0, qnan_value);
+  TEST_c_c (casin, minus_zero, qnan_value, minus_zero, qnan_value);
 
-  TEST_c_c (casin, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
-  TEST_c_c (casin, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
+  TEST_c_c (casin, plus_infty, qnan_value, qnan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
+  TEST_c_c (casin, minus_infty, qnan_value, qnan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
 
-  TEST_c_c (casin, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
-  TEST_c_c (casin, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
+  TEST_c_c (casin, qnan_value, 10.5, qnan_value, qnan_value, INVALID_EXCEPTION_OK);
+  TEST_c_c (casin, qnan_value, -10.5, qnan_value, qnan_value, INVALID_EXCEPTION_OK);
 
-  TEST_c_c (casin, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
-  TEST_c_c (casin, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
+  TEST_c_c (casin, 0.75, qnan_value, qnan_value, qnan_value, INVALID_EXCEPTION_OK);
+  TEST_c_c (casin, -0.75, qnan_value, qnan_value, qnan_value, INVALID_EXCEPTION_OK);
 
-  TEST_c_c (casin, nan_value, nan_value, nan_value, nan_value);
+  TEST_c_c (casin, qnan_value, qnan_value, qnan_value, qnan_value);
 
   TEST_c_c (casin, plus_zero, -1.5L, plus_zero, -1.194763217287109304111930828519090523536L);
   TEST_c_c (casin, minus_zero, -1.5L, minus_zero, -1.194763217287109304111930828519090523536L);
@@ -1877,22 +1877,22 @@ casinh_test (void)
   TEST_c_c (casinh, plus_infty, 0.5, plus_infty, 0.0);
   TEST_c_c (casinh, plus_infty, -0.5, plus_infty, minus_zero);
 
-  TEST_c_c (casinh, plus_infty, nan_value, plus_infty, nan_value);
-  TEST_c_c (casinh, minus_infty, nan_value, minus_infty, nan_value);
+  TEST_c_c (casinh, plus_infty, qnan_value, plus_infty, qnan_value);
+  TEST_c_c (casinh, minus_infty, qnan_value, minus_infty, qnan_value);
 
-  TEST_c_c (casinh, nan_value, 0, nan_value, 0.0);
-  TEST_c_c (casinh, nan_value, minus_zero, nan_value, minus_zero);
+  TEST_c_c (casinh, qnan_value, 0, qnan_value, 0.0);
+  TEST_c_c (casinh, qnan_value, minus_zero, qnan_value, minus_zero);
 
-  TEST_c_c (casinh, nan_value, plus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
-  TEST_c_c (casinh, nan_value, minus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
+  TEST_c_c (casinh, qnan_value, plus_infty, plus_infty, qnan_value, IGNORE_ZERO_INF_SIGN);
+  TEST_c_c (casinh, qnan_value, minus_infty, plus_infty, qnan_value, IGNORE_ZERO_INF_SIGN);
 
-  TEST_c_c (casinh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
-  TEST_c_c (casinh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
+  TEST_c_c (casinh, 10.5, qnan_value, qnan_value, qnan_value, INVALID_EXCEPTION_OK);
+  TEST_c_c (casinh, -10.5, qnan_value, qnan_value, qnan_value, INVALID_EXCEPTION_OK);
 
-  TEST_c_c (casinh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
-  TEST_c_c (casinh, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
+  TEST_c_c (casinh, qnan_value, 0.75, qnan_value, qnan_value, INVALID_EXCEPTION_OK);
+  TEST_c_c (casinh, -0.75, qnan_value, qnan_value, qnan_value, INVALID_EXCEPTION_OK);
 
-  TEST_c_c (casinh, nan_value, nan_value, nan_value, nan_value);
+  TEST_c_c (casinh, qnan_value, qnan_value, qnan_value, qnan_value);
 
   TEST_c_c (casinh, plus_zero, -1.5L, 0.9624236501192068949955178268487368462704L, -M_PI_2l);
   TEST_c_c (casinh, minus_zero, -1.5L, -0.9624236501192068949955178268487368462704L, -M_PI_2l);
@@ -2034,25 +2034,25 @@ catan_test (void)
   TEST_c_c (catan, 0.5, plus_infty, M_PI_2l, 0);
   TEST_c_c (catan, -0.5, plus_infty, -M_PI_2l, 0);
 
-  TEST_c_c (catan, nan_value, 0.0, nan_value, 0);
-  TEST_c_c (catan, nan_value, minus_zero, nan_value, minus_zero);
+  TEST_c_c (catan, qnan_value, 0.0, qnan_value, 0);
+  TEST_c_c (catan, qnan_value, minus_zero, qnan_value, minus_zero);
 
-  TEST_c_c (catan, nan_value, plus_infty, nan_value, 0);
-  TEST_c_c (catan, nan_value, minus_infty, nan_value, minus_zero);
+  TEST_c_c (catan, qnan_value, plus_infty, qnan_value, 0);
+  TEST_c_c (catan, qnan_value, minus_infty, qnan_value, minus_zero);
 
-  TEST_c_c (catan, 0.0, nan_value, nan_value, nan_value);
-  TEST_c_c (catan, minus_zero, nan_value, nan_value, nan_value);
+  TEST_c_c (catan, 0.0, qnan_value, qnan_value, qnan_value);
+  TEST_c_c (catan, minus_zero, qnan_value, qnan_value, qnan_value);
 
-  TEST_c_c (catan, plus_infty, nan_value, M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
-  TEST_c_c (catan, minus_infty, nan_value, -M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
+  TEST_c_c (catan, plus_infty, qnan_value, M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
+  TEST_c_c (catan, minus_infty, qnan_value, -M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
 
-  TEST_c_c (catan, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
-  TEST_c_c (catan, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
+  TEST_c_c (catan, qnan_value, 10.5, qnan_value, qnan_value, INVALID_EXCEPTION_OK);
+  TEST_c_c (catan, qnan_value, -10.5, qnan_value, qnan_value, INVALID_EXCEPTION_OK);
 
-  TEST_c_c (catan, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
-  TEST_c_c (catan, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
+  TEST_c_c (catan, 0.75, qnan_value, qnan_value, qnan_value, INVALID_EXCEPTION_OK);
+  TEST_c_c (catan, -0.75, qnan_value, qnan_value, qnan_value, INVALID_EXCEPTION_OK);
 
-  TEST_c_c (catan, nan_value, nan_value, nan_value, nan_value);
+  TEST_c_c (catan, qnan_value, qnan_value, qnan_value, qnan_value);
 
   TEST_c_c (catan, 0.75L, 1.25L, 1.10714871779409050301706546017853704L, 0.549306144334054845697622618461262852L);
   TEST_c_c (catan, -2, -3, -1.4099210495965755225306193844604208L, -0.22907268296853876629588180294200276L);
@@ -2100,25 +2100,25 @@ catanh_test (void)
   TEST_c_c (catanh, plus_infty, 0.5, 0.0, M_PI_2l);
   TEST_c_c (catanh, plus_infty, -0.5, 0.0, -M_PI_2l);
 
-  TEST_c_c (catanh, 0, nan_value, 0.0, nan_value);
-  TEST_c_c (catanh, minus_zero, nan_value, minus_zero, nan_value);
+  TEST_c_c (catanh, 0, qnan_value, 0.0, qnan_value);
+  TEST_c_c (catanh, minus_zero, qnan_value, minus_zero, qnan_value);
 
-  TEST_c_c (catanh, plus_infty, nan_value, 0.0, nan_value);
-  TEST_c_c (catanh, minus_infty, nan_value, minus_zero, nan_value);
+  TEST_c_c (catanh, plus_infty, qnan_value, 0.0, qnan_value);
+  TEST_c_c (catanh, minus_infty, qnan_value, minus_zero, qnan_value);
 
-  TEST_c_c (catanh, nan_value, 0, nan_value, nan_value);
-  TEST_c_c (catanh, nan_value, minus_zero, nan_value, nan_value);
+  TEST_c_c (catanh, qnan_value, 0, qnan_value, qnan_value);
+  TEST_c_c (catanh, qnan_value, minus_zero, qnan_value, qnan_value);
 
-  TEST_c_c (catanh, nan_value, plus_infty, 0.0, M_PI_2l, IGNORE_ZERO_INF_SIGN);
-  TEST_c_c (catanh, nan_value, minus_infty, 0.0, -M_PI_2l, IGNORE_ZERO_INF_SIGN);
+  TEST_c_c (catanh, qnan_value, plus_infty, 0.0, M_PI_2l, IGNORE_ZERO_INF_SIGN);
+  TEST_c_c (catanh, qnan_value, minus_infty, 0.0, -M_PI_2l, IGNORE_ZERO_INF_SIGN);
 
-  TEST_c_c (catanh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
-  TEST_c_c (catanh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
+  TEST_c_c (catanh, 10.5, qnan_value, qnan_value, qnan_value, INVALID_EXCEPTION_OK);
+  TEST_c_c (catanh, -10.5, qnan_value, qnan_value, qnan_value, INVALID_EXCEPTION_OK);
 
-  TEST_c_c (catanh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
-  TEST_c_c (catanh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
+  TEST_c_c (catanh, qnan_value, 0.75, qnan_value, qnan_value, INVALID_EXCEPTION_OK);
+  TEST_c_c (catanh, qnan_value, -0.75, qnan_value, qnan_value, INVALID_EXCEPTION_OK);
 
-  TEST_c_c (catanh, nan_value, nan_value, nan_value, nan_value);
+  TEST_c_c (catanh, qnan_value, qnan_value, qnan_value, qnan_value);
 
   TEST_c_c (catanh, 0.75L, 1.25L, 0.261492138795671927078652057366532140L, 0.996825126463918666098902241310446708L);
   TEST_c_c (catanh, -2, -3, -0.14694666622552975204743278515471595L, -1.3389725222944935611241935759091443L);
@@ -2142,7 +2142,7 @@ cbrt_test (void)
 
   TEST_f_f (cbrt, plus_infty, plus_infty);
   TEST_f_f (cbrt, minus_infty, minus_infty);
-  TEST_f_f (cbrt, nan_value, nan_value);
+  TEST_f_f (cbrt, qnan_value, qnan_value);
 
   TEST_f_f (cbrt, -0.001L, -0.1L);
   TEST_f_f (cbrt, 8, 2);
@@ -2170,50 +2170,50 @@ ccos_test (void)
   TEST_c_c (ccos, 0.0, minus_zero, 1.0, 0.0);
   TEST_c_c (ccos, minus_zero, minus_zero, 1.0, minus_zero);
 
-  TEST_c_c (ccos, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
-  TEST_c_c (ccos, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
-  TEST_c_c (ccos, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
-  TEST_c_c (ccos, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
+  TEST_c_c (ccos, plus_infty, 0.0, qnan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
+  TEST_c_c (ccos, plus_infty, minus_zero, qnan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
+  TEST_c_c (ccos, minus_infty, 0.0, qnan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
+  TEST_c_c (ccos, minus_infty, minus_zero, qnan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
 
   TEST_c_c (ccos, 0.0, plus_infty, plus_infty, minus_zero);
   TEST_c_c (ccos, 0.0, minus_infty, plus_infty, 0.0);
   TEST_c_c (ccos, minus_zero, plus_infty, plus_infty, 0.0);
   TEST_c_c (ccos, minus_zero, minus_infty, plus_infty, minus_zero);
 
-  TEST_c_c (ccos, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
-  TEST_c_c (ccos, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
-  TEST_c_c (ccos, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
-  TEST_c_c (ccos, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
+  TEST_c_c (ccos, plus_infty, plus_infty, plus_infty, qnan_value, INV