1 use crate::f32::consts;
2 use crate::num::FpCategory as Fp;
12 assert_eq!(f32::NAN.min(2.0), 2.0);
13 assert_eq!(2.0f32.min(f32::NAN), 2.0);
18 assert_eq!(f32::NAN.max(2.0), 2.0);
19 assert_eq!(2.0f32.max(f32::NAN), 2.0);
24 assert!(f32::NAN.minimum(2.0).is_nan());
25 assert!(2.0f32.minimum(f32::NAN).is_nan());
30 assert!(f32::NAN.maximum(2.0).is_nan());
31 assert!(2.0f32.maximum(f32::NAN).is_nan());
36 let nan: f32 = f32::NAN;
37 assert!(nan.is_nan());
38 assert!(!nan.is_infinite());
39 assert!(!nan.is_finite());
40 assert!(!nan.is_normal());
41 assert!(nan.is_sign_positive());
42 assert!(!nan.is_sign_negative());
43 assert_eq!(Fp::Nan, nan.classify());
48 let inf: f32 = f32::INFINITY;
49 assert!(inf.is_infinite());
50 assert!(!inf.is_finite());
51 assert!(inf.is_sign_positive());
52 assert!(!inf.is_sign_negative());
53 assert!(!inf.is_nan());
54 assert!(!inf.is_normal());
55 assert_eq!(Fp::Infinite, inf.classify());
59 fn test_neg_infinity() {
60 let neg_inf: f32 = f32::NEG_INFINITY;
61 assert!(neg_inf.is_infinite());
62 assert!(!neg_inf.is_finite());
63 assert!(!neg_inf.is_sign_positive());
64 assert!(neg_inf.is_sign_negative());
65 assert!(!neg_inf.is_nan());
66 assert!(!neg_inf.is_normal());
67 assert_eq!(Fp::Infinite, neg_inf.classify());
72 let zero: f32 = 0.0f32;
73 assert_eq!(0.0, zero);
74 assert!(!zero.is_infinite());
75 assert!(zero.is_finite());
76 assert!(zero.is_sign_positive());
77 assert!(!zero.is_sign_negative());
78 assert!(!zero.is_nan());
79 assert!(!zero.is_normal());
80 assert_eq!(Fp::Zero, zero.classify());
85 let neg_zero: f32 = -0.0;
86 assert_eq!(0.0, neg_zero);
87 assert!(!neg_zero.is_infinite());
88 assert!(neg_zero.is_finite());
89 assert!(!neg_zero.is_sign_positive());
90 assert!(neg_zero.is_sign_negative());
91 assert!(!neg_zero.is_nan());
92 assert!(!neg_zero.is_normal());
93 assert_eq!(Fp::Zero, neg_zero.classify());
98 let one: f32 = 1.0f32;
100 assert!(!one.is_infinite());
101 assert!(one.is_finite());
102 assert!(one.is_sign_positive());
103 assert!(!one.is_sign_negative());
104 assert!(!one.is_nan());
105 assert!(one.is_normal());
106 assert_eq!(Fp::Normal, one.classify());
111 let nan: f32 = f32::NAN;
112 let inf: f32 = f32::INFINITY;
113 let neg_inf: f32 = f32::NEG_INFINITY;
114 assert!(nan.is_nan());
115 assert!(!0.0f32.is_nan());
116 assert!(!5.3f32.is_nan());
117 assert!(!(-10.732f32).is_nan());
118 assert!(!inf.is_nan());
119 assert!(!neg_inf.is_nan());
123 fn test_is_infinite() {
124 let nan: f32 = f32::NAN;
125 let inf: f32 = f32::INFINITY;
126 let neg_inf: f32 = f32::NEG_INFINITY;
127 assert!(!nan.is_infinite());
128 assert!(inf.is_infinite());
129 assert!(neg_inf.is_infinite());
130 assert!(!0.0f32.is_infinite());
131 assert!(!42.8f32.is_infinite());
132 assert!(!(-109.2f32).is_infinite());
136 fn test_is_finite() {
137 let nan: f32 = f32::NAN;
138 let inf: f32 = f32::INFINITY;
139 let neg_inf: f32 = f32::NEG_INFINITY;
140 assert!(!nan.is_finite());
141 assert!(!inf.is_finite());
142 assert!(!neg_inf.is_finite());
143 assert!(0.0f32.is_finite());
144 assert!(42.8f32.is_finite());
145 assert!((-109.2f32).is_finite());
149 fn test_is_normal() {
150 let nan: f32 = f32::NAN;
151 let inf: f32 = f32::INFINITY;
152 let neg_inf: f32 = f32::NEG_INFINITY;
153 let zero: f32 = 0.0f32;
154 let neg_zero: f32 = -0.0;
155 assert!(!nan.is_normal());
156 assert!(!inf.is_normal());
157 assert!(!neg_inf.is_normal());
158 assert!(!zero.is_normal());
159 assert!(!neg_zero.is_normal());
160 assert!(1f32.is_normal());
161 assert!(1e-37f32.is_normal());
162 assert!(!1e-38f32.is_normal());
167 let nan: f32 = f32::NAN;
168 let inf: f32 = f32::INFINITY;
169 let neg_inf: f32 = f32::NEG_INFINITY;
170 let zero: f32 = 0.0f32;
171 let neg_zero: f32 = -0.0;
172 assert_eq!(nan.classify(), Fp::Nan);
173 assert_eq!(inf.classify(), Fp::Infinite);
174 assert_eq!(neg_inf.classify(), Fp::Infinite);
175 assert_eq!(zero.classify(), Fp::Zero);
176 assert_eq!(neg_zero.classify(), Fp::Zero);
177 assert_eq!(1f32.classify(), Fp::Normal);
178 assert_eq!(1e-37f32.classify(), Fp::Normal);
179 assert_eq!(1e-38f32.classify(), Fp::Subnormal);
184 assert_approx_eq!(1.0f32.floor(), 1.0f32);
185 assert_approx_eq!(1.3f32.floor(), 1.0f32);
186 assert_approx_eq!(1.5f32.floor(), 1.0f32);
187 assert_approx_eq!(1.7f32.floor(), 1.0f32);
188 assert_approx_eq!(0.0f32.floor(), 0.0f32);
189 assert_approx_eq!((-0.0f32).floor(), -0.0f32);
190 assert_approx_eq!((-1.0f32).floor(), -1.0f32);
191 assert_approx_eq!((-1.3f32).floor(), -2.0f32);
192 assert_approx_eq!((-1.5f32).floor(), -2.0f32);
193 assert_approx_eq!((-1.7f32).floor(), -2.0f32);
198 assert_approx_eq!(1.0f32.ceil(), 1.0f32);
199 assert_approx_eq!(1.3f32.ceil(), 2.0f32);
200 assert_approx_eq!(1.5f32.ceil(), 2.0f32);
201 assert_approx_eq!(1.7f32.ceil(), 2.0f32);
202 assert_approx_eq!(0.0f32.ceil(), 0.0f32);
203 assert_approx_eq!((-0.0f32).ceil(), -0.0f32);
204 assert_approx_eq!((-1.0f32).ceil(), -1.0f32);
205 assert_approx_eq!((-1.3f32).ceil(), -1.0f32);
206 assert_approx_eq!((-1.5f32).ceil(), -1.0f32);
207 assert_approx_eq!((-1.7f32).ceil(), -1.0f32);
212 assert_approx_eq!(1.0f32.round(), 1.0f32);
213 assert_approx_eq!(1.3f32.round(), 1.0f32);
214 assert_approx_eq!(1.5f32.round(), 2.0f32);
215 assert_approx_eq!(1.7f32.round(), 2.0f32);
216 assert_approx_eq!(0.0f32.round(), 0.0f32);
217 assert_approx_eq!((-0.0f32).round(), -0.0f32);
218 assert_approx_eq!((-1.0f32).round(), -1.0f32);
219 assert_approx_eq!((-1.3f32).round(), -1.0f32);
220 assert_approx_eq!((-1.5f32).round(), -2.0f32);
221 assert_approx_eq!((-1.7f32).round(), -2.0f32);
226 assert_approx_eq!(1.0f32.trunc(), 1.0f32);
227 assert_approx_eq!(1.3f32.trunc(), 1.0f32);
228 assert_approx_eq!(1.5f32.trunc(), 1.0f32);
229 assert_approx_eq!(1.7f32.trunc(), 1.0f32);
230 assert_approx_eq!(0.0f32.trunc(), 0.0f32);
231 assert_approx_eq!((-0.0f32).trunc(), -0.0f32);
232 assert_approx_eq!((-1.0f32).trunc(), -1.0f32);
233 assert_approx_eq!((-1.3f32).trunc(), -1.0f32);
234 assert_approx_eq!((-1.5f32).trunc(), -1.0f32);
235 assert_approx_eq!((-1.7f32).trunc(), -1.0f32);
240 assert_approx_eq!(1.0f32.fract(), 0.0f32);
241 assert_approx_eq!(1.3f32.fract(), 0.3f32);
242 assert_approx_eq!(1.5f32.fract(), 0.5f32);
243 assert_approx_eq!(1.7f32.fract(), 0.7f32);
244 assert_approx_eq!(0.0f32.fract(), 0.0f32);
245 assert_approx_eq!((-0.0f32).fract(), -0.0f32);
246 assert_approx_eq!((-1.0f32).fract(), -0.0f32);
247 assert_approx_eq!((-1.3f32).fract(), -0.3f32);
248 assert_approx_eq!((-1.5f32).fract(), -0.5f32);
249 assert_approx_eq!((-1.7f32).fract(), -0.7f32);
254 assert_eq!(f32::INFINITY.abs(), f32::INFINITY);
255 assert_eq!(1f32.abs(), 1f32);
256 assert_eq!(0f32.abs(), 0f32);
257 assert_eq!((-0f32).abs(), 0f32);
258 assert_eq!((-1f32).abs(), 1f32);
259 assert_eq!(f32::NEG_INFINITY.abs(), f32::INFINITY);
260 assert_eq!((1f32 / f32::NEG_INFINITY).abs(), 0f32);
261 assert!(f32::NAN.abs().is_nan());
266 assert_eq!(f32::INFINITY.signum(), 1f32);
267 assert_eq!(1f32.signum(), 1f32);
268 assert_eq!(0f32.signum(), 1f32);
269 assert_eq!((-0f32).signum(), -1f32);
270 assert_eq!((-1f32).signum(), -1f32);
271 assert_eq!(f32::NEG_INFINITY.signum(), -1f32);
272 assert_eq!((1f32 / f32::NEG_INFINITY).signum(), -1f32);
273 assert!(f32::NAN.signum().is_nan());
277 fn test_is_sign_positive() {
278 assert!(f32::INFINITY.is_sign_positive());
279 assert!(1f32.is_sign_positive());
280 assert!(0f32.is_sign_positive());
281 assert!(!(-0f32).is_sign_positive());
282 assert!(!(-1f32).is_sign_positive());
283 assert!(!f32::NEG_INFINITY.is_sign_positive());
284 assert!(!(1f32 / f32::NEG_INFINITY).is_sign_positive());
285 assert!(f32::NAN.is_sign_positive());
286 assert!(!(-f32::NAN).is_sign_positive());
290 fn test_is_sign_negative() {
291 assert!(!f32::INFINITY.is_sign_negative());
292 assert!(!1f32.is_sign_negative());
293 assert!(!0f32.is_sign_negative());
294 assert!((-0f32).is_sign_negative());
295 assert!((-1f32).is_sign_negative());
296 assert!(f32::NEG_INFINITY.is_sign_negative());
297 assert!((1f32 / f32::NEG_INFINITY).is_sign_negative());
298 assert!(!f32::NAN.is_sign_negative());
299 assert!((-f32::NAN).is_sign_negative());
304 let nan: f32 = f32::NAN;
305 let inf: f32 = f32::INFINITY;
306 let neg_inf: f32 = f32::NEG_INFINITY;
307 assert_approx_eq!(12.3f32.mul_add(4.5, 6.7), 62.05);
308 assert_approx_eq!((-12.3f32).mul_add(-4.5, -6.7), 48.65);
309 assert_approx_eq!(0.0f32.mul_add(8.9, 1.2), 1.2);
310 assert_approx_eq!(3.4f32.mul_add(-0.0, 5.6), 5.6);
311 assert!(nan.mul_add(7.8, 9.0).is_nan());
312 assert_eq!(inf.mul_add(7.8, 9.0), inf);
313 assert_eq!(neg_inf.mul_add(7.8, 9.0), neg_inf);
314 assert_eq!(8.9f32.mul_add(inf, 3.2), inf);
315 assert_eq!((-3.2f32).mul_add(2.4, neg_inf), neg_inf);
320 let nan: f32 = f32::NAN;
321 let inf: f32 = f32::INFINITY;
322 let neg_inf: f32 = f32::NEG_INFINITY;
323 assert_eq!(1.0f32.recip(), 1.0);
324 assert_eq!(2.0f32.recip(), 0.5);
325 assert_eq!((-0.4f32).recip(), -2.5);
326 assert_eq!(0.0f32.recip(), inf);
327 assert!(nan.recip().is_nan());
328 assert_eq!(inf.recip(), 0.0);
329 assert_eq!(neg_inf.recip(), 0.0);
334 let nan: f32 = f32::NAN;
335 let inf: f32 = f32::INFINITY;
336 let neg_inf: f32 = f32::NEG_INFINITY;
337 assert_eq!(1.0f32.powi(1), 1.0);
338 assert_approx_eq!((-3.1f32).powi(2), 9.61);
339 assert_approx_eq!(5.9f32.powi(-2), 0.028727);
340 assert_eq!(8.3f32.powi(0), 1.0);
341 assert!(nan.powi(2).is_nan());
342 assert_eq!(inf.powi(3), inf);
343 assert_eq!(neg_inf.powi(2), inf);
348 let nan: f32 = f32::NAN;
349 let inf: f32 = f32::INFINITY;
350 let neg_inf: f32 = f32::NEG_INFINITY;
351 assert_eq!(1.0f32.powf(1.0), 1.0);
352 assert_approx_eq!(3.4f32.powf(4.5), 246.408218);
353 assert_approx_eq!(2.7f32.powf(-3.2), 0.041652);
354 assert_approx_eq!((-3.1f32).powf(2.0), 9.61);
355 assert_approx_eq!(5.9f32.powf(-2.0), 0.028727);
356 assert_eq!(8.3f32.powf(0.0), 1.0);
357 assert!(nan.powf(2.0).is_nan());
358 assert_eq!(inf.powf(2.0), inf);
359 assert_eq!(neg_inf.powf(3.0), neg_inf);
363 fn test_sqrt_domain() {
364 assert!(f32::NAN.sqrt().is_nan());
365 assert!(f32::NEG_INFINITY.sqrt().is_nan());
366 assert!((-1.0f32).sqrt().is_nan());
367 assert_eq!((-0.0f32).sqrt(), -0.0);
368 assert_eq!(0.0f32.sqrt(), 0.0);
369 assert_eq!(1.0f32.sqrt(), 1.0);
370 assert_eq!(f32::INFINITY.sqrt(), f32::INFINITY);
375 assert_eq!(1.0, 0.0f32.exp());
376 assert_approx_eq!(2.718282, 1.0f32.exp());
377 assert_approx_eq!(148.413162, 5.0f32.exp());
379 let inf: f32 = f32::INFINITY;
380 let neg_inf: f32 = f32::NEG_INFINITY;
381 let nan: f32 = f32::NAN;
382 assert_eq!(inf, inf.exp());
383 assert_eq!(0.0, neg_inf.exp());
384 assert!(nan.exp().is_nan());
389 assert_eq!(32.0, 5.0f32.exp2());
390 assert_eq!(1.0, 0.0f32.exp2());
392 let inf: f32 = f32::INFINITY;
393 let neg_inf: f32 = f32::NEG_INFINITY;
394 let nan: f32 = f32::NAN;
395 assert_eq!(inf, inf.exp2());
396 assert_eq!(0.0, neg_inf.exp2());
397 assert!(nan.exp2().is_nan());
402 let nan: f32 = f32::NAN;
403 let inf: f32 = f32::INFINITY;
404 let neg_inf: f32 = f32::NEG_INFINITY;
405 assert_approx_eq!(1.0f32.exp().ln(), 1.0);
406 assert!(nan.ln().is_nan());
407 assert_eq!(inf.ln(), inf);
408 assert!(neg_inf.ln().is_nan());
409 assert!((-2.3f32).ln().is_nan());
410 assert_eq!((-0.0f32).ln(), neg_inf);
411 assert_eq!(0.0f32.ln(), neg_inf);
412 assert_approx_eq!(4.0f32.ln(), 1.386294);
417 let nan: f32 = f32::NAN;
418 let inf: f32 = f32::INFINITY;
419 let neg_inf: f32 = f32::NEG_INFINITY;
420 assert_eq!(10.0f32.log(10.0), 1.0);
421 assert_approx_eq!(2.3f32.log(3.5), 0.664858);
422 assert_eq!(1.0f32.exp().log(1.0f32.exp()), 1.0);
423 assert!(1.0f32.log(1.0).is_nan());
424 assert!(1.0f32.log(-13.9).is_nan());
425 assert!(nan.log(2.3).is_nan());
426 assert_eq!(inf.log(10.0), inf);
427 assert!(neg_inf.log(8.8).is_nan());
428 assert!((-2.3f32).log(0.1).is_nan());
429 assert_eq!((-0.0f32).log(2.0), neg_inf);
430 assert_eq!(0.0f32.log(7.0), neg_inf);
435 let nan: f32 = f32::NAN;
436 let inf: f32 = f32::INFINITY;
437 let neg_inf: f32 = f32::NEG_INFINITY;
438 assert_approx_eq!(10.0f32.log2(), 3.321928);
439 assert_approx_eq!(2.3f32.log2(), 1.201634);
440 assert_approx_eq!(1.0f32.exp().log2(), 1.442695);
441 assert!(nan.log2().is_nan());
442 assert_eq!(inf.log2(), inf);
443 assert!(neg_inf.log2().is_nan());
444 assert!((-2.3f32).log2().is_nan());
445 assert_eq!((-0.0f32).log2(), neg_inf);
446 assert_eq!(0.0f32.log2(), neg_inf);
451 let nan: f32 = f32::NAN;
452 let inf: f32 = f32::INFINITY;
453 let neg_inf: f32 = f32::NEG_INFINITY;
454 assert_eq!(10.0f32.log10(), 1.0);
455 assert_approx_eq!(2.3f32.log10(), 0.361728);
456 assert_approx_eq!(1.0f32.exp().log10(), 0.434294);
457 assert_eq!(1.0f32.log10(), 0.0);
458 assert!(nan.log10().is_nan());
459 assert_eq!(inf.log10(), inf);
460 assert!(neg_inf.log10().is_nan());
461 assert!((-2.3f32).log10().is_nan());
462 assert_eq!((-0.0f32).log10(), neg_inf);
463 assert_eq!(0.0f32.log10(), neg_inf);
467 fn test_to_degrees() {
468 let pi: f32 = consts::PI;
469 let nan: f32 = f32::NAN;
470 let inf: f32 = f32::INFINITY;
471 let neg_inf: f32 = f32::NEG_INFINITY;
472 assert_eq!(0.0f32.to_degrees(), 0.0);
473 assert_approx_eq!((-5.8f32).to_degrees(), -332.315521);
474 assert_eq!(pi.to_degrees(), 180.0);
475 assert!(nan.to_degrees().is_nan());
476 assert_eq!(inf.to_degrees(), inf);
477 assert_eq!(neg_inf.to_degrees(), neg_inf);
478 assert_eq!(1_f32.to_degrees(), 57.2957795130823208767981548141051703);
482 fn test_to_radians() {
483 let pi: f32 = consts::PI;
484 let nan: f32 = f32::NAN;
485 let inf: f32 = f32::INFINITY;
486 let neg_inf: f32 = f32::NEG_INFINITY;
487 assert_eq!(0.0f32.to_radians(), 0.0);
488 assert_approx_eq!(154.6f32.to_radians(), 2.698279);
489 assert_approx_eq!((-332.31f32).to_radians(), -5.799903);
490 assert_eq!(180.0f32.to_radians(), pi);
491 assert!(nan.to_radians().is_nan());
492 assert_eq!(inf.to_radians(), inf);
493 assert_eq!(neg_inf.to_radians(), neg_inf);
498 assert_eq!(0.0f32.asinh(), 0.0f32);
499 assert_eq!((-0.0f32).asinh(), -0.0f32);
501 let inf: f32 = f32::INFINITY;
502 let neg_inf: f32 = f32::NEG_INFINITY;
503 let nan: f32 = f32::NAN;
504 assert_eq!(inf.asinh(), inf);
505 assert_eq!(neg_inf.asinh(), neg_inf);
506 assert!(nan.asinh().is_nan());
507 assert!((-0.0f32).asinh().is_sign_negative()); // issue 63271
508 assert_approx_eq!(2.0f32.asinh(), 1.443635475178810342493276740273105f32);
509 assert_approx_eq!((-2.0f32).asinh(), -1.443635475178810342493276740273105f32);
510 // regression test for the catastrophic cancellation fixed in 72486
511 assert_approx_eq!((-3000.0f32).asinh(), -8.699514775987968673236893537700647f32);
516 assert_eq!(1.0f32.acosh(), 0.0f32);
517 assert!(0.999f32.acosh().is_nan());
519 let inf: f32 = f32::INFINITY;
520 let neg_inf: f32 = f32::NEG_INFINITY;
521 let nan: f32 = f32::NAN;
522 assert_eq!(inf.acosh(), inf);
523 assert!(neg_inf.acosh().is_nan());
524 assert!(nan.acosh().is_nan());
525 assert_approx_eq!(2.0f32.acosh(), 1.31695789692481670862504634730796844f32);
526 assert_approx_eq!(3.0f32.acosh(), 1.76274717403908605046521864995958461f32);
531 assert_eq!(0.0f32.atanh(), 0.0f32);
532 assert_eq!((-0.0f32).atanh(), -0.0f32);
534 let inf32: f32 = f32::INFINITY;
535 let neg_inf32: f32 = f32::NEG_INFINITY;
536 assert_eq!(1.0f32.atanh(), inf32);
537 assert_eq!((-1.0f32).atanh(), neg_inf32);
539 assert!(2f64.atanh().atanh().is_nan());
540 assert!((-2f64).atanh().atanh().is_nan());
542 let inf64: f32 = f32::INFINITY;
543 let neg_inf64: f32 = f32::NEG_INFINITY;
544 let nan32: f32 = f32::NAN;
545 assert!(inf64.atanh().is_nan());
546 assert!(neg_inf64.atanh().is_nan());
547 assert!(nan32.atanh().is_nan());
549 assert_approx_eq!(0.5f32.atanh(), 0.54930614433405484569762261846126285f32);
550 assert_approx_eq!((-0.5f32).atanh(), -0.54930614433405484569762261846126285f32);
554 fn test_real_consts() {
557 let pi: f32 = consts::PI;
558 let frac_pi_2: f32 = consts::FRAC_PI_2;
559 let frac_pi_3: f32 = consts::FRAC_PI_3;
560 let frac_pi_4: f32 = consts::FRAC_PI_4;
561 let frac_pi_6: f32 = consts::FRAC_PI_6;
562 let frac_pi_8: f32 = consts::FRAC_PI_8;
563 let frac_1_pi: f32 = consts::FRAC_1_PI;
564 let frac_2_pi: f32 = consts::FRAC_2_PI;
565 let frac_2_sqrtpi: f32 = consts::FRAC_2_SQRT_PI;
566 let sqrt2: f32 = consts::SQRT_2;
567 let frac_1_sqrt2: f32 = consts::FRAC_1_SQRT_2;
568 let e: f32 = consts::E;
569 let log2_e: f32 = consts::LOG2_E;
570 let log10_e: f32 = consts::LOG10_E;
571 let ln_2: f32 = consts::LN_2;
572 let ln_10: f32 = consts::LN_10;
574 assert_approx_eq!(frac_pi_2, pi / 2f32);
575 assert_approx_eq!(frac_pi_3, pi / 3f32);
576 assert_approx_eq!(frac_pi_4, pi / 4f32);
577 assert_approx_eq!(frac_pi_6, pi / 6f32);
578 assert_approx_eq!(frac_pi_8, pi / 8f32);
579 assert_approx_eq!(frac_1_pi, 1f32 / pi);
580 assert_approx_eq!(frac_2_pi, 2f32 / pi);
581 assert_approx_eq!(frac_2_sqrtpi, 2f32 / pi.sqrt());
582 assert_approx_eq!(sqrt2, 2f32.sqrt());
583 assert_approx_eq!(frac_1_sqrt2, 1f32 / 2f32.sqrt());
584 assert_approx_eq!(log2_e, e.log2());
585 assert_approx_eq!(log10_e, e.log10());
586 assert_approx_eq!(ln_2, 2f32.ln());
587 assert_approx_eq!(ln_10, 10f32.ln());
591 fn test_float_bits_conv() {
592 assert_eq!((1f32).to_bits(), 0x3f800000);
593 assert_eq!((12.5f32).to_bits(), 0x41480000);
594 assert_eq!((1337f32).to_bits(), 0x44a72000);
595 assert_eq!((-14.25f32).to_bits(), 0xc1640000);
596 assert_approx_eq!(f32::from_bits(0x3f800000), 1.0);
597 assert_approx_eq!(f32::from_bits(0x41480000), 12.5);
598 assert_approx_eq!(f32::from_bits(0x44a72000), 1337.0);
599 assert_approx_eq!(f32::from_bits(0xc1640000), -14.25);
601 // Check that NaNs roundtrip their bits regardless of signaling-ness
602 // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits
603 let masked_nan1 = f32::NAN.to_bits() ^ 0x002A_AAAA;
604 let masked_nan2 = f32::NAN.to_bits() ^ 0x0055_5555;
605 assert!(f32::from_bits(masked_nan1).is_nan());
606 assert!(f32::from_bits(masked_nan2).is_nan());
608 assert_eq!(f32::from_bits(masked_nan1).to_bits(), masked_nan1);
609 assert_eq!(f32::from_bits(masked_nan2).to_bits(), masked_nan2);
614 fn test_clamp_min_greater_than_max() {
615 let _ = 1.0f32.clamp(3.0, 1.0);
620 fn test_clamp_min_is_nan() {
621 let _ = 1.0f32.clamp(f32::NAN, 1.0);
626 fn test_clamp_max_is_nan() {
627 let _ = 1.0f32.clamp(3.0, f32::NAN);
631 fn test_total_cmp() {
632 use core::cmp::Ordering;
634 fn quiet_bit_mask() -> u32 {
635 1 << (f32::MANTISSA_DIGITS - 2)
638 fn min_subnorm() -> f32 {
639 f32::MIN_POSITIVE / f32::powf(2.0, f32::MANTISSA_DIGITS as f32 - 1.0)
642 fn max_subnorm() -> f32 {
643 f32::MIN_POSITIVE - min_subnorm()
647 f32::from_bits(f32::NAN.to_bits() | quiet_bit_mask())
651 f32::from_bits((f32::NAN.to_bits() & !quiet_bit_mask()) + 42)
654 assert_eq!(Ordering::Equal, (-q_nan()).total_cmp(&-q_nan()));
655 assert_eq!(Ordering::Equal, (-s_nan()).total_cmp(&-s_nan()));
656 assert_eq!(Ordering::Equal, (-f32::INFINITY).total_cmp(&-f32::INFINITY));
657 assert_eq!(Ordering::Equal, (-f32::MAX).total_cmp(&-f32::MAX));
658 assert_eq!(Ordering::Equal, (-2.5_f32).total_cmp(&-2.5));
659 assert_eq!(Ordering::Equal, (-1.0_f32).total_cmp(&-1.0));
660 assert_eq!(Ordering::Equal, (-1.5_f32).total_cmp(&-1.5));
661 assert_eq!(Ordering::Equal, (-0.5_f32).total_cmp(&-0.5));
662 assert_eq!(Ordering::Equal, (-f32::MIN_POSITIVE).total_cmp(&-f32::MIN_POSITIVE));
663 assert_eq!(Ordering::Equal, (-max_subnorm()).total_cmp(&-max_subnorm()));
664 assert_eq!(Ordering::Equal, (-min_subnorm()).total_cmp(&-min_subnorm()));
665 assert_eq!(Ordering::Equal, (-0.0_f32).total_cmp(&-0.0));
666 assert_eq!(Ordering::Equal, 0.0_f32.total_cmp(&0.0));
667 assert_eq!(Ordering::Equal, min_subnorm().total_cmp(&min_subnorm()));
668 assert_eq!(Ordering::Equal, max_subnorm().total_cmp(&max_subnorm()));
669 assert_eq!(Ordering::Equal, f32::MIN_POSITIVE.total_cmp(&f32::MIN_POSITIVE));
670 assert_eq!(Ordering::Equal, 0.5_f32.total_cmp(&0.5));
671 assert_eq!(Ordering::Equal, 1.0_f32.total_cmp(&1.0));
672 assert_eq!(Ordering::Equal, 1.5_f32.total_cmp(&1.5));
673 assert_eq!(Ordering::Equal, 2.5_f32.total_cmp(&2.5));
674 assert_eq!(Ordering::Equal, f32::MAX.total_cmp(&f32::MAX));
675 assert_eq!(Ordering::Equal, f32::INFINITY.total_cmp(&f32::INFINITY));
676 assert_eq!(Ordering::Equal, s_nan().total_cmp(&s_nan()));
677 assert_eq!(Ordering::Equal, q_nan().total_cmp(&q_nan()));
679 assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-s_nan()));
680 assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-f32::INFINITY));
681 assert_eq!(Ordering::Less, (-f32::INFINITY).total_cmp(&-f32::MAX));
682 assert_eq!(Ordering::Less, (-f32::MAX).total_cmp(&-2.5));
683 assert_eq!(Ordering::Less, (-2.5_f32).total_cmp(&-1.5));
684 assert_eq!(Ordering::Less, (-1.5_f32).total_cmp(&-1.0));
685 assert_eq!(Ordering::Less, (-1.0_f32).total_cmp(&-0.5));
686 assert_eq!(Ordering::Less, (-0.5_f32).total_cmp(&-f32::MIN_POSITIVE));
687 assert_eq!(Ordering::Less, (-f32::MIN_POSITIVE).total_cmp(&-max_subnorm()));
688 assert_eq!(Ordering::Less, (-max_subnorm()).total_cmp(&-min_subnorm()));
689 assert_eq!(Ordering::Less, (-min_subnorm()).total_cmp(&-0.0));
690 assert_eq!(Ordering::Less, (-0.0_f32).total_cmp(&0.0));
691 assert_eq!(Ordering::Less, 0.0_f32.total_cmp(&min_subnorm()));
692 assert_eq!(Ordering::Less, min_subnorm().total_cmp(&max_subnorm()));
693 assert_eq!(Ordering::Less, max_subnorm().total_cmp(&f32::MIN_POSITIVE));
694 assert_eq!(Ordering::Less, f32::MIN_POSITIVE.total_cmp(&0.5));
695 assert_eq!(Ordering::Less, 0.5_f32.total_cmp(&1.0));
696 assert_eq!(Ordering::Less, 1.0_f32.total_cmp(&1.5));
697 assert_eq!(Ordering::Less, 1.5_f32.total_cmp(&2.5));
698 assert_eq!(Ordering::Less, 2.5_f32.total_cmp(&f32::MAX));
699 assert_eq!(Ordering::Less, f32::MAX.total_cmp(&f32::INFINITY));
700 assert_eq!(Ordering::Less, f32::INFINITY.total_cmp(&s_nan()));
701 assert_eq!(Ordering::Less, s_nan().total_cmp(&q_nan()));
703 assert_eq!(Ordering::Greater, (-s_nan()).total_cmp(&-q_nan()));
704 assert_eq!(Ordering::Greater, (-f32::INFINITY).total_cmp(&-s_nan()));
705 assert_eq!(Ordering::Greater, (-f32::MAX).total_cmp(&-f32::INFINITY));
706 assert_eq!(Ordering::Greater, (-2.5_f32).total_cmp(&-f32::MAX));
707 assert_eq!(Ordering::Greater, (-1.5_f32).total_cmp(&-2.5));
708 assert_eq!(Ordering::Greater, (-1.0_f32).total_cmp(&-1.5));
709 assert_eq!(Ordering::Greater, (-0.5_f32).total_cmp(&-1.0));
710 assert_eq!(Ordering::Greater, (-f32::MIN_POSITIVE).total_cmp(&-0.5));
711 assert_eq!(Ordering::Greater, (-max_subnorm()).total_cmp(&-f32::MIN_POSITIVE));
712 assert_eq!(Ordering::Greater, (-min_subnorm()).total_cmp(&-max_subnorm()));
713 assert_eq!(Ordering::Greater, (-0.0_f32).total_cmp(&-min_subnorm()));
714 assert_eq!(Ordering::Greater, 0.0_f32.total_cmp(&-0.0));
715 assert_eq!(Ordering::Greater, min_subnorm().total_cmp(&0.0));
716 assert_eq!(Ordering::Greater, max_subnorm().total_cmp(&min_subnorm()));
717 assert_eq!(Ordering::Greater, f32::MIN_POSITIVE.total_cmp(&max_subnorm()));
718 assert_eq!(Ordering::Greater, 0.5_f32.total_cmp(&f32::MIN_POSITIVE));
719 assert_eq!(Ordering::Greater, 1.0_f32.total_cmp(&0.5));
720 assert_eq!(Ordering::Greater, 1.5_f32.total_cmp(&1.0));
721 assert_eq!(Ordering::Greater, 2.5_f32.total_cmp(&1.5));
722 assert_eq!(Ordering::Greater, f32::MAX.total_cmp(&2.5));
723 assert_eq!(Ordering::Greater, f32::INFINITY.total_cmp(&f32::MAX));
724 assert_eq!(Ordering::Greater, s_nan().total_cmp(&f32::INFINITY));
725 assert_eq!(Ordering::Greater, q_nan().total_cmp(&s_nan()));
727 assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-s_nan()));
728 assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-f32::INFINITY));
729 assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-f32::MAX));
730 assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-2.5));
731 assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-1.5));
732 assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-1.0));
733 assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-0.5));
734 assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-f32::MIN_POSITIVE));
735 assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-max_subnorm()));
736 assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-min_subnorm()));
737 assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-0.0));
738 assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&0.0));
739 assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&min_subnorm()));
740 assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&max_subnorm()));
741 assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&f32::MIN_POSITIVE));
742 assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&0.5));
743 assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&1.0));
744 assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&1.5));
745 assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&2.5));
746 assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&f32::MAX));
747 assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&f32::INFINITY));
748 assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&s_nan()));
750 assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-f32::INFINITY));
751 assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-f32::MAX));
752 assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-2.5));
753 assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-1.5));
754 assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-1.0));
755 assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-0.5));
756 assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-f32::MIN_POSITIVE));
757 assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-max_subnorm()));
758 assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-min_subnorm()));
759 assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-0.0));
760 assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&0.0));
761 assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&min_subnorm()));
762 assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&max_subnorm()));
763 assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&f32::MIN_POSITIVE));
764 assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&0.5));
765 assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&1.0));
766 assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&1.5));
767 assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&2.5));
768 assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&f32::MAX));
769 assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&f32::INFINITY));
770 assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&s_nan()));