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), "NaN");
86 assert_eq!(pretty(f64::INFINITY), "inf");
87 assert_eq!(pretty(f64::NEG_INFINITY), "-inf");
88 }
89
90 #[test]
test_switch_to_subnormal()91 fn test_switch_to_subnormal() {
92 check!(2.2250738585072014e-308);
93 }
94
95 #[test]
test_min_and_max()96 fn test_min_and_max() {
97 assert_eq!(f64::from_bits(0x7fefffffffffffff), 1.7976931348623157e308);
98 check!(1.7976931348623157e308);
99 assert_eq!(f64::from_bits(1), 5e-324);
100 check!(5e-324);
101 }
102
103 #[test]
test_lots_of_trailing_zeros()104 fn test_lots_of_trailing_zeros() {
105 check!(2.9802322387695312e-8);
106 }
107
108 #[test]
test_regression()109 fn test_regression() {
110 check!(-2.109808898695963e16);
111 check!(4.940656e-318);
112 check!(1.18575755e-316);
113 check!(2.989102097996e-312);
114 check!(9060801153433600.0);
115 check!(4.708356024711512e18);
116 check!(9.409340012568248e18);
117 check!(1.2345678);
118 }
119
120 #[test]
test_looks_like_pow5()121 fn test_looks_like_pow5() {
122 // These numbers have a mantissa that is a multiple of the largest power of
123 // 5 that fits, and an exponent that causes the computation for q to result
124 // in 22, which is a corner case for Ryū.
125 assert_eq!(f64::from_bits(0x4830F0CF064DD592), 5.764607523034235e39);
126 check!(5.764607523034235e39);
127 assert_eq!(f64::from_bits(0x4840F0CF064DD592), 1.152921504606847e40);
128 check!(1.152921504606847e40);
129 assert_eq!(f64::from_bits(0x4850F0CF064DD592), 2.305843009213694e40);
130 check!(2.305843009213694e40);
131 }
132
133 #[test]
test_output_length()134 fn test_output_length() {
135 check!(1.0); // already tested in Basic
136 check!(1.2);
137 check!(1.23);
138 check!(1.234);
139 check!(1.2345);
140 check!(1.23456);
141 check!(1.234567);
142 check!(1.2345678); // already tested in Regression
143 check!(1.23456789);
144 check!(1.234567895); // 1.234567890 would be trimmed
145 check!(1.2345678901);
146 check!(1.23456789012);
147 check!(1.234567890123);
148 check!(1.2345678901234);
149 check!(1.23456789012345);
150 check!(1.234567890123456);
151 check!(1.2345678901234567);
152
153 // Test 32-bit chunking
154 check!(4.294967294); // 2^32 - 2
155 check!(4.294967295); // 2^32 - 1
156 check!(4.294967296); // 2^32
157 check!(4.294967297); // 2^32 + 1
158 check!(4.294967298); // 2^32 + 2
159 }
160
161 // Test min, max shift values in shiftright128
162 #[test]
test_min_max_shift()163 fn test_min_max_shift() {
164 let max_mantissa = (1u64 << 53) - 1;
165
166 // 32-bit opt-size=0: 49 <= dist <= 50
167 // 32-bit opt-size=1: 30 <= dist <= 50
168 // 64-bit opt-size=0: 50 <= dist <= 50
169 // 64-bit opt-size=1: 30 <= dist <= 50
170 assert_eq!(1.7800590868057611E-307, ieee_parts_to_double(false, 4, 0));
171 check!(1.7800590868057611e-307);
172 // 32-bit opt-size=0: 49 <= dist <= 49
173 // 32-bit opt-size=1: 28 <= dist <= 49
174 // 64-bit opt-size=0: 50 <= dist <= 50
175 // 64-bit opt-size=1: 28 <= dist <= 50
176 assert_eq!(
177 2.8480945388892175E-306,
178 ieee_parts_to_double(false, 6, max_mantissa)
179 );
180 check!(2.8480945388892175e-306);
181 // 32-bit opt-size=0: 52 <= dist <= 53
182 // 32-bit opt-size=1: 2 <= dist <= 53
183 // 64-bit opt-size=0: 53 <= dist <= 53
184 // 64-bit opt-size=1: 2 <= dist <= 53
185 assert_eq!(2.446494580089078E-296, ieee_parts_to_double(false, 41, 0));
186 check!(2.446494580089078e-296);
187 // 32-bit opt-size=0: 52 <= dist <= 52
188 // 32-bit opt-size=1: 2 <= dist <= 52
189 // 64-bit opt-size=0: 53 <= dist <= 53
190 // 64-bit opt-size=1: 2 <= dist <= 53
191 assert_eq!(
192 4.8929891601781557E-296,
193 ieee_parts_to_double(false, 40, max_mantissa)
194 );
195 check!(4.8929891601781557e-296);
196
197 // 32-bit opt-size=0: 57 <= dist <= 58
198 // 32-bit opt-size=1: 57 <= dist <= 58
199 // 64-bit opt-size=0: 58 <= dist <= 58
200 // 64-bit opt-size=1: 58 <= dist <= 58
201 assert_eq!(1.8014398509481984E16, ieee_parts_to_double(false, 1077, 0));
202 check!(1.8014398509481984e16);
203 // 32-bit opt-size=0: 57 <= dist <= 57
204 // 32-bit opt-size=1: 57 <= dist <= 57
205 // 64-bit opt-size=0: 58 <= dist <= 58
206 // 64-bit opt-size=1: 58 <= dist <= 58
207 assert_eq!(
208 3.6028797018963964E16,
209 ieee_parts_to_double(false, 1076, max_mantissa)
210 );
211 check!(3.6028797018963964e16);
212 // 32-bit opt-size=0: 51 <= dist <= 52
213 // 32-bit opt-size=1: 51 <= dist <= 59
214 // 64-bit opt-size=0: 52 <= dist <= 52
215 // 64-bit opt-size=1: 52 <= dist <= 59
216 assert_eq!(2.900835519859558E-216, ieee_parts_to_double(false, 307, 0));
217 check!(2.900835519859558e-216);
218 // 32-bit opt-size=0: 51 <= dist <= 51
219 // 32-bit opt-size=1: 51 <= dist <= 59
220 // 64-bit opt-size=0: 52 <= dist <= 52
221 // 64-bit opt-size=1: 52 <= dist <= 59
222 assert_eq!(
223 5.801671039719115E-216,
224 ieee_parts_to_double(false, 306, max_mantissa)
225 );
226 check!(5.801671039719115e-216);
227
228 // https://github.com/ulfjack/ryu/commit/19e44d16d80236f5de25800f56d82606d1be00b9#commitcomment-30146483
229 // 32-bit opt-size=0: 49 <= dist <= 49
230 // 32-bit opt-size=1: 44 <= dist <= 49
231 // 64-bit opt-size=0: 50 <= dist <= 50
232 // 64-bit opt-size=1: 44 <= dist <= 50
233 assert_eq!(
234 3.196104012172126E-27,
235 ieee_parts_to_double(false, 934, 0x000FA7161A4D6E0C)
236 );
237 check!(3.196104012172126e-27);
238 }
239
240 #[test]
test_small_integers()241 fn test_small_integers() {
242 check!(9007199254740991.0); // 2^53-1
243 check!(9007199254740992.0); // 2^53
244
245 check!(1.0);
246 check!(12.0);
247 check!(123.0);
248 check!(1234.0);
249 check!(12345.0);
250 check!(123456.0);
251 check!(1234567.0);
252 check!(12345678.0);
253 check!(123456789.0);
254 check!(1234567890.0);
255 check!(1234567895.0);
256 check!(12345678901.0);
257 check!(123456789012.0);
258 check!(1234567890123.0);
259 check!(12345678901234.0);
260 check!(123456789012345.0);
261 check!(1234567890123456.0);
262
263 // 10^i
264 check!(1.0);
265 check!(10.0);
266 check!(100.0);
267 check!(1000.0);
268 check!(10000.0);
269 check!(100000.0);
270 check!(1000000.0);
271 check!(10000000.0);
272 check!(100000000.0);
273 check!(1000000000.0);
274 check!(10000000000.0);
275 check!(100000000000.0);
276 check!(1000000000000.0);
277 check!(10000000000000.0);
278 check!(100000000000000.0);
279 check!(1000000000000000.0);
280
281 // 10^15 + 10^i
282 check!(1000000000000001.0);
283 check!(1000000000000010.0);
284 check!(1000000000000100.0);
285 check!(1000000000001000.0);
286 check!(1000000000010000.0);
287 check!(1000000000100000.0);
288 check!(1000000001000000.0);
289 check!(1000000010000000.0);
290 check!(1000000100000000.0);
291 check!(1000001000000000.0);
292 check!(1000010000000000.0);
293 check!(1000100000000000.0);
294 check!(1001000000000000.0);
295 check!(1010000000000000.0);
296 check!(1100000000000000.0);
297
298 // Largest power of 2 <= 10^(i+1)
299 check!(8.0);
300 check!(64.0);
301 check!(512.0);
302 check!(8192.0);
303 check!(65536.0);
304 check!(524288.0);
305 check!(8388608.0);
306 check!(67108864.0);
307 check!(536870912.0);
308 check!(8589934592.0);
309 check!(68719476736.0);
310 check!(549755813888.0);
311 check!(8796093022208.0);
312 check!(70368744177664.0);
313 check!(562949953421312.0);
314 check!(9007199254740992.0);
315
316 // 1000 * (Largest power of 2 <= 10^(i+1))
317 check!(8000.0);
318 check!(64000.0);
319 check!(512000.0);
320 check!(8192000.0);
321 check!(65536000.0);
322 check!(524288000.0);
323 check!(8388608000.0);
324 check!(67108864000.0);
325 check!(536870912000.0);
326 check!(8589934592000.0);
327 check!(68719476736000.0);
328 check!(549755813888000.0);
329 check!(8796093022208000.0);
330 }
331