@@ -89,12 +89,12 @@ macro_rules! add {
89
89
if a_exponent. 0 == 0 {
90
90
let ( exponent, significand) = <$ty>:: normalize( a_significand. 0 ) ;
91
91
a_exponent = Wrapping ( exponent) ;
92
- a_significand = Wrapping ( significand) ;
92
+ a_significand = Wrapping ( significand) ;
93
93
}
94
94
if b_exponent. 0 == 0 {
95
95
let ( exponent, significand) = <$ty>:: normalize( b_significand. 0 ) ;
96
96
b_exponent = Wrapping ( exponent) ;
97
- b_significand = Wrapping ( significand) ;
97
+ b_significand = Wrapping ( significand) ;
98
98
}
99
99
100
100
// The sign of the result is the sign of the larger operand, a. If they
@@ -123,8 +123,8 @@ macro_rules! add {
123
123
if subtraction {
124
124
a_significand -= b_significand;
125
125
// If a == -b, return +zero.
126
- if a_significand. 0 == 0 {
127
- return ( <$ty as Float >:: from_repr( 0 ) ) ;
126
+ if a_significand. 0 == 0 {
127
+ return ( <$ty as Float >:: from_repr( 0 ) ) ;
128
128
}
129
129
130
130
// If partial cancellation occured, we need to left-shift the result
@@ -148,7 +148,7 @@ macro_rules! add {
148
148
}
149
149
150
150
// If we have overflowed the type, return +/- infinity:
151
- if a_exponent >= Wrapping ( max_exponent. 0 as i32 ) {
151
+ if a_exponent >= Wrapping ( max_exponent. 0 as i32 ) {
152
152
return ( <$ty>:: from_repr( ( inf_rep | result_sign) . 0 ) ) ;
153
153
}
154
154
@@ -198,20 +198,18 @@ pub extern fn __aeabi_fadd(a: f32, b: f32) -> f32 {
198
198
199
199
#[ cfg( test) ]
200
200
mod tests {
201
- use core:: { f32, f64} ;
202
- use qc:: { U32 , U64 } ;
203
201
use float:: Float ;
202
+ use qc:: { F32 , F64 } ;
204
203
205
204
// NOTE The tests below have special handing for NaN values.
206
- // Because NaN != NaN, the floating-point representations must be used
205
+ // Because NaN != NaN, the representations are compared
207
206
// Because there are many diffferent values of NaN, and the implementation
208
207
// doesn't care about calculating the 'correct' one, if both values are NaN
209
208
// the values are considered equivalent.
210
209
211
- // TODO: Add F32/F64 to qc so that they print the right values (at the very least)
212
210
quickcheck ! {
213
- fn addsf3( a: U32 , b: U32 ) -> bool {
214
- let ( a, b) = ( f32 :: from_repr ( a. 0 ) , f32 :: from_repr ( b. 0 ) ) ;
211
+ fn addsf3( a: F32 , b: F32 ) -> bool {
212
+ let ( a, b) = ( a. 0 , b. 0 ) ;
215
213
let x = super :: __addsf3( a, b) ;
216
214
let y = a + b;
217
215
if !( x. is_nan( ) && y. is_nan( ) ) {
@@ -221,8 +219,8 @@ mod tests {
221
219
}
222
220
}
223
221
224
- fn adddf3( a: U64 , b: U64 ) -> bool {
225
- let ( a, b) = ( f64 :: from_repr ( a. 0 ) , f64 :: from_repr ( b. 0 ) ) ;
222
+ fn adddf3( a: F64 , b: F64 ) -> bool {
223
+ let ( a, b) = ( a. 0 , b. 0 ) ;
226
224
let x = super :: __adddf3( a, b) ;
227
225
let y = a + b;
228
226
if !( x. is_nan( ) && y. is_nan( ) ) {
@@ -232,95 +230,4 @@ mod tests {
232
230
}
233
231
}
234
232
}
235
-
236
- // More tests for special float values
237
-
238
- #[ test]
239
- fn test_float_tiny_plus_tiny ( ) {
240
- let tiny = f32:: from_repr ( 1 ) ;
241
- let r = super :: __addsf3 ( tiny, tiny) ;
242
- assert_eq ! ( r, tiny + tiny) ;
243
- }
244
-
245
- #[ test]
246
- fn test_double_tiny_plus_tiny ( ) {
247
- let tiny = f64:: from_repr ( 1 ) ;
248
- let r = super :: __adddf3 ( tiny, tiny) ;
249
- assert_eq ! ( r, tiny + tiny) ;
250
- }
251
-
252
- #[ test]
253
- fn test_float_small_plus_small ( ) {
254
- let a = f32:: from_repr ( 327 ) ;
255
- let b = f32:: from_repr ( 256 ) ;
256
- let r = super :: __addsf3 ( a, b) ;
257
- assert_eq ! ( r, a + b) ;
258
- }
259
-
260
- #[ test]
261
- fn test_double_small_plus_small ( ) {
262
- let a = f64:: from_repr ( 327 ) ;
263
- let b = f64:: from_repr ( 256 ) ;
264
- let r = super :: __adddf3 ( a, b) ;
265
- assert_eq ! ( r, a + b) ;
266
- }
267
-
268
- #[ test]
269
- fn test_float_one_plus_one ( ) {
270
- let r = super :: __addsf3 ( 1f32 , 1f32 ) ;
271
- assert_eq ! ( r, 1f32 + 1f32 ) ;
272
- }
273
-
274
- #[ test]
275
- fn test_double_one_plus_one ( ) {
276
- let r = super :: __adddf3 ( 1f64 , 1f64 ) ;
277
- assert_eq ! ( r, 1f64 + 1f64 ) ;
278
- }
279
-
280
- #[ test]
281
- fn test_float_different_nan ( ) {
282
- let a = f32:: from_repr ( 1 ) ;
283
- let b = f32:: from_repr ( 0b11111111100100010001001010101010 ) ;
284
- let x = super :: __addsf3 ( a, b) ;
285
- let y = a + b;
286
- if !( x. is_nan ( ) && y. is_nan ( ) ) {
287
- assert_eq ! ( x. repr( ) , y. repr( ) ) ;
288
- }
289
- }
290
-
291
- #[ test]
292
- fn test_double_different_nan ( ) {
293
- let a = f64:: from_repr ( 1 ) ;
294
- let b = f64:: from_repr (
295
- 0b1111111111110010001000100101010101001000101010000110100011101011 ) ;
296
- let x = super :: __adddf3 ( a, b) ;
297
- let y = a + b;
298
- if !( x. is_nan ( ) && y. is_nan ( ) ) {
299
- assert_eq ! ( x. repr( ) , y. repr( ) ) ;
300
- }
301
- }
302
-
303
- #[ test]
304
- fn test_float_nan ( ) {
305
- let r = super :: __addsf3 ( f32:: NAN , 1.23 ) ;
306
- assert_eq ! ( r. repr( ) , f32 :: NAN . repr( ) ) ;
307
- }
308
-
309
- #[ test]
310
- fn test_double_nan ( ) {
311
- let r = super :: __adddf3 ( f64:: NAN , 1.23 ) ;
312
- assert_eq ! ( r. repr( ) , f64 :: NAN . repr( ) ) ;
313
- }
314
-
315
- #[ test]
316
- fn test_float_inf ( ) {
317
- let r = super :: __addsf3 ( f32:: INFINITY , -123.4 ) ;
318
- assert_eq ! ( r, f32 :: INFINITY ) ;
319
- }
320
-
321
- #[ test]
322
- fn test_double_inf ( ) {
323
- let r = super :: __adddf3 ( f64:: INFINITY , -123.4 ) ;
324
- assert_eq ! ( r, f64 :: INFINITY ) ;
325
- }
326
233
}
0 commit comments