1 // Translated from C to Rust. The original C code can be found at
2 // https://github.com/ulfjack/ryu and carries the following license:
3 //
4 // Copyright 2018 Ulf Adams
5 //
6 // The contents of this file may be used under the terms of the Apache License,
7 // Version 2.0.
8 //
9 //    (See accompanying file LICENSE-Apache or copy at
10 //     http://www.apache.org/licenses/LICENSE-2.0)
11 //
12 // Alternatively, the contents of this file may be used under the terms of
13 // the Boost Software License, Version 1.0.
14 //    (See accompanying file LICENSE-Boost or copy at
15 //     https://www.boost.org/LICENSE_1_0.txt)
16 //
17 // Unless required by applicable law or agreed to in writing, this software
18 // is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
19 // KIND, either express or implied.
20 
21 #![allow(
22     clippy::approx_constant,
23     clippy::cast_lossless,
24     clippy::float_cmp,
25     clippy::int_plus_one,
26     clippy::non_ascii_literal,
27     clippy::unreadable_literal,
28     clippy::unseparated_literal_suffix
29 )]
30 
31 #[macro_use]
32 mod macros;
33 
34 use std::f64;
35 
pretty(f: f64) -> String36 fn pretty(f: f64) -> String {
37     ryu::Buffer::new().format(f).to_owned()
38 }
39 
ieee_parts_to_double(sign: bool, ieee_exponent: u32, ieee_mantissa: u64) -> f6440 fn ieee_parts_to_double(sign: bool, ieee_exponent: u32, ieee_mantissa: u64) -> f64 {
41     assert!(ieee_exponent <= 2047);
42     assert!(ieee_mantissa <= (1u64 << 53) - 1);
43     f64::from_bits(((sign as u64) << 63) | ((ieee_exponent as u64) << 52) | ieee_mantissa)
44 }
45 
46 #[test]
test_ryu()47 fn test_ryu() {
48     check!(0.3);
49     check!(1234000000000000.0);
50     check!(1.234e16);
51     check!(2.71828);
52     check!(1.1e128);
53     check!(1.1e-64);
54     check!(2.718281828459045);
55     check!(5e-324);
56     check!(1.7976931348623157e308);
57 }
58 
59 #[test]
test_random()60 fn test_random() {
61     let n = if cfg!(miri) { 100 } else { 1000000 };
62     let mut buffer = ryu::Buffer::new();
63     for _ in 0..n {
64         let f: f64 = rand::random();
65         assert_eq!(f, buffer.format_finite(f).parse().unwrap());
66     }
67 }
68 
69 #[test]
70 #[cfg_attr(miri, ignore)]
test_non_finite()71 fn test_non_finite() {
72     for i in 0u64..1 << 23 {
73         let f = f64::from_bits((((1 << 11) - 1) << 52) + (i << 29));
74         assert!(!f.is_finite(), "f={}", f);
75         ryu::Buffer::new().format_finite(f);
76     }
77 }
78 
79 #[test]
test_basic()80 fn test_basic() {
81     check!(0.0);
82     check!(-0.0);
83     check!(1.0);
84     check!(-1.0);
85     assert_eq!(pretty(f64::NAN.copysign(1.0)), "NaN");
86     assert_eq!(pretty(f64::NAN.copysign(-1.0)), "NaN");
87     assert_eq!(pretty(f64::INFINITY), "inf");
88     assert_eq!(pretty(f64::NEG_INFINITY), "-inf");
89 }
90 
91 #[test]
test_switch_to_subnormal()92 fn test_switch_to_subnormal() {
93     check!(2.2250738585072014e-308);
94 }
95 
96 #[test]
test_min_and_max()97 fn test_min_and_max() {
98     assert_eq!(f64::from_bits(0x7fefffffffffffff), 1.7976931348623157e308);
99     check!(1.7976931348623157e308);
100     assert_eq!(f64::from_bits(1), 5e-324);
101     check!(5e-324);
102 }
103 
104 #[test]
test_lots_of_trailing_zeros()105 fn test_lots_of_trailing_zeros() {
106     check!(2.9802322387695312e-8);
107 }
108 
109 #[test]
test_regression()110 fn test_regression() {
111     check!(-2.109808898695963e16);
112     check!(4.940656e-318);
113     check!(1.18575755e-316);
114     check!(2.989102097996e-312);
115     check!(9060801153433600.0);
116     check!(4.708356024711512e18);
117     check!(9.409340012568248e18);
118     check!(1.2345678);
119 }
120 
121 #[test]
test_looks_like_pow5()122 fn test_looks_like_pow5() {
123     // These numbers have a mantissa that is a multiple of the largest power of
124     // 5 that fits, and an exponent that causes the computation for q to result
125     // in 22, which is a corner case for Ryū.
126     assert_eq!(f64::from_bits(0x4830F0CF064DD592), 5.764607523034235e39);
127     check!(5.764607523034235e39);
128     assert_eq!(f64::from_bits(0x4840F0CF064DD592), 1.152921504606847e40);
129     check!(1.152921504606847e40);
130     assert_eq!(f64::from_bits(0x4850F0CF064DD592), 2.305843009213694e40);
131     check!(2.305843009213694e40);
132 }
133 
134 #[test]
test_output_length()135 fn test_output_length() {
136     check!(1.0); // already tested in Basic
137     check!(1.2);
138     check!(1.23);
139     check!(1.234);
140     check!(1.2345);
141     check!(1.23456);
142     check!(1.234567);
143     check!(1.2345678); // already tested in Regression
144     check!(1.23456789);
145     check!(1.234567895); // 1.234567890 would be trimmed
146     check!(1.2345678901);
147     check!(1.23456789012);
148     check!(1.234567890123);
149     check!(1.2345678901234);
150     check!(1.23456789012345);
151     check!(1.234567890123456);
152     check!(1.2345678901234567);
153 
154     // Test 32-bit chunking
155     check!(4.294967294); // 2^32 - 2
156     check!(4.294967295); // 2^32 - 1
157     check!(4.294967296); // 2^32
158     check!(4.294967297); // 2^32 + 1
159     check!(4.294967298); // 2^32 + 2
160 }
161 
162 // Test min, max shift values in shiftright128
163 #[test]
test_min_max_shift()164 fn test_min_max_shift() {
165     let max_mantissa = (1u64 << 53) - 1;
166 
167     // 32-bit opt-size=0:  49 <= dist <= 50
168     // 32-bit opt-size=1:  30 <= dist <= 50
169     // 64-bit opt-size=0:  50 <= dist <= 50
170     // 64-bit opt-size=1:  30 <= dist <= 50
171     assert_eq!(1.7800590868057611E-307, ieee_parts_to_double(false, 4, 0));
172     check!(1.7800590868057611e-307);
173     // 32-bit opt-size=0:  49 <= dist <= 49
174     // 32-bit opt-size=1:  28 <= dist <= 49
175     // 64-bit opt-size=0:  50 <= dist <= 50
176     // 64-bit opt-size=1:  28 <= dist <= 50
177     assert_eq!(
178         2.8480945388892175E-306,
179         ieee_parts_to_double(false, 6, max_mantissa)
180     );
181     check!(2.8480945388892175e-306);
182     // 32-bit opt-size=0:  52 <= dist <= 53
183     // 32-bit opt-size=1:   2 <= dist <= 53
184     // 64-bit opt-size=0:  53 <= dist <= 53
185     // 64-bit opt-size=1:   2 <= dist <= 53
186     assert_eq!(2.446494580089078E-296, ieee_parts_to_double(false, 41, 0));
187     check!(2.446494580089078e-296);
188     // 32-bit opt-size=0:  52 <= dist <= 52
189     // 32-bit opt-size=1:   2 <= dist <= 52
190     // 64-bit opt-size=0:  53 <= dist <= 53
191     // 64-bit opt-size=1:   2 <= dist <= 53
192     assert_eq!(
193         4.8929891601781557E-296,
194         ieee_parts_to_double(false, 40, max_mantissa)
195     );
196     check!(4.8929891601781557e-296);
197 
198     // 32-bit opt-size=0:  57 <= dist <= 58
199     // 32-bit opt-size=1:  57 <= dist <= 58
200     // 64-bit opt-size=0:  58 <= dist <= 58
201     // 64-bit opt-size=1:  58 <= dist <= 58
202     assert_eq!(1.8014398509481984E16, ieee_parts_to_double(false, 1077, 0));
203     check!(1.8014398509481984e16);
204     // 32-bit opt-size=0:  57 <= dist <= 57
205     // 32-bit opt-size=1:  57 <= dist <= 57
206     // 64-bit opt-size=0:  58 <= dist <= 58
207     // 64-bit opt-size=1:  58 <= dist <= 58
208     assert_eq!(
209         3.6028797018963964E16,
210         ieee_parts_to_double(false, 1076, max_mantissa)
211     );
212     check!(3.6028797018963964e16);
213     // 32-bit opt-size=0:  51 <= dist <= 52
214     // 32-bit opt-size=1:  51 <= dist <= 59
215     // 64-bit opt-size=0:  52 <= dist <= 52
216     // 64-bit opt-size=1:  52 <= dist <= 59
217     assert_eq!(2.900835519859558E-216, ieee_parts_to_double(false, 307, 0));
218     check!(2.900835519859558e-216);
219     // 32-bit opt-size=0:  51 <= dist <= 51
220     // 32-bit opt-size=1:  51 <= dist <= 59
221     // 64-bit opt-size=0:  52 <= dist <= 52
222     // 64-bit opt-size=1:  52 <= dist <= 59
223     assert_eq!(
224         5.801671039719115E-216,
225         ieee_parts_to_double(false, 306, max_mantissa)
226     );
227     check!(5.801671039719115e-216);
228 
229     // https://github.com/ulfjack/ryu/commit/19e44d16d80236f5de25800f56d82606d1be00b9#commitcomment-30146483
230     // 32-bit opt-size=0:  49 <= dist <= 49
231     // 32-bit opt-size=1:  44 <= dist <= 49
232     // 64-bit opt-size=0:  50 <= dist <= 50
233     // 64-bit opt-size=1:  44 <= dist <= 50
234     assert_eq!(
235         3.196104012172126E-27,
236         ieee_parts_to_double(false, 934, 0x000FA7161A4D6E0C)
237     );
238     check!(3.196104012172126e-27);
239 }
240 
241 #[test]
test_small_integers()242 fn test_small_integers() {
243     check!(9007199254740991.0); // 2^53-1
244     check!(9007199254740992.0); // 2^53
245 
246     check!(1.0);
247     check!(12.0);
248     check!(123.0);
249     check!(1234.0);
250     check!(12345.0);
251     check!(123456.0);
252     check!(1234567.0);
253     check!(12345678.0);
254     check!(123456789.0);
255     check!(1234567890.0);
256     check!(1234567895.0);
257     check!(12345678901.0);
258     check!(123456789012.0);
259     check!(1234567890123.0);
260     check!(12345678901234.0);
261     check!(123456789012345.0);
262     check!(1234567890123456.0);
263 
264     // 10^i
265     check!(1.0);
266     check!(10.0);
267     check!(100.0);
268     check!(1000.0);
269     check!(10000.0);
270     check!(100000.0);
271     check!(1000000.0);
272     check!(10000000.0);
273     check!(100000000.0);
274     check!(1000000000.0);
275     check!(10000000000.0);
276     check!(100000000000.0);
277     check!(1000000000000.0);
278     check!(10000000000000.0);
279     check!(100000000000000.0);
280     check!(1000000000000000.0);
281 
282     // 10^15 + 10^i
283     check!(1000000000000001.0);
284     check!(1000000000000010.0);
285     check!(1000000000000100.0);
286     check!(1000000000001000.0);
287     check!(1000000000010000.0);
288     check!(1000000000100000.0);
289     check!(1000000001000000.0);
290     check!(1000000010000000.0);
291     check!(1000000100000000.0);
292     check!(1000001000000000.0);
293     check!(1000010000000000.0);
294     check!(1000100000000000.0);
295     check!(1001000000000000.0);
296     check!(1010000000000000.0);
297     check!(1100000000000000.0);
298 
299     // Largest power of 2 <= 10^(i+1)
300     check!(8.0);
301     check!(64.0);
302     check!(512.0);
303     check!(8192.0);
304     check!(65536.0);
305     check!(524288.0);
306     check!(8388608.0);
307     check!(67108864.0);
308     check!(536870912.0);
309     check!(8589934592.0);
310     check!(68719476736.0);
311     check!(549755813888.0);
312     check!(8796093022208.0);
313     check!(70368744177664.0);
314     check!(562949953421312.0);
315     check!(9007199254740992.0);
316 
317     // 1000 * (Largest power of 2 <= 10^(i+1))
318     check!(8000.0);
319     check!(64000.0);
320     check!(512000.0);
321     check!(8192000.0);
322     check!(65536000.0);
323     check!(524288000.0);
324     check!(8388608000.0);
325     check!(67108864000.0);
326     check!(536870912000.0);
327     check!(8589934592000.0);
328     check!(68719476736000.0);
329     check!(549755813888000.0);
330     check!(8796093022208000.0);
331 }
332