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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
--- druntime/src/core/stdc/math.d 2018-03-04 08:20:53.000000000 +0100
+++ - 2018-08-03 22:10:15.242825116 +0200
@@ -232,8 +232,148 @@
int isunordered(double x, double y);
int isunordered(real x, real y);
}
+version( CRuntime_Glibc )
+{
+ enum
+ {
+ ///
+ FP_NAN,
+ ///
+ FP_INFINITE,
+ ///
+ FP_ZERO,
+ ///
+ FP_SUBNORMAL,
+ ///
+ FP_NORMAL,
+ }
+
+ enum
+ {
+ ///
+ FP_FAST_FMA = 0,
+ ///
+ FP_FAST_FMAF = 0,
+ ///
+ FP_FAST_FMAL = 0,
+ }
+
+ int __fpclassifyf(float x);
+ int __fpclassify(double x);
+ int __fpclassifyl(real x);
+
+ //int __finitef(float x);
+ //int __finite(double x);
+ //int __finitel(real x);
-version( CRuntime_DigitalMars )
+ //int __isinff(float x);
+ //int __isinf(double x);
+ //int __isinfl(real x);
+
+ //int __isnanf(float x);
+ //int __isnan(double x);
+ //int __isnanl(real x);
+
+ int __signbitf(float x);
+ int __signbit(double x);
+ int __signbitl(real x);
+
+ extern (D)
+ {
+ //int fpclassify(real-floating x);
+ ///
+ int fpclassify(float x) { return __fpclassifyf(x); }
+ ///
+ int fpclassify(double x) { return __fpclassify(x); }
+ ///
+ int fpclassify(real x)
+{
+ return (real.sizeof == double.sizeof)
+ ? __fpclassify(x)
+ : __fpclassifyl(x);
+ }
+ private uint __FLOAT_BITS(float __f)
+ {
+ union __u_t {
+ float __f;
+ uint __i;
+ }
+ __u_t __u;
+ __u.__f = __f;
+ return __u.__i;
+ }
+ private ulong __DOUBLE_BITS(double __f)
+ {
+ union __u_t {
+ double __f;
+ ulong __i;
+ }
+ __u_t __u;
+ __u.__f = __f;
+ return __u.__i;
+ }
+ //int isfinite(real-floating x);
+ ///
+ int isfinite(float x) { return (__FLOAT_BITS(x) & 0x7fffffff) < 0x7f800000; }
+ ///
+ int isfinite(double x) { return (__DOUBLE_BITS(x) & -1UL>>1) < 0x7ffUL<<52; }
+ ///
+ int isfinite(real x)
+ {
+ return (real.sizeof == double.sizeof)
+ ? isfinite(cast(double)x)
+ : __fpclassifyl(x) > FP_INFINITE;
+ }
+
+ //int isinf(real-floating x);
+ ///
+ int isinf(float x) { return (__FLOAT_BITS(x) & 0x7fffffff) == 0x7f800000; }
+ ///
+ int isinf(double x) { return (__DOUBLE_BITS(x) & -1UL>>1) == 0x7ffUL<<52; }
+ ///
+ int isinf(real x)
+ {
+ return (real.sizeof == double.sizeof)
+ ? isinf(cast(double)x)
+ : __fpclassifyl(x) == FP_INFINITE;
+ }
+
+ //int isnan(real-floating x);
+ ///
+ int isnan(float x) { return (__FLOAT_BITS(x) & 0x7fffffff) > 0x7f800000; }
+ ///
+ int isnan(double x) { return (__DOUBLE_BITS(x) & -1UL>>1) > 0x7ffUL<<52; }
+ ///
+ int isnan(real x)
+ {
+ return (real.sizeof == double.sizeof)
+ ? isnan(cast(double)x)
+ : __fpclassifyl(x) == FP_NAN;
+ }
+
+ //int isnormal(real-floating x);
+ ///
+ int isnormal(float x) { return fpclassify(x) == FP_NORMAL; }
+ ///
+ int isnormal(double x) { return fpclassify(x) == FP_NORMAL; }
+ ///
+ int isnormal(real x) { return fpclassify(x) == FP_NORMAL; }
+
+ //int signbit(real-floating x);
+ ///
+ int signbit(float x) { return __signbitf(x); }
+ ///
+ int signbit(double x) { return __signbit(x); }
+ ///
+ int signbit(real x)
+ {
+ return (real.sizeof == double.sizeof)
+ ? __signbit(x)
+ : __signbitl(x);
+ }
+ }
+}
+else version( CRuntime_DigitalMars )
{
enum
{
|