1 // ignore-tidy-filelength
3 use rustc_apfloat::{Category, ExpInt, IEK_INF, IEK_NAN, IEK_ZERO};
4 use rustc_apfloat::{Float, FloatConvert, ParseError, Round, Status};
5 use rustc_apfloat::ieee::{Half, Single, Double, Quad, X87DoubleExtended};
6 use rustc_apfloat::unpack;
9 fn from_f32(input: f32) -> Self;
10 fn to_f32(self) -> f32;
13 impl SingleExt for Single {
14 fn from_f32(input: f32) -> Self {
15 Self::from_bits(input.to_bits() as u128)
18 fn to_f32(self) -> f32 {
19 f32::from_bits(self.to_bits() as u32)
24 fn from_f64(input: f64) -> Self;
25 fn to_f64(self) -> f64;
28 impl DoubleExt for Double {
29 fn from_f64(input: f64) -> Self {
30 Self::from_bits(input.to_bits() as u128)
33 fn to_f64(self) -> f64 {
34 f64::from_bits(self.to_bits() as u64)
40 // We test qNaN, -qNaN, +sNaN, -sNaN with and without payloads.
42 assert!(!Single::qnan(None).is_signaling());
43 assert!(!(-Single::qnan(None)).is_signaling());
44 assert!(!Single::qnan(Some(payload)).is_signaling());
45 assert!(!(-Single::qnan(Some(payload))).is_signaling());
46 assert!(Single::snan(None).is_signaling());
47 assert!((-Single::snan(None)).is_signaling());
48 assert!(Single::snan(Some(payload)).is_signaling());
49 assert!((-Single::snan(Some(payload))).is_signaling());
54 // 1. Test Special Cases Values.
56 // Test all special values for nextUp and nextDown perscribed by IEEE-754R
71 // nextUp(+inf) = +inf.
72 let test = unpack!(status=, Quad::INFINITY.next_up());
73 let expected = Quad::INFINITY;
74 assert_eq!(status, Status::OK);
75 assert!(test.is_infinite());
76 assert!(!test.is_negative());
77 assert!(test.bitwise_eq(expected));
79 // nextDown(+inf) = -nextUp(-inf) = -(-largest) = largest
80 let test = unpack!(status=, Quad::INFINITY.next_down());
81 let expected = Quad::largest();
82 assert_eq!(status, Status::OK);
83 assert!(!test.is_negative());
84 assert!(test.bitwise_eq(expected));
86 // nextUp(-inf) = -largest
87 let test = unpack!(status=, (-Quad::INFINITY).next_up());
88 let expected = -Quad::largest();
89 assert_eq!(status, Status::OK);
90 assert!(test.is_negative());
91 assert!(test.bitwise_eq(expected));
93 // nextDown(-inf) = -nextUp(+inf) = -(+inf) = -inf.
94 let test = unpack!(status=, (-Quad::INFINITY).next_down());
95 let expected = -Quad::INFINITY;
96 assert_eq!(status, Status::OK);
97 assert!(test.is_infinite() && test.is_negative());
98 assert!(test.bitwise_eq(expected));
100 // nextUp(largest) = +inf
101 let test = unpack!(status=, Quad::largest().next_up());
102 let expected = Quad::INFINITY;
103 assert_eq!(status, Status::OK);
104 assert!(test.is_infinite() && !test.is_negative());
105 assert!(test.bitwise_eq(expected));
107 // nextDown(largest) = -nextUp(-largest)
108 // = -(-largest + inc)
110 let test = unpack!(status=, Quad::largest().next_down());
111 let expected = "0x1.fffffffffffffffffffffffffffep+16383"
114 assert_eq!(status, Status::OK);
115 assert!(!test.is_infinite() && !test.is_negative());
116 assert!(test.bitwise_eq(expected));
118 // nextUp(-largest) = -largest + inc.
119 let test = unpack!(status=, (-Quad::largest()).next_up());
120 let expected = "-0x1.fffffffffffffffffffffffffffep+16383"
123 assert_eq!(status, Status::OK);
124 assert!(test.bitwise_eq(expected));
126 // nextDown(-largest) = -nextUp(largest) = -(inf) = -inf.
127 let test = unpack!(status=, (-Quad::largest()).next_down());
128 let expected = -Quad::INFINITY;
129 assert_eq!(status, Status::OK);
130 assert!(test.is_infinite() && test.is_negative());
131 assert!(test.bitwise_eq(expected));
133 // nextUp(smallest) = smallest + inc.
134 let test = unpack!(status=, "0x0.0000000000000000000000000001p-16382"
138 let expected = "0x0.0000000000000000000000000002p-16382"
141 assert_eq!(status, Status::OK);
142 assert!(test.bitwise_eq(expected));
144 // nextDown(smallest) = -nextUp(-smallest) = -(-0) = +0.
145 let test = unpack!(status=, "0x0.0000000000000000000000000001p-16382"
149 let expected = Quad::ZERO;
150 assert_eq!(status, Status::OK);
151 assert!(test.is_pos_zero());
152 assert!(test.bitwise_eq(expected));
154 // nextUp(-smallest) = -0.
155 let test = unpack!(status=, "-0x0.0000000000000000000000000001p-16382"
159 let expected = -Quad::ZERO;
160 assert_eq!(status, Status::OK);
161 assert!(test.is_neg_zero());
162 assert!(test.bitwise_eq(expected));
164 // nextDown(-smallest) = -nextUp(smallest) = -smallest - inc.
165 let test = unpack!(status=, "-0x0.0000000000000000000000000001p-16382"
169 let expected = "-0x0.0000000000000000000000000002p-16382"
172 assert_eq!(status, Status::OK);
173 assert!(test.bitwise_eq(expected));
175 // nextUp(qNaN) = qNaN
176 let test = unpack!(status=, Quad::qnan(None).next_up());
177 let expected = Quad::qnan(None);
178 assert_eq!(status, Status::OK);
179 assert!(test.bitwise_eq(expected));
181 // nextDown(qNaN) = qNaN
182 let test = unpack!(status=, Quad::qnan(None).next_down());
183 let expected = Quad::qnan(None);
184 assert_eq!(status, Status::OK);
185 assert!(test.bitwise_eq(expected));
187 // nextUp(sNaN) = qNaN
188 let test = unpack!(status=, Quad::snan(None).next_up());
189 let expected = Quad::qnan(None);
190 assert_eq!(status, Status::INVALID_OP);
191 assert!(test.bitwise_eq(expected));
193 // nextDown(sNaN) = qNaN
194 let test = unpack!(status=, Quad::snan(None).next_down());
195 let expected = Quad::qnan(None);
196 assert_eq!(status, Status::INVALID_OP);
197 assert!(test.bitwise_eq(expected));
199 // nextUp(+0) = +smallest
200 let test = unpack!(status=, Quad::ZERO.next_up());
201 let expected = Quad::SMALLEST;
202 assert_eq!(status, Status::OK);
203 assert!(test.bitwise_eq(expected));
205 // nextDown(+0) = -nextUp(-0) = -smallest
206 let test = unpack!(status=, Quad::ZERO.next_down());
207 let expected = -Quad::SMALLEST;
208 assert_eq!(status, Status::OK);
209 assert!(test.bitwise_eq(expected));
211 // nextUp(-0) = +smallest
212 let test = unpack!(status=, (-Quad::ZERO).next_up());
213 let expected = Quad::SMALLEST;
214 assert_eq!(status, Status::OK);
215 assert!(test.bitwise_eq(expected));
217 // nextDown(-0) = -nextUp(0) = -smallest
218 let test = unpack!(status=, (-Quad::ZERO).next_down());
219 let expected = -Quad::SMALLEST;
220 assert_eq!(status, Status::OK);
221 assert!(test.bitwise_eq(expected));
223 // 2. Binade Boundary Tests.
225 // 2a. Test denormal <-> normal binade boundaries.
226 // * nextUp(+Largest Denormal) -> +Smallest Normal.
227 // * nextDown(-Largest Denormal) -> -Smallest Normal.
228 // * nextUp(-Smallest Normal) -> -Largest Denormal.
229 // * nextDown(+Smallest Normal) -> +Largest Denormal.
231 // nextUp(+Largest Denormal) -> +Smallest Normal.
232 let test = unpack!(status=, "0x0.ffffffffffffffffffffffffffffp-16382"
236 let expected = "0x1.0000000000000000000000000000p-16382"
239 assert_eq!(status, Status::OK);
240 assert!(!test.is_denormal());
241 assert!(test.bitwise_eq(expected));
243 // nextDown(-Largest Denormal) -> -Smallest Normal.
244 let test = unpack!(status=, "-0x0.ffffffffffffffffffffffffffffp-16382"
248 let expected = "-0x1.0000000000000000000000000000p-16382"
251 assert_eq!(status, Status::OK);
252 assert!(!test.is_denormal());
253 assert!(test.bitwise_eq(expected));
255 // nextUp(-Smallest Normal) -> -Largest Denormal.
256 let test = unpack!(status=, "-0x1.0000000000000000000000000000p-16382"
260 let expected = "-0x0.ffffffffffffffffffffffffffffp-16382"
263 assert_eq!(status, Status::OK);
264 assert!(test.is_denormal());
265 assert!(test.bitwise_eq(expected));
267 // nextDown(+Smallest Normal) -> +Largest Denormal.
268 let test = unpack!(status=, "+0x1.0000000000000000000000000000p-16382"
272 let expected = "+0x0.ffffffffffffffffffffffffffffp-16382"
275 assert_eq!(status, Status::OK);
276 assert!(test.is_denormal());
277 assert!(test.bitwise_eq(expected));
279 // 2b. Test normal <-> normal binade boundaries.
280 // * nextUp(-Normal Binade Boundary) -> -Normal Binade Boundary + 1.
281 // * nextDown(+Normal Binade Boundary) -> +Normal Binade Boundary - 1.
282 // * nextUp(+Normal Binade Boundary - 1) -> +Normal Binade Boundary.
283 // * nextDown(-Normal Binade Boundary + 1) -> -Normal Binade Boundary.
285 // nextUp(-Normal Binade Boundary) -> -Normal Binade Boundary + 1.
286 let test = unpack!(status=, "-0x1p+1".parse::<Quad>().unwrap().next_up());
287 let expected = "-0x1.ffffffffffffffffffffffffffffp+0"
290 assert_eq!(status, Status::OK);
291 assert!(test.bitwise_eq(expected));
293 // nextDown(+Normal Binade Boundary) -> +Normal Binade Boundary - 1.
294 let test = unpack!(status=, "0x1p+1".parse::<Quad>().unwrap().next_down());
295 let expected = "0x1.ffffffffffffffffffffffffffffp+0"
298 assert_eq!(status, Status::OK);
299 assert!(test.bitwise_eq(expected));
301 // nextUp(+Normal Binade Boundary - 1) -> +Normal Binade Boundary.
302 let test = unpack!(status=, "0x1.ffffffffffffffffffffffffffffp+0"
306 let expected = "0x1p+1".parse::<Quad>().unwrap();
307 assert_eq!(status, Status::OK);
308 assert!(test.bitwise_eq(expected));
310 // nextDown(-Normal Binade Boundary + 1) -> -Normal Binade Boundary.
311 let test = unpack!(status=, "-0x1.ffffffffffffffffffffffffffffp+0"
315 let expected = "-0x1p+1".parse::<Quad>().unwrap();
316 assert_eq!(status, Status::OK);
317 assert!(test.bitwise_eq(expected));
319 // 2c. Test using next at binade boundaries with a direction away from the
320 // binade boundary. Away from denormal <-> normal boundaries.
322 // This is to make sure that even though we are at a binade boundary, since
323 // we are rounding away, we do not trigger the binade boundary code. Thus we
325 // * nextUp(-Largest Denormal) -> -Largest Denormal + inc.
326 // * nextDown(+Largest Denormal) -> +Largest Denormal - inc.
327 // * nextUp(+Smallest Normal) -> +Smallest Normal + inc.
328 // * nextDown(-Smallest Normal) -> -Smallest Normal - inc.
330 // nextUp(-Largest Denormal) -> -Largest Denormal + inc.
331 let test = unpack!(status=, "-0x0.ffffffffffffffffffffffffffffp-16382"
335 let expected = "-0x0.fffffffffffffffffffffffffffep-16382"
338 assert_eq!(status, Status::OK);
339 assert!(test.is_denormal());
340 assert!(test.is_negative());
341 assert!(test.bitwise_eq(expected));
343 // nextDown(+Largest Denormal) -> +Largest Denormal - inc.
344 let test = unpack!(status=, "0x0.ffffffffffffffffffffffffffffp-16382"
348 let expected = "0x0.fffffffffffffffffffffffffffep-16382"
351 assert_eq!(status, Status::OK);
352 assert!(test.is_denormal());
353 assert!(!test.is_negative());
354 assert!(test.bitwise_eq(expected));
356 // nextUp(+Smallest Normal) -> +Smallest Normal + inc.
357 let test = unpack!(status=, "0x1.0000000000000000000000000000p-16382"
361 let expected = "0x1.0000000000000000000000000001p-16382"
364 assert_eq!(status, Status::OK);
365 assert!(!test.is_denormal());
366 assert!(!test.is_negative());
367 assert!(test.bitwise_eq(expected));
369 // nextDown(-Smallest Normal) -> -Smallest Normal - inc.
370 let test = unpack!(status=, "-0x1.0000000000000000000000000000p-16382"
374 let expected = "-0x1.0000000000000000000000000001p-16382"
377 assert_eq!(status, Status::OK);
378 assert!(!test.is_denormal());
379 assert!(test.is_negative());
380 assert!(test.bitwise_eq(expected));
382 // 2d. Test values which cause our exponent to go to min exponent. This
383 // is to ensure that guards in the code to check for min exponent
385 // * nextUp(-0x1p-16381) -> -0x1.ffffffffffffffffffffffffffffp-16382
386 // * nextDown(-0x1.ffffffffffffffffffffffffffffp-16382) ->
388 // * nextUp(0x1.ffffffffffffffffffffffffffffp-16382) -> 0x1p-16382
389 // * nextDown(0x1p-16382) -> 0x1.ffffffffffffffffffffffffffffp-16382
391 // nextUp(-0x1p-16381) -> -0x1.ffffffffffffffffffffffffffffp-16382
392 let test = unpack!(status=, "-0x1p-16381".parse::<Quad>().unwrap().next_up());
393 let expected = "-0x1.ffffffffffffffffffffffffffffp-16382"
396 assert_eq!(status, Status::OK);
397 assert!(test.bitwise_eq(expected));
399 // nextDown(-0x1.ffffffffffffffffffffffffffffp-16382) ->
401 let test = unpack!(status=, "-0x1.ffffffffffffffffffffffffffffp-16382"
405 let expected = "-0x1p-16381".parse::<Quad>().unwrap();
406 assert_eq!(status, Status::OK);
407 assert!(test.bitwise_eq(expected));
409 // nextUp(0x1.ffffffffffffffffffffffffffffp-16382) -> 0x1p-16381
410 let test = unpack!(status=, "0x1.ffffffffffffffffffffffffffffp-16382"
414 let expected = "0x1p-16381".parse::<Quad>().unwrap();
415 assert_eq!(status, Status::OK);
416 assert!(test.bitwise_eq(expected));
418 // nextDown(0x1p-16381) -> 0x1.ffffffffffffffffffffffffffffp-16382
419 let test = unpack!(status=, "0x1p-16381".parse::<Quad>().unwrap().next_down());
420 let expected = "0x1.ffffffffffffffffffffffffffffp-16382"
423 assert_eq!(status, Status::OK);
424 assert!(test.bitwise_eq(expected));
426 // 3. Now we test both denormal/normal computation which will not cause us
427 // to go across binade boundaries. Specifically we test:
428 // * nextUp(+Denormal) -> +Denormal.
429 // * nextDown(+Denormal) -> +Denormal.
430 // * nextUp(-Denormal) -> -Denormal.
431 // * nextDown(-Denormal) -> -Denormal.
432 // * nextUp(+Normal) -> +Normal.
433 // * nextDown(+Normal) -> +Normal.
434 // * nextUp(-Normal) -> -Normal.
435 // * nextDown(-Normal) -> -Normal.
437 // nextUp(+Denormal) -> +Denormal.
438 let test = unpack!(status=, "0x0.ffffffffffffffffffffffff000cp-16382"
442 let expected = "0x0.ffffffffffffffffffffffff000dp-16382"
445 assert_eq!(status, Status::OK);
446 assert!(test.is_denormal());
447 assert!(!test.is_negative());
448 assert!(test.bitwise_eq(expected));
450 // nextDown(+Denormal) -> +Denormal.
451 let test = unpack!(status=, "0x0.ffffffffffffffffffffffff000cp-16382"
455 let expected = "0x0.ffffffffffffffffffffffff000bp-16382"
458 assert_eq!(status, Status::OK);
459 assert!(test.is_denormal());
460 assert!(!test.is_negative());
461 assert!(test.bitwise_eq(expected));
463 // nextUp(-Denormal) -> -Denormal.
464 let test = unpack!(status=, "-0x0.ffffffffffffffffffffffff000cp-16382"
468 let expected = "-0x0.ffffffffffffffffffffffff000bp-16382"
471 assert_eq!(status, Status::OK);
472 assert!(test.is_denormal());
473 assert!(test.is_negative());
474 assert!(test.bitwise_eq(expected));
476 // nextDown(-Denormal) -> -Denormal
477 let test = unpack!(status=, "-0x0.ffffffffffffffffffffffff000cp-16382"
481 let expected = "-0x0.ffffffffffffffffffffffff000dp-16382"
484 assert_eq!(status, Status::OK);
485 assert!(test.is_denormal());
486 assert!(test.is_negative());
487 assert!(test.bitwise_eq(expected));
489 // nextUp(+Normal) -> +Normal.
490 let test = unpack!(status=, "0x1.ffffffffffffffffffffffff000cp-16000"
494 let expected = "0x1.ffffffffffffffffffffffff000dp-16000"
497 assert_eq!(status, Status::OK);
498 assert!(!test.is_denormal());
499 assert!(!test.is_negative());
500 assert!(test.bitwise_eq(expected));
502 // nextDown(+Normal) -> +Normal.
503 let test = unpack!(status=, "0x1.ffffffffffffffffffffffff000cp-16000"
507 let expected = "0x1.ffffffffffffffffffffffff000bp-16000"
510 assert_eq!(status, Status::OK);
511 assert!(!test.is_denormal());
512 assert!(!test.is_negative());
513 assert!(test.bitwise_eq(expected));
515 // nextUp(-Normal) -> -Normal.
516 let test = unpack!(status=, "-0x1.ffffffffffffffffffffffff000cp-16000"
520 let expected = "-0x1.ffffffffffffffffffffffff000bp-16000"
523 assert_eq!(status, Status::OK);
524 assert!(!test.is_denormal());
525 assert!(test.is_negative());
526 assert!(test.bitwise_eq(expected));
528 // nextDown(-Normal) -> -Normal.
529 let test = unpack!(status=, "-0x1.ffffffffffffffffffffffff000cp-16000"
533 let expected = "-0x1.ffffffffffffffffffffffff000dp-16000"
536 assert_eq!(status, Status::OK);
537 assert!(!test.is_denormal());
538 assert!(test.is_negative());
539 assert!(test.bitwise_eq(expected));
545 let mut f1 = Single::from_f32(14.5);
546 let f2 = Single::from_f32(-14.5);
547 let f3 = Single::from_f32(225.0);
548 f1 = f1.mul_add(f2, f3).value;
549 assert_eq!(14.75, f1.to_f32());
553 let val2 = Single::from_f32(2.0);
554 let mut f1 = Single::from_f32(1.17549435e-38);
555 let mut f2 = Single::from_f32(1.17549435e-38);
558 let f3 = Single::from_f32(12.0);
559 f1 = f1.mul_add(f2, f3).value;
560 assert_eq!(12.0, f1.to_f32());
563 // Test for correct zero sign when answer is exactly zero.
564 // fma(1.0, -1.0, 1.0) -> +ve 0.
566 let mut f1 = Double::from_f64(1.0);
567 let f2 = Double::from_f64(-1.0);
568 let f3 = Double::from_f64(1.0);
569 f1 = f1.mul_add(f2, f3).value;
570 assert!(!f1.is_negative() && f1.is_zero());
573 // Test for correct zero sign when answer is exactly zero and rounding towards
575 // fma(1.0, -1.0, 1.0) -> +ve 0.
577 let mut f1 = Double::from_f64(1.0);
578 let f2 = Double::from_f64(-1.0);
579 let f3 = Double::from_f64(1.0);
580 f1 = f1.mul_add_r(f2, f3, Round::TowardNegative).value;
581 assert!(f1.is_negative() && f1.is_zero());
584 // Test for correct (in this case -ve) sign when adding like signed zeros.
585 // Test fma(0.0, -0.0, -0.0) -> -ve 0.
587 let mut f1 = Double::from_f64(0.0);
588 let f2 = Double::from_f64(-0.0);
589 let f3 = Double::from_f64(-0.0);
590 f1 = f1.mul_add(f2, f3).value;
591 assert!(f1.is_negative() && f1.is_zero());
594 // Test -ve sign preservation when small negative results underflow.
596 let mut f1 = "-0x1p-1074".parse::<Double>().unwrap();
597 let f2 = "+0x1p-1074".parse::<Double>().unwrap();
598 let f3 = Double::from_f64(0.0);
599 f1 = f1.mul_add(f2, f3).value;
600 assert!(f1.is_negative() && f1.is_zero());
603 // Test x87 extended precision case from http://llvm.org/PR20728.
605 let mut m1 = X87DoubleExtended::from_u128(1).value;
606 let m2 = X87DoubleExtended::from_u128(1).value;
607 let a = X87DoubleExtended::from_u128(3).value;
609 let mut loses_info = false;
610 m1 = m1.mul_add(m2, a).value;
611 let r: Single = m1.convert(&mut loses_info).value;
612 assert!(!loses_info);
613 assert_eq!(4.0, r.to_f32());
619 let f1 = Double::from_f64(1.0);
620 let f2 = Double::from_f64(2.0);
621 let nan = Double::NAN;
623 assert_eq!(1.0, f1.min(f2).to_f64());
624 assert_eq!(1.0, f2.min(f1).to_f64());
625 assert_eq!(1.0, f1.min(nan).to_f64());
626 assert_eq!(1.0, nan.min(f1).to_f64());
631 let f1 = Double::from_f64(1.0);
632 let f2 = Double::from_f64(2.0);
633 let nan = Double::NAN;
635 assert_eq!(2.0, f1.max(f2).to_f64());
636 assert_eq!(2.0, f2.max(f1).to_f64());
637 assert_eq!(1.0, f1.max(nan).to_f64());
638 assert_eq!(1.0, nan.max(f1).to_f64());
643 // Test single precision
645 assert!(!Single::from_f32(0.0).is_denormal());
647 let mut t = "1.17549435082228750797e-38".parse::<Single>().unwrap();
648 assert!(!t.is_denormal());
650 let val2 = Single::from_f32(2.0e0);
652 assert!(t.is_denormal());
655 // Test double precision
657 assert!(!Double::from_f64(0.0).is_denormal());
659 let mut t = "2.22507385850720138309e-308".parse::<Double>().unwrap();
660 assert!(!t.is_denormal());
662 let val2 = Double::from_f64(2.0e0);
664 assert!(t.is_denormal());
667 // Test Intel double-ext
669 assert!(!X87DoubleExtended::from_u128(0).value.is_denormal());
671 let mut t = "3.36210314311209350626e-4932"
672 .parse::<X87DoubleExtended>()
674 assert!(!t.is_denormal());
676 t /= X87DoubleExtended::from_u128(2).value;
677 assert!(t.is_denormal());
680 // Test quadruple precision
682 assert!(!Quad::from_u128(0).value.is_denormal());
684 let mut t = "3.36210314311209350626267781732175260e-4932"
687 assert!(!t.is_denormal());
689 t /= Quad::from_u128(2).value;
690 assert!(t.is_denormal());
695 fn decimal_strings_without_null_terminators() {
696 // Make sure that we can parse strings without null terminators.
698 let val = "0.00"[..3].parse::<Double>().unwrap();
699 assert_eq!(val.to_f64(), 0.0);
700 let val = "0.01"[..3].parse::<Double>().unwrap();
701 assert_eq!(val.to_f64(), 0.0);
702 let val = "0.09"[..3].parse::<Double>().unwrap();
703 assert_eq!(val.to_f64(), 0.0);
704 let val = "0.095"[..4].parse::<Double>().unwrap();
705 assert_eq!(val.to_f64(), 0.09);
706 let val = "0.00e+3"[..7].parse::<Double>().unwrap();
707 assert_eq!(val.to_f64(), 0.00);
708 let val = "0e+3"[..4].parse::<Double>().unwrap();
709 assert_eq!(val.to_f64(), 0.00);
714 fn from_zero_decimal_string() {
715 assert_eq!(0.0, "0".parse::<Double>().unwrap().to_f64());
716 assert_eq!(0.0, "+0".parse::<Double>().unwrap().to_f64());
717 assert_eq!(-0.0, "-0".parse::<Double>().unwrap().to_f64());
719 assert_eq!(0.0, "0.".parse::<Double>().unwrap().to_f64());
720 assert_eq!(0.0, "+0.".parse::<Double>().unwrap().to_f64());
721 assert_eq!(-0.0, "-0.".parse::<Double>().unwrap().to_f64());
723 assert_eq!(0.0, ".0".parse::<Double>().unwrap().to_f64());
724 assert_eq!(0.0, "+.0".parse::<Double>().unwrap().to_f64());
725 assert_eq!(-0.0, "-.0".parse::<Double>().unwrap().to_f64());
727 assert_eq!(0.0, "0.0".parse::<Double>().unwrap().to_f64());
728 assert_eq!(0.0, "+0.0".parse::<Double>().unwrap().to_f64());
729 assert_eq!(-0.0, "-0.0".parse::<Double>().unwrap().to_f64());
731 assert_eq!(0.0, "00000.".parse::<Double>().unwrap().to_f64());
732 assert_eq!(0.0, "+00000.".parse::<Double>().unwrap().to_f64());
733 assert_eq!(-0.0, "-00000.".parse::<Double>().unwrap().to_f64());
735 assert_eq!(0.0, ".00000".parse::<Double>().unwrap().to_f64());
736 assert_eq!(0.0, "+.00000".parse::<Double>().unwrap().to_f64());
737 assert_eq!(-0.0, "-.00000".parse::<Double>().unwrap().to_f64());
739 assert_eq!(0.0, "0000.00000".parse::<Double>().unwrap().to_f64());
740 assert_eq!(0.0, "+0000.00000".parse::<Double>().unwrap().to_f64());
741 assert_eq!(-0.0, "-0000.00000".parse::<Double>().unwrap().to_f64());
745 fn from_zero_decimal_single_exponent_string() {
746 assert_eq!(0.0, "0e1".parse::<Double>().unwrap().to_f64());
747 assert_eq!(0.0, "+0e1".parse::<Double>().unwrap().to_f64());
748 assert_eq!(-0.0, "-0e1".parse::<Double>().unwrap().to_f64());
750 assert_eq!(0.0, "0e+1".parse::<Double>().unwrap().to_f64());
751 assert_eq!(0.0, "+0e+1".parse::<Double>().unwrap().to_f64());
752 assert_eq!(-0.0, "-0e+1".parse::<Double>().unwrap().to_f64());
754 assert_eq!(0.0, "0e-1".parse::<Double>().unwrap().to_f64());
755 assert_eq!(0.0, "+0e-1".parse::<Double>().unwrap().to_f64());
756 assert_eq!(-0.0, "-0e-1".parse::<Double>().unwrap().to_f64());
759 assert_eq!(0.0, "0.e1".parse::<Double>().unwrap().to_f64());
760 assert_eq!(0.0, "+0.e1".parse::<Double>().unwrap().to_f64());
761 assert_eq!(-0.0, "-0.e1".parse::<Double>().unwrap().to_f64());
763 assert_eq!(0.0, "0.e+1".parse::<Double>().unwrap().to_f64());
764 assert_eq!(0.0, "+0.e+1".parse::<Double>().unwrap().to_f64());
765 assert_eq!(-0.0, "-0.e+1".parse::<Double>().unwrap().to_f64());
767 assert_eq!(0.0, "0.e-1".parse::<Double>().unwrap().to_f64());
768 assert_eq!(0.0, "+0.e-1".parse::<Double>().unwrap().to_f64());
769 assert_eq!(-0.0, "-0.e-1".parse::<Double>().unwrap().to_f64());
771 assert_eq!(0.0, ".0e1".parse::<Double>().unwrap().to_f64());
772 assert_eq!(0.0, "+.0e1".parse::<Double>().unwrap().to_f64());
773 assert_eq!(-0.0, "-.0e1".parse::<Double>().unwrap().to_f64());
775 assert_eq!(0.0, ".0e+1".parse::<Double>().unwrap().to_f64());
776 assert_eq!(0.0, "+.0e+1".parse::<Double>().unwrap().to_f64());
777 assert_eq!(-0.0, "-.0e+1".parse::<Double>().unwrap().to_f64());
779 assert_eq!(0.0, ".0e-1".parse::<Double>().unwrap().to_f64());
780 assert_eq!(0.0, "+.0e-1".parse::<Double>().unwrap().to_f64());
781 assert_eq!(-0.0, "-.0e-1".parse::<Double>().unwrap().to_f64());
784 assert_eq!(0.0, "0.0e1".parse::<Double>().unwrap().to_f64());
785 assert_eq!(0.0, "+0.0e1".parse::<Double>().unwrap().to_f64());
786 assert_eq!(-0.0, "-0.0e1".parse::<Double>().unwrap().to_f64());
788 assert_eq!(0.0, "0.0e+1".parse::<Double>().unwrap().to_f64());
789 assert_eq!(0.0, "+0.0e+1".parse::<Double>().unwrap().to_f64());
790 assert_eq!(-0.0, "-0.0e+1".parse::<Double>().unwrap().to_f64());
792 assert_eq!(0.0, "0.0e-1".parse::<Double>().unwrap().to_f64());
793 assert_eq!(0.0, "+0.0e-1".parse::<Double>().unwrap().to_f64());
794 assert_eq!(-0.0, "-0.0e-1".parse::<Double>().unwrap().to_f64());
797 assert_eq!(0.0, "000.0000e1".parse::<Double>().unwrap().to_f64());
798 assert_eq!(0.0, "+000.0000e+1".parse::<Double>().unwrap().to_f64());
799 assert_eq!(-0.0, "-000.0000e+1".parse::<Double>().unwrap().to_f64());
803 fn from_zero_decimal_large_exponent_string() {
804 assert_eq!(0.0, "0e1234".parse::<Double>().unwrap().to_f64());
805 assert_eq!(0.0, "+0e1234".parse::<Double>().unwrap().to_f64());
806 assert_eq!(-0.0, "-0e1234".parse::<Double>().unwrap().to_f64());
808 assert_eq!(0.0, "0e+1234".parse::<Double>().unwrap().to_f64());
809 assert_eq!(0.0, "+0e+1234".parse::<Double>().unwrap().to_f64());
810 assert_eq!(-0.0, "-0e+1234".parse::<Double>().unwrap().to_f64());
812 assert_eq!(0.0, "0e-1234".parse::<Double>().unwrap().to_f64());
813 assert_eq!(0.0, "+0e-1234".parse::<Double>().unwrap().to_f64());
814 assert_eq!(-0.0, "-0e-1234".parse::<Double>().unwrap().to_f64());
816 assert_eq!(0.0, "000.0000e1234".parse::<Double>().unwrap().to_f64());
817 assert_eq!(0.0, "000.0000e-1234".parse::<Double>().unwrap().to_f64());
821 fn from_zero_hexadecimal_string() {
822 assert_eq!(0.0, "0x0p1".parse::<Double>().unwrap().to_f64());
823 assert_eq!(0.0, "+0x0p1".parse::<Double>().unwrap().to_f64());
824 assert_eq!(-0.0, "-0x0p1".parse::<Double>().unwrap().to_f64());
826 assert_eq!(0.0, "0x0p+1".parse::<Double>().unwrap().to_f64());
827 assert_eq!(0.0, "+0x0p+1".parse::<Double>().unwrap().to_f64());
828 assert_eq!(-0.0, "-0x0p+1".parse::<Double>().unwrap().to_f64());
830 assert_eq!(0.0, "0x0p-1".parse::<Double>().unwrap().to_f64());
831 assert_eq!(0.0, "+0x0p-1".parse::<Double>().unwrap().to_f64());
832 assert_eq!(-0.0, "-0x0p-1".parse::<Double>().unwrap().to_f64());
835 assert_eq!(0.0, "0x0.p1".parse::<Double>().unwrap().to_f64());
836 assert_eq!(0.0, "+0x0.p1".parse::<Double>().unwrap().to_f64());
837 assert_eq!(-0.0, "-0x0.p1".parse::<Double>().unwrap().to_f64());
839 assert_eq!(0.0, "0x0.p+1".parse::<Double>().unwrap().to_f64());
840 assert_eq!(0.0, "+0x0.p+1".parse::<Double>().unwrap().to_f64());
841 assert_eq!(-0.0, "-0x0.p+1".parse::<Double>().unwrap().to_f64());
843 assert_eq!(0.0, "0x0.p-1".parse::<Double>().unwrap().to_f64());
844 assert_eq!(0.0, "+0x0.p-1".parse::<Double>().unwrap().to_f64());
845 assert_eq!(-0.0, "-0x0.p-1".parse::<Double>().unwrap().to_f64());
848 assert_eq!(0.0, "0x.0p1".parse::<Double>().unwrap().to_f64());
849 assert_eq!(0.0, "+0x.0p1".parse::<Double>().unwrap().to_f64());
850 assert_eq!(-0.0, "-0x.0p1".parse::<Double>().unwrap().to_f64());
852 assert_eq!(0.0, "0x.0p+1".parse::<Double>().unwrap().to_f64());
853 assert_eq!(0.0, "+0x.0p+1".parse::<Double>().unwrap().to_f64());
854 assert_eq!(-0.0, "-0x.0p+1".parse::<Double>().unwrap().to_f64());
856 assert_eq!(0.0, "0x.0p-1".parse::<Double>().unwrap().to_f64());
857 assert_eq!(0.0, "+0x.0p-1".parse::<Double>().unwrap().to_f64());
858 assert_eq!(-0.0, "-0x.0p-1".parse::<Double>().unwrap().to_f64());
861 assert_eq!(0.0, "0x0.0p1".parse::<Double>().unwrap().to_f64());
862 assert_eq!(0.0, "+0x0.0p1".parse::<Double>().unwrap().to_f64());
863 assert_eq!(-0.0, "-0x0.0p1".parse::<Double>().unwrap().to_f64());
865 assert_eq!(0.0, "0x0.0p+1".parse::<Double>().unwrap().to_f64());
866 assert_eq!(0.0, "+0x0.0p+1".parse::<Double>().unwrap().to_f64());
867 assert_eq!(-0.0, "-0x0.0p+1".parse::<Double>().unwrap().to_f64());
869 assert_eq!(0.0, "0x0.0p-1".parse::<Double>().unwrap().to_f64());
870 assert_eq!(0.0, "+0x0.0p-1".parse::<Double>().unwrap().to_f64());
871 assert_eq!(-0.0, "-0x0.0p-1".parse::<Double>().unwrap().to_f64());
874 assert_eq!(0.0, "0x00000.p1".parse::<Double>().unwrap().to_f64());
875 assert_eq!(0.0, "0x0000.00000p1".parse::<Double>().unwrap().to_f64());
876 assert_eq!(0.0, "0x.00000p1".parse::<Double>().unwrap().to_f64());
877 assert_eq!(0.0, "0x0.p1".parse::<Double>().unwrap().to_f64());
878 assert_eq!(0.0, "0x0p1234".parse::<Double>().unwrap().to_f64());
879 assert_eq!(-0.0, "-0x0p1234".parse::<Double>().unwrap().to_f64());
880 assert_eq!(0.0, "0x00000.p1234".parse::<Double>().unwrap().to_f64());
881 assert_eq!(0.0, "0x0000.00000p1234".parse::<Double>().unwrap().to_f64());
882 assert_eq!(0.0, "0x.00000p1234".parse::<Double>().unwrap().to_f64());
883 assert_eq!(0.0, "0x0.p1234".parse::<Double>().unwrap().to_f64());
887 fn from_decimal_string() {
888 assert_eq!(1.0, "1".parse::<Double>().unwrap().to_f64());
889 assert_eq!(2.0, "2.".parse::<Double>().unwrap().to_f64());
890 assert_eq!(0.5, ".5".parse::<Double>().unwrap().to_f64());
891 assert_eq!(1.0, "1.0".parse::<Double>().unwrap().to_f64());
892 assert_eq!(-2.0, "-2".parse::<Double>().unwrap().to_f64());
893 assert_eq!(-4.0, "-4.".parse::<Double>().unwrap().to_f64());
894 assert_eq!(-0.5, "-.5".parse::<Double>().unwrap().to_f64());
895 assert_eq!(-1.5, "-1.5".parse::<Double>().unwrap().to_f64());
896 assert_eq!(1.25e12, "1.25e12".parse::<Double>().unwrap().to_f64());
897 assert_eq!(1.25e+12, "1.25e+12".parse::<Double>().unwrap().to_f64());
898 assert_eq!(1.25e-12, "1.25e-12".parse::<Double>().unwrap().to_f64());
899 assert_eq!(1024.0, "1024.".parse::<Double>().unwrap().to_f64());
900 assert_eq!(1024.05, "1024.05000".parse::<Double>().unwrap().to_f64());
901 assert_eq!(0.05, ".05000".parse::<Double>().unwrap().to_f64());
902 assert_eq!(2.0, "2.".parse::<Double>().unwrap().to_f64());
903 assert_eq!(2.0e2, "2.e2".parse::<Double>().unwrap().to_f64());
904 assert_eq!(2.0e+2, "2.e+2".parse::<Double>().unwrap().to_f64());
905 assert_eq!(2.0e-2, "2.e-2".parse::<Double>().unwrap().to_f64());
906 assert_eq!(2.05e2, "002.05000e2".parse::<Double>().unwrap().to_f64());
907 assert_eq!(2.05e+2, "002.05000e+2".parse::<Double>().unwrap().to_f64());
908 assert_eq!(2.05e-2, "002.05000e-2".parse::<Double>().unwrap().to_f64());
909 assert_eq!(2.05e12, "002.05000e12".parse::<Double>().unwrap().to_f64());
912 "002.05000e+12".parse::<Double>().unwrap().to_f64()
916 "002.05000e-12".parse::<Double>().unwrap().to_f64()
919 // These are "carefully selected" to overflow the fast log-base
920 // calculations in the implementation.
921 assert!("99e99999".parse::<Double>().unwrap().is_infinite());
922 assert!("-99e99999".parse::<Double>().unwrap().is_infinite());
923 assert!("1e-99999".parse::<Double>().unwrap().is_pos_zero());
924 assert!("-1e-99999".parse::<Double>().unwrap().is_neg_zero());
926 assert_eq!(2.71828, "2.71828".parse::<Double>().unwrap().to_f64());
930 fn from_hexadecimal_string() {
931 assert_eq!(1.0, "0x1p0".parse::<Double>().unwrap().to_f64());
932 assert_eq!(1.0, "+0x1p0".parse::<Double>().unwrap().to_f64());
933 assert_eq!(-1.0, "-0x1p0".parse::<Double>().unwrap().to_f64());
935 assert_eq!(1.0, "0x1p+0".parse::<Double>().unwrap().to_f64());
936 assert_eq!(1.0, "+0x1p+0".parse::<Double>().unwrap().to_f64());
937 assert_eq!(-1.0, "-0x1p+0".parse::<Double>().unwrap().to_f64());
939 assert_eq!(1.0, "0x1p-0".parse::<Double>().unwrap().to_f64());
940 assert_eq!(1.0, "+0x1p-0".parse::<Double>().unwrap().to_f64());
941 assert_eq!(-1.0, "-0x1p-0".parse::<Double>().unwrap().to_f64());
944 assert_eq!(2.0, "0x1p1".parse::<Double>().unwrap().to_f64());
945 assert_eq!(2.0, "+0x1p1".parse::<Double>().unwrap().to_f64());
946 assert_eq!(-2.0, "-0x1p1".parse::<Double>().unwrap().to_f64());
948 assert_eq!(2.0, "0x1p+1".parse::<Double>().unwrap().to_f64());
949 assert_eq!(2.0, "+0x1p+1".parse::<Double>().unwrap().to_f64());
950 assert_eq!(-2.0, "-0x1p+1".parse::<Double>().unwrap().to_f64());
952 assert_eq!(0.5, "0x1p-1".parse::<Double>().unwrap().to_f64());
953 assert_eq!(0.5, "+0x1p-1".parse::<Double>().unwrap().to_f64());
954 assert_eq!(-0.5, "-0x1p-1".parse::<Double>().unwrap().to_f64());
957 assert_eq!(3.0, "0x1.8p1".parse::<Double>().unwrap().to_f64());
958 assert_eq!(3.0, "+0x1.8p1".parse::<Double>().unwrap().to_f64());
959 assert_eq!(-3.0, "-0x1.8p1".parse::<Double>().unwrap().to_f64());
961 assert_eq!(3.0, "0x1.8p+1".parse::<Double>().unwrap().to_f64());
962 assert_eq!(3.0, "+0x1.8p+1".parse::<Double>().unwrap().to_f64());
963 assert_eq!(-3.0, "-0x1.8p+1".parse::<Double>().unwrap().to_f64());
965 assert_eq!(0.75, "0x1.8p-1".parse::<Double>().unwrap().to_f64());
966 assert_eq!(0.75, "+0x1.8p-1".parse::<Double>().unwrap().to_f64());
967 assert_eq!(-0.75, "-0x1.8p-1".parse::<Double>().unwrap().to_f64());
970 assert_eq!(8192.0, "0x1000.000p1".parse::<Double>().unwrap().to_f64());
971 assert_eq!(8192.0, "+0x1000.000p1".parse::<Double>().unwrap().to_f64());
972 assert_eq!(-8192.0, "-0x1000.000p1".parse::<Double>().unwrap().to_f64());
974 assert_eq!(8192.0, "0x1000.000p+1".parse::<Double>().unwrap().to_f64());
975 assert_eq!(8192.0, "+0x1000.000p+1".parse::<Double>().unwrap().to_f64());
978 "-0x1000.000p+1".parse::<Double>().unwrap().to_f64()
981 assert_eq!(2048.0, "0x1000.000p-1".parse::<Double>().unwrap().to_f64());
982 assert_eq!(2048.0, "+0x1000.000p-1".parse::<Double>().unwrap().to_f64());
985 "-0x1000.000p-1".parse::<Double>().unwrap().to_f64()
989 assert_eq!(8192.0, "0x1000p1".parse::<Double>().unwrap().to_f64());
990 assert_eq!(8192.0, "+0x1000p1".parse::<Double>().unwrap().to_f64());
991 assert_eq!(-8192.0, "-0x1000p1".parse::<Double>().unwrap().to_f64());
993 assert_eq!(8192.0, "0x1000p+1".parse::<Double>().unwrap().to_f64());
994 assert_eq!(8192.0, "+0x1000p+1".parse::<Double>().unwrap().to_f64());
995 assert_eq!(-8192.0, "-0x1000p+1".parse::<Double>().unwrap().to_f64());
997 assert_eq!(2048.0, "0x1000p-1".parse::<Double>().unwrap().to_f64());
998 assert_eq!(2048.0, "+0x1000p-1".parse::<Double>().unwrap().to_f64());
999 assert_eq!(-2048.0, "-0x1000p-1".parse::<Double>().unwrap().to_f64());
1002 assert_eq!(16384.0, "0x10p10".parse::<Double>().unwrap().to_f64());
1003 assert_eq!(16384.0, "+0x10p10".parse::<Double>().unwrap().to_f64());
1004 assert_eq!(-16384.0, "-0x10p10".parse::<Double>().unwrap().to_f64());
1006 assert_eq!(16384.0, "0x10p+10".parse::<Double>().unwrap().to_f64());
1007 assert_eq!(16384.0, "+0x10p+10".parse::<Double>().unwrap().to_f64());
1008 assert_eq!(-16384.0, "-0x10p+10".parse::<Double>().unwrap().to_f64());
1010 assert_eq!(0.015625, "0x10p-10".parse::<Double>().unwrap().to_f64());
1011 assert_eq!(0.015625, "+0x10p-10".parse::<Double>().unwrap().to_f64());
1012 assert_eq!(-0.015625, "-0x10p-10".parse::<Double>().unwrap().to_f64());
1014 assert_eq!(1.0625, "0x1.1p0".parse::<Double>().unwrap().to_f64());
1015 assert_eq!(1.0, "0x1p0".parse::<Double>().unwrap().to_f64());
1018 "0x1p-150".parse::<Double>().unwrap().to_f64(),
1019 "+0x800000000000000001.p-221"
1026 "0x80000000000004000000.010p-28"
1035 let to_string = |d: f64, precision: usize, width: usize| {
1036 let x = Double::from_f64(d);
1038 format!("{:1$}", x, width)
1040 format!("{:2$.1$}", x, precision, width)
1043 assert_eq!("10", to_string(10.0, 6, 3));
1044 assert_eq!("1.0E+1", to_string(10.0, 6, 0));
1045 assert_eq!("10100", to_string(1.01E+4, 5, 2));
1046 assert_eq!("1.01E+4", to_string(1.01E+4, 4, 2));
1047 assert_eq!("1.01E+4", to_string(1.01E+4, 5, 1));
1048 assert_eq!("0.0101", to_string(1.01E-2, 5, 2));
1049 assert_eq!("0.0101", to_string(1.01E-2, 4, 2));
1050 assert_eq!("1.01E-2", to_string(1.01E-2, 5, 1));
1052 "0.78539816339744828",
1053 to_string(0.78539816339744830961, 0, 3)
1056 "4.9406564584124654E-324",
1057 to_string(4.9406564584124654e-324, 0, 3)
1059 assert_eq!("873.18340000000001", to_string(873.1834, 0, 1));
1060 assert_eq!("8.7318340000000001E+2", to_string(873.1834, 0, 0));
1062 "1.7976931348623157E+308",
1063 to_string(1.7976931348623157E+308, 0, 0)
1066 let to_string = |d: f64, precision: usize, width: usize| {
1067 let x = Double::from_f64(d);
1069 format!("{:#1$}", x, width)
1071 format!("{:#2$.1$}", x, precision, width)
1074 assert_eq!("10", to_string(10.0, 6, 3));
1075 assert_eq!("1.000000e+01", to_string(10.0, 6, 0));
1076 assert_eq!("10100", to_string(1.01E+4, 5, 2));
1077 assert_eq!("1.0100e+04", to_string(1.01E+4, 4, 2));
1078 assert_eq!("1.01000e+04", to_string(1.01E+4, 5, 1));
1079 assert_eq!("0.0101", to_string(1.01E-2, 5, 2));
1080 assert_eq!("0.0101", to_string(1.01E-2, 4, 2));
1081 assert_eq!("1.01000e-02", to_string(1.01E-2, 5, 1));
1083 "0.78539816339744828",
1084 to_string(0.78539816339744830961, 0, 3)
1087 "4.94065645841246540e-324",
1088 to_string(4.9406564584124654e-324, 0, 3)
1090 assert_eq!("873.18340000000001", to_string(873.1834, 0, 1));
1091 assert_eq!("8.73183400000000010e+02", to_string(873.1834, 0, 0));
1093 "1.79769313486231570e+308",
1094 to_string(1.7976931348623157E+308, 0, 0)
1100 let mut is_exact = false;
1104 "10".parse::<Double>().unwrap().to_u128_r(
1113 Status::INVALID_OP.and(0),
1114 "-10".parse::<Double>().unwrap().to_u128_r(
1123 Status::INVALID_OP.and(31),
1124 "32".parse::<Double>().unwrap().to_u128_r(
1133 Status::INEXACT.and(7),
1134 "7.9".parse::<Double>().unwrap().to_u128_r(
1143 Status::OK.and(-10),
1144 "-10".parse::<Double>().unwrap().to_i128_r(
1153 Status::INVALID_OP.and(-16),
1154 "-17".parse::<Double>().unwrap().to_i128_r(
1163 Status::INVALID_OP.and(15),
1164 "16".parse::<Double>().unwrap().to_i128_r(
1175 fn nanbits<T: Float>(signaling: bool, negative: bool, fill: u128) -> u128 {
1176 let x = if signaling {
1188 assert_eq!(0x7fc00000, nanbits::<Single>(false, false, 0));
1189 assert_eq!(0xffc00000, nanbits::<Single>(false, true, 0));
1190 assert_eq!(0x7fc0ae72, nanbits::<Single>(false, false, 0xae72));
1191 assert_eq!(0x7fffae72, nanbits::<Single>(false, false, 0xffffae72));
1192 assert_eq!(0x7fa00000, nanbits::<Single>(true, false, 0));
1193 assert_eq!(0xffa00000, nanbits::<Single>(true, true, 0));
1194 assert_eq!(0x7f80ae72, nanbits::<Single>(true, false, 0xae72));
1195 assert_eq!(0x7fbfae72, nanbits::<Single>(true, false, 0xffffae72));
1197 assert_eq!(0x7ff8000000000000, nanbits::<Double>(false, false, 0));
1198 assert_eq!(0xfff8000000000000, nanbits::<Double>(false, true, 0));
1199 assert_eq!(0x7ff800000000ae72, nanbits::<Double>(false, false, 0xae72));
1202 nanbits::<Double>(false, false, 0xffffffffffffae72)
1204 assert_eq!(0x7ff4000000000000, nanbits::<Double>(true, false, 0));
1205 assert_eq!(0xfff4000000000000, nanbits::<Double>(true, true, 0));
1206 assert_eq!(0x7ff000000000ae72, nanbits::<Double>(true, false, 0xae72));
1209 nanbits::<Double>(true, false, 0xffffffffffffae72)
1214 fn string_decimal_death() {
1216 "".parse::<Double>(),
1217 Err(ParseError("Invalid string length"))
1220 "+".parse::<Double>(),
1221 Err(ParseError("String has no digits"))
1224 "-".parse::<Double>(),
1225 Err(ParseError("String has no digits"))
1229 "\0".parse::<Double>(),
1230 Err(ParseError("Invalid character in significand"))
1233 "1\0".parse::<Double>(),
1234 Err(ParseError("Invalid character in significand"))
1237 "1\02".parse::<Double>(),
1238 Err(ParseError("Invalid character in significand"))
1241 "1\02e1".parse::<Double>(),
1242 Err(ParseError("Invalid character in significand"))
1245 "1e\0".parse::<Double>(),
1246 Err(ParseError("Invalid character in exponent"))
1249 "1e1\0".parse::<Double>(),
1250 Err(ParseError("Invalid character in exponent"))
1253 "1e1\02".parse::<Double>(),
1254 Err(ParseError("Invalid character in exponent"))
1258 "1.0f".parse::<Double>(),
1259 Err(ParseError("Invalid character in significand"))
1263 "..".parse::<Double>(),
1264 Err(ParseError("String contains multiple dots"))
1267 "..0".parse::<Double>(),
1268 Err(ParseError("String contains multiple dots"))
1271 "1.0.0".parse::<Double>(),
1272 Err(ParseError("String contains multiple dots"))
1277 fn string_decimal_significand_death() {
1279 ".".parse::<Double>(),
1280 Err(ParseError("Significand has no digits"))
1283 "+.".parse::<Double>(),
1284 Err(ParseError("Significand has no digits"))
1287 "-.".parse::<Double>(),
1288 Err(ParseError("Significand has no digits"))
1293 "e".parse::<Double>(),
1294 Err(ParseError("Significand has no digits"))
1297 "+e".parse::<Double>(),
1298 Err(ParseError("Significand has no digits"))
1301 "-e".parse::<Double>(),
1302 Err(ParseError("Significand has no digits"))
1306 "e1".parse::<Double>(),
1307 Err(ParseError("Significand has no digits"))
1310 "+e1".parse::<Double>(),
1311 Err(ParseError("Significand has no digits"))
1314 "-e1".parse::<Double>(),
1315 Err(ParseError("Significand has no digits"))
1319 ".e1".parse::<Double>(),
1320 Err(ParseError("Significand has no digits"))
1323 "+.e1".parse::<Double>(),
1324 Err(ParseError("Significand has no digits"))
1327 "-.e1".parse::<Double>(),
1328 Err(ParseError("Significand has no digits"))
1333 ".e".parse::<Double>(),
1334 Err(ParseError("Significand has no digits"))
1337 "+.e".parse::<Double>(),
1338 Err(ParseError("Significand has no digits"))
1341 "-.e".parse::<Double>(),
1342 Err(ParseError("Significand has no digits"))
1347 fn string_decimal_exponent_death() {
1349 "1e".parse::<Double>(),
1350 Err(ParseError("Exponent has no digits"))
1353 "+1e".parse::<Double>(),
1354 Err(ParseError("Exponent has no digits"))
1357 "-1e".parse::<Double>(),
1358 Err(ParseError("Exponent has no digits"))
1362 "1.e".parse::<Double>(),
1363 Err(ParseError("Exponent has no digits"))
1366 "+1.e".parse::<Double>(),
1367 Err(ParseError("Exponent has no digits"))
1370 "-1.e".parse::<Double>(),
1371 Err(ParseError("Exponent has no digits"))
1375 ".1e".parse::<Double>(),
1376 Err(ParseError("Exponent has no digits"))
1379 "+.1e".parse::<Double>(),
1380 Err(ParseError("Exponent has no digits"))
1383 "-.1e".parse::<Double>(),
1384 Err(ParseError("Exponent has no digits"))
1388 "1.1e".parse::<Double>(),
1389 Err(ParseError("Exponent has no digits"))
1392 "+1.1e".parse::<Double>(),
1393 Err(ParseError("Exponent has no digits"))
1396 "-1.1e".parse::<Double>(),
1397 Err(ParseError("Exponent has no digits"))
1402 "1e+".parse::<Double>(),
1403 Err(ParseError("Exponent has no digits"))
1406 "1e-".parse::<Double>(),
1407 Err(ParseError("Exponent has no digits"))
1411 ".1e".parse::<Double>(),
1412 Err(ParseError("Exponent has no digits"))
1415 ".1e+".parse::<Double>(),
1416 Err(ParseError("Exponent has no digits"))
1419 ".1e-".parse::<Double>(),
1420 Err(ParseError("Exponent has no digits"))
1424 "1.0e".parse::<Double>(),
1425 Err(ParseError("Exponent has no digits"))
1428 "1.0e+".parse::<Double>(),
1429 Err(ParseError("Exponent has no digits"))
1432 "1.0e-".parse::<Double>(),
1433 Err(ParseError("Exponent has no digits"))
1438 fn string_hexadecimal_death() {
1439 assert_eq!("0x".parse::<Double>(), Err(ParseError("Invalid string")));
1440 assert_eq!("+0x".parse::<Double>(), Err(ParseError("Invalid string")));
1441 assert_eq!("-0x".parse::<Double>(), Err(ParseError("Invalid string")));
1444 "0x0".parse::<Double>(),
1445 Err(ParseError("Hex strings require an exponent"))
1448 "+0x0".parse::<Double>(),
1449 Err(ParseError("Hex strings require an exponent"))
1452 "-0x0".parse::<Double>(),
1453 Err(ParseError("Hex strings require an exponent"))
1457 "0x0.".parse::<Double>(),
1458 Err(ParseError("Hex strings require an exponent"))
1461 "+0x0.".parse::<Double>(),
1462 Err(ParseError("Hex strings require an exponent"))
1465 "-0x0.".parse::<Double>(),
1466 Err(ParseError("Hex strings require an exponent"))
1470 "0x.0".parse::<Double>(),
1471 Err(ParseError("Hex strings require an exponent"))
1474 "+0x.0".parse::<Double>(),
1475 Err(ParseError("Hex strings require an exponent"))
1478 "-0x.0".parse::<Double>(),
1479 Err(ParseError("Hex strings require an exponent"))
1483 "0x0.0".parse::<Double>(),
1484 Err(ParseError("Hex strings require an exponent"))
1487 "+0x0.0".parse::<Double>(),
1488 Err(ParseError("Hex strings require an exponent"))
1491 "-0x0.0".parse::<Double>(),
1492 Err(ParseError("Hex strings require an exponent"))
1496 "0x\0".parse::<Double>(),
1497 Err(ParseError("Invalid character in significand"))
1500 "0x1\0".parse::<Double>(),
1501 Err(ParseError("Invalid character in significand"))
1504 "0x1\02".parse::<Double>(),
1505 Err(ParseError("Invalid character in significand"))
1508 "0x1\02p1".parse::<Double>(),
1509 Err(ParseError("Invalid character in significand"))
1512 "0x1p\0".parse::<Double>(),
1513 Err(ParseError("Invalid character in exponent"))
1516 "0x1p1\0".parse::<Double>(),
1517 Err(ParseError("Invalid character in exponent"))
1520 "0x1p1\02".parse::<Double>(),
1521 Err(ParseError("Invalid character in exponent"))
1525 "0x1p0f".parse::<Double>(),
1526 Err(ParseError("Invalid character in exponent"))
1530 "0x..p1".parse::<Double>(),
1531 Err(ParseError("String contains multiple dots"))
1534 "0x..0p1".parse::<Double>(),
1535 Err(ParseError("String contains multiple dots"))
1538 "0x1.0.0p1".parse::<Double>(),
1539 Err(ParseError("String contains multiple dots"))
1544 fn string_hexadecimal_significand_death() {
1546 "0x.".parse::<Double>(),
1547 Err(ParseError("Significand has no digits"))
1550 "+0x.".parse::<Double>(),
1551 Err(ParseError("Significand has no digits"))
1554 "-0x.".parse::<Double>(),
1555 Err(ParseError("Significand has no digits"))
1559 "0xp".parse::<Double>(),
1560 Err(ParseError("Significand has no digits"))
1563 "+0xp".parse::<Double>(),
1564 Err(ParseError("Significand has no digits"))
1567 "-0xp".parse::<Double>(),
1568 Err(ParseError("Significand has no digits"))
1572 "0xp+".parse::<Double>(),
1573 Err(ParseError("Significand has no digits"))
1576 "+0xp+".parse::<Double>(),
1577 Err(ParseError("Significand has no digits"))
1580 "-0xp+".parse::<Double>(),
1581 Err(ParseError("Significand has no digits"))
1585 "0xp-".parse::<Double>(),
1586 Err(ParseError("Significand has no digits"))
1589 "+0xp-".parse::<Double>(),
1590 Err(ParseError("Significand has no digits"))
1593 "-0xp-".parse::<Double>(),
1594 Err(ParseError("Significand has no digits"))
1599 "0x.p".parse::<Double>(),
1600 Err(ParseError("Significand has no digits"))
1603 "+0x.p".parse::<Double>(),
1604 Err(ParseError("Significand has no digits"))
1607 "-0x.p".parse::<Double>(),
1608 Err(ParseError("Significand has no digits"))
1612 "0x.p+".parse::<Double>(),
1613 Err(ParseError("Significand has no digits"))
1616 "+0x.p+".parse::<Double>(),
1617 Err(ParseError("Significand has no digits"))
1620 "-0x.p+".parse::<Double>(),
1621 Err(ParseError("Significand has no digits"))
1625 "0x.p-".parse::<Double>(),
1626 Err(ParseError("Significand has no digits"))
1629 "+0x.p-".parse::<Double>(),
1630 Err(ParseError("Significand has no digits"))
1633 "-0x.p-".parse::<Double>(),
1634 Err(ParseError("Significand has no digits"))
1639 fn string_hexadecimal_exponent_death() {
1641 "0x1p".parse::<Double>(),
1642 Err(ParseError("Exponent has no digits"))
1645 "+0x1p".parse::<Double>(),
1646 Err(ParseError("Exponent has no digits"))
1649 "-0x1p".parse::<Double>(),
1650 Err(ParseError("Exponent has no digits"))
1654 "0x1p+".parse::<Double>(),
1655 Err(ParseError("Exponent has no digits"))
1658 "+0x1p+".parse::<Double>(),
1659 Err(ParseError("Exponent has no digits"))
1662 "-0x1p+".parse::<Double>(),
1663 Err(ParseError("Exponent has no digits"))
1667 "0x1p-".parse::<Double>(),
1668 Err(ParseError("Exponent has no digits"))
1671 "+0x1p-".parse::<Double>(),
1672 Err(ParseError("Exponent has no digits"))
1675 "-0x1p-".parse::<Double>(),
1676 Err(ParseError("Exponent has no digits"))
1681 "0x1.p".parse::<Double>(),
1682 Err(ParseError("Exponent has no digits"))
1685 "+0x1.p".parse::<Double>(),
1686 Err(ParseError("Exponent has no digits"))
1689 "-0x1.p".parse::<Double>(),
1690 Err(ParseError("Exponent has no digits"))
1694 "0x1.p+".parse::<Double>(),
1695 Err(ParseError("Exponent has no digits"))
1698 "+0x1.p+".parse::<Double>(),
1699 Err(ParseError("Exponent has no digits"))
1702 "-0x1.p+".parse::<Double>(),
1703 Err(ParseError("Exponent has no digits"))
1707 "0x1.p-".parse::<Double>(),
1708 Err(ParseError("Exponent has no digits"))
1711 "+0x1.p-".parse::<Double>(),
1712 Err(ParseError("Exponent has no digits"))
1715 "-0x1.p-".parse::<Double>(),
1716 Err(ParseError("Exponent has no digits"))
1721 "0x.1p".parse::<Double>(),
1722 Err(ParseError("Exponent has no digits"))
1725 "+0x.1p".parse::<Double>(),
1726 Err(ParseError("Exponent has no digits"))
1729 "-0x.1p".parse::<Double>(),
1730 Err(ParseError("Exponent has no digits"))
1734 "0x.1p+".parse::<Double>(),
1735 Err(ParseError("Exponent has no digits"))
1738 "+0x.1p+".parse::<Double>(),
1739 Err(ParseError("Exponent has no digits"))
1742 "-0x.1p+".parse::<Double>(),
1743 Err(ParseError("Exponent has no digits"))
1747 "0x.1p-".parse::<Double>(),
1748 Err(ParseError("Exponent has no digits"))
1751 "+0x.1p-".parse::<Double>(),
1752 Err(ParseError("Exponent has no digits"))
1755 "-0x.1p-".parse::<Double>(),
1756 Err(ParseError("Exponent has no digits"))
1761 "0x1.1p".parse::<Double>(),
1762 Err(ParseError("Exponent has no digits"))
1765 "+0x1.1p".parse::<Double>(),
1766 Err(ParseError("Exponent has no digits"))
1769 "-0x1.1p".parse::<Double>(),
1770 Err(ParseError("Exponent has no digits"))
1774 "0x1.1p+".parse::<Double>(),
1775 Err(ParseError("Exponent has no digits"))
1778 "+0x1.1p+".parse::<Double>(),
1779 Err(ParseError("Exponent has no digits"))
1782 "-0x1.1p+".parse::<Double>(),
1783 Err(ParseError("Exponent has no digits"))
1787 "0x1.1p-".parse::<Double>(),
1788 Err(ParseError("Exponent has no digits"))
1791 "+0x1.1p-".parse::<Double>(),
1792 Err(ParseError("Exponent has no digits"))
1795 "-0x1.1p-".parse::<Double>(),
1796 Err(ParseError("Exponent has no digits"))
1801 fn exact_inverse() {
1802 // Trivial operation.
1804 Double::from_f64(2.0)
1805 .get_exact_inverse()
1807 .bitwise_eq(Double::from_f64(0.5))
1810 Single::from_f32(2.0)
1811 .get_exact_inverse()
1813 .bitwise_eq(Single::from_f32(0.5))
1819 .get_exact_inverse()
1821 .bitwise_eq("0.5".parse::<Quad>().unwrap())
1825 .parse::<X87DoubleExtended>()
1827 .get_exact_inverse()
1829 .bitwise_eq("0.5".parse::<X87DoubleExtended>().unwrap())
1834 Single::from_f32(1.17549435e-38)
1835 .get_exact_inverse()
1837 .bitwise_eq(Single::from_f32(8.5070592e+37))
1840 // Large float, inverse is a denormal.
1841 assert!(Single::from_f32(1.7014118e38).get_exact_inverse().is_none());
1843 assert!(Double::from_f64(0.0).get_exact_inverse().is_none());
1844 // Denormalized float
1846 Single::from_f32(1.40129846e-45)
1847 .get_exact_inverse()
1853 fn round_to_integral() {
1854 let t = Double::from_f64(-0.5);
1855 assert_eq!(-0.0, t.round_to_integral(Round::TowardZero).value.to_f64());
1858 t.round_to_integral(Round::TowardNegative).value.to_f64()
1862 t.round_to_integral(Round::TowardPositive).value.to_f64()
1866 t.round_to_integral(Round::NearestTiesToEven).value.to_f64()
1869 let s = Double::from_f64(3.14);
1870 assert_eq!(3.0, s.round_to_integral(Round::TowardZero).value.to_f64());
1873 s.round_to_integral(Round::TowardNegative).value.to_f64()
1877 s.round_to_integral(Round::TowardPositive).value.to_f64()
1881 s.round_to_integral(Round::NearestTiesToEven).value.to_f64()
1884 let r = Double::largest();
1887 r.round_to_integral(Round::TowardZero).value.to_f64()
1891 r.round_to_integral(Round::TowardNegative).value.to_f64()
1895 r.round_to_integral(Round::TowardPositive).value.to_f64()
1899 r.round_to_integral(Round::NearestTiesToEven).value.to_f64()
1902 let p = Double::ZERO.round_to_integral(Round::TowardZero).value;
1903 assert_eq!(0.0, p.to_f64());
1904 let p = (-Double::ZERO).round_to_integral(Round::TowardZero).value;
1905 assert_eq!(-0.0, p.to_f64());
1906 let p = Double::NAN.round_to_integral(Round::TowardZero).value;
1907 assert!(p.to_f64().is_nan());
1908 let p = Double::INFINITY.round_to_integral(Round::TowardZero).value;
1909 assert!(p.to_f64().is_infinite() && p.to_f64() > 0.0);
1910 let p = (-Double::INFINITY)
1911 .round_to_integral(Round::TowardZero)
1913 assert!(p.to_f64().is_infinite() && p.to_f64() < 0.0);
1918 let t = Double::from_f64(-0.0);
1919 assert!(t.is_integer());
1920 let t = Double::from_f64(3.14159);
1921 assert!(!t.is_integer());
1922 let t = Double::NAN;
1923 assert!(!t.is_integer());
1924 let t = Double::INFINITY;
1925 assert!(!t.is_integer());
1926 let t = -Double::INFINITY;
1927 assert!(!t.is_integer());
1928 let t = Double::largest();
1929 assert!(t.is_integer());
1934 assert_eq!(3.402823466e+38, Single::largest().to_f32());
1935 assert_eq!(1.7976931348623158e+308, Double::largest().to_f64());
1940 let test = Single::SMALLEST;
1941 let expected = "0x0.000002p-126".parse::<Single>().unwrap();
1942 assert!(!test.is_negative());
1943 assert!(test.is_finite_non_zero());
1944 assert!(test.is_denormal());
1945 assert!(test.bitwise_eq(expected));
1947 let test = -Single::SMALLEST;
1948 let expected = "-0x0.000002p-126".parse::<Single>().unwrap();
1949 assert!(test.is_negative());
1950 assert!(test.is_finite_non_zero());
1951 assert!(test.is_denormal());
1952 assert!(test.bitwise_eq(expected));
1954 let test = Quad::SMALLEST;
1955 let expected = "0x0.0000000000000000000000000001p-16382"
1958 assert!(!test.is_negative());
1959 assert!(test.is_finite_non_zero());
1960 assert!(test.is_denormal());
1961 assert!(test.bitwise_eq(expected));
1963 let test = -Quad::SMALLEST;
1964 let expected = "-0x0.0000000000000000000000000001p-16382"
1967 assert!(test.is_negative());
1968 assert!(test.is_finite_non_zero());
1969 assert!(test.is_denormal());
1970 assert!(test.bitwise_eq(expected));
1974 fn smallest_normalized() {
1975 let test = Single::smallest_normalized();
1976 let expected = "0x1p-126".parse::<Single>().unwrap();
1977 assert!(!test.is_negative());
1978 assert!(test.is_finite_non_zero());
1979 assert!(!test.is_denormal());
1980 assert!(test.bitwise_eq(expected));
1982 let test = -Single::smallest_normalized();
1983 let expected = "-0x1p-126".parse::<Single>().unwrap();
1984 assert!(test.is_negative());
1985 assert!(test.is_finite_non_zero());
1986 assert!(!test.is_denormal());
1987 assert!(test.bitwise_eq(expected));
1989 let test = Quad::smallest_normalized();
1990 let expected = "0x1p-16382".parse::<Quad>().unwrap();
1991 assert!(!test.is_negative());
1992 assert!(test.is_finite_non_zero());
1993 assert!(!test.is_denormal());
1994 assert!(test.bitwise_eq(expected));
1996 let test = -Quad::smallest_normalized();
1997 let expected = "-0x1p-16382".parse::<Quad>().unwrap();
1998 assert!(test.is_negative());
1999 assert!(test.is_finite_non_zero());
2000 assert!(!test.is_denormal());
2001 assert!(test.bitwise_eq(expected));
2006 assert_eq!(0.0, Single::from_f32(0.0).to_f32());
2007 assert_eq!(-0.0, Single::from_f32(-0.0).to_f32());
2008 assert!(Single::from_f32(-0.0).is_negative());
2010 assert_eq!(0.0, Double::from_f64(0.0).to_f64());
2011 assert_eq!(-0.0, Double::from_f64(-0.0).to_f64());
2012 assert!(Double::from_f64(-0.0).is_negative());
2014 fn test<T: Float>(sign: bool, bits: u128) {
2015 let test = if sign { -T::ZERO } else { T::ZERO };
2016 let pattern = if sign { "-0x0p+0" } else { "0x0p+0" };
2017 let expected = pattern.parse::<T>().unwrap();
2018 assert!(test.is_zero());
2019 assert_eq!(sign, test.is_negative());
2020 assert!(test.bitwise_eq(expected));
2021 assert_eq!(bits, test.to_bits());
2023 test::<Half>(false, 0);
2024 test::<Half>(true, 0x8000);
2025 test::<Single>(false, 0);
2026 test::<Single>(true, 0x80000000);
2027 test::<Double>(false, 0);
2028 test::<Double>(true, 0x8000000000000000);
2029 test::<Quad>(false, 0);
2030 test::<Quad>(true, 0x8000000000000000_0000000000000000);
2031 test::<X87DoubleExtended>(false, 0);
2032 test::<X87DoubleExtended>(true, 0x8000_0000000000000000);
2037 assert!(Double::from_f64(-42.0).bitwise_eq(
2038 Double::from_f64(42.0).copy_sign(
2039 Double::from_f64(-1.0),
2042 assert!(Double::from_f64(42.0).bitwise_eq(
2043 Double::from_f64(-42.0).copy_sign(
2044 Double::from_f64(1.0),
2047 assert!(Double::from_f64(-42.0).bitwise_eq(
2048 Double::from_f64(-42.0).copy_sign(
2049 Double::from_f64(-1.0),
2052 assert!(Double::from_f64(42.0).bitwise_eq(
2053 Double::from_f64(42.0).copy_sign(
2054 Double::from_f64(1.0),
2061 let mut loses_info = false;
2062 let test = "1.0".parse::<Double>().unwrap();
2063 let test: Single = test.convert(&mut loses_info).value;
2064 assert_eq!(1.0, test.to_f32());
2065 assert!(!loses_info);
2067 let mut test = "0x1p-53".parse::<X87DoubleExtended>().unwrap();
2068 let one = "1.0".parse::<X87DoubleExtended>().unwrap();
2070 let test: Double = test.convert(&mut loses_info).value;
2071 assert_eq!(1.0, test.to_f64());
2072 assert!(loses_info);
2074 let mut test = "0x1p-53".parse::<Quad>().unwrap();
2075 let one = "1.0".parse::<Quad>().unwrap();
2077 let test: Double = test.convert(&mut loses_info).value;
2078 assert_eq!(1.0, test.to_f64());
2079 assert!(loses_info);
2081 let test = "0xf.fffffffp+28".parse::<X87DoubleExtended>().unwrap();
2082 let test: Double = test.convert(&mut loses_info).value;
2083 assert_eq!(4294967295.0, test.to_f64());
2084 assert!(!loses_info);
2086 let test = Single::snan(None);
2087 let x87_snan = X87DoubleExtended::snan(None);
2088 let test: X87DoubleExtended = test.convert(&mut loses_info).value;
2089 assert!(test.bitwise_eq(x87_snan));
2090 assert!(!loses_info);
2092 let test = Single::qnan(None);
2093 let x87_qnan = X87DoubleExtended::qnan(None);
2094 let test: X87DoubleExtended = test.convert(&mut loses_info).value;
2095 assert!(test.bitwise_eq(x87_qnan));
2096 assert!(!loses_info);
2098 let test = X87DoubleExtended::snan(None);
2099 let test: X87DoubleExtended = test.convert(&mut loses_info).value;
2100 assert!(test.bitwise_eq(x87_snan));
2101 assert!(!loses_info);
2103 let test = X87DoubleExtended::qnan(None);
2104 let test: X87DoubleExtended = test.convert(&mut loses_info).value;
2105 assert!(test.bitwise_eq(x87_qnan));
2106 assert!(!loses_info);
2111 let t = "0x1p+0".parse::<Single>().unwrap();
2112 assert!(!t.is_negative());
2113 let t = "-0x1p+0".parse::<Single>().unwrap();
2114 assert!(t.is_negative());
2116 assert!(!Single::INFINITY.is_negative());
2117 assert!((-Single::INFINITY).is_negative());
2119 assert!(!Single::ZERO.is_negative());
2120 assert!((-Single::ZERO).is_negative());
2122 assert!(!Single::NAN.is_negative());
2123 assert!((-Single::NAN).is_negative());
2125 assert!(!Single::snan(None).is_negative());
2126 assert!((-Single::snan(None)).is_negative());
2131 let t = "0x1p+0".parse::<Single>().unwrap();
2132 assert!(t.is_normal());
2134 assert!(!Single::INFINITY.is_normal());
2135 assert!(!Single::ZERO.is_normal());
2136 assert!(!Single::NAN.is_normal());
2137 assert!(!Single::snan(None).is_normal());
2138 assert!(!"0x1p-149".parse::<Single>().unwrap().is_normal());
2143 let t = "0x1p+0".parse::<Single>().unwrap();
2144 assert!(t.is_finite());
2145 assert!(!Single::INFINITY.is_finite());
2146 assert!(Single::ZERO.is_finite());
2147 assert!(!Single::NAN.is_finite());
2148 assert!(!Single::snan(None).is_finite());
2149 assert!("0x1p-149".parse::<Single>().unwrap().is_finite());
2154 let t = "0x1p+0".parse::<Single>().unwrap();
2155 assert!(!t.is_infinite());
2156 assert!(Single::INFINITY.is_infinite());
2157 assert!(!Single::ZERO.is_infinite());
2158 assert!(!Single::NAN.is_infinite());
2159 assert!(!Single::snan(None).is_infinite());
2160 assert!(!"0x1p-149".parse::<Single>().unwrap().is_infinite());
2165 let t = "0x1p+0".parse::<Single>().unwrap();
2166 assert!(!t.is_nan());
2167 assert!(!Single::INFINITY.is_nan());
2168 assert!(!Single::ZERO.is_nan());
2169 assert!(Single::NAN.is_nan());
2170 assert!(Single::snan(None).is_nan());
2171 assert!(!"0x1p-149".parse::<Single>().unwrap().is_nan());
2175 fn is_finite_non_zero() {
2176 // Test positive/negative normal value.
2177 assert!("0x1p+0".parse::<Single>().unwrap().is_finite_non_zero());
2178 assert!("-0x1p+0".parse::<Single>().unwrap().is_finite_non_zero());
2180 // Test positive/negative denormal value.
2181 assert!("0x1p-149".parse::<Single>().unwrap().is_finite_non_zero());
2182 assert!("-0x1p-149".parse::<Single>().unwrap().is_finite_non_zero());
2184 // Test +/- Infinity.
2185 assert!(!Single::INFINITY.is_finite_non_zero());
2186 assert!(!(-Single::INFINITY).is_finite_non_zero());
2189 assert!(!Single::ZERO.is_finite_non_zero());
2190 assert!(!(-Single::ZERO).is_finite_non_zero());
2192 // Test +/- qNaN. +/- don't mean anything with qNaN but paranoia can't hurt in
2194 assert!(!Single::NAN.is_finite_non_zero());
2195 assert!(!(-Single::NAN).is_finite_non_zero());
2197 // Test +/- sNaN. +/- don't mean anything with sNaN but paranoia can't hurt in
2199 assert!(!Single::snan(None).is_finite_non_zero());
2200 assert!(!(-Single::snan(None)).is_finite_non_zero());
2205 // Test Special Cases against each other and normal values.
2208 // 1. Since we perform only default exception handling all operations with
2209 // signaling NaNs should have a result that is a quiet NaN. Currently they
2212 let p_inf = Single::INFINITY;
2213 let m_inf = -Single::INFINITY;
2214 let p_zero = Single::ZERO;
2215 let m_zero = -Single::ZERO;
2216 let qnan = Single::NAN;
2217 let p_normal_value = "0x1p+0".parse::<Single>().unwrap();
2218 let m_normal_value = "-0x1p+0".parse::<Single>().unwrap();
2219 let p_largest_value = Single::largest();
2220 let m_largest_value = -Single::largest();
2221 let p_smallest_value = Single::SMALLEST;
2222 let m_smallest_value = -Single::SMALLEST;
2223 let p_smallest_normalized = Single::smallest_normalized();
2224 let m_smallest_normalized = -Single::smallest_normalized();
2226 let overflow_status = Status::OVERFLOW | Status::INEXACT;
2228 let special_cases = [
2229 (p_inf, p_inf, "inf", Status::OK, Category::Infinity),
2230 (p_inf, m_inf, "nan", Status::INVALID_OP, Category::NaN),
2231 (p_inf, p_zero, "inf", Status::OK, Category::Infinity),
2232 (p_inf, m_zero, "inf", Status::OK, Category::Infinity),
2233 (p_inf, qnan, "nan", Status::OK, Category::NaN),
2236 (p_inf, snan, "nan", Status::INVALID_OP, Category::NaN),
2238 (p_inf, p_normal_value, "inf", Status::OK, Category::Infinity),
2239 (p_inf, m_normal_value, "inf", Status::OK, Category::Infinity),
2270 p_smallest_normalized,
2277 m_smallest_normalized,
2282 (m_inf, p_inf, "nan", Status::INVALID_OP, Category::NaN),
2283 (m_inf, m_inf, "-inf", Status::OK, Category::Infinity),
2284 (m_inf, p_zero, "-inf", Status::OK, Category::Infinity),
2285 (m_inf, m_zero, "-inf", Status::OK, Category::Infinity),
2286 (m_inf, qnan, "nan", Status::OK, Category::NaN),
2289 (m_inf, snan, "nan", Status::INVALID_OP, Category::NaN),
2335 p_smallest_normalized,
2342 m_smallest_normalized,
2347 (p_zero, p_inf, "inf", Status::OK, Category::Infinity),
2348 (p_zero, m_inf, "-inf", Status::OK, Category::Infinity),
2349 (p_zero, p_zero, "0x0p+0", Status::OK, Category::Zero),
2350 (p_zero, m_zero, "0x0p+0", Status::OK, Category::Zero),
2351 (p_zero, qnan, "nan", Status::OK, Category::NaN),
2354 (p_zero, snan, "nan", Status::INVALID_OP, Category::NaN),
2400 p_smallest_normalized,
2407 m_smallest_normalized,
2412 (m_zero, p_inf, "inf", Status::OK, Category::Infinity),
2413 (m_zero, m_inf, "-inf", Status::OK, Category::Infinity),
2414 (m_zero, p_zero, "0x0p+0", Status::OK, Category::Zero),
2415 (m_zero, m_zero, "-0x0p+0", Status::OK, Category::Zero),
2416 (m_zero, qnan, "nan", Status::OK, Category::NaN),
2419 (m_zero, snan, "nan", Status::INVALID_OP, Category::NaN),
2465 p_smallest_normalized,
2472 m_smallest_normalized,
2477 (qnan, p_inf, "nan", Status::OK, Category::NaN),
2478 (qnan, m_inf, "nan", Status::OK, Category::NaN),
2479 (qnan, p_zero, "nan", Status::OK, Category::NaN),
2480 (qnan, m_zero, "nan", Status::OK, Category::NaN),
2481 (qnan, qnan, "nan", Status::OK, Category::NaN),
2484 (qnan, snan, "nan", Status::INVALID_OP, Category::NaN),
2486 (qnan, p_normal_value, "nan", Status::OK, Category::NaN),
2487 (qnan, m_normal_value, "nan", Status::OK, Category::NaN),
2488 (qnan, p_largest_value, "nan", Status::OK, Category::NaN),
2489 (qnan, m_largest_value, "nan", Status::OK, Category::NaN),
2490 (qnan, p_smallest_value, "nan", Status::OK, Category::NaN),
2491 (qnan, m_smallest_value, "nan", Status::OK, Category::NaN),
2494 p_smallest_normalized,
2501 m_smallest_normalized,
2508 (snan, p_inf, "nan", Status::INVALID_OP, Category::NaN),
2509 (snan, m_inf, "nan", Status::INVALID_OP, Category::NaN),
2510 (snan, p_zero, "nan", Status::INVALID_OP, Category::NaN),
2511 (snan, m_zero, "nan", Status::INVALID_OP, Category::NaN),
2512 (snan, qnan, "nan", Status::INVALID_OP, Category::NaN),
2513 (snan, snan, "nan", Status::INVALID_OP, Category::NaN),
2514 (snan, p_normal_value, "nan", Status::INVALID_OP, Category::NaN),
2515 (snan, m_normal_value, "nan", Status::INVALID_OP, Category::NaN),
2516 (snan, p_largest_value, "nan", Status::INVALID_OP, Category::NaN),
2517 (snan, m_largest_value, "nan", Status::INVALID_OP, Category::NaN),
2518 (snan, p_smallest_value, "nan", Status::INVALID_OP, Category::NaN),
2519 (snan, m_smallest_value, "nan", Status::INVALID_OP, Category::NaN),
2520 (snan, p_smallest_normalized, "nan", Status::INVALID_OP, Category::NaN),
2521 (snan, m_smallest_normalized, "nan", Status::INVALID_OP, Category::NaN),
2523 (p_normal_value, p_inf, "inf", Status::OK, Category::Infinity),
2545 (p_normal_value, qnan, "nan", Status::OK, Category::NaN),
2548 (p_normal_value, snan, "nan", Status::INVALID_OP, Category::NaN),
2594 p_smallest_normalized,
2601 m_smallest_normalized,
2606 (m_normal_value, p_inf, "inf", Status::OK, Category::Infinity),
2628 (m_normal_value, qnan, "nan", Status::OK, Category::NaN),
2631 (m_normal_value, snan, "nan", Status::INVALID_OP, Category::NaN),
2677 p_smallest_normalized,
2684 m_smallest_normalized,
2717 (p_largest_value, qnan, "nan", Status::OK, Category::NaN),
2720 (p_largest_value, snan, "nan", Status::INVALID_OP, Category::NaN),
2766 p_smallest_normalized,
2773 m_smallest_normalized,
2806 (m_largest_value, qnan, "nan", Status::OK, Category::NaN),
2809 (m_largest_value, snan, "nan", Status::INVALID_OP, Category::NaN),
2855 p_smallest_normalized,
2862 m_smallest_normalized,
2895 (p_smallest_value, qnan, "nan", Status::OK, Category::NaN),
2898 (p_smallest_value, snan, "nan", Status::INVALID_OP, Category::NaN),
2944 p_smallest_normalized,
2951 m_smallest_normalized,
2984 (m_smallest_value, qnan, "nan", Status::OK, Category::NaN),
2987 (m_smallest_value, snan, "nan", Status::INVALID_OP, Category::NaN),
3033 p_smallest_normalized,
3040 m_smallest_normalized,
3046 p_smallest_normalized,
3053 p_smallest_normalized,
3060 p_smallest_normalized,
3067 p_smallest_normalized,
3074 p_smallest_normalized,
3082 (p_smallest_normalized, snan, "nan", Status::INVALID_OP, Category::NaN),
3085 p_smallest_normalized,
3092 p_smallest_normalized,
3099 p_smallest_normalized,
3106 p_smallest_normalized,
3113 p_smallest_normalized,
3120 p_smallest_normalized,
3127 p_smallest_normalized,
3128 p_smallest_normalized,
3134 p_smallest_normalized,
3135 m_smallest_normalized,
3141 m_smallest_normalized,
3148 m_smallest_normalized,
3155 m_smallest_normalized,
3162 m_smallest_normalized,
3169 m_smallest_normalized,
3177 (m_smallest_normalized, snan, "nan", Status::INVALID_OP, Category::NaN),
3180 m_smallest_normalized,
3187 m_smallest_normalized,
3194 m_smallest_normalized,
3201 m_smallest_normalized,
3208 m_smallest_normalized,
3215 m_smallest_normalized,
3222 m_smallest_normalized,
3223 p_smallest_normalized,
3229 m_smallest_normalized,
3230 m_smallest_normalized,
3237 for &(x, y, e_result, e_status, e_category) in &special_cases[..] {
3239 let result = unpack!(status=, x + y);
3240 assert_eq!(status, e_status);
3241 assert_eq!(result.category(), e_category);
3242 assert!(result.bitwise_eq(e_result.parse::<Single>().unwrap()));
3248 // Test Special Cases against each other and normal values.
3251 // 1. Since we perform only default exception handling all operations with
3252 // signaling NaNs should have a result that is a quiet NaN. Currently they
3255 let p_inf = Single::INFINITY;
3256 let m_inf = -Single::INFINITY;
3257 let p_zero = Single::ZERO;
3258 let m_zero = -Single::ZERO;
3259 let qnan = Single::NAN;
3260 let p_normal_value = "0x1p+0".parse::<Single>().unwrap();
3261 let m_normal_value = "-0x1p+0".parse::<Single>().unwrap();
3262 let p_largest_value = Single::largest();
3263 let m_largest_value = -Single::largest();
3264 let p_smallest_value = Single::SMALLEST;
3265 let m_smallest_value = -Single::SMALLEST;
3266 let p_smallest_normalized = Single::smallest_normalized();
3267 let m_smallest_normalized = -Single::smallest_normalized();
3269 let overflow_status = Status::OVERFLOW | Status::INEXACT;
3271 let special_cases = [
3272 (p_inf, p_inf, "nan", Status::INVALID_OP, Category::NaN),
3273 (p_inf, m_inf, "inf", Status::OK, Category::Infinity),
3274 (p_inf, p_zero, "inf", Status::OK, Category::Infinity),
3275 (p_inf, m_zero, "inf", Status::OK, Category::Infinity),
3276 (p_inf, qnan, "-nan", Status::OK, Category::NaN),
3279 (p_inf, snan, "-nan", Status::INVALID_OP, Category::NaN),
3281 (p_inf, p_normal_value, "inf", Status::OK, Category::Infinity),
3282 (p_inf, m_normal_value, "inf", Status::OK, Category::Infinity),
3313 p_smallest_normalized,
3320 m_smallest_normalized,
3325 (m_inf, p_inf, "-inf", Status::OK, Category::Infinity),
3326 (m_inf, m_inf, "nan", Status::INVALID_OP, Category::NaN),
3327 (m_inf, p_zero, "-inf", Status::OK, Category::Infinity),
3328 (m_inf, m_zero, "-inf", Status::OK, Category::Infinity),
3329 (m_inf, qnan, "-nan", Status::OK, Category::NaN),
3332 (m_inf, snan, "-nan", Status::INVALID_OP, Category::NaN),
3378 p_smallest_normalized,
3385 m_smallest_normalized,
3390 (p_zero, p_inf, "-inf", Status::OK, Category::Infinity),
3391 (p_zero, m_inf, "inf", Status::OK, Category::Infinity),
3392 (p_zero, p_zero, "0x0p+0", Status::OK, Category::Zero),
3393 (p_zero, m_zero, "0x0p+0", Status::OK, Category::Zero),
3394 (p_zero, qnan, "-nan", Status::OK, Category::NaN),
3397 (p_zero, snan, "-nan", Status::INVALID_OP, Category::NaN),
3443 p_smallest_normalized,
3450 m_smallest_normalized,
3455 (m_zero, p_inf, "-inf", Status::OK, Category::Infinity),
3456 (m_zero, m_inf, "inf", Status::OK, Category::Infinity),
3457 (m_zero, p_zero, "-0x0p+0", Status::OK, Category::Zero),
3458 (m_zero, m_zero, "0x0p+0", Status::OK, Category::Zero),
3459 (m_zero, qnan, "-nan", Status::OK, Category::NaN),
3462 (m_zero, snan, "-nan", Status::INVALID_OP, Category::NaN),
3508 p_smallest_normalized,
3515 m_smallest_normalized,
3520 (qnan, p_inf, "nan", Status::OK, Category::NaN),
3521 (qnan, m_inf, "nan", Status::OK, Category::NaN),
3522 (qnan, p_zero, "nan", Status::OK, Category::NaN),
3523 (qnan, m_zero, "nan", Status::OK, Category::NaN),
3524 (qnan, qnan, "nan", Status::OK, Category::NaN),
3527 (qnan, snan, "nan", Status::INVALID_OP, Category::NaN),
3529 (qnan, p_normal_value, "nan", Status::OK, Category::NaN),
3530 (qnan, m_normal_value, "nan", Status::OK, Category::NaN),
3531 (qnan, p_largest_value, "nan", Status::OK, Category::NaN),
3532 (qnan, m_largest_value, "nan", Status::OK, Category::NaN),
3533 (qnan, p_smallest_value, "nan", Status::OK, Category::NaN),
3534 (qnan, m_smallest_value, "nan", Status::OK, Category::NaN),
3537 p_smallest_normalized,
3544 m_smallest_normalized,
3551 (snan, p_inf, "nan", Status::INVALID_OP, Category::NaN),
3552 (snan, m_inf, "nan", Status::INVALID_OP, Category::NaN),
3553 (snan, p_zero, "nan", Status::INVALID_OP, Category::NaN),
3554 (snan, m_zero, "nan", Status::INVALID_OP, Category::NaN),
3555 (snan, qnan, "nan", Status::INVALID_OP, Category::NaN),
3556 (snan, snan, "nan", Status::INVALID_OP, Category::NaN),
3557 (snan, p_normal_value, "nan", Status::INVALID_OP, Category::NaN),
3558 (snan, m_normal_value, "nan", Status::INVALID_OP, Category::NaN),
3559 (snan, p_largest_value, "nan", Status::INVALID_OP, Category::NaN),
3560 (snan, m_largest_value, "nan", Status::INVALID_OP, Category::NaN),
3561 (snan, p_smallest_value, "nan", Status::INVALID_OP, Category::NaN),
3562 (snan, m_smallest_value, "nan", Status::INVALID_OP, Category::NaN),
3563 (snan, p_smallest_normalized, "nan", Status::INVALID_OP, Category::NaN),
3564 (snan, m_smallest_normalized, "nan", Status::INVALID_OP, Category::NaN),
3573 (p_normal_value, m_inf, "inf", Status::OK, Category::Infinity),
3588 (p_normal_value, qnan, "-nan", Status::OK, Category::NaN),
3591 (p_normal_value, snan, "-nan", Status::INVALID_OP, Category::NaN),
3637 p_smallest_normalized,
3644 m_smallest_normalized,
3656 (m_normal_value, m_inf, "inf", Status::OK, Category::Infinity),
3671 (m_normal_value, qnan, "-nan", Status::OK, Category::NaN),
3674 (m_normal_value, snan, "-nan", Status::INVALID_OP, Category::NaN),
3720 p_smallest_normalized,
3727 m_smallest_normalized,
3760 (p_largest_value, qnan, "-nan", Status::OK, Category::NaN),
3763 (p_largest_value, snan, "-nan", Status::INVALID_OP, Category::NaN),
3809 p_smallest_normalized,
3816 m_smallest_normalized,
3849 (m_largest_value, qnan, "-nan", Status::OK, Category::NaN),
3852 (m_largest_value, snan, "-nan", Status::INVALID_OP, Category::NaN),
3898 p_smallest_normalized,
3905 m_smallest_normalized,
3938 (p_smallest_value, qnan, "-nan", Status::OK, Category::NaN),
3941 (p_smallest_value, snan, "-nan", Status::INVALID_OP, Category::NaN),
3987 p_smallest_normalized,
3994 m_smallest_normalized,
4027 (m_smallest_value, qnan, "-nan", Status::OK, Category::NaN),
4030 (m_smallest_value, snan, "-nan", Status::INVALID_OP, Category::NaN),
4076 p_smallest_normalized,
4083 m_smallest_normalized,
4089 p_smallest_normalized,
4096 p_smallest_normalized,
4103 p_smallest_normalized,
4110 p_smallest_normalized,
4117 p_smallest_normalized,
4125 (p_smallest_normalized, snan, "-nan", Status::INVALID_OP, Category::NaN),
4128 p_smallest_normalized,
4135 p_smallest_normalized,
4142 p_smallest_normalized,
4149 p_smallest_normalized,
4156 p_smallest_normalized,
4163 p_smallest_normalized,
4170 p_smallest_normalized,
4171 p_smallest_normalized,
4177 p_smallest_normalized,
4178 m_smallest_normalized,
4184 m_smallest_normalized,
4191 m_smallest_normalized,
4198 m_smallest_normalized,
4205 m_smallest_normalized,
4212 m_smallest_normalized,
4220 (m_smallest_normalized, snan, "-nan", Status::INVALID_OP, Category::NaN),
4223 m_smallest_normalized,
4230 m_smallest_normalized,
4237 m_smallest_normalized,
4244 m_smallest_normalized,
4251 m_smallest_normalized,
4258 m_smallest_normalized,
4265 m_smallest_normalized,
4266 p_smallest_normalized,
4272 m_smallest_normalized,
4273 m_smallest_normalized,
4280 for &(x, y, e_result, e_status, e_category) in &special_cases[..] {
4282 let result = unpack!(status=, x - y);
4283 assert_eq!(status, e_status);
4284 assert_eq!(result.category(), e_category);
4285 assert!(result.bitwise_eq(e_result.parse::<Single>().unwrap()));
4291 // Test Special Cases against each other and normal values.
4294 // 1. Since we perform only default exception handling all operations with
4295 // signaling NaNs should have a result that is a quiet NaN. Currently they
4298 let p_inf = Single::INFINITY;
4299 let m_inf = -Single::INFINITY;
4300 let p_zero = Single::ZERO;
4301 let m_zero = -Single::ZERO;
4302 let qnan = Single::NAN;
4303 let p_normal_value = "0x1p+0".parse::<Single>().unwrap();
4304 let m_normal_value = "-0x1p+0".parse::<Single>().unwrap();
4305 let p_largest_value = Single::largest();
4306 let m_largest_value = -Single::largest();
4307 let p_smallest_value = Single::SMALLEST;
4308 let m_smallest_value = -Single::SMALLEST;
4309 let p_smallest_normalized = Single::smallest_normalized();
4310 let m_smallest_normalized = -Single::smallest_normalized();
4312 let overflow_status = Status::OVERFLOW | Status::INEXACT;
4313 let underflow_status = Status::UNDERFLOW | Status::INEXACT;
4315 let special_cases = [
4316 (p_inf, p_inf, "inf", Status::OK, Category::Infinity),
4317 (p_inf, m_inf, "-inf", Status::OK, Category::Infinity),
4318 (p_inf, p_zero, "nan", Status::INVALID_OP, Category::NaN),
4319 (p_inf, m_zero, "nan", Status::INVALID_OP, Category::NaN),
4320 (p_inf, qnan, "nan", Status::OK, Category::NaN),
4323 (p_inf, snan, "nan", Status::INVALID_OP, Category::NaN),
4325 (p_inf, p_normal_value, "inf", Status::OK, Category::Infinity),
4363 p_smallest_normalized,
4370 m_smallest_normalized,
4375 (m_inf, p_inf, "-inf", Status::OK, Category::Infinity),
4376 (m_inf, m_inf, "inf", Status::OK, Category::Infinity),
4377 (m_inf, p_zero, "nan", Status::INVALID_OP, Category::NaN),
4378 (m_inf, m_zero, "nan", Status::INVALID_OP, Category::NaN),
4379 (m_inf, qnan, "nan", Status::OK, Category::NaN),
4382 (m_inf, snan, "nan", Status::INVALID_OP, Category::NaN),
4391 (m_inf, m_normal_value, "inf", Status::OK, Category::Infinity),
4422 p_smallest_normalized,
4429 m_smallest_normalized,
4434 (p_zero, p_inf, "nan", Status::INVALID_OP, Category::NaN),
4435 (p_zero, m_inf, "nan", Status::INVALID_OP, Category::NaN),
4436 (p_zero, p_zero, "0x0p+0", Status::OK, Category::Zero),
4437 (p_zero, m_zero, "-0x0p+0", Status::OK, Category::Zero),
4438 (p_zero, qnan, "nan", Status::OK, Category::NaN),
4441 (p_zero, snan, "nan", Status::INVALID_OP, Category::NaN),
4443 (p_zero, p_normal_value, "0x0p+0", Status::OK, Category::Zero),
4481 p_smallest_normalized,
4488 m_smallest_normalized,
4493 (m_zero, p_inf, "nan", Status::INVALID_OP, Category::NaN),
4494 (m_zero, m_inf, "nan", Status::INVALID_OP, Category::NaN),
4495 (m_zero, p_zero, "-0x0p+0", Status::OK, Category::Zero),
4496 (m_zero, m_zero, "0x0p+0", Status::OK, Category::Zero),
4497 (m_zero, qnan, "nan", Status::OK, Category::NaN),
4500 (m_zero, snan, "nan", Status::INVALID_OP, Category::NaN),
4509 (m_zero, m_normal_value, "0x0p+0", Status::OK, Category::Zero),
4540 p_smallest_normalized,
4547 m_smallest_normalized,
4552 (qnan, p_inf, "nan", Status::OK, Category::NaN),
4553 (qnan, m_inf, "nan", Status::OK, Category::NaN),
4554 (qnan, p_zero, "nan", Status::OK, Category::NaN),
4555 (qnan, m_zero, "nan", Status::OK, Category::NaN),
4556 (qnan, qnan, "nan", Status::OK, Category::NaN),
4559 (qnan, snan, "nan", Status::INVALID_OP, Category::NaN),
4561 (qnan, p_normal_value, "nan", Status::OK, Category::NaN),
4562 (qnan, m_normal_value, "nan", Status::OK, Category::NaN),
4563 (qnan, p_largest_value, "nan", Status::OK, Category::NaN),
4564 (qnan, m_largest_value, "nan", Status::OK, Category::NaN),
4565 (qnan, p_smallest_value, "nan", Status::OK, Category::NaN),
4566 (qnan, m_smallest_value, "nan", Status::OK, Category::NaN),
4569 p_smallest_normalized,
4576 m_smallest_normalized,
4583 (snan, p_inf, "nan", Status::INVALID_OP, Category::NaN),
4584 (snan, m_inf, "nan", Status::INVALID_OP, Category::NaN),
4585 (snan, p_zero, "nan", Status::INVALID_OP, Category::NaN),
4586 (snan, m_zero, "nan", Status::INVALID_OP, Category::NaN),
4587 (snan, qnan, "nan", Status::INVALID_OP, Category::NaN),
4588 (snan, snan, "nan", Status::INVALID_OP, Category::NaN),
4589 (snan, p_normal_value, "nan", Status::INVALID_OP, Category::NaN),
4590 (snan, m_normal_value, "nan", Status::INVALID_OP, Category::NaN),
4591 (snan, p_largest_value, "nan", Status::INVALID_OP, Category::NaN),
4592 (snan, m_largest_value, "nan", Status::INVALID_OP, Category::NaN),
4593 (snan, p_smallest_value, "nan", Status::INVALID_OP, Category::NaN),
4594 (snan, m_smallest_value, "nan", Status::INVALID_OP, Category::NaN),
4595 (snan, p_smallest_normalized, "nan", Status::INVALID_OP, Category::NaN),
4596 (snan, m_smallest_normalized, "nan", Status::INVALID_OP, Category::NaN),
4598 (p_normal_value, p_inf, "inf", Status::OK, Category::Infinity),
4606 (p_normal_value, p_zero, "0x0p+0", Status::OK, Category::Zero),
4614 (p_normal_value, qnan, "nan", Status::OK, Category::NaN),
4617 (p_normal_value, snan, "nan", Status::INVALID_OP, Category::NaN),
4663 p_smallest_normalized,
4670 m_smallest_normalized,
4682 (m_normal_value, m_inf, "inf", Status::OK, Category::Infinity),
4690 (m_normal_value, m_zero, "0x0p+0", Status::OK, Category::Zero),
4691 (m_normal_value, qnan, "nan", Status::OK, Category::NaN),
4694 (m_normal_value, snan, "nan", Status::INVALID_OP, Category::NaN),
4740 p_smallest_normalized,
4747 m_smallest_normalized,
4780 (p_largest_value, qnan, "nan", Status::OK, Category::NaN),
4783 (p_largest_value, snan, "nan", Status::INVALID_OP, Category::NaN),
4829 p_smallest_normalized,
4836 m_smallest_normalized,
4869 (m_largest_value, qnan, "nan", Status::OK, Category::NaN),
4872 (m_largest_value, snan, "nan", Status::INVALID_OP, Category::NaN),
4918 p_smallest_normalized,
4925 m_smallest_normalized,
4958 (p_smallest_value, qnan, "nan", Status::OK, Category::NaN),
4961 (p_smallest_value, snan, "nan", Status::INVALID_OP, Category::NaN),
5007 p_smallest_normalized,
5014 m_smallest_normalized,
5047 (m_smallest_value, qnan, "nan", Status::OK, Category::NaN),
5050 (m_smallest_value, snan, "nan", Status::INVALID_OP, Category::NaN),
5096 p_smallest_normalized,
5103 m_smallest_normalized,
5109 p_smallest_normalized,
5116 p_smallest_normalized,
5123 p_smallest_normalized,
5130 p_smallest_normalized,
5137 p_smallest_normalized,
5145 (p_smallest_normalized, snan, "nan", Status::INVALID_OP, Category::NaN),
5148 p_smallest_normalized,
5155 p_smallest_normalized,
5162 p_smallest_normalized,
5169 p_smallest_normalized,
5176 p_smallest_normalized,
5183 p_smallest_normalized,
5190 p_smallest_normalized,
5191 p_smallest_normalized,
5197 p_smallest_normalized,
5198 m_smallest_normalized,
5204 m_smallest_normalized,
5211 m_smallest_normalized,
5218 m_smallest_normalized,
5225 m_smallest_normalized,
5232 m_smallest_normalized,
5240 (m_smallest_normalized, snan, "nan", Status::INVALID_OP, Category::NaN),
5243 m_smallest_normalized,
5250 m_smallest_normalized,
5257 m_smallest_normalized,
5264 m_smallest_normalized,
5271 m_smallest_normalized,
5278 m_smallest_normalized,
5285 m_smallest_normalized,
5286 p_smallest_normalized,
5292 m_smallest_normalized,
5293 m_smallest_normalized,
5300 for &(x, y, e_result, e_status, e_category) in &special_cases[..] {
5302 let result = unpack!(status=, x * y);
5303 assert_eq!(status, e_status);
5304 assert_eq!(result.category(), e_category);
5305 assert!(result.bitwise_eq(e_result.parse::<Single>().unwrap()));
5311 // Test Special Cases against each other and normal values.
5314 // 1. Since we perform only default exception handling all operations with
5315 // signaling NaNs should have a result that is a quiet NaN. Currently they
5318 let p_inf = Single::INFINITY;
5319 let m_inf = -Single::INFINITY;
5320 let p_zero = Single::ZERO;
5321 let m_zero = -Single::ZERO;
5322 let qnan = Single::NAN;
5323 let p_normal_value = "0x1p+0".parse::<Single>().unwrap();
5324 let m_normal_value = "-0x1p+0".parse::<Single>().unwrap();
5325 let p_largest_value = Single::largest();
5326 let m_largest_value = -Single::largest();
5327 let p_smallest_value = Single::SMALLEST;
5328 let m_smallest_value = -Single::SMALLEST;
5329 let p_smallest_normalized = Single::smallest_normalized();
5330 let m_smallest_normalized = -Single::smallest_normalized();
5332 let overflow_status = Status::OVERFLOW | Status::INEXACT;
5333 let underflow_status = Status::UNDERFLOW | Status::INEXACT;
5335 let special_cases = [
5336 (p_inf, p_inf, "nan", Status::INVALID_OP, Category::NaN),
5337 (p_inf, m_inf, "nan", Status::INVALID_OP, Category::NaN),
5338 (p_inf, p_zero, "inf", Status::OK, Category::Infinity),
5339 (p_inf, m_zero, "-inf", Status::OK, Category::Infinity),
5340 (p_inf, qnan, "nan", Status::OK, Category::NaN),
5343 (p_inf, snan, "nan", Status::INVALID_OP, Category::NaN),
5345 (p_inf, p_normal_value, "inf", Status::OK, Category::Infinity),
5383 p_smallest_normalized,
5390 m_smallest_normalized,
5395 (m_inf, p_inf, "nan", Status::INVALID_OP, Category::NaN),
5396 (m_inf, m_inf, "nan", Status::INVALID_OP, Category::NaN),
5397 (m_inf, p_zero, "-inf", Status::OK, Category::Infinity),
5398 (m_inf, m_zero, "inf", Status::OK, Category::Infinity),
5399 (m_inf, qnan, "nan", Status::OK, Category::NaN),
5402 (m_inf, snan, "nan", Status::INVALID_OP, Category::NaN),
5411 (m_inf, m_normal_value, "inf", Status::OK, Category::Infinity),
5442 p_smallest_normalized,
5449 m_smallest_normalized,
5454 (p_zero, p_inf, "0x0p+0", Status::OK, Category::Zero),
5455 (p_zero, m_inf, "-0x0p+0", Status::OK, Category::Zero),
5456 (p_zero, p_zero, "nan", Status::INVALID_OP, Category::NaN),
5457 (p_zero, m_zero, "nan", Status::INVALID_OP, Category::NaN),
5458 (p_zero, qnan, "nan", Status::OK, Category::NaN),
5461 (p_zero, snan, "nan", Status::INVALID_OP, Category::NaN),
5463 (p_zero, p_normal_value, "0x0p+0", Status::OK, Category::Zero),
5501 p_smallest_normalized,
5508 m_smallest_normalized,
5513 (m_zero, p_inf, "-0x0p+0", Status::OK, Category::Zero),
5514 (m_zero, m_inf, "0x0p+0", Status::OK, Category::Zero),
5515 (m_zero, p_zero, "nan", Status::INVALID_OP, Category::NaN),
5516 (m_zero, m_zero, "nan", Status::INVALID_OP, Category::NaN),
5517 (m_zero, qnan, "nan", Status::OK, Category::NaN),
5520 (m_zero, snan, "nan", Status::INVALID_OP, Category::NaN),
5529 (m_zero, m_normal_value, "0x0p+0", Status::OK, Category::Zero),
5560 p_smallest_normalized,
5567 m_smallest_normalized,
5572 (qnan, p_inf, "nan", Status::OK, Category::NaN),
5573 (qnan, m_inf, "nan", Status::OK, Category::NaN),
5574 (qnan, p_zero, "nan", Status::OK, Category::NaN),
5575 (qnan, m_zero, "nan", Status::OK, Category::NaN),
5576 (qnan, qnan, "nan", Status::OK, Category::NaN),
5579 (qnan, snan, "nan", Status::INVALID_OP, Category::NaN),
5581 (qnan, p_normal_value, "nan", Status::OK, Category::NaN),
5582 (qnan, m_normal_value, "nan", Status::OK, Category::NaN),
5583 (qnan, p_largest_value, "nan", Status::OK, Category::NaN),
5584 (qnan, m_largest_value, "nan", Status::OK, Category::NaN),
5585 (qnan, p_smallest_value, "nan", Status::OK, Category::NaN),
5586 (qnan, m_smallest_value, "nan", Status::OK, Category::NaN),
5589 p_smallest_normalized,
5596 m_smallest_normalized,
5603 (snan, p_inf, "nan", Status::INVALID_OP, Category::NaN),
5604 (snan, m_inf, "nan", Status::INVALID_OP, Category::NaN),
5605 (snan, p_zero, "nan", Status::INVALID_OP, Category::NaN),
5606 (snan, m_zero, "nan", Status::INVALID_OP, Category::NaN),
5607 (snan, qnan, "nan", Status::INVALID_OP, Category::NaN),
5608 (snan, snan, "nan", Status::INVALID_OP, Category::NaN),
5609 (snan, p_normal_value, "nan", Status::INVALID_OP, Category::NaN),
5610 (snan, m_normal_value, "nan", Status::INVALID_OP, Category::NaN),
5611 (snan, p_largest_value, "nan", Status::INVALID_OP, Category::NaN),
5612 (snan, m_largest_value, "nan", Status::INVALID_OP, Category::NaN),
5613 (snan, p_smallest_value, "nan", Status::INVALID_OP, Category::NaN),
5614 (snan, m_smallest_value, "nan", Status::INVALID_OP, Category::NaN),
5615 (snan, p_smallest_normalized, "nan", Status::INVALID_OP, Category::NaN),
5616 (snan, m_smallest_normalized, "nan", Status::INVALID_OP, Category::NaN),
5618 (p_normal_value, p_inf, "0x0p+0", Status::OK, Category::Zero),
5619 (p_normal_value, m_inf, "-0x0p+0", Status::OK, Category::Zero),
5624 Status::DIV_BY_ZERO,
5631 Status::DIV_BY_ZERO,
5634 (p_normal_value, qnan, "nan", Status::OK, Category::NaN),
5637 (p_normal_value, snan, "nan", Status::INVALID_OP, Category::NaN),
5683 p_smallest_normalized,
5690 m_smallest_normalized,
5695 (m_normal_value, p_inf, "-0x0p+0", Status::OK, Category::Zero),
5696 (m_normal_value, m_inf, "0x0p+0", Status::OK, Category::Zero),
5701 Status::DIV_BY_ZERO,
5708 Status::DIV_BY_ZERO,
5711 (m_normal_value, qnan, "nan", Status::OK, Category::NaN),
5714 (m_normal_value, snan, "nan", Status::INVALID_OP, Category::NaN),
5760 p_smallest_normalized,
5767 m_smallest_normalized,
5772 (p_largest_value, p_inf, "0x0p+0", Status::OK, Category::Zero),
5784 Status::DIV_BY_ZERO,
5791 Status::DIV_BY_ZERO,
5794 (p_largest_value, qnan, "nan", Status::OK, Category::NaN),
5797 (p_largest_value, snan, "nan", Status::INVALID_OP, Category::NaN),
5843 p_smallest_normalized,
5850 m_smallest_normalized,
5862 (m_largest_value, m_inf, "0x0p+0", Status::OK, Category::Zero),
5867 Status::DIV_BY_ZERO,
5874 Status::DIV_BY_ZERO,
5877 (m_largest_value, qnan, "nan", Status::OK, Category::NaN),
5880 (m_largest_value, snan, "nan", Status::INVALID_OP, Category::NaN),
5926 p_smallest_normalized,
5933 m_smallest_normalized,
5956 Status::DIV_BY_ZERO,
5963 Status::DIV_BY_ZERO,
5966 (p_smallest_value, qnan, "nan", Status::OK, Category::NaN),
5969 (p_smallest_value, snan, "nan", Status::INVALID_OP, Category::NaN),
6015 p_smallest_normalized,
6022 m_smallest_normalized,
6045 Status::DIV_BY_ZERO,
6052 Status::DIV_BY_ZERO,
6055 (m_smallest_value, qnan, "nan", Status::OK, Category::NaN),
6058 (m_smallest_value, snan, "nan", Status::INVALID_OP, Category::NaN),
6104 p_smallest_normalized,
6111 m_smallest_normalized,
6117 p_smallest_normalized,
6124 p_smallest_normalized,
6131 p_smallest_normalized,
6134 Status::DIV_BY_ZERO,
6138 p_smallest_normalized,
6141 Status::DIV_BY_ZERO,
6145 p_smallest_normalized,
6153 (p_smallest_normalized, snan, "nan", Status::INVALID_OP, Category::NaN),
6156 p_smallest_normalized,
6163 p_smallest_normalized,
6170 p_smallest_normalized,
6177 p_smallest_normalized,
6184 p_smallest_normalized,
6191 p_smallest_normalized,
6198 p_smallest_normalized,
6199 p_smallest_normalized,
6205 p_smallest_normalized,
6206 m_smallest_normalized,
6212 m_smallest_normalized,
6219 m_smallest_normalized,
6226 m_smallest_normalized,
6229 Status::DIV_BY_ZERO,
6233 m_smallest_normalized,
6236 Status::DIV_BY_ZERO,
6240 m_smallest_normalized,
6248 (m_smallest_normalized, snan, "nan", Status::INVALID_OP, Category::NaN),
6251 m_smallest_normalized,
6258 m_smallest_normalized,
6265 m_smallest_normalized,
6272 m_smallest_normalized,
6279 m_smallest_normalized,
6286 m_smallest_normalized,
6293 m_smallest_normalized,
6294 p_smallest_normalized,
6300 m_smallest_normalized,
6301 m_smallest_normalized,
6308 for &(x, y, e_result, e_status, e_category) in &special_cases[..] {
6310 let result = unpack!(status=, x / y);
6311 assert_eq!(status, e_status);
6312 assert_eq!(result.category(), e_category);
6313 assert!(result.bitwise_eq(e_result.parse::<Single>().unwrap()));
6318 fn operator_overloads() {
6319 // This is mostly testing that these operator overloads compile.
6320 let one = "0x1p+0".parse::<Single>().unwrap();
6321 let two = "0x2p+0".parse::<Single>().unwrap();
6322 assert!(two.bitwise_eq((one + one).value));
6323 assert!(one.bitwise_eq((two - one).value));
6324 assert!(two.bitwise_eq((one * two).value));
6325 assert!(one.bitwise_eq((two / two).value));
6330 let p_inf = Single::INFINITY;
6331 let m_inf = -Single::INFINITY;
6332 let p_zero = Single::ZERO;
6333 let m_zero = -Single::ZERO;
6334 let p_qnan = Single::NAN;
6335 let m_qnan = -Single::NAN;
6336 let p_snan = Single::snan(None);
6337 let m_snan = -Single::snan(None);
6338 let p_normal_value = "0x1p+0".parse::<Single>().unwrap();
6339 let m_normal_value = "-0x1p+0".parse::<Single>().unwrap();
6340 let p_largest_value = Single::largest();
6341 let m_largest_value = -Single::largest();
6342 let p_smallest_value = Single::SMALLEST;
6343 let m_smallest_value = -Single::SMALLEST;
6344 let p_smallest_normalized = Single::smallest_normalized();
6345 let m_smallest_normalized = -Single::smallest_normalized();
6347 assert!(p_inf.bitwise_eq(p_inf.abs()));
6348 assert!(p_inf.bitwise_eq(m_inf.abs()));
6349 assert!(p_zero.bitwise_eq(p_zero.abs()));
6350 assert!(p_zero.bitwise_eq(m_zero.abs()));
6351 assert!(p_qnan.bitwise_eq(p_qnan.abs()));
6352 assert!(p_qnan.bitwise_eq(m_qnan.abs()));
6353 assert!(p_snan.bitwise_eq(p_snan.abs()));
6354 assert!(p_snan.bitwise_eq(m_snan.abs()));
6355 assert!(p_normal_value.bitwise_eq(p_normal_value.abs()));
6356 assert!(p_normal_value.bitwise_eq(m_normal_value.abs()));
6357 assert!(p_largest_value.bitwise_eq(p_largest_value.abs()));
6358 assert!(p_largest_value.bitwise_eq(m_largest_value.abs()));
6359 assert!(p_smallest_value.bitwise_eq(p_smallest_value.abs()));
6360 assert!(p_smallest_value.bitwise_eq(m_smallest_value.abs()));
6361 assert!(p_smallest_normalized.bitwise_eq(
6362 p_smallest_normalized.abs(),
6364 assert!(p_smallest_normalized.bitwise_eq(
6365 m_smallest_normalized.abs(),
6371 let one = "1.0".parse::<Single>().unwrap();
6372 let neg_one = "-1.0".parse::<Single>().unwrap();
6373 let zero = Single::ZERO;
6374 let neg_zero = -Single::ZERO;
6375 let inf = Single::INFINITY;
6376 let neg_inf = -Single::INFINITY;
6377 let qnan = Single::NAN;
6378 let neg_qnan = -Single::NAN;
6380 assert!(neg_one.bitwise_eq(-one));
6381 assert!(one.bitwise_eq(-neg_one));
6382 assert!(neg_zero.bitwise_eq(-zero));
6383 assert!(zero.bitwise_eq(-neg_zero));
6384 assert!(neg_inf.bitwise_eq(-inf));
6385 assert!(inf.bitwise_eq(-neg_inf));
6386 assert!(neg_inf.bitwise_eq(-inf));
6387 assert!(inf.bitwise_eq(-neg_inf));
6388 assert!(neg_qnan.bitwise_eq(-qnan));
6389 assert!(qnan.bitwise_eq(-neg_qnan));
6394 assert_eq!(-1074, Double::SMALLEST.ilogb());
6395 assert_eq!(-1074, (-Double::SMALLEST).ilogb());
6398 "0x1.ffffffffffffep-1024".parse::<Double>().unwrap().ilogb()
6402 "0x1.ffffffffffffep-1023".parse::<Double>().unwrap().ilogb()
6406 "-0x1.ffffffffffffep-1023"
6411 assert_eq!(-51, "0x1p-51".parse::<Double>().unwrap().ilogb());
6414 "0x1.c60f120d9f87cp-1023".parse::<Double>().unwrap().ilogb()
6416 assert_eq!(-2, "0x0.ffffp-1".parse::<Double>().unwrap().ilogb());
6417 assert_eq!(-1023, "0x1.fffep-1023".parse::<Double>().unwrap().ilogb());
6418 assert_eq!(1023, Double::largest().ilogb());
6419 assert_eq!(1023, (-Double::largest()).ilogb());
6422 assert_eq!(0, "0x1p+0".parse::<Single>().unwrap().ilogb());
6423 assert_eq!(0, "-0x1p+0".parse::<Single>().unwrap().ilogb());
6424 assert_eq!(42, "0x1p+42".parse::<Single>().unwrap().ilogb());
6425 assert_eq!(-42, "0x1p-42".parse::<Single>().unwrap().ilogb());
6427 assert_eq!(IEK_INF, Single::INFINITY.ilogb());
6428 assert_eq!(IEK_INF, (-Single::INFINITY).ilogb());
6429 assert_eq!(IEK_ZERO, Single::ZERO.ilogb());
6430 assert_eq!(IEK_ZERO, (-Single::ZERO).ilogb());
6431 assert_eq!(IEK_NAN, Single::NAN.ilogb());
6432 assert_eq!(IEK_NAN, Single::snan(None).ilogb());
6434 assert_eq!(127, Single::largest().ilogb());
6435 assert_eq!(127, (-Single::largest()).ilogb());
6437 assert_eq!(-149, Single::SMALLEST.ilogb());
6438 assert_eq!(-149, (-Single::SMALLEST).ilogb());
6439 assert_eq!(-126, Single::smallest_normalized().ilogb());
6440 assert_eq!(-126, (-Single::smallest_normalized()).ilogb());
6445 assert!("0x1p+0".parse::<Single>().unwrap().bitwise_eq(
6446 "0x1p+0".parse::<Single>().unwrap().scalbn(0),
6448 assert!("0x1p+42".parse::<Single>().unwrap().bitwise_eq(
6449 "0x1p+0".parse::<Single>().unwrap().scalbn(42),
6451 assert!("0x1p-42".parse::<Single>().unwrap().bitwise_eq(
6452 "0x1p+0".parse::<Single>().unwrap().scalbn(-42),
6455 let p_inf = Single::INFINITY;
6456 let m_inf = -Single::INFINITY;
6457 let p_zero = Single::ZERO;
6458 let m_zero = -Single::ZERO;
6459 let p_qnan = Single::NAN;
6460 let m_qnan = -Single::NAN;
6461 let snan = Single::snan(None);
6463 assert!(p_inf.bitwise_eq(p_inf.scalbn(0)));
6464 assert!(m_inf.bitwise_eq(m_inf.scalbn(0)));
6465 assert!(p_zero.bitwise_eq(p_zero.scalbn(0)));
6466 assert!(m_zero.bitwise_eq(m_zero.scalbn(0)));
6467 assert!(p_qnan.bitwise_eq(p_qnan.scalbn(0)));
6468 assert!(m_qnan.bitwise_eq(m_qnan.scalbn(0)));
6469 assert!(!snan.scalbn(0).is_signaling());
6471 let scalbn_snan = snan.scalbn(1);
6472 assert!(scalbn_snan.is_nan() && !scalbn_snan.is_signaling());
6474 // Make sure highest bit of payload is preserved.
6475 let payload = (1 << 50) | (1 << 49) | (1234 << 32) | 1;
6477 let snan_with_payload = Double::snan(Some(payload));
6478 let quiet_payload = snan_with_payload.scalbn(1);
6479 assert!(quiet_payload.is_nan() && !quiet_payload.is_signaling());
6480 assert_eq!(payload, quiet_payload.to_bits() & ((1 << 51) - 1));
6482 assert!(p_inf.bitwise_eq(
6483 "0x1p+0".parse::<Single>().unwrap().scalbn(128),
6485 assert!(m_inf.bitwise_eq(
6486 "-0x1p+0".parse::<Single>().unwrap().scalbn(128),
6488 assert!(p_inf.bitwise_eq(
6489 "0x1p+127".parse::<Single>().unwrap().scalbn(1),
6491 assert!(p_zero.bitwise_eq(
6492 "0x1p-127".parse::<Single>().unwrap().scalbn(-127),
6494 assert!(m_zero.bitwise_eq(
6495 "-0x1p-127".parse::<Single>().unwrap().scalbn(-127),
6497 assert!("-0x1p-149".parse::<Single>().unwrap().bitwise_eq(
6498 "-0x1p-127".parse::<Single>().unwrap().scalbn(-22),
6500 assert!(p_zero.bitwise_eq(
6501 "0x1p-126".parse::<Single>().unwrap().scalbn(-24),
6505 let smallest_f64 = Double::SMALLEST;
6506 let neg_smallest_f64 = -Double::SMALLEST;
6508 let largest_f64 = Double::largest();
6509 let neg_largest_f64 = -Double::largest();
6511 let largest_denormal_f64 = "0x1.ffffffffffffep-1023".parse::<Double>().unwrap();
6512 let neg_largest_denormal_f64 = "-0x1.ffffffffffffep-1023".parse::<Double>().unwrap();
6515 assert!(smallest_f64.bitwise_eq(
6516 "0x1p-1074".parse::<Double>().unwrap().scalbn(0),
6518 assert!(neg_smallest_f64.bitwise_eq(
6519 "-0x1p-1074".parse::<Double>().unwrap().scalbn(0),
6522 assert!("0x1p+1023".parse::<Double>().unwrap().bitwise_eq(
6523 smallest_f64.scalbn(
6528 assert!(smallest_f64.scalbn(-2097).is_pos_zero());
6529 assert!(smallest_f64.scalbn(-2098).is_pos_zero());
6530 assert!(smallest_f64.scalbn(-2099).is_pos_zero());
6531 assert!("0x1p+1022".parse::<Double>().unwrap().bitwise_eq(
6532 smallest_f64.scalbn(
6536 assert!("0x1p+1023".parse::<Double>().unwrap().bitwise_eq(
6537 smallest_f64.scalbn(
6541 assert!(smallest_f64.scalbn(2098).is_infinite());
6542 assert!(smallest_f64.scalbn(2099).is_infinite());
6544 // Test for integer overflows when adding to exponent.
6545 assert!(smallest_f64.scalbn(-ExpInt::max_value()).is_pos_zero());
6546 assert!(largest_f64.scalbn(ExpInt::max_value()).is_infinite());
6548 assert!(largest_denormal_f64.bitwise_eq(
6549 largest_denormal_f64.scalbn(0),
6551 assert!(neg_largest_denormal_f64.bitwise_eq(
6552 neg_largest_denormal_f64.scalbn(0),
6556 "0x1.ffffffffffffep-1022"
6559 .bitwise_eq(largest_denormal_f64.scalbn(1))
6562 "-0x1.ffffffffffffep-1021"
6565 .bitwise_eq(neg_largest_denormal_f64.scalbn(2))
6569 "0x1.ffffffffffffep+1"
6572 .bitwise_eq(largest_denormal_f64.scalbn(1024))
6574 assert!(largest_denormal_f64.scalbn(-1023).is_pos_zero());
6575 assert!(largest_denormal_f64.scalbn(-1024).is_pos_zero());
6576 assert!(largest_denormal_f64.scalbn(-2048).is_pos_zero());
6577 assert!(largest_denormal_f64.scalbn(2047).is_infinite());
6578 assert!(largest_denormal_f64.scalbn(2098).is_infinite());
6579 assert!(largest_denormal_f64.scalbn(2099).is_infinite());
6582 "0x1.ffffffffffffep-2"
6585 .bitwise_eq(largest_denormal_f64.scalbn(1021))
6588 "0x1.ffffffffffffep-1"
6591 .bitwise_eq(largest_denormal_f64.scalbn(1022))
6594 "0x1.ffffffffffffep+0"
6597 .bitwise_eq(largest_denormal_f64.scalbn(1023))
6600 "0x1.ffffffffffffep+1023"
6603 .bitwise_eq(largest_denormal_f64.scalbn(2046))
6605 assert!("0x1p+974".parse::<Double>().unwrap().bitwise_eq(
6606 smallest_f64.scalbn(
6611 let random_denormal_f64 = "0x1.c60f120d9f87cp+51".parse::<Double>().unwrap();
6613 "0x1.c60f120d9f87cp-972"
6616 .bitwise_eq(random_denormal_f64.scalbn(-1023))
6619 "0x1.c60f120d9f87cp-1"
6622 .bitwise_eq(random_denormal_f64.scalbn(-52))
6625 "0x1.c60f120d9f87cp-2"
6628 .bitwise_eq(random_denormal_f64.scalbn(-53))
6631 "0x1.c60f120d9f87cp+0"
6634 .bitwise_eq(random_denormal_f64.scalbn(-51))
6637 assert!(random_denormal_f64.scalbn(-2097).is_pos_zero());
6638 assert!(random_denormal_f64.scalbn(-2090).is_pos_zero());
6641 assert!("-0x1p-1073".parse::<Double>().unwrap().bitwise_eq(
6642 neg_largest_f64.scalbn(-2097),
6645 assert!("-0x1p-1024".parse::<Double>().unwrap().bitwise_eq(
6646 neg_largest_f64.scalbn(-2048),
6649 assert!("0x1p-1073".parse::<Double>().unwrap().bitwise_eq(
6655 assert!("0x1p-1074".parse::<Double>().unwrap().bitwise_eq(
6660 assert!("-0x1p-1074".parse::<Double>().unwrap().bitwise_eq(
6661 neg_largest_f64.scalbn(-2098),
6663 assert!(neg_largest_f64.scalbn(-2099).is_neg_zero());
6664 assert!(largest_f64.scalbn(1).is_infinite());
6667 assert!("0x1p+0".parse::<Double>().unwrap().bitwise_eq(
6668 "0x1p+52".parse::<Double>().unwrap().scalbn(-52),
6671 assert!("0x1p-103".parse::<Double>().unwrap().bitwise_eq(
6672 "0x1p-51".parse::<Double>().unwrap().scalbn(-52),
6678 let p_zero = Double::ZERO;
6679 let m_zero = -Double::ZERO;
6680 let one = Double::from_f64(1.0);
6681 let m_one = Double::from_f64(-1.0);
6683 let largest_denormal = "0x1.ffffffffffffep-1023".parse::<Double>().unwrap();
6684 let neg_largest_denormal = "-0x1.ffffffffffffep-1023".parse::<Double>().unwrap();
6686 let smallest = Double::SMALLEST;
6687 let neg_smallest = -Double::SMALLEST;
6689 let largest = Double::largest();
6690 let neg_largest = -Double::largest();
6692 let p_inf = Double::INFINITY;
6693 let m_inf = -Double::INFINITY;
6695 let p_qnan = Double::NAN;
6696 let m_qnan = -Double::NAN;
6697 let snan = Double::snan(None);
6699 // Make sure highest bit of payload is preserved.
6700 let payload = (1 << 50) | (1 << 49) | (1234 << 32) | 1;
6702 let snan_with_payload = Double::snan(Some(payload));
6706 let frac = p_zero.frexp(&mut exp);
6708 assert!(frac.is_pos_zero());
6710 let frac = m_zero.frexp(&mut exp);
6712 assert!(frac.is_neg_zero());
6715 let frac = one.frexp(&mut exp);
6717 assert!("0x1p-1".parse::<Double>().unwrap().bitwise_eq(frac));
6719 let frac = m_one.frexp(&mut exp);
6721 assert!("-0x1p-1".parse::<Double>().unwrap().bitwise_eq(frac));
6723 let frac = largest_denormal.frexp(&mut exp);
6724 assert_eq!(-1022, exp);
6726 "0x1.ffffffffffffep-1"
6732 let frac = neg_largest_denormal.frexp(&mut exp);
6733 assert_eq!(-1022, exp);
6735 "-0x1.ffffffffffffep-1"
6742 let frac = smallest.frexp(&mut exp);
6743 assert_eq!(-1073, exp);
6744 assert!("0x1p-1".parse::<Double>().unwrap().bitwise_eq(frac));
6746 let frac = neg_smallest.frexp(&mut exp);
6747 assert_eq!(-1073, exp);
6748 assert!("-0x1p-1".parse::<Double>().unwrap().bitwise_eq(frac));
6751 let frac = largest.frexp(&mut exp);
6752 assert_eq!(1024, exp);
6754 "0x1.fffffffffffffp-1"
6760 let frac = neg_largest.frexp(&mut exp);
6761 assert_eq!(1024, exp);
6763 "-0x1.fffffffffffffp-1"
6770 let frac = p_inf.frexp(&mut exp);
6771 assert_eq!(IEK_INF, exp);
6772 assert!(frac.is_infinite() && !frac.is_negative());
6774 let frac = m_inf.frexp(&mut exp);
6775 assert_eq!(IEK_INF, exp);
6776 assert!(frac.is_infinite() && frac.is_negative());
6778 let frac = p_qnan.frexp(&mut exp);
6779 assert_eq!(IEK_NAN, exp);
6780 assert!(frac.is_nan());
6782 let frac = m_qnan.frexp(&mut exp);
6783 assert_eq!(IEK_NAN, exp);
6784 assert!(frac.is_nan());
6786 let frac = snan.frexp(&mut exp);
6787 assert_eq!(IEK_NAN, exp);
6788 assert!(frac.is_nan() && !frac.is_signaling());
6790 let frac = snan_with_payload.frexp(&mut exp);
6791 assert_eq!(IEK_NAN, exp);
6792 assert!(frac.is_nan() && !frac.is_signaling());
6793 assert_eq!(payload, frac.to_bits() & ((1 << 51) - 1));
6795 let frac = "0x0.ffffp-1".parse::<Double>().unwrap().frexp(&mut exp);
6796 assert_eq!(-1, exp);
6797 assert!("0x1.fffep-1".parse::<Double>().unwrap().bitwise_eq(frac));
6799 let frac = "0x1p-51".parse::<Double>().unwrap().frexp(&mut exp);
6800 assert_eq!(-50, exp);
6801 assert!("0x1p-1".parse::<Double>().unwrap().bitwise_eq(frac));
6803 let frac = "0x1.c60f120d9f87cp+51".parse::<Double>().unwrap().frexp(
6806 assert_eq!(52, exp);
6808 "0x1.c60f120d9f87cp-1"
6819 let f1 = "1.5".parse::<Double>().unwrap();
6820 let f2 = "1.0".parse::<Double>().unwrap();
6821 let expected = "0.5".parse::<Double>().unwrap();
6822 assert!(unpack!(status=, f1 % f2).bitwise_eq(expected));
6823 assert_eq!(status, Status::OK);
6826 let f1 = "0.5".parse::<Double>().unwrap();
6827 let f2 = "1.0".parse::<Double>().unwrap();
6828 let expected = "0.5".parse::<Double>().unwrap();
6829 assert!(unpack!(status=, f1 % f2).bitwise_eq(expected));
6830 assert_eq!(status, Status::OK);
6833 let f1 = "0x1.3333333333333p-2".parse::<Double>().unwrap(); // 0.3
6834 let f2 = "0x1.47ae147ae147bp-7".parse::<Double>().unwrap(); // 0.01
6835 // 0.009999999999999983
6836 let expected = "0x1.47ae147ae1471p-7".parse::<Double>().unwrap();
6837 assert!(unpack!(status=, f1 % f2).bitwise_eq(expected));
6838 assert_eq!(status, Status::OK);
6841 let f1 = "0x1p64".parse::<Double>().unwrap(); // 1.8446744073709552e19
6842 let f2 = "1.5".parse::<Double>().unwrap();
6843 let expected = "1.0".parse::<Double>().unwrap();
6844 assert!(unpack!(status=, f1 % f2).bitwise_eq(expected));
6845 assert_eq!(status, Status::OK);
6848 let f1 = "0x1p1000".parse::<Double>().unwrap();
6849 let f2 = "0x1p-1000".parse::<Double>().unwrap();
6850 let expected = "0.0".parse::<Double>().unwrap();
6851 assert!(unpack!(status=, f1 % f2).bitwise_eq(expected));
6852 assert_eq!(status, Status::OK);
6855 let f1 = "0.0".parse::<Double>().unwrap();
6856 let f2 = "1.0".parse::<Double>().unwrap();
6857 let expected = "0.0".parse::<Double>().unwrap();
6858 assert!(unpack!(status=, f1 % f2).bitwise_eq(expected));
6859 assert_eq!(status, Status::OK);
6862 let f1 = "1.0".parse::<Double>().unwrap();
6863 let f2 = "0.0".parse::<Double>().unwrap();
6864 assert!(unpack!(status=, f1 % f2).is_nan());
6865 assert_eq!(status, Status::INVALID_OP);
6868 let f1 = "0.0".parse::<Double>().unwrap();
6869 let f2 = "0.0".parse::<Double>().unwrap();
6870 assert!(unpack!(status=, f1 % f2).is_nan());
6871 assert_eq!(status, Status::INVALID_OP);
6874 let f1 = Double::INFINITY;
6875 let f2 = "1.0".parse::<Double>().unwrap();
6876 assert!(unpack!(status=, f1 % f2).is_nan());
6877 assert_eq!(status, Status::INVALID_OP);