Mail Archives: djgpp-workers/2008/06/12/03:58:58
I have implemented the missing macros: isgreater, isgreaterequal, isless, islessequal,
islessgreater and isunordered. A test programm for all is* macros have been added,
also a doc file.
Suggestions, object, comments are welcome.
Regards,
Juan M. Guerrero
2008-06-10 Juan Manuel Guerrero <juan DOT guerrero AT gmx DOT de>
* src/include/math.h: The macros isgreater, isgreaterequal, isless,
islessequal, islessgreater and isunordered have been added.
* src/libc/c99/math/ismacros.txh: Documentation about is* family of
macros added.
* tests/libc/c99/math/makefile: Entry for t-ismac.c added.
* tests/libc/c99/math/t-ismac.c: Test file for the is* family of macros.
* src/docs/kb/wc204.txi: Info about is* macros added.
diff -aprNU3 djgpp.orig/include/math.h djgpp/include/math.h
--- djgpp.orig/include/math.h 2008-04-06 21:14:54 +0000
+++ djgpp/include/math.h 2008-06-12 09:05:54 +0000
@@ -107,20 +107,47 @@ extern float __dj_nan;
/* Extended with Unnormals (for long doubles). */
#define FP_UNNORMAL 0x00010000
-#define fpclassify(x) ((sizeof(x)==sizeof(float))? __fpclassifyf(x) : \
- (sizeof(x)==sizeof(double))? __fpclassifyd(x) : \
- __fpclassifyld(x))
-
-#define signbit(x) (__extension__ ({__typeof__(x) __x = (x); \
- (sizeof(__x) == sizeof(float)) ? __signbitf(__x) : \
- (sizeof(__x) == sizeof(double)) ? __signbitd(__x) : \
- __signbitld(__x); \
- }))
-
-#define isfinite(x) ((fpclassify(x) & (FP_NORMAL|FP_SUBNORMAL|FP_ZERO)) != 0)
-#define isinf(x) (fpclassify(x)==FP_INFINITE)
-#define isnan(x) (fpclassify(x)==FP_NAN)
-#define isnormal(x) (fpclassify(x)==FP_NORMAL)
+#define fpclassify(x) (__extension__ ({__typeof__(x) __x = (x); \
+ (sizeof(__x) == sizeof(float)) ? __fpclassifyf(__x) : \
+ (sizeof(__x) == sizeof(double)) ? __fpclassifyd(__x) : \
+ __fpclassifyld(__x); \
+ }))
+
+#define signbit(x) (__extension__ ({__typeof__(x) __x = (x); \
+ (sizeof(__x) == sizeof(float)) ? __signbitf(__x) : \
+ (sizeof(__x) == sizeof(double)) ? __signbitd(__x) : \
+ __signbitld(__x); \
+ }))
+
+#define isfinite(x) ((fpclassify(x) & (FP_NORMAL | FP_SUBNORMAL | FP_ZERO)) != 0)
+#define isinf(x) (fpclassify(x) == FP_INFINITE)
+#define isnan(x) (fpclassify(x) == FP_NAN)
+#define isnormal(x) (fpclassify(x) == FP_NORMAL)
+
+#define isgreater(x, y) (__extension__ ({__typeof__(x) __x = (x); \
+ __typeof__(y) __y = (y); \
+ !isunordered(__x, __y) && (__x > __y); \
+ }))
+#define isgreaterequal(x, y) (__extension__ ({__typeof__(x) __x = (x); \
+ __typeof__(y) __y = (y); \
+ !isunordered(__x, __y) && (__x >= __y); \
+ }))
+#define isless(x, y) (__extension__ ({__typeof__(x) __x = (x); \
+ __typeof__(y) __y = (y); \
+ !isunordered(__x, __y) && (__x < __y); \
+ }))
+#define islessequal(x, y) (__extension__ ({__typeof__(x) __x = (x); \
+ __typeof__(y) __y = (y); \
+ !isunordered(__x, __y) && (__x <= __y); \
+ }))
+#define islessgreater(x, y) (__extension__ ({__typeof__(x) __x = (x); \
+ __typeof__(y) __y = (y); \
+ !isunordered(__x, __y) && (__x < __y || __x > __y); \
+ }))
+#define isunordered(x, y) (__extension__ ({__typeof__(x) __xx = (x); \
+ __typeof__(y) __yy = (y); \
+ (fpclassify(__xx) == FP_NAN) || (fpclassify(__yy) == FP_NAN); \
+ }))
int __fpclassifyf(float) __attribute__((const));
int __fpclassifyd(double) __attribute__((const));
diff -aprNU3 djgpp.orig/src/libc/c99/math/ismacros.txh djgpp/src/libc/c99/math/ismacros.txh
--- djgpp.orig/src/libc/c99/math/ismacros.txh 1970-01-01 00:00:00 +0000
+++ djgpp/src/libc/c99/math/ismacros.txh 2008-06-12 09:05:54 +0000
@@ -0,0 +1,422 @@
+@node isfinite, math
+@findex isfinite
+@subheading Syntax
+
+@example
+#include <math.h>
+
+int isfinite(x);
+@end example
+
+@subheading Description
+
+The macro @code{isfinite} will determine whether its argument @var{x} has a finite
+value (zero, subnormal, or normal, and not infinite or NaN). The operands can be
+of any real floating-point type.
+
+@subheading Return Value
+
+non-zero for a finite value;
+zero else.
+
+@subheading Portability
+
+@portability !ansi-c89, ansi-c99
+
+@subheading Example
+
+@example
+long double ld = 3.14159265358979;
+
+if (isfinite(ld))
+ printf("value is finite.\n");
+else if (isinf(ld))
+ printf("value is infinite.\n");
+else if (isnan(ld))
+ printf("value is NaN.\n");
+
+@end example
+
+@c ----------------------------------------------------------------------
+@node isgreater, math
+@findex isgreater
+@subheading Syntax
+
+@example
+#include <math.h>
+
+int isgreater(x, y);
+@end example
+
+@subheading Description
+
+The macro @code{isgreater} will determine whether its first argument @var{x} is
+greater than its second argument @var{y} without failing if one of the operands is
+@code{NaN}. The operands can be of any real floating-point type and the macro is
+guaranteed to evaluate their operands only once.
+
+@subheading Return Value
+
+zero if one of @var{x} or @var{y} is @code{NaN};
+else the result of (@var{x}) > (@var{y}).
+
+@subheading Portability
+
+@portability !ansi-c89, ansi-c99
+
+@subheading Example
+
+@example
+float f = 1;
+double d = INFINITY;
+
+if (isnan(f) || isnan(d))
+ printf("f or d is NaN.\n");
+else
+@{
+ if (isgreater(f, d))
+ printf("f is greater than d.\n");
+ else
+ printf("f is not greater than d.\n");
+@}
+
+@end example
+
+@c ----------------------------------------------------------------------
+@node isgreaterequal, math
+@findex isgreaterequal
+@subheading Syntax
+
+@example
+#include <math.h>
+
+int isgreaterequal(x, y);
+@end example
+
+@subheading Description
+
+The macro @code{isgreaterequal} will determine whether its first argument @var{x} is
+greater than or equal to its second argument @var{y} without failing if one of the operands
+is @code{NaN}. The operands can be of any real floating-point type and the macro is
+guaranteed to evaluate their operands only once.
+
+@subheading Return Value
+
+zero if one of @var{x} or @var{y} is @code{NaN};
+else the result of (@var{x}) >= (@var{y}).
+
+@subheading Portability
+
+@portability !ansi-c89, ansi-c99
+
+@subheading Example
+
+@example
+float f = 1;
+double d = INFINITY;
+
+if (isnan(f) || isnan(d))
+ printf("f or d is NaN.\n");
+else
+@{
+ if (isgreaterequal(f, d))
+ printf("f is greater than or equal to d.\n");
+ else
+ printf("f is not greater than d.\n");
+@}
+
+@end example
+
+@c ----------------------------------------------------------------------
+@node isinf, math
+@findex isinf
+@subheading Syntax
+
+@example
+#include <math.h>
+
+int isinf(x);
+@end example
+
+@subheading Description
+
+The macro @code{isinf} will determine whether its argument @var{x} value is a positive
+or negative infinity. The operands can be of any real floating-point type.
+
+@subheading Return Value
+
+non-zero for a infinite value (positive or negative);
+zero else.
+
+@subheading Portability
+
+@portability !ansi-c89, ansi-c99
+
+@subheading Example
+
+@example
+double d = INFINITY;
+
+if (isinf(d))
+ printf("value is infinite.\n");
+else if (isnan(d))
+ printf("value is NaN.\n");
+else
+ printf("value is finite.\n");
+
+@end example
+
+@c ----------------------------------------------------------------------
+@node isless, math
+@findex isless
+@subheading Syntax
+
+@example
+#include <math.h>
+
+int isless(x, y);
+@end example
+
+@subheading Description
+
+The macro @code{isless} will determine whether its first argument @var{x} is less than
+its second argument @var{y} without failing if one of the operands is @code{NaN}. The
+operands can be of any real floating-point type and the macro is guaranteed to evaluate
+their operands only once.
+
+@subheading Return Value
+
+zero if one of @var{x} or @var{y} is @code{NaN};
+else the result of (@var{x}) < (@var{y}).
+
+@subheading Portability
+
+@portability !ansi-c89, ansi-c99
+
+@subheading Example
+
+@example
+float f = 1;
+double d = INFINITY;
+
+if (isnan(f) || isnan(d))
+ printf("f or d is NaN.\n");
+else
+@{
+ if (isless(f, d))
+ printf("f is less than d.\n");
+ else
+ printf("f is not less than d.\n");
+@}
+
+@end example
+
+@c ----------------------------------------------------------------------
+@node islessequal, math
+@findex islessequal
+@subheading Syntax
+
+@example
+#include <math.h>
+
+int islessequal(x, y);
+@end example
+
+@subheading Description
+
+The macro @code{islessequal} will determine whether its first argument @var{x} is less
+than or equal to its second argument @var{y} without failing if one of the operands is
+@code{NaN}. The operands can be of any real floating-point type and the macro is
+guaranteed to evaluate their operands only once.
+
+@subheading Return Value
+
+zero if one of @var{x} or @var{y} is @code{NaN};
+else the result of (@var{x}) <= (@var{y}).
+
+@subheading Portability
+
+@portability !ansi-c89, ansi-c99
+
+@subheading Example
+
+@example
+float f = 1;
+double d = INFINITY;
+
+if (isnan(f) || isnan(d))
+ printf("f or d is NaN.\n");
+else
+@{
+ if (islessequal(f, d))
+ printf("f is less than or equal to d.\n");
+ else
+ printf("f is not less than d.\n");
+@}
+
+@end example
+
+@c ----------------------------------------------------------------------
+@node islessgreater, math
+@findex islessgreater
+@subheading Syntax
+
+@example
+#include <math.h>
+
+int islessgreater(x, y);
+@end example
+
+@subheading Description
+
+The macro @code{islessgreater} will determine whether its first argument @var{x} is less
+than or greater than its second argument @var{y} without failing if one of the operands
+is @code{NaN}. The operands can be of any real floating-point type and the macro is
+guaranteed to evaluate their operands only once.
+
+@subheading Return Value
+
+zero if one of @var{x} or @var{y} is @code{NaN};
+else the result of (@var{x}) < (@var{y}) || (@var{x}) > (@var{y}).
+
+@subheading Portability
+
+@portability !ansi-c89, ansi-c99
+
+@subheading Example
+
+@example
+double d = 1;
+long double ld = 1;
+
+if (isnan(ld) || isnan(d))
+ printf("ld or d is NaN.\n");
+else
+@{
+ if (islessgreater(lf, d))
+ printf("ld is less than d or ld is greater than d.\n");
+ else
+ printf("ld is equal to d.\n");
+@}
+
+@end example
+
+@c ----------------------------------------------------------------------
+@node isnan, math
+@findex isnan
+@subheading Syntax
+
+@example
+#include <math.h>
+
+int isnan(x);
+@end example
+
+@subheading Description
+
+The macro @code{isnan} will determine whether its argument @var{x} is a NaN. The operands
+can be of any real floating-point type.
+
+@subheading Return Value
+
+non-zero for NaN;
+zero else.
+
+@subheading Portability
+
+@portability !ansi-c89, ansi-c99
+
+@subheading Example
+
+@example
+float f = NAN;
+
+if (isnan(f))
+ printf("value is NaN.\n");
+else if (isinf(f))
+ printf("value is infinite.\n");
+else
+ printf("value is finite.\n");
+
+@end example
+
+@c ----------------------------------------------------------------------
+@node isnormal, math
+@findex isnormal
+@subheading Syntax
+
+@example
+#include <math.h>
+
+int isnormal(x);
+@end example
+
+@subheading Description
+
+The macro @code{isnormal} will determine whether its argument @var{x} is normal
+(neither zero, subnormal, infinite nor NaN). The operands can be of any real
+floating-point type.
+
+@subheading Return Value
+
+non-zero for a normal value;
+zero else.
+
+@subheading Portability
+
+@portability !ansi-c89, ansi-c99
+
+@subheading Example
+
+@example
+long double ld = 3.14159265358979;
+
+if (isfinite(ld))
+@{
+ if (isnormal(ld))
+ printf("value is normal.\n");
+ else
+ printf("value is either zero or subnormal.\n");
+@}
+else
+ printf("value is either infinity or NaN.\n");
+
+@end example
+
+@c ----------------------------------------------------------------------
+@node isunordered, math
+@findex isunordered
+@subheading Syntax
+
+@example
+#include <math.h>
+
+int isunordered(x);
+@end example
+
+@subheading Description
+
+The macro @code{isunordered} will determine whether its arguments @var{x} or @var{y} are unordered.
+The operands can be of any real floating-point type.
+
+@subheading Return Value
+
+non-zero if one of @var{x} or @var{y} is @code{NaN};
+zero else.
+
+@subheading Portability
+
+@portability !ansi-c89, ansi-c99
+
+@subheading Example
+
+@example
+float pi = 3.14159;
+long double x = NAN;
+
+if (isunordered(pi, x))
+ printf("one of the values is NaN.\n");
+
+@end example
+
+@c ----------------------------------------------------------------------
diff -aprNU3 djgpp.orig/tests/libc/c99/math/makefile djgpp/tests/libc/c99/math/makefile
--- djgpp.orig/tests/libc/c99/math/makefile 2003-10-25 11:22:52 +0000
+++ djgpp/tests/libc/c99/math/makefile 2008-06-12 09:05:54 +0000
@@ -3,5 +3,6 @@ TOP=../..
SRC += t-fpclas.c
SRC += t-nan.c
SRC += t-nan2.c
+SRC += t-ismac.c
include $(TOP)/../makefile.inc
diff -aprNU3 djgpp.orig/tests/libc/c99/math/t-ismac.c djgpp/tests/libc/c99/math/t-ismac.c
--- djgpp.orig/tests/libc/c99/math/t-ismac.c 1970-01-01 00:00:00 +0000
+++ djgpp/tests/libc/c99/math/t-ismac.c 2008-06-12 09:05:54 +0000
@@ -0,0 +1,472 @@
+#include <stdio.h>
+#include <math.h>
+#include <libc/ieee.h>
+
+
+typedef union
+{
+ long_double_t ldt;
+ long double ld;
+} test_long_double_union_t;
+
+typedef struct {
+ const char *class;
+ const char *type;
+ test_long_double_union_t number;
+} test_long_double_t;
+
+
+typedef union
+{
+ double_t dt;
+ double d;
+} test_double_union_t;
+
+typedef struct {
+ const char *class;
+ const char *type;
+ test_double_union_t number;
+} test_double_t;
+
+
+typedef union
+{
+ float_t ft;
+ float f;
+} test_float_union_t;
+
+typedef struct {
+ const char *class;
+ const char *type;
+ test_float_union_t number;
+} test_float_t;
+
+
+int main(void)
+{
+ int i;
+
+ test_long_double_t test_ld[] = {
+ /* Normals. (4) */
+ {"long double", "small positive normal", {{1, 0x80000000, 1, 0}}}, /* Smallest possible > 0. */
+ {"long double", "small negative normal", {{1, 0x80000000, 1, 1}}}, /* Biggest possible < 0. */
+ {"long double", "big positive normal", {{0xFFFFFFFF, 0xFFFFFFFF, 0x7FFE, 0}}}, /* Big number. */
+ {"long double", "big negative normal", {{0xFFFFFFFF, 0xFFFFFFFF, 0x7FFE, 1}}}, /* Big -number. */
+
+ /* Subnormals aka denormals. (4 + 2) */
+ {"long double", "positive subnormal", {{1, 0, 0, 0}}}, /* Smallest possible > 0. */
+ {"long double", "negative subnormal", {{1, 0, 0, 1}}}, /* Biggest possible < 0. */
+
+ /* Zeros. (4 + 2 + 2) */
+ {"long double", "positive zero", {{0, 0, 0, 0 }}}, /* 0.0 */
+ {"long double", "negative zero", {{0, 0, 0, 1 }}}, /* -0.0 */
+
+ /* Infinities. (4 + 2 + 2 + 2) */
+ {"long double", "positive infinity", {{0, 0x80000000, 0x7FFF, 0}}}, /* Inf. */
+ {"long double", "negative infinity", {{0, 0x80000000, 0x7FFF, 1}}}, /* -Inf. */
+
+ /* NaNs. (4 + 2 + 2 + 2 + 4) */
+ {"long double", "positive signalling NaN", {{1, 0x80000000, 0x7FFF, 0}}}, /* SNaN */
+ {"long double", "negative signalling NaN", {{1, 0x80000000, 0x7FFF, 1}}}, /* -SNaN */
+ {"long double", "positive quiet NaN", {{0, 0xFFFFFFFF, 0x7FFF, 0}}}, /* QNaN */
+ {"long double", "negative quiet NaN", {{0, 0xFFFFFFFF, 0x7FFF, 1}}} /* -QNaN */
+ };
+
+ test_double_t test_d[] = {
+ /* Normals. */
+ {"double", "small positive normal", {{1, 0, 1, 0}}}, /* Small number. */
+ {"double", "small negative normal", {{1, 0, 1, 1}}}, /* Small -number. */
+ {"double", "big positive normal", {{0xFFFFFFFF, 0x7FFFF, 0x7FE, 0}}}, /* Big number. */
+ {"double", "big negative normal", {{0xFFFFFFFF, 0x7FFFF, 0x7FE, 1}}}, /* Big -number. */
+
+ /* Subnormals aka denormals. */
+ {"double", "positive subnormal", {{1, 0, 0, 0}}}, /* Very small number. */
+ {"double", "negative subnormal", {{1, 0, 0, 1}}}, /* Very small -number. */
+
+ /* Zeros. */
+ {"double", "positive zero", {{0, 0, 0, 0}}}, /* 0.0 */
+ {"double", "negative zero", {{0, 0, 0, 1}}}, /* -0.0 */
+
+ /* Infinities. */
+ {"double", "positive infinity", {{0, 0, 0x7FF, 0}}}, /* Inf. */
+ {"double", "negative infinity", {{0, 0, 0x7FF, 1}}}, /* -Inf. */
+
+ /* NaNs. */
+ {"double", "positive signalling NaN", {{1, 0, 0x7FF, 0}}}, /* SNaN */
+ {"double", "negative signalling NaN", {{1, 0, 0x7FF, 1}}}, /* -SNaN */
+ {"double", "positive quiet NaN", {{0, 0xFFFFF, 0x7FF, 0}}}, /* QNaN */
+ {"double", "negative quiet NaN", {{0, 0xFFFFF, 0x7FF, 1}}} /* -QNaN */
+ };
+
+ test_float_t test_f[] = {
+ /* Normals. */
+ {"float", "small positive normal", {{1, 1, 0}}}, /* Small number. */
+ {"float", "small negative normal", {{1, 1, 1}}}, /* Small -number. */
+ {"float", "big positive normal", {{0xFF, 0xFE, 0}}}, /* Big number. */
+ {"float", "big negative normal", {{0xFF, 0xFE, 1}}}, /* Big -number. */
+
+ /* Subnormals aka denormals. */
+ {"float", "positive subnormal", {{1, 0, 0}}}, /* Very small number. */
+ {"float", "negative subnormal", {{1, 0, 1}}}, /* Very small -number. */
+
+ /* Zeros. */
+ {"float", "positive zero", {{0, 0, 0}}}, /* 0.0 */
+ {"float", "negative zero", {{0, 0, 1}}}, /* -0.0 */
+
+ /* Infinities. */
+ {"float", "positive infinity", {{0, 0xFF, 0}}}, /* Inf */
+ {"float", "negative infinity", {{0, 0xFF, 1}}}, /* -Inf */
+
+ /* NaNs. */
+ {"float", "positive signalling NaN", {{1, 0xFF, 0}}}, /* SNaN */
+ {"float", "negative signalling NaN", {{1, 0xFF, 1}}}, /* -SNaN */
+ {"float", "positive quiet NaN", {{0x7FFFFF, 0xFF, 0}}}, /* QNaN */
+ {"float", "negative quiet NaN", {{0x7FFFFF, 0xFF, 1}}} /* -QNaN */
+ };
+
+
+
+ /*
+ * isfinite must return non-zero for normals, subnormals and zero,
+ * and zero for infinity and NaN.
+ */
+ printf("Testing isfinite macro...\n"
+ "isfinite(x) must return non-zero if x is normal, subnormal and zero,\n"
+ "and zero for infinity and NaN.\n");
+ for (i = 0; i < (4 + 2 + 2); i++)
+ {
+ printf("Testing isfinite(%La) for a %s %s: %d\n", test_ld[i].number.ld, test_ld[i].class, test_ld[i].type, isfinite(test_ld[i].number.ld));
+ printf("Testing isfinite(%a) for a %s %s: %d\n", test_d[i].number.d, test_d[i].class, test_d[i].type, isfinite(test_d[i].number.d));
+ printf("Testing isfinite(%a) for a %s %s: %d\n\n", test_f[i].number.f, test_f[i].class, test_f[i].type, isfinite(test_f[i].number.f));
+ }
+ for (; i < (4 + 2 + 2 + 2 + 4); i++)
+ {
+ printf("Testing isfinite(%La) for a %s %s: %d\n", test_ld[i].number.ld, test_ld[i].class, test_ld[i].type, isfinite(test_ld[i].number.ld));
+ printf("Testing isfinite(%a) for a %s %s: %d\n", test_d[i].number.d, test_d[i].class, test_d[i].type, isfinite(test_d[i].number.d));
+ printf("Testing isfinite(%a) for a %s %s: %d\n\n", test_f[i].number.f, test_f[i].class, test_f[i].type, isfinite(test_f[i].number.f));
+ }
+ printf("----------------------------------------------------------------------\n");
+
+
+
+ /*
+ * isnormal must return non-zero for normals
+ * and zero for subnormals, zero, infinity and NaN.
+ */
+ printf("\n\nTesting isnormal macro...\n"
+ "isnormal(x) must return non-zero if x is normal\n"
+ "and zero for subnormals, zero, infinity and NaN.\n");
+ for (i = 0; i < 4; i++)
+ {
+ printf("Testing isnormal(%La) for a %s %s: %d\n", test_ld[i].number.ld, test_ld[i].class, test_ld[i].type, isnormal(test_ld[i].number.ld));
+ printf("Testing isnormal(%a) for a %s %s: %d\n", test_d[i].number.d, test_d[i].class, test_d[i].type, isnormal(test_d[i].number.d));
+ printf("Testing isnormal(%a) for a %s %s: %d\n\n", test_f[i].number.f, test_f[i].class, test_f[i].type, isnormal(test_f[i].number.f));
+ }
+ for (; i < (4 + 2 + 2 + 2 + 4); i++)
+ {
+ printf("Testing isnormal(%La) for a %s %s: %d\n", test_ld[i].number.ld, test_ld[i].class, test_ld[i].type, isnormal(test_ld[i].number.ld));
+ printf("Testing isnormal(%a) for a %s %s: %d\n", test_d[i].number.d, test_d[i].class, test_d[i].type, isnormal(test_d[i].number.d));
+ printf("Testing isnormal(%a) for a %s %s: %d\n\n", test_f[i].number.f, test_f[i].class, test_f[i].type, isnormal(test_f[i].number.f));
+ }
+ printf("----------------------------------------------------------------------\n");
+
+
+
+ /*
+ * isinf must return non-zero for infinity (positive or negative)
+ * and zero else.
+ */
+ printf("\n\nTesting isinf macro...\n"
+ "isinf(x) must return non-zero if x is infinity (positive or negative)\n"
+ "else zero.\n");
+ for (i = 0; i < (4 + 2 + 2); i++)
+ {
+ printf("Testing isinf(%La) for a %s %s: %d\n", test_ld[i].number.ld, test_ld[i].class, test_ld[i].type, isinf(test_ld[i].number.ld));
+ printf("Testing isinf(%a) for a %s %s: %d\n", test_d[i].number.d, test_d[i].class, test_d[i].type, isinf(test_d[i].number.d));
+ printf("Testing isinf(%a) for a %s %s: %d\n\n", test_f[i].number.f, test_f[i].class, test_f[i].type, isinf(test_f[i].number.f));
+ }
+ for (; i < (4 + 2 + 2 + 2); i++)
+ {
+ printf("Testing isinf(%La) for a %s %s: %d\n", test_ld[i].number.ld, test_ld[i].class, test_ld[i].type, isinf(test_ld[i].number.ld));
+ printf("Testing isinf(%a) for a %s %s: %d\n", test_d[i].number.d, test_d[i].class, test_d[i].type, isinf(test_d[i].number.d));
+ printf("Testing isinf(%a) for a %s %s: %d\n\n", test_f[i].number.f, test_f[i].class, test_f[i].type, isinf(test_f[i].number.f));
+ }
+ for (; i <(4 + 2 + 2 + 2 + 4); i++)
+ {
+ printf("Testing isinf(%La) for a %s %s: %d\n", test_ld[i].number.ld, test_ld[i].class, test_ld[i].type, isinf(test_ld[i].number.ld));
+ printf("Testing isinf(%a) for a %s %s: %d\n", test_d[i].number.d, test_d[i].class, test_d[i].type, isinf(test_d[i].number.d));
+ printf("Testing isinf(%a) for a %s %s: %d\n\n", test_f[i].number.f, test_f[i].class, test_f[i].type, isinf(test_f[i].number.f));
+ }
+ printf("----------------------------------------------------------------------\n");
+
+
+
+ /*
+ * isnan must return non-zero for [SQ]NaN (positive or negative)
+ * and zero else.
+ */
+ printf("\n\nTesting isnan macro...\n"
+ "isnan(x) must return non-zero if x is [SQ]NaN (positive or negative)\n"
+ "else zero.\n");
+ for (i = 0; i < 10; i++)
+ {
+ printf("Testing isnan(%La) for a %s %s: %d\n", test_ld[i].number.ld, test_ld[i].class, test_ld[i].type, isnan(test_ld[i].number.ld));
+ printf("Testing isnan(%a) for a %s %s: %d\n", test_d[i].number.d, test_d[i].class, test_d[i].type, isnan(test_d[i].number.d));
+ printf("Testing isnan(%a) for a %s %s: %d\n\n", test_f[i].number.f, test_f[i].class, test_f[i].type, isnan(test_f[i].number.f));
+ }
+ for (; i < 10 + 4; i++)
+ {
+ printf("Testing isnan(%La) for a %s %s: %d\n", test_ld[i].number.ld, test_ld[i].class, test_ld[i].type, isnan(test_ld[i].number.ld));
+ printf("Testing isnan(%a) for a %s %s: %d\n", test_d[i].number.d, test_d[i].class, test_d[i].type, isnan(test_d[i].number.d));
+ printf("Testing isnan(%a) for a %s %s: %d\n\n", test_f[i].number.f, test_f[i].class, test_f[i].type, isnan(test_f[i].number.f));
+ }
+ printf("----------------------------------------------------------------------\n");
+
+
+
+ /*
+ * isgreater must return zero if x or y is [SQ]NaN (positive or negative)
+ * and else the result of x > y.
+ */
+ printf("\n\nTesting isgreater macro...\n"
+ "isgreater(x, y) must return zero if x or y is [SQ]NaN (positive or negative)\n"
+ "and else the result of x > y.\n");
+ for (i = 0; i < 4; i++)
+ {
+ printf("Testing isgreater(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, isgreater(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing isgreater(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, isgreater(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing isgreater(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, isgreater(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ for (; i < (4 + 2); i++)
+ {
+ printf("Testing isgreater(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, isgreater(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing isgreater(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, isgreater(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing isgreater(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, isgreater(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ for (; i < (4 + 2 + 2); i++)
+ {
+ printf("Testing isgreater(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, isgreater(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing isgreater(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, isgreater(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing isgreater(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, isgreater(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ for (; i < (4 + 2 + 2 + 2); i++)
+ {
+ printf("Testing isgreater(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, isgreater(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing isgreater(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, isgreater(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing isgreater(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, isgreater(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ for (; i < (4 + 2 + 2 + 2 + 4); i++)
+ {
+ printf("Testing isgreater(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, isgreater(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing isgreater(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, isgreater(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing isgreater(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, isgreater(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ printf("----------------------------------------------------------------------\n");
+
+
+
+ /*
+ * isgreaterequal must return zero if x or y is [SQ]NaN (positive or negative)
+ * and else the result of x >= y.
+ */
+ printf("\n\nTesting isgreaterequal macro...\n"
+ "isgreaterequal(x, y) must return zero if x or y is [SQ]NaN (positive or negative)\n"
+ "and else the result of x >= y.\n");
+ for (i = 0; i < 4; i++)
+ {
+ printf("Testing isgreaterequal(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, isgreaterequal(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing isgreaterequal(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, isgreaterequal(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing isgreaterequal(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, isgreaterequal(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ for (; i < (4 + 2); i++)
+ {
+ printf("Testing isgreaterequal(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, isgreaterequal(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing isgreaterequal(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, isgreaterequal(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing isgreaterequal(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, isgreaterequal(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ for (; i < (4 + 2 + 2); i++)
+ {
+ printf("Testing isgreaterequal(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, isgreaterequal(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing isgreaterequal(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, isgreaterequal(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing isgreaterequal(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, isgreaterequal(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ for (; i < (4 + 2 + 2 + 2); i++)
+ {
+ printf("Testing isgreaterequal(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, isgreaterequal(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing isgreaterequal(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, isgreaterequal(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing isgreaterequal(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, isgreaterequal(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ for (; i < (4 + 2 + 2 + 2 + 4); i++)
+ {
+ printf("Testing isgreaterequal(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, isgreaterequal(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing isgreaterequal(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, isgreaterequal(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing isgreaterequal(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, isgreaterequal(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ printf("----------------------------------------------------------------------\n");
+
+
+
+ /*
+ * isless must return zero if x or y is [SQ]NaN (positive or negative)
+ * and else the result of x < y.
+ */
+ printf("\n\nTesting isless macro...\n"
+ "isless(x, y) must return zero if x or y is [SQ]NaN (positive or negative)\n"
+ "and else the result of x < y.\n");
+ for (i = 0; i < 4; i++)
+ {
+ printf("Testing isless(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, isless(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing isless(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, isless(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing isless(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, isless(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ for (; i < (4 + 2); i++)
+ {
+ printf("Testing isless(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, isless(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing isless(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, isless(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing isless(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, isless(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ for (; i < (4 + 2 + 2); i++)
+ {
+ printf("Testing isless(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, isless(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing isless(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, isless(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing isless(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, isless(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ for (; i < (4 + 2 + 2 + 2); i++)
+ {
+ printf("Testing isless(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, isless(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing isless(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, isless(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing isless(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, isless(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ for (; i < (4 + 2 + 2 + 2 + 4); i++)
+ {
+ printf("Testing isless(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, isless(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing isless(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, isless(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing isless(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, isless(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ printf("----------------------------------------------------------------------\n");
+
+
+
+ /*
+ * islessequal must return zero if x or y is [SQ]NaN (positive or negative)
+ * and else the result of x <= y.
+ */
+ printf("\n\nTesting islessequal macro...\n"
+ "islessequal(x, y) must return zero if x or y is [SQ]NaN (positive or negative)\n"
+ "and else the result of x <= y.\n");
+ for (i = 0; i < 4; i++)
+ {
+ printf("Testing islessequal(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, islessequal(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing islessequal(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, islessequal(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing islessequal(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, islessequal(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ for (; i < (4 + 2); i++)
+ {
+ printf("Testing islessequal(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, islessequal(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing islessequal(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, islessequal(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing islessequal(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, islessequal(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ for (; i < (4 + 2 + 2); i++)
+ {
+ printf("Testing islessequal(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, islessequal(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing islessequal(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, islessequal(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing islessequal(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, islessequal(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ for (; i < (4 + 2 + 2 + 2); i++)
+ {
+ printf("Testing islessequal(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, islessequal(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing islessequal(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, islessequal(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing islessequal(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, islessequal(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ for (; i < (4 + 2 + 2 + 2 + 4); i++)
+ {
+ printf("Testing islessequal(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, islessequal(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing islessequal(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, islessequal(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing islessequal(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, islessequal(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ printf("----------------------------------------------------------------------\n");
+
+
+
+ /*
+ * islessgreater must return zero if x or y is [SQ]NaN (positive or negative)
+ * and else the result of (x < y) || x > y).
+ */
+ printf("\n\nTesting islessgreater macro...\n"
+ "islessgreater(x, y) must return zero if x or y is [SQ]NaN (positive or negative)\n"
+ "and else the result of (x < y) || x > y).\n");
+ for (i = 0; i < 4; i++)
+ {
+ printf("Testing islessgreater(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, islessgreater(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing islessgreater(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, islessgreater(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing islessgreater(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, islessgreater(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ for (; i < (4 + 2); i++)
+ {
+ printf("Testing islessgreater(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, islessgreater(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing islessgreater(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, islessgreater(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing islessgreater(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, islessgreater(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ for (; i < (4 + 2 + 2); i++)
+ {
+ printf("Testing islessgreater(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, islessgreater(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing islessgreater(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, islessgreater(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing islessgreater(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, islessgreater(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ for (; i < (4 + 2 + 2 + 2); i++)
+ {
+ printf("Testing islessgreater(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, islessgreater(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing islessgreater(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, islessgreater(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing islessgreater(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, islessgreater(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ for (; i < (4 + 2 + 2 + 2 + 4); i++)
+ {
+ printf("Testing islessgreater(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, islessgreater(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing islessgreater(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, islessgreater(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing islessgreater(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, islessgreater(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ printf("----------------------------------------------------------------------\n");
+
+
+
+ /*
+ * isunordered must return non-zero if x or y is [SQ]NaN (positive or negative)
+ * and zero else.
+ */
+ printf("\n\nTesting isunordered macro...\n"
+ "isunordered(x, y) must return non-zero if x or y is [SQ]NaN (positive or negative)\n"
+ "and zero else.\n");
+ for (i = 0; i < 4; i++)
+ {
+ printf("Testing isunordered(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, isunordered(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing isunordered(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, isunordered(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing isunordered(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, isunordered(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ for (; i < (4 + 2); i++)
+ {
+ printf("Testing isunordered(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, isunordered(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing isunordered(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, isunordered(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing isunordered(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, isunordered(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ for (; i < (4 + 2 + 2); i++)
+ {
+ printf("Testing isunordered(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, isunordered(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing isunordered(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, isunordered(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing isunordered(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, isunordered(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ for (; i < (4 + 2 + 2 + 2); i++)
+ {
+ printf("Testing isunordered(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, isunordered(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing isunordered(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, isunordered(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing isunordered(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, isunordered(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ for (; i < (4 + 2 + 2 + 2 + 4); i++)
+ {
+ printf("Testing isunordered(%La, %a) for a %s %s and %s %s: %d\n", test_ld[i].number.ld, test_d[i].number.d, test_ld[i].class, test_ld[i].type, test_d[i].class, test_d[i].type, isunordered(test_ld[i].number.ld, test_d[i].number.d));
+ printf("Testing isunordered(%a, %a) for a %s %s and %s %s: %d\n", test_d[i].number.d, test_f[i].number.f, test_d[i].class, test_d[i].type, test_f[i].class, test_f[i].type, isunordered(test_d[i].number.d, test_f[i].number.f));
+ printf("Testing isunordered(%a, %La) for a %s %s and %s %s: %d\n\n", test_f[i].number.f, test_ld[i].number.ld, test_f[i].class, test_f[i].type, test_ld[i].class, test_ld[i].type, isunordered(test_f[i].number.f, test_ld[i].number.ld));
+ }
+ printf("----------------------------------------------------------------------\n");
+
+ return 0;
+}
- Raw text -