1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
|
/* Test of __unordsf2() function (used by GCC 4.3.0), Infs.
$Id: unord-02.c,v 1.1.2.2 2008/03/22 04:13:14 dmix Exp $
*/
#include <stdio.h>
#include <stdlib.h>
#include "progmem.h"
#ifdef __AVR__
extern int __unordsf2 (float, float);
# define UNORDSF2 __unordsf2
# define EXIT exit
#else
# include <math.h>
# define UNORDSF2 isunordered
# define EXIT(x) exit ((x) < 255 ? (x) : 255)
#endif
union lofl_u {
long lo;
float fl;
};
PROGMEM const struct { /* Table of test cases. */
union lofl_u x, y;
unsigned char z; /* result */
} t[] = {
/* 0.0 and Inf, all signes */
{ { 0x00000000 }, { 0x7f800000 }, 0 },
{ { 0x80000000 }, { 0x7f800000 }, 0 },
{ { 0x00000000 }, { 0xff800000 }, 0 },
{ { 0x80000000 }, { 0xff800000 }, 0 },
/* nonzero and +Inf */
{ { 0xff7fffff }, { 0x7f800000 }, 0 },
{ { 0x80800000 }, { 0x7f800000 }, 0 },
{ { 0x807fffff }, { 0x7f800000 }, 0 },
{ { 0x80000001 }, { 0x7f800000 }, 0 },
{ { 0x00000001 }, { 0x7f800000 }, 0 },
{ { 0x007fffff }, { 0x7f800000 }, 0 },
{ { 0x00800000 }, { 0x7f800000 }, 0 },
{ { 0x7f7fffff }, { 0x7f800000 }, 0 },
/* nonzero and -Inf */
{ { 0xff7fffff }, { 0xff800000 }, 0 },
{ { 0x80800000 }, { 0xff800000 }, 0 },
{ { 0x807fffff }, { 0xff800000 }, 0 },
{ { 0x80000001 }, { 0xff800000 }, 0 },
{ { 0x00000001 }, { 0xff800000 }, 0 },
{ { 0x007fffff }, { 0xff800000 }, 0 },
{ { 0x00800000 }, { 0xff800000 }, 0 },
{ { 0x7f7fffff }, { 0xff800000 }, 0 },
/* +Inf and nonzero */
{ { 0x7f800000 }, { 0xff7fffff }, 0 },
{ { 0x7f800000 }, { 0x80800000 }, 0 },
{ { 0x7f800000 }, { 0x807fffff }, 0 },
{ { 0x7f800000 }, { 0x80000001 }, 0 },
{ { 0x7f800000 }, { 0x00000001 }, 0 },
{ { 0x7f800000 }, { 0x007fffff }, 0 },
{ { 0x7f800000 }, { 0x00800000 }, 0 },
{ { 0x7f800000 }, { 0x7f7fffff }, 0 },
/* -Inf and nonzero */
{ { 0xff800000 }, { 0xff7fffff }, 0 },
{ { 0xff800000 }, { 0x80800000 }, 0 },
{ { 0xff800000 }, { 0x807fffff }, 0 },
{ { 0xff800000 }, { 0x80000001 }, 0 },
{ { 0xff800000 }, { 0x00000001 }, 0 },
{ { 0xff800000 }, { 0x007fffff }, 0 },
{ { 0xff800000 }, { 0x00800000 }, 0 },
{ { 0xff800000 }, { 0x7f7fffff }, 0 },
/* Inf and Inf, all signes */
{ { 0x7f800000 }, { 0x7f800000 }, 0 },
{ { 0xff800000 }, { 0xff800000 }, 0 },
{ { 0xff800000 }, { 0x7f800000 }, 0 },
{ { 0x7f800000 }, { 0xff800000 }, 0 },
};
volatile union lofl_u x, y;
int main ()
{
int i;
unsigned char z;
for (i = 0; i < (int) (sizeof(t) / sizeof(t[0])); i++) {
x.lo = pgm_read_dword (& t[i].x);
y.lo = pgm_read_dword (& t[i].y);
z = UNORDSF2 (x.fl, y.fl) ? 1 : 0;
if (z != pgm_read_byte (& t[i].z))
EXIT (i + 1);
}
return 0;
}
|
