@@ -74,24 +74,77 @@ mod tests {
74
74
fn fminimum_spec_test < F : Float > ( f : impl Fn ( F , F ) -> F ) {
75
75
let cases = [
76
76
( F :: ZERO , F :: ZERO , F :: ZERO ) ,
77
- ( F :: ONE , F :: ONE , F :: ONE ) ,
77
+ ( F :: ZERO , F :: NEG_ZERO , F :: NEG_ZERO ) ,
78
78
( F :: ZERO , F :: ONE , F :: ZERO ) ,
79
- ( F :: ONE , F :: ZERO , F :: ZERO ) ,
80
79
( F :: ZERO , F :: NEG_ONE , F :: NEG_ONE ) ,
80
+ ( F :: ZERO , F :: INFINITY , F :: ZERO ) ,
81
+ ( F :: ZERO , F :: NEG_INFINITY , F :: NEG_INFINITY ) ,
82
+ ( F :: ZERO , F :: NAN , F :: NAN ) ,
83
+ ( F :: ZERO , F :: NEG_NAN , F :: NEG_NAN ) ,
84
+ ( F :: NEG_ZERO , F :: ZERO , F :: NEG_ZERO ) ,
85
+ ( F :: NEG_ZERO , F :: NEG_ZERO , F :: NEG_ZERO ) ,
86
+ ( F :: NEG_ZERO , F :: ONE , F :: NEG_ZERO ) ,
87
+ ( F :: NEG_ZERO , F :: NEG_ONE , F :: NEG_ONE ) ,
88
+ ( F :: NEG_ZERO , F :: INFINITY , F :: NEG_ZERO ) ,
89
+ ( F :: NEG_ZERO , F :: NEG_INFINITY , F :: NEG_INFINITY ) ,
90
+ ( F :: NEG_ZERO , F :: NAN , F :: NAN ) ,
91
+ ( F :: NEG_ZERO , F :: NEG_NAN , F :: NEG_NAN ) ,
92
+ ( F :: ONE , F :: ZERO , F :: ZERO ) ,
93
+ ( F :: ONE , F :: NEG_ZERO , F :: NEG_ZERO ) ,
94
+ ( F :: ONE , F :: ONE , F :: ONE ) ,
95
+ ( F :: ONE , F :: NEG_ONE , F :: NEG_ONE ) ,
96
+ ( F :: ONE , F :: INFINITY , F :: ONE ) ,
97
+ ( F :: ONE , F :: NEG_INFINITY , F :: NEG_INFINITY ) ,
98
+ ( F :: ONE , F :: NAN , F :: NAN ) ,
99
+ ( F :: ONE , F :: NEG_NAN , F :: NEG_NAN ) ,
81
100
( F :: NEG_ONE , F :: ZERO , F :: NEG_ONE ) ,
101
+ ( F :: NEG_ONE , F :: NEG_ZERO , F :: NEG_ONE ) ,
102
+ ( F :: NEG_ONE , F :: ONE , F :: NEG_ONE ) ,
103
+ ( F :: NEG_ONE , F :: NEG_ONE , F :: NEG_ONE ) ,
104
+ ( F :: NEG_ONE , F :: INFINITY , F :: NEG_ONE ) ,
105
+ ( F :: NEG_ONE , F :: NEG_INFINITY , F :: NEG_INFINITY ) ,
106
+ ( F :: NEG_ONE , F :: NAN , F :: NAN ) ,
107
+ ( F :: NEG_ONE , F :: NEG_NAN , F :: NEG_NAN ) ,
82
108
( F :: INFINITY , F :: ZERO , F :: ZERO ) ,
109
+ ( F :: INFINITY , F :: NEG_ZERO , F :: NEG_ZERO ) ,
110
+ ( F :: INFINITY , F :: ONE , F :: ONE ) ,
111
+ ( F :: INFINITY , F :: NEG_ONE , F :: NEG_ONE ) ,
112
+ ( F :: INFINITY , F :: INFINITY , F :: INFINITY ) ,
113
+ ( F :: INFINITY , F :: NEG_INFINITY , F :: NEG_INFINITY ) ,
114
+ ( F :: INFINITY , F :: NAN , F :: NAN ) ,
115
+ ( F :: INFINITY , F :: NEG_NAN , F :: NEG_NAN ) ,
83
116
( F :: NEG_INFINITY , F :: ZERO , F :: NEG_INFINITY ) ,
117
+ ( F :: NEG_INFINITY , F :: NEG_ZERO , F :: NEG_INFINITY ) ,
118
+ ( F :: NEG_INFINITY , F :: ONE , F :: NEG_INFINITY ) ,
119
+ ( F :: NEG_INFINITY , F :: NEG_ONE , F :: NEG_INFINITY ) ,
120
+ ( F :: NEG_INFINITY , F :: INFINITY , F :: NEG_INFINITY ) ,
121
+ ( F :: NEG_INFINITY , F :: NEG_INFINITY , F :: NEG_INFINITY ) ,
122
+ ( F :: NEG_INFINITY , F :: NAN , F :: NAN ) ,
123
+ ( F :: NEG_INFINITY , F :: NEG_NAN , F :: NEG_NAN ) ,
84
124
( F :: NAN , F :: ZERO , F :: NAN ) ,
85
- ( F :: ZERO , F :: NAN , F :: NAN ) ,
125
+ ( F :: NAN , F :: NEG_ZERO , F :: NAN ) ,
126
+ ( F :: NAN , F :: ONE , F :: NAN ) ,
127
+ ( F :: NAN , F :: NEG_ONE , F :: NAN ) ,
128
+ ( F :: NAN , F :: INFINITY , F :: NAN ) ,
129
+ ( F :: NAN , F :: NEG_INFINITY , F :: NAN ) ,
86
130
( F :: NAN , F :: NAN , F :: NAN ) ,
87
- ( F :: ZERO , F :: NEG_ZERO , F :: NEG_ZERO ) ,
88
- ( F :: NEG_ZERO , F :: ZERO , F :: NEG_ZERO ) ,
131
+ ( F :: NEG_NAN , F :: ZERO , F :: NEG_NAN ) ,
132
+ ( F :: NEG_NAN , F :: NEG_ZERO , F :: NEG_NAN ) ,
133
+ ( F :: NEG_NAN , F :: ONE , F :: NEG_NAN ) ,
134
+ ( F :: NEG_NAN , F :: NEG_ONE , F :: NEG_NAN ) ,
135
+ ( F :: NEG_NAN , F :: INFINITY , F :: NEG_NAN ) ,
136
+ ( F :: NEG_NAN , F :: NEG_INFINITY , F :: NEG_NAN ) ,
137
+ ( F :: NEG_NAN , F :: NEG_NAN , F :: NEG_NAN ) ,
89
138
] ;
90
139
91
140
for ( x, y, res) in cases {
92
141
let val = f ( x, y) ;
93
142
assert_biteq ! ( val, res, "fminimum({}, {})" , Hexf ( x) , Hexf ( y) ) ;
94
143
}
144
+
145
+ // Ordering between NaNs does not matter
146
+ assert ! ( f( F :: NAN , F :: NEG_NAN ) . is_nan( ) ) ;
147
+ assert ! ( f( F :: NEG_NAN , F :: NAN ) . is_nan( ) ) ;
95
148
}
96
149
97
150
#[ test]
@@ -119,24 +172,77 @@ mod tests {
119
172
fn fmaximum_spec_test < F : Float > ( f : impl Fn ( F , F ) -> F ) {
120
173
let cases = [
121
174
( F :: ZERO , F :: ZERO , F :: ZERO ) ,
122
- ( F :: ONE , F :: ONE , F :: ONE ) ,
175
+ ( F :: ZERO , F :: NEG_ZERO , F :: ZERO ) ,
123
176
( F :: ZERO , F :: ONE , F :: ONE ) ,
124
- ( F :: ONE , F :: ZERO , F :: ONE ) ,
125
177
( F :: ZERO , F :: NEG_ONE , F :: ZERO ) ,
178
+ ( F :: ZERO , F :: INFINITY , F :: INFINITY ) ,
179
+ ( F :: ZERO , F :: NEG_INFINITY , F :: ZERO ) ,
180
+ ( F :: ZERO , F :: NAN , F :: NAN ) ,
181
+ ( F :: ZERO , F :: NEG_NAN , F :: NEG_NAN ) ,
182
+ ( F :: NEG_ZERO , F :: ZERO , F :: ZERO ) ,
183
+ ( F :: NEG_ZERO , F :: NEG_ZERO , F :: NEG_ZERO ) ,
184
+ ( F :: NEG_ZERO , F :: ONE , F :: ONE ) ,
185
+ ( F :: NEG_ZERO , F :: NEG_ONE , F :: NEG_ZERO ) ,
186
+ ( F :: NEG_ZERO , F :: INFINITY , F :: INFINITY ) ,
187
+ ( F :: NEG_ZERO , F :: NEG_INFINITY , F :: NEG_ZERO ) ,
188
+ ( F :: NEG_ZERO , F :: NAN , F :: NAN ) ,
189
+ ( F :: NEG_ZERO , F :: NEG_NAN , F :: NEG_NAN ) ,
190
+ ( F :: ONE , F :: ZERO , F :: ONE ) ,
191
+ ( F :: ONE , F :: NEG_ZERO , F :: ONE ) ,
192
+ ( F :: ONE , F :: ONE , F :: ONE ) ,
193
+ ( F :: ONE , F :: NEG_ONE , F :: ONE ) ,
194
+ ( F :: ONE , F :: INFINITY , F :: INFINITY ) ,
195
+ ( F :: ONE , F :: NEG_INFINITY , F :: ONE ) ,
196
+ ( F :: ONE , F :: NAN , F :: NAN ) ,
197
+ ( F :: ONE , F :: NEG_NAN , F :: NEG_NAN ) ,
126
198
( F :: NEG_ONE , F :: ZERO , F :: ZERO ) ,
199
+ ( F :: NEG_ONE , F :: NEG_ZERO , F :: NEG_ZERO ) ,
200
+ ( F :: NEG_ONE , F :: ONE , F :: ONE ) ,
201
+ ( F :: NEG_ONE , F :: NEG_ONE , F :: NEG_ONE ) ,
202
+ ( F :: NEG_ONE , F :: INFINITY , F :: INFINITY ) ,
203
+ ( F :: NEG_ONE , F :: NEG_INFINITY , F :: NEG_ONE ) ,
204
+ ( F :: NEG_ONE , F :: NAN , F :: NAN ) ,
205
+ ( F :: NEG_ONE , F :: NEG_NAN , F :: NEG_NAN ) ,
127
206
( F :: INFINITY , F :: ZERO , F :: INFINITY ) ,
207
+ ( F :: INFINITY , F :: NEG_ZERO , F :: INFINITY ) ,
208
+ ( F :: INFINITY , F :: ONE , F :: INFINITY ) ,
209
+ ( F :: INFINITY , F :: NEG_ONE , F :: INFINITY ) ,
210
+ ( F :: INFINITY , F :: INFINITY , F :: INFINITY ) ,
211
+ ( F :: INFINITY , F :: NEG_INFINITY , F :: INFINITY ) ,
212
+ ( F :: INFINITY , F :: NAN , F :: NAN ) ,
213
+ ( F :: INFINITY , F :: NEG_NAN , F :: NEG_NAN ) ,
128
214
( F :: NEG_INFINITY , F :: ZERO , F :: ZERO ) ,
215
+ ( F :: NEG_INFINITY , F :: NEG_ZERO , F :: NEG_ZERO ) ,
216
+ ( F :: NEG_INFINITY , F :: ONE , F :: ONE ) ,
217
+ ( F :: NEG_INFINITY , F :: NEG_ONE , F :: NEG_ONE ) ,
218
+ ( F :: NEG_INFINITY , F :: INFINITY , F :: INFINITY ) ,
219
+ ( F :: NEG_INFINITY , F :: NEG_INFINITY , F :: NEG_INFINITY ) ,
220
+ ( F :: NEG_INFINITY , F :: NAN , F :: NAN ) ,
221
+ ( F :: NEG_INFINITY , F :: NEG_NAN , F :: NEG_NAN ) ,
129
222
( F :: NAN , F :: ZERO , F :: NAN ) ,
130
- ( F :: ZERO , F :: NAN , F :: NAN ) ,
223
+ ( F :: NAN , F :: NEG_ZERO , F :: NAN ) ,
224
+ ( F :: NAN , F :: ONE , F :: NAN ) ,
225
+ ( F :: NAN , F :: NEG_ONE , F :: NAN ) ,
226
+ ( F :: NAN , F :: INFINITY , F :: NAN ) ,
227
+ ( F :: NAN , F :: NEG_INFINITY , F :: NAN ) ,
131
228
( F :: NAN , F :: NAN , F :: NAN ) ,
132
- ( F :: ZERO , F :: NEG_ZERO , F :: ZERO ) ,
133
- ( F :: NEG_ZERO , F :: ZERO , F :: ZERO ) ,
229
+ ( F :: NEG_NAN , F :: ZERO , F :: NEG_NAN ) ,
230
+ ( F :: NEG_NAN , F :: NEG_ZERO , F :: NEG_NAN ) ,
231
+ ( F :: NEG_NAN , F :: ONE , F :: NEG_NAN ) ,
232
+ ( F :: NEG_NAN , F :: NEG_ONE , F :: NEG_NAN ) ,
233
+ ( F :: NEG_NAN , F :: INFINITY , F :: NEG_NAN ) ,
234
+ ( F :: NEG_NAN , F :: NEG_INFINITY , F :: NEG_NAN ) ,
235
+ ( F :: NEG_NAN , F :: NEG_NAN , F :: NEG_NAN ) ,
134
236
] ;
135
237
136
238
for ( x, y, res) in cases {
137
239
let val = f ( x, y) ;
138
240
assert_biteq ! ( val, res, "fmaximum({}, {})" , Hexf ( x) , Hexf ( y) ) ;
139
241
}
242
+
243
+ // Ordering between NaNs does not matter
244
+ assert ! ( f( F :: NAN , F :: NEG_NAN ) . is_nan( ) ) ;
245
+ assert ! ( f( F :: NEG_NAN , F :: NAN ) . is_nan( ) ) ;
140
246
}
141
247
142
248
#[ test]
0 commit comments