]>
Commit | Line | Data |
---|---|---|
1b1a35ee XL |
1 | use crate::f64::consts; |
2 | use crate::num::FpCategory as Fp; | |
3 | use crate::num::*; | |
4 | ||
5 | #[test] | |
6 | fn test_num_f64() { | |
7 | test_num(10f64, 2f64); | |
8 | } | |
9 | ||
10 | #[test] | |
11 | fn test_min_nan() { | |
12 | assert_eq!(f64::NAN.min(2.0), 2.0); | |
13 | assert_eq!(2.0f64.min(f64::NAN), 2.0); | |
14 | } | |
15 | ||
16 | #[test] | |
17 | fn test_max_nan() { | |
18 | assert_eq!(f64::NAN.max(2.0), 2.0); | |
19 | assert_eq!(2.0f64.max(f64::NAN), 2.0); | |
20 | } | |
21 | ||
22 | #[test] | |
23 | fn test_nan() { | |
24 | let nan: f64 = f64::NAN; | |
25 | assert!(nan.is_nan()); | |
26 | assert!(!nan.is_infinite()); | |
27 | assert!(!nan.is_finite()); | |
28 | assert!(!nan.is_normal()); | |
29 | assert!(nan.is_sign_positive()); | |
30 | assert!(!nan.is_sign_negative()); | |
31 | assert_eq!(Fp::Nan, nan.classify()); | |
32 | } | |
33 | ||
34 | #[test] | |
35 | fn test_infinity() { | |
36 | let inf: f64 = f64::INFINITY; | |
37 | assert!(inf.is_infinite()); | |
38 | assert!(!inf.is_finite()); | |
39 | assert!(inf.is_sign_positive()); | |
40 | assert!(!inf.is_sign_negative()); | |
41 | assert!(!inf.is_nan()); | |
42 | assert!(!inf.is_normal()); | |
43 | assert_eq!(Fp::Infinite, inf.classify()); | |
44 | } | |
45 | ||
46 | #[test] | |
47 | fn test_neg_infinity() { | |
48 | let neg_inf: f64 = f64::NEG_INFINITY; | |
49 | assert!(neg_inf.is_infinite()); | |
50 | assert!(!neg_inf.is_finite()); | |
51 | assert!(!neg_inf.is_sign_positive()); | |
52 | assert!(neg_inf.is_sign_negative()); | |
53 | assert!(!neg_inf.is_nan()); | |
54 | assert!(!neg_inf.is_normal()); | |
55 | assert_eq!(Fp::Infinite, neg_inf.classify()); | |
56 | } | |
57 | ||
58 | #[test] | |
59 | fn test_zero() { | |
60 | let zero: f64 = 0.0f64; | |
61 | assert_eq!(0.0, zero); | |
62 | assert!(!zero.is_infinite()); | |
63 | assert!(zero.is_finite()); | |
64 | assert!(zero.is_sign_positive()); | |
65 | assert!(!zero.is_sign_negative()); | |
66 | assert!(!zero.is_nan()); | |
67 | assert!(!zero.is_normal()); | |
68 | assert_eq!(Fp::Zero, zero.classify()); | |
69 | } | |
70 | ||
71 | #[test] | |
72 | fn test_neg_zero() { | |
73 | let neg_zero: f64 = -0.0; | |
74 | assert_eq!(0.0, neg_zero); | |
75 | assert!(!neg_zero.is_infinite()); | |
76 | assert!(neg_zero.is_finite()); | |
77 | assert!(!neg_zero.is_sign_positive()); | |
78 | assert!(neg_zero.is_sign_negative()); | |
79 | assert!(!neg_zero.is_nan()); | |
80 | assert!(!neg_zero.is_normal()); | |
81 | assert_eq!(Fp::Zero, neg_zero.classify()); | |
82 | } | |
83 | ||
84 | #[cfg_attr(all(target_arch = "wasm32", target_os = "emscripten"), ignore)] // issue 42630 | |
85 | #[test] | |
86 | fn test_one() { | |
87 | let one: f64 = 1.0f64; | |
88 | assert_eq!(1.0, one); | |
89 | assert!(!one.is_infinite()); | |
90 | assert!(one.is_finite()); | |
91 | assert!(one.is_sign_positive()); | |
92 | assert!(!one.is_sign_negative()); | |
93 | assert!(!one.is_nan()); | |
94 | assert!(one.is_normal()); | |
95 | assert_eq!(Fp::Normal, one.classify()); | |
96 | } | |
97 | ||
98 | #[test] | |
99 | fn test_is_nan() { | |
100 | let nan: f64 = f64::NAN; | |
101 | let inf: f64 = f64::INFINITY; | |
102 | let neg_inf: f64 = f64::NEG_INFINITY; | |
103 | assert!(nan.is_nan()); | |
104 | assert!(!0.0f64.is_nan()); | |
105 | assert!(!5.3f64.is_nan()); | |
106 | assert!(!(-10.732f64).is_nan()); | |
107 | assert!(!inf.is_nan()); | |
108 | assert!(!neg_inf.is_nan()); | |
109 | } | |
110 | ||
111 | #[test] | |
112 | fn test_is_infinite() { | |
113 | let nan: f64 = f64::NAN; | |
114 | let inf: f64 = f64::INFINITY; | |
115 | let neg_inf: f64 = f64::NEG_INFINITY; | |
116 | assert!(!nan.is_infinite()); | |
117 | assert!(inf.is_infinite()); | |
118 | assert!(neg_inf.is_infinite()); | |
119 | assert!(!0.0f64.is_infinite()); | |
120 | assert!(!42.8f64.is_infinite()); | |
121 | assert!(!(-109.2f64).is_infinite()); | |
122 | } | |
123 | ||
124 | #[test] | |
125 | fn test_is_finite() { | |
126 | let nan: f64 = f64::NAN; | |
127 | let inf: f64 = f64::INFINITY; | |
128 | let neg_inf: f64 = f64::NEG_INFINITY; | |
129 | assert!(!nan.is_finite()); | |
130 | assert!(!inf.is_finite()); | |
131 | assert!(!neg_inf.is_finite()); | |
132 | assert!(0.0f64.is_finite()); | |
133 | assert!(42.8f64.is_finite()); | |
134 | assert!((-109.2f64).is_finite()); | |
135 | } | |
136 | ||
137 | #[cfg_attr(all(target_arch = "wasm32", target_os = "emscripten"), ignore)] // issue 42630 | |
138 | #[test] | |
139 | fn test_is_normal() { | |
140 | let nan: f64 = f64::NAN; | |
141 | let inf: f64 = f64::INFINITY; | |
142 | let neg_inf: f64 = f64::NEG_INFINITY; | |
143 | let zero: f64 = 0.0f64; | |
144 | let neg_zero: f64 = -0.0; | |
145 | assert!(!nan.is_normal()); | |
146 | assert!(!inf.is_normal()); | |
147 | assert!(!neg_inf.is_normal()); | |
148 | assert!(!zero.is_normal()); | |
149 | assert!(!neg_zero.is_normal()); | |
150 | assert!(1f64.is_normal()); | |
151 | assert!(1e-307f64.is_normal()); | |
152 | assert!(!1e-308f64.is_normal()); | |
153 | } | |
154 | ||
155 | #[cfg_attr(all(target_arch = "wasm32", target_os = "emscripten"), ignore)] // issue 42630 | |
156 | #[test] | |
157 | fn test_classify() { | |
158 | let nan: f64 = f64::NAN; | |
159 | let inf: f64 = f64::INFINITY; | |
160 | let neg_inf: f64 = f64::NEG_INFINITY; | |
161 | let zero: f64 = 0.0f64; | |
162 | let neg_zero: f64 = -0.0; | |
163 | assert_eq!(nan.classify(), Fp::Nan); | |
164 | assert_eq!(inf.classify(), Fp::Infinite); | |
165 | assert_eq!(neg_inf.classify(), Fp::Infinite); | |
166 | assert_eq!(zero.classify(), Fp::Zero); | |
167 | assert_eq!(neg_zero.classify(), Fp::Zero); | |
168 | assert_eq!(1e-307f64.classify(), Fp::Normal); | |
169 | assert_eq!(1e-308f64.classify(), Fp::Subnormal); | |
170 | } | |
171 | ||
172 | #[test] | |
173 | fn test_floor() { | |
174 | assert_approx_eq!(1.0f64.floor(), 1.0f64); | |
175 | assert_approx_eq!(1.3f64.floor(), 1.0f64); | |
176 | assert_approx_eq!(1.5f64.floor(), 1.0f64); | |
177 | assert_approx_eq!(1.7f64.floor(), 1.0f64); | |
178 | assert_approx_eq!(0.0f64.floor(), 0.0f64); | |
179 | assert_approx_eq!((-0.0f64).floor(), -0.0f64); | |
180 | assert_approx_eq!((-1.0f64).floor(), -1.0f64); | |
181 | assert_approx_eq!((-1.3f64).floor(), -2.0f64); | |
182 | assert_approx_eq!((-1.5f64).floor(), -2.0f64); | |
183 | assert_approx_eq!((-1.7f64).floor(), -2.0f64); | |
184 | } | |
185 | ||
186 | #[test] | |
187 | fn test_ceil() { | |
188 | assert_approx_eq!(1.0f64.ceil(), 1.0f64); | |
189 | assert_approx_eq!(1.3f64.ceil(), 2.0f64); | |
190 | assert_approx_eq!(1.5f64.ceil(), 2.0f64); | |
191 | assert_approx_eq!(1.7f64.ceil(), 2.0f64); | |
192 | assert_approx_eq!(0.0f64.ceil(), 0.0f64); | |
193 | assert_approx_eq!((-0.0f64).ceil(), -0.0f64); | |
194 | assert_approx_eq!((-1.0f64).ceil(), -1.0f64); | |
195 | assert_approx_eq!((-1.3f64).ceil(), -1.0f64); | |
196 | assert_approx_eq!((-1.5f64).ceil(), -1.0f64); | |
197 | assert_approx_eq!((-1.7f64).ceil(), -1.0f64); | |
198 | } | |
199 | ||
200 | #[test] | |
201 | fn test_round() { | |
202 | assert_approx_eq!(1.0f64.round(), 1.0f64); | |
203 | assert_approx_eq!(1.3f64.round(), 1.0f64); | |
204 | assert_approx_eq!(1.5f64.round(), 2.0f64); | |
205 | assert_approx_eq!(1.7f64.round(), 2.0f64); | |
206 | assert_approx_eq!(0.0f64.round(), 0.0f64); | |
207 | assert_approx_eq!((-0.0f64).round(), -0.0f64); | |
208 | assert_approx_eq!((-1.0f64).round(), -1.0f64); | |
209 | assert_approx_eq!((-1.3f64).round(), -1.0f64); | |
210 | assert_approx_eq!((-1.5f64).round(), -2.0f64); | |
211 | assert_approx_eq!((-1.7f64).round(), -2.0f64); | |
212 | } | |
213 | ||
214 | #[test] | |
215 | fn test_trunc() { | |
216 | assert_approx_eq!(1.0f64.trunc(), 1.0f64); | |
217 | assert_approx_eq!(1.3f64.trunc(), 1.0f64); | |
218 | assert_approx_eq!(1.5f64.trunc(), 1.0f64); | |
219 | assert_approx_eq!(1.7f64.trunc(), 1.0f64); | |
220 | assert_approx_eq!(0.0f64.trunc(), 0.0f64); | |
221 | assert_approx_eq!((-0.0f64).trunc(), -0.0f64); | |
222 | assert_approx_eq!((-1.0f64).trunc(), -1.0f64); | |
223 | assert_approx_eq!((-1.3f64).trunc(), -1.0f64); | |
224 | assert_approx_eq!((-1.5f64).trunc(), -1.0f64); | |
225 | assert_approx_eq!((-1.7f64).trunc(), -1.0f64); | |
226 | } | |
227 | ||
228 | #[test] | |
229 | fn test_fract() { | |
230 | assert_approx_eq!(1.0f64.fract(), 0.0f64); | |
231 | assert_approx_eq!(1.3f64.fract(), 0.3f64); | |
232 | assert_approx_eq!(1.5f64.fract(), 0.5f64); | |
233 | assert_approx_eq!(1.7f64.fract(), 0.7f64); | |
234 | assert_approx_eq!(0.0f64.fract(), 0.0f64); | |
235 | assert_approx_eq!((-0.0f64).fract(), -0.0f64); | |
236 | assert_approx_eq!((-1.0f64).fract(), -0.0f64); | |
237 | assert_approx_eq!((-1.3f64).fract(), -0.3f64); | |
238 | assert_approx_eq!((-1.5f64).fract(), -0.5f64); | |
239 | assert_approx_eq!((-1.7f64).fract(), -0.7f64); | |
240 | } | |
241 | ||
242 | #[test] | |
243 | fn test_abs() { | |
244 | assert_eq!(f64::INFINITY.abs(), f64::INFINITY); | |
245 | assert_eq!(1f64.abs(), 1f64); | |
246 | assert_eq!(0f64.abs(), 0f64); | |
247 | assert_eq!((-0f64).abs(), 0f64); | |
248 | assert_eq!((-1f64).abs(), 1f64); | |
249 | assert_eq!(f64::NEG_INFINITY.abs(), f64::INFINITY); | |
250 | assert_eq!((1f64 / f64::NEG_INFINITY).abs(), 0f64); | |
251 | assert!(f64::NAN.abs().is_nan()); | |
252 | } | |
253 | ||
254 | #[test] | |
255 | fn test_signum() { | |
256 | assert_eq!(f64::INFINITY.signum(), 1f64); | |
257 | assert_eq!(1f64.signum(), 1f64); | |
258 | assert_eq!(0f64.signum(), 1f64); | |
259 | assert_eq!((-0f64).signum(), -1f64); | |
260 | assert_eq!((-1f64).signum(), -1f64); | |
261 | assert_eq!(f64::NEG_INFINITY.signum(), -1f64); | |
262 | assert_eq!((1f64 / f64::NEG_INFINITY).signum(), -1f64); | |
263 | assert!(f64::NAN.signum().is_nan()); | |
264 | } | |
265 | ||
266 | #[test] | |
267 | fn test_is_sign_positive() { | |
268 | assert!(f64::INFINITY.is_sign_positive()); | |
269 | assert!(1f64.is_sign_positive()); | |
270 | assert!(0f64.is_sign_positive()); | |
271 | assert!(!(-0f64).is_sign_positive()); | |
272 | assert!(!(-1f64).is_sign_positive()); | |
273 | assert!(!f64::NEG_INFINITY.is_sign_positive()); | |
274 | assert!(!(1f64 / f64::NEG_INFINITY).is_sign_positive()); | |
275 | assert!(f64::NAN.is_sign_positive()); | |
276 | assert!(!(-f64::NAN).is_sign_positive()); | |
277 | } | |
278 | ||
279 | #[test] | |
280 | fn test_is_sign_negative() { | |
281 | assert!(!f64::INFINITY.is_sign_negative()); | |
282 | assert!(!1f64.is_sign_negative()); | |
283 | assert!(!0f64.is_sign_negative()); | |
284 | assert!((-0f64).is_sign_negative()); | |
285 | assert!((-1f64).is_sign_negative()); | |
286 | assert!(f64::NEG_INFINITY.is_sign_negative()); | |
287 | assert!((1f64 / f64::NEG_INFINITY).is_sign_negative()); | |
288 | assert!(!f64::NAN.is_sign_negative()); | |
289 | assert!((-f64::NAN).is_sign_negative()); | |
290 | } | |
291 | ||
f2b60f7d FG |
292 | #[allow(unused_macros)] |
293 | macro_rules! assert_f64_biteq { | |
294 | ($left : expr, $right : expr) => { | |
295 | let l: &f64 = &$left; | |
296 | let r: &f64 = &$right; | |
297 | let lb = l.to_bits(); | |
298 | let rb = r.to_bits(); | |
299 | assert_eq!(lb, rb, "float {} ({:#x}) is not equal to {} ({:#x})", *l, lb, *r, rb); | |
300 | }; | |
301 | } | |
302 | ||
303 | // Ignore test on x87 floating point, these platforms do not guarantee NaN | |
304 | // payloads are preserved and flush denormals to zero, failing the tests. | |
305 | #[cfg(not(target_arch = "x86"))] | |
306 | #[test] | |
307 | fn test_next_up() { | |
308 | let tiny = f64::from_bits(1); | |
309 | let tiny_up = f64::from_bits(2); | |
310 | let max_down = f64::from_bits(0x7fef_ffff_ffff_fffe); | |
311 | let largest_subnormal = f64::from_bits(0x000f_ffff_ffff_ffff); | |
312 | let smallest_normal = f64::from_bits(0x0010_0000_0000_0000); | |
313 | assert_f64_biteq!(f64::NEG_INFINITY.next_up(), f64::MIN); | |
314 | assert_f64_biteq!(f64::MIN.next_up(), -max_down); | |
315 | assert_f64_biteq!((-1.0 - f64::EPSILON).next_up(), -1.0); | |
316 | assert_f64_biteq!((-smallest_normal).next_up(), -largest_subnormal); | |
317 | assert_f64_biteq!((-tiny_up).next_up(), -tiny); | |
318 | assert_f64_biteq!((-tiny).next_up(), -0.0f64); | |
319 | assert_f64_biteq!((-0.0f64).next_up(), tiny); | |
320 | assert_f64_biteq!(0.0f64.next_up(), tiny); | |
321 | assert_f64_biteq!(tiny.next_up(), tiny_up); | |
322 | assert_f64_biteq!(largest_subnormal.next_up(), smallest_normal); | |
323 | assert_f64_biteq!(1.0f64.next_up(), 1.0 + f64::EPSILON); | |
324 | assert_f64_biteq!(f64::MAX.next_up(), f64::INFINITY); | |
325 | assert_f64_biteq!(f64::INFINITY.next_up(), f64::INFINITY); | |
326 | ||
327 | let nan0 = f64::NAN; | |
328 | let nan1 = f64::from_bits(f64::NAN.to_bits() ^ 0x000a_aaaa_aaaa_aaaa); | |
329 | let nan2 = f64::from_bits(f64::NAN.to_bits() ^ 0x0005_5555_5555_5555); | |
330 | assert_f64_biteq!(nan0.next_up(), nan0); | |
331 | assert_f64_biteq!(nan1.next_up(), nan1); | |
332 | assert_f64_biteq!(nan2.next_up(), nan2); | |
333 | } | |
334 | ||
335 | // Ignore test on x87 floating point, these platforms do not guarantee NaN | |
336 | // payloads are preserved and flush denormals to zero, failing the tests. | |
337 | #[cfg(not(target_arch = "x86"))] | |
338 | #[test] | |
339 | fn test_next_down() { | |
340 | let tiny = f64::from_bits(1); | |
341 | let tiny_up = f64::from_bits(2); | |
342 | let max_down = f64::from_bits(0x7fef_ffff_ffff_fffe); | |
343 | let largest_subnormal = f64::from_bits(0x000f_ffff_ffff_ffff); | |
344 | let smallest_normal = f64::from_bits(0x0010_0000_0000_0000); | |
345 | assert_f64_biteq!(f64::NEG_INFINITY.next_down(), f64::NEG_INFINITY); | |
346 | assert_f64_biteq!(f64::MIN.next_down(), f64::NEG_INFINITY); | |
347 | assert_f64_biteq!((-max_down).next_down(), f64::MIN); | |
348 | assert_f64_biteq!((-1.0f64).next_down(), -1.0 - f64::EPSILON); | |
349 | assert_f64_biteq!((-largest_subnormal).next_down(), -smallest_normal); | |
350 | assert_f64_biteq!((-tiny).next_down(), -tiny_up); | |
351 | assert_f64_biteq!((-0.0f64).next_down(), -tiny); | |
352 | assert_f64_biteq!((0.0f64).next_down(), -tiny); | |
353 | assert_f64_biteq!(tiny.next_down(), 0.0f64); | |
354 | assert_f64_biteq!(tiny_up.next_down(), tiny); | |
355 | assert_f64_biteq!(smallest_normal.next_down(), largest_subnormal); | |
356 | assert_f64_biteq!((1.0 + f64::EPSILON).next_down(), 1.0f64); | |
357 | assert_f64_biteq!(f64::MAX.next_down(), max_down); | |
358 | assert_f64_biteq!(f64::INFINITY.next_down(), f64::MAX); | |
359 | ||
360 | let nan0 = f64::NAN; | |
361 | let nan1 = f64::from_bits(f64::NAN.to_bits() ^ 0x000a_aaaa_aaaa_aaaa); | |
362 | let nan2 = f64::from_bits(f64::NAN.to_bits() ^ 0x0005_5555_5555_5555); | |
363 | assert_f64_biteq!(nan0.next_down(), nan0); | |
364 | assert_f64_biteq!(nan1.next_down(), nan1); | |
365 | assert_f64_biteq!(nan2.next_down(), nan2); | |
366 | } | |
367 | ||
1b1a35ee XL |
368 | #[test] |
369 | fn test_mul_add() { | |
370 | let nan: f64 = f64::NAN; | |
371 | let inf: f64 = f64::INFINITY; | |
372 | let neg_inf: f64 = f64::NEG_INFINITY; | |
373 | assert_approx_eq!(12.3f64.mul_add(4.5, 6.7), 62.05); | |
374 | assert_approx_eq!((-12.3f64).mul_add(-4.5, -6.7), 48.65); | |
375 | assert_approx_eq!(0.0f64.mul_add(8.9, 1.2), 1.2); | |
376 | assert_approx_eq!(3.4f64.mul_add(-0.0, 5.6), 5.6); | |
377 | assert!(nan.mul_add(7.8, 9.0).is_nan()); | |
378 | assert_eq!(inf.mul_add(7.8, 9.0), inf); | |
379 | assert_eq!(neg_inf.mul_add(7.8, 9.0), neg_inf); | |
380 | assert_eq!(8.9f64.mul_add(inf, 3.2), inf); | |
381 | assert_eq!((-3.2f64).mul_add(2.4, neg_inf), neg_inf); | |
382 | } | |
383 | ||
384 | #[test] | |
385 | fn test_recip() { | |
386 | let nan: f64 = f64::NAN; | |
387 | let inf: f64 = f64::INFINITY; | |
388 | let neg_inf: f64 = f64::NEG_INFINITY; | |
389 | assert_eq!(1.0f64.recip(), 1.0); | |
390 | assert_eq!(2.0f64.recip(), 0.5); | |
391 | assert_eq!((-0.4f64).recip(), -2.5); | |
392 | assert_eq!(0.0f64.recip(), inf); | |
393 | assert!(nan.recip().is_nan()); | |
394 | assert_eq!(inf.recip(), 0.0); | |
395 | assert_eq!(neg_inf.recip(), 0.0); | |
396 | } | |
397 | ||
398 | #[test] | |
399 | fn test_powi() { | |
400 | let nan: f64 = f64::NAN; | |
401 | let inf: f64 = f64::INFINITY; | |
402 | let neg_inf: f64 = f64::NEG_INFINITY; | |
403 | assert_eq!(1.0f64.powi(1), 1.0); | |
404 | assert_approx_eq!((-3.1f64).powi(2), 9.61); | |
405 | assert_approx_eq!(5.9f64.powi(-2), 0.028727); | |
406 | assert_eq!(8.3f64.powi(0), 1.0); | |
407 | assert!(nan.powi(2).is_nan()); | |
408 | assert_eq!(inf.powi(3), inf); | |
409 | assert_eq!(neg_inf.powi(2), inf); | |
410 | } | |
411 | ||
412 | #[test] | |
413 | fn test_powf() { | |
414 | let nan: f64 = f64::NAN; | |
415 | let inf: f64 = f64::INFINITY; | |
416 | let neg_inf: f64 = f64::NEG_INFINITY; | |
417 | assert_eq!(1.0f64.powf(1.0), 1.0); | |
418 | assert_approx_eq!(3.4f64.powf(4.5), 246.408183); | |
419 | assert_approx_eq!(2.7f64.powf(-3.2), 0.041652); | |
420 | assert_approx_eq!((-3.1f64).powf(2.0), 9.61); | |
421 | assert_approx_eq!(5.9f64.powf(-2.0), 0.028727); | |
422 | assert_eq!(8.3f64.powf(0.0), 1.0); | |
423 | assert!(nan.powf(2.0).is_nan()); | |
424 | assert_eq!(inf.powf(2.0), inf); | |
425 | assert_eq!(neg_inf.powf(3.0), neg_inf); | |
426 | } | |
427 | ||
428 | #[test] | |
429 | fn test_sqrt_domain() { | |
430 | assert!(f64::NAN.sqrt().is_nan()); | |
431 | assert!(f64::NEG_INFINITY.sqrt().is_nan()); | |
432 | assert!((-1.0f64).sqrt().is_nan()); | |
433 | assert_eq!((-0.0f64).sqrt(), -0.0); | |
434 | assert_eq!(0.0f64.sqrt(), 0.0); | |
435 | assert_eq!(1.0f64.sqrt(), 1.0); | |
436 | assert_eq!(f64::INFINITY.sqrt(), f64::INFINITY); | |
437 | } | |
438 | ||
439 | #[test] | |
440 | fn test_exp() { | |
441 | assert_eq!(1.0, 0.0f64.exp()); | |
442 | assert_approx_eq!(2.718282, 1.0f64.exp()); | |
443 | assert_approx_eq!(148.413159, 5.0f64.exp()); | |
444 | ||
445 | let inf: f64 = f64::INFINITY; | |
446 | let neg_inf: f64 = f64::NEG_INFINITY; | |
447 | let nan: f64 = f64::NAN; | |
448 | assert_eq!(inf, inf.exp()); | |
449 | assert_eq!(0.0, neg_inf.exp()); | |
450 | assert!(nan.exp().is_nan()); | |
451 | } | |
452 | ||
453 | #[test] | |
454 | fn test_exp2() { | |
455 | assert_eq!(32.0, 5.0f64.exp2()); | |
456 | assert_eq!(1.0, 0.0f64.exp2()); | |
457 | ||
458 | let inf: f64 = f64::INFINITY; | |
459 | let neg_inf: f64 = f64::NEG_INFINITY; | |
460 | let nan: f64 = f64::NAN; | |
461 | assert_eq!(inf, inf.exp2()); | |
462 | assert_eq!(0.0, neg_inf.exp2()); | |
463 | assert!(nan.exp2().is_nan()); | |
464 | } | |
465 | ||
466 | #[test] | |
467 | fn test_ln() { | |
468 | let nan: f64 = f64::NAN; | |
469 | let inf: f64 = f64::INFINITY; | |
470 | let neg_inf: f64 = f64::NEG_INFINITY; | |
471 | assert_approx_eq!(1.0f64.exp().ln(), 1.0); | |
472 | assert!(nan.ln().is_nan()); | |
473 | assert_eq!(inf.ln(), inf); | |
474 | assert!(neg_inf.ln().is_nan()); | |
475 | assert!((-2.3f64).ln().is_nan()); | |
476 | assert_eq!((-0.0f64).ln(), neg_inf); | |
477 | assert_eq!(0.0f64.ln(), neg_inf); | |
478 | assert_approx_eq!(4.0f64.ln(), 1.386294); | |
479 | } | |
480 | ||
481 | #[test] | |
482 | fn test_log() { | |
483 | let nan: f64 = f64::NAN; | |
484 | let inf: f64 = f64::INFINITY; | |
485 | let neg_inf: f64 = f64::NEG_INFINITY; | |
486 | assert_eq!(10.0f64.log(10.0), 1.0); | |
487 | assert_approx_eq!(2.3f64.log(3.5), 0.664858); | |
488 | assert_eq!(1.0f64.exp().log(1.0f64.exp()), 1.0); | |
489 | assert!(1.0f64.log(1.0).is_nan()); | |
490 | assert!(1.0f64.log(-13.9).is_nan()); | |
491 | assert!(nan.log(2.3).is_nan()); | |
492 | assert_eq!(inf.log(10.0), inf); | |
493 | assert!(neg_inf.log(8.8).is_nan()); | |
494 | assert!((-2.3f64).log(0.1).is_nan()); | |
495 | assert_eq!((-0.0f64).log(2.0), neg_inf); | |
496 | assert_eq!(0.0f64.log(7.0), neg_inf); | |
497 | } | |
498 | ||
499 | #[test] | |
500 | fn test_log2() { | |
501 | let nan: f64 = f64::NAN; | |
502 | let inf: f64 = f64::INFINITY; | |
503 | let neg_inf: f64 = f64::NEG_INFINITY; | |
504 | assert_approx_eq!(10.0f64.log2(), 3.321928); | |
505 | assert_approx_eq!(2.3f64.log2(), 1.201634); | |
506 | assert_approx_eq!(1.0f64.exp().log2(), 1.442695); | |
507 | assert!(nan.log2().is_nan()); | |
508 | assert_eq!(inf.log2(), inf); | |
509 | assert!(neg_inf.log2().is_nan()); | |
510 | assert!((-2.3f64).log2().is_nan()); | |
511 | assert_eq!((-0.0f64).log2(), neg_inf); | |
512 | assert_eq!(0.0f64.log2(), neg_inf); | |
513 | } | |
514 | ||
515 | #[test] | |
516 | fn test_log10() { | |
517 | let nan: f64 = f64::NAN; | |
518 | let inf: f64 = f64::INFINITY; | |
519 | let neg_inf: f64 = f64::NEG_INFINITY; | |
520 | assert_eq!(10.0f64.log10(), 1.0); | |
521 | assert_approx_eq!(2.3f64.log10(), 0.361728); | |
522 | assert_approx_eq!(1.0f64.exp().log10(), 0.434294); | |
523 | assert_eq!(1.0f64.log10(), 0.0); | |
524 | assert!(nan.log10().is_nan()); | |
525 | assert_eq!(inf.log10(), inf); | |
526 | assert!(neg_inf.log10().is_nan()); | |
527 | assert!((-2.3f64).log10().is_nan()); | |
528 | assert_eq!((-0.0f64).log10(), neg_inf); | |
529 | assert_eq!(0.0f64.log10(), neg_inf); | |
530 | } | |
531 | ||
532 | #[test] | |
533 | fn test_to_degrees() { | |
534 | let pi: f64 = consts::PI; | |
535 | let nan: f64 = f64::NAN; | |
536 | let inf: f64 = f64::INFINITY; | |
537 | let neg_inf: f64 = f64::NEG_INFINITY; | |
538 | assert_eq!(0.0f64.to_degrees(), 0.0); | |
539 | assert_approx_eq!((-5.8f64).to_degrees(), -332.315521); | |
540 | assert_eq!(pi.to_degrees(), 180.0); | |
541 | assert!(nan.to_degrees().is_nan()); | |
542 | assert_eq!(inf.to_degrees(), inf); | |
543 | assert_eq!(neg_inf.to_degrees(), neg_inf); | |
544 | } | |
545 | ||
546 | #[test] | |
547 | fn test_to_radians() { | |
548 | let pi: f64 = consts::PI; | |
549 | let nan: f64 = f64::NAN; | |
550 | let inf: f64 = f64::INFINITY; | |
551 | let neg_inf: f64 = f64::NEG_INFINITY; | |
552 | assert_eq!(0.0f64.to_radians(), 0.0); | |
553 | assert_approx_eq!(154.6f64.to_radians(), 2.698279); | |
554 | assert_approx_eq!((-332.31f64).to_radians(), -5.799903); | |
555 | assert_eq!(180.0f64.to_radians(), pi); | |
556 | assert!(nan.to_radians().is_nan()); | |
557 | assert_eq!(inf.to_radians(), inf); | |
558 | assert_eq!(neg_inf.to_radians(), neg_inf); | |
559 | } | |
560 | ||
561 | #[test] | |
562 | fn test_asinh() { | |
563 | assert_eq!(0.0f64.asinh(), 0.0f64); | |
564 | assert_eq!((-0.0f64).asinh(), -0.0f64); | |
565 | ||
566 | let inf: f64 = f64::INFINITY; | |
567 | let neg_inf: f64 = f64::NEG_INFINITY; | |
568 | let nan: f64 = f64::NAN; | |
569 | assert_eq!(inf.asinh(), inf); | |
570 | assert_eq!(neg_inf.asinh(), neg_inf); | |
571 | assert!(nan.asinh().is_nan()); | |
572 | assert!((-0.0f64).asinh().is_sign_negative()); | |
573 | // issue 63271 | |
574 | assert_approx_eq!(2.0f64.asinh(), 1.443635475178810342493276740273105f64); | |
575 | assert_approx_eq!((-2.0f64).asinh(), -1.443635475178810342493276740273105f64); | |
576 | // regression test for the catastrophic cancellation fixed in 72486 | |
577 | assert_approx_eq!((-67452098.07139316f64).asinh(), -18.72007542627454439398548429400083); | |
487cf647 FG |
578 | |
579 | // test for low accuracy from issue 104548 | |
580 | assert_approx_eq!(60.0f64, 60.0f64.sinh().asinh()); | |
581 | // mul needed for approximate comparison to be meaningful | |
582 | assert_approx_eq!(1.0f64, 1e-15f64.sinh().asinh() * 1e15f64); | |
1b1a35ee XL |
583 | } |
584 | ||
585 | #[test] | |
586 | fn test_acosh() { | |
587 | assert_eq!(1.0f64.acosh(), 0.0f64); | |
588 | assert!(0.999f64.acosh().is_nan()); | |
589 | ||
590 | let inf: f64 = f64::INFINITY; | |
591 | let neg_inf: f64 = f64::NEG_INFINITY; | |
592 | let nan: f64 = f64::NAN; | |
593 | assert_eq!(inf.acosh(), inf); | |
594 | assert!(neg_inf.acosh().is_nan()); | |
595 | assert!(nan.acosh().is_nan()); | |
596 | assert_approx_eq!(2.0f64.acosh(), 1.31695789692481670862504634730796844f64); | |
597 | assert_approx_eq!(3.0f64.acosh(), 1.76274717403908605046521864995958461f64); | |
487cf647 FG |
598 | |
599 | // test for low accuracy from issue 104548 | |
600 | assert_approx_eq!(60.0f64, 60.0f64.cosh().acosh()); | |
1b1a35ee XL |
601 | } |
602 | ||
603 | #[test] | |
604 | fn test_atanh() { | |
605 | assert_eq!(0.0f64.atanh(), 0.0f64); | |
606 | assert_eq!((-0.0f64).atanh(), -0.0f64); | |
607 | ||
608 | let inf: f64 = f64::INFINITY; | |
609 | let neg_inf: f64 = f64::NEG_INFINITY; | |
610 | let nan: f64 = f64::NAN; | |
611 | assert_eq!(1.0f64.atanh(), inf); | |
612 | assert_eq!((-1.0f64).atanh(), neg_inf); | |
613 | assert!(2f64.atanh().atanh().is_nan()); | |
614 | assert!((-2f64).atanh().atanh().is_nan()); | |
615 | assert!(inf.atanh().is_nan()); | |
616 | assert!(neg_inf.atanh().is_nan()); | |
617 | assert!(nan.atanh().is_nan()); | |
618 | assert_approx_eq!(0.5f64.atanh(), 0.54930614433405484569762261846126285f64); | |
619 | assert_approx_eq!((-0.5f64).atanh(), -0.54930614433405484569762261846126285f64); | |
620 | } | |
621 | ||
622 | #[test] | |
623 | fn test_real_consts() { | |
624 | use super::consts; | |
625 | let pi: f64 = consts::PI; | |
626 | let frac_pi_2: f64 = consts::FRAC_PI_2; | |
627 | let frac_pi_3: f64 = consts::FRAC_PI_3; | |
628 | let frac_pi_4: f64 = consts::FRAC_PI_4; | |
629 | let frac_pi_6: f64 = consts::FRAC_PI_6; | |
630 | let frac_pi_8: f64 = consts::FRAC_PI_8; | |
631 | let frac_1_pi: f64 = consts::FRAC_1_PI; | |
632 | let frac_2_pi: f64 = consts::FRAC_2_PI; | |
633 | let frac_2_sqrtpi: f64 = consts::FRAC_2_SQRT_PI; | |
634 | let sqrt2: f64 = consts::SQRT_2; | |
635 | let frac_1_sqrt2: f64 = consts::FRAC_1_SQRT_2; | |
636 | let e: f64 = consts::E; | |
637 | let log2_e: f64 = consts::LOG2_E; | |
638 | let log10_e: f64 = consts::LOG10_E; | |
639 | let ln_2: f64 = consts::LN_2; | |
640 | let ln_10: f64 = consts::LN_10; | |
641 | ||
642 | assert_approx_eq!(frac_pi_2, pi / 2f64); | |
643 | assert_approx_eq!(frac_pi_3, pi / 3f64); | |
644 | assert_approx_eq!(frac_pi_4, pi / 4f64); | |
645 | assert_approx_eq!(frac_pi_6, pi / 6f64); | |
646 | assert_approx_eq!(frac_pi_8, pi / 8f64); | |
647 | assert_approx_eq!(frac_1_pi, 1f64 / pi); | |
648 | assert_approx_eq!(frac_2_pi, 2f64 / pi); | |
649 | assert_approx_eq!(frac_2_sqrtpi, 2f64 / pi.sqrt()); | |
650 | assert_approx_eq!(sqrt2, 2f64.sqrt()); | |
651 | assert_approx_eq!(frac_1_sqrt2, 1f64 / 2f64.sqrt()); | |
652 | assert_approx_eq!(log2_e, e.log2()); | |
653 | assert_approx_eq!(log10_e, e.log10()); | |
654 | assert_approx_eq!(ln_2, 2f64.ln()); | |
655 | assert_approx_eq!(ln_10, 10f64.ln()); | |
656 | } | |
657 | ||
658 | #[test] | |
659 | fn test_float_bits_conv() { | |
660 | assert_eq!((1f64).to_bits(), 0x3ff0000000000000); | |
661 | assert_eq!((12.5f64).to_bits(), 0x4029000000000000); | |
662 | assert_eq!((1337f64).to_bits(), 0x4094e40000000000); | |
663 | assert_eq!((-14.25f64).to_bits(), 0xc02c800000000000); | |
664 | assert_approx_eq!(f64::from_bits(0x3ff0000000000000), 1.0); | |
665 | assert_approx_eq!(f64::from_bits(0x4029000000000000), 12.5); | |
666 | assert_approx_eq!(f64::from_bits(0x4094e40000000000), 1337.0); | |
667 | assert_approx_eq!(f64::from_bits(0xc02c800000000000), -14.25); | |
668 | ||
669 | // Check that NaNs roundtrip their bits regardless of signaling-ness | |
670 | // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits | |
671 | let masked_nan1 = f64::NAN.to_bits() ^ 0x000A_AAAA_AAAA_AAAA; | |
672 | let masked_nan2 = f64::NAN.to_bits() ^ 0x0005_5555_5555_5555; | |
673 | assert!(f64::from_bits(masked_nan1).is_nan()); | |
674 | assert!(f64::from_bits(masked_nan2).is_nan()); | |
675 | ||
676 | assert_eq!(f64::from_bits(masked_nan1).to_bits(), masked_nan1); | |
677 | assert_eq!(f64::from_bits(masked_nan2).to_bits(), masked_nan2); | |
678 | } | |
679 | ||
680 | #[test] | |
681 | #[should_panic] | |
682 | fn test_clamp_min_greater_than_max() { | |
683 | let _ = 1.0f64.clamp(3.0, 1.0); | |
684 | } | |
685 | ||
686 | #[test] | |
687 | #[should_panic] | |
688 | fn test_clamp_min_is_nan() { | |
689 | let _ = 1.0f64.clamp(f64::NAN, 1.0); | |
690 | } | |
691 | ||
692 | #[test] | |
693 | #[should_panic] | |
694 | fn test_clamp_max_is_nan() { | |
695 | let _ = 1.0f64.clamp(3.0, f64::NAN); | |
696 | } | |
697 | ||
698 | #[test] | |
699 | fn test_total_cmp() { | |
700 | use core::cmp::Ordering; | |
701 | ||
702 | fn quiet_bit_mask() -> u64 { | |
703 | 1 << (f64::MANTISSA_DIGITS - 2) | |
704 | } | |
705 | ||
706 | fn min_subnorm() -> f64 { | |
707 | f64::MIN_POSITIVE / f64::powf(2.0, f64::MANTISSA_DIGITS as f64 - 1.0) | |
708 | } | |
709 | ||
710 | fn max_subnorm() -> f64 { | |
711 | f64::MIN_POSITIVE - min_subnorm() | |
712 | } | |
713 | ||
714 | fn q_nan() -> f64 { | |
715 | f64::from_bits(f64::NAN.to_bits() | quiet_bit_mask()) | |
716 | } | |
717 | ||
718 | fn s_nan() -> f64 { | |
719 | f64::from_bits((f64::NAN.to_bits() & !quiet_bit_mask()) + 42) | |
720 | } | |
721 | ||
722 | assert_eq!(Ordering::Equal, (-q_nan()).total_cmp(&-q_nan())); | |
723 | assert_eq!(Ordering::Equal, (-s_nan()).total_cmp(&-s_nan())); | |
724 | assert_eq!(Ordering::Equal, (-f64::INFINITY).total_cmp(&-f64::INFINITY)); | |
725 | assert_eq!(Ordering::Equal, (-f64::MAX).total_cmp(&-f64::MAX)); | |
726 | assert_eq!(Ordering::Equal, (-2.5_f64).total_cmp(&-2.5)); | |
727 | assert_eq!(Ordering::Equal, (-1.0_f64).total_cmp(&-1.0)); | |
728 | assert_eq!(Ordering::Equal, (-1.5_f64).total_cmp(&-1.5)); | |
729 | assert_eq!(Ordering::Equal, (-0.5_f64).total_cmp(&-0.5)); | |
730 | assert_eq!(Ordering::Equal, (-f64::MIN_POSITIVE).total_cmp(&-f64::MIN_POSITIVE)); | |
731 | assert_eq!(Ordering::Equal, (-max_subnorm()).total_cmp(&-max_subnorm())); | |
732 | assert_eq!(Ordering::Equal, (-min_subnorm()).total_cmp(&-min_subnorm())); | |
733 | assert_eq!(Ordering::Equal, (-0.0_f64).total_cmp(&-0.0)); | |
734 | assert_eq!(Ordering::Equal, 0.0_f64.total_cmp(&0.0)); | |
735 | assert_eq!(Ordering::Equal, min_subnorm().total_cmp(&min_subnorm())); | |
736 | assert_eq!(Ordering::Equal, max_subnorm().total_cmp(&max_subnorm())); | |
737 | assert_eq!(Ordering::Equal, f64::MIN_POSITIVE.total_cmp(&f64::MIN_POSITIVE)); | |
738 | assert_eq!(Ordering::Equal, 0.5_f64.total_cmp(&0.5)); | |
739 | assert_eq!(Ordering::Equal, 1.0_f64.total_cmp(&1.0)); | |
740 | assert_eq!(Ordering::Equal, 1.5_f64.total_cmp(&1.5)); | |
741 | assert_eq!(Ordering::Equal, 2.5_f64.total_cmp(&2.5)); | |
742 | assert_eq!(Ordering::Equal, f64::MAX.total_cmp(&f64::MAX)); | |
743 | assert_eq!(Ordering::Equal, f64::INFINITY.total_cmp(&f64::INFINITY)); | |
744 | assert_eq!(Ordering::Equal, s_nan().total_cmp(&s_nan())); | |
745 | assert_eq!(Ordering::Equal, q_nan().total_cmp(&q_nan())); | |
746 | ||
747 | assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-s_nan())); | |
748 | assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-f64::INFINITY)); | |
749 | assert_eq!(Ordering::Less, (-f64::INFINITY).total_cmp(&-f64::MAX)); | |
750 | assert_eq!(Ordering::Less, (-f64::MAX).total_cmp(&-2.5)); | |
751 | assert_eq!(Ordering::Less, (-2.5_f64).total_cmp(&-1.5)); | |
752 | assert_eq!(Ordering::Less, (-1.5_f64).total_cmp(&-1.0)); | |
753 | assert_eq!(Ordering::Less, (-1.0_f64).total_cmp(&-0.5)); | |
754 | assert_eq!(Ordering::Less, (-0.5_f64).total_cmp(&-f64::MIN_POSITIVE)); | |
755 | assert_eq!(Ordering::Less, (-f64::MIN_POSITIVE).total_cmp(&-max_subnorm())); | |
756 | assert_eq!(Ordering::Less, (-max_subnorm()).total_cmp(&-min_subnorm())); | |
757 | assert_eq!(Ordering::Less, (-min_subnorm()).total_cmp(&-0.0)); | |
758 | assert_eq!(Ordering::Less, (-0.0_f64).total_cmp(&0.0)); | |
759 | assert_eq!(Ordering::Less, 0.0_f64.total_cmp(&min_subnorm())); | |
760 | assert_eq!(Ordering::Less, min_subnorm().total_cmp(&max_subnorm())); | |
761 | assert_eq!(Ordering::Less, max_subnorm().total_cmp(&f64::MIN_POSITIVE)); | |
762 | assert_eq!(Ordering::Less, f64::MIN_POSITIVE.total_cmp(&0.5)); | |
763 | assert_eq!(Ordering::Less, 0.5_f64.total_cmp(&1.0)); | |
764 | assert_eq!(Ordering::Less, 1.0_f64.total_cmp(&1.5)); | |
765 | assert_eq!(Ordering::Less, 1.5_f64.total_cmp(&2.5)); | |
766 | assert_eq!(Ordering::Less, 2.5_f64.total_cmp(&f64::MAX)); | |
767 | assert_eq!(Ordering::Less, f64::MAX.total_cmp(&f64::INFINITY)); | |
768 | assert_eq!(Ordering::Less, f64::INFINITY.total_cmp(&s_nan())); | |
769 | assert_eq!(Ordering::Less, s_nan().total_cmp(&q_nan())); | |
770 | ||
771 | assert_eq!(Ordering::Greater, (-s_nan()).total_cmp(&-q_nan())); | |
772 | assert_eq!(Ordering::Greater, (-f64::INFINITY).total_cmp(&-s_nan())); | |
773 | assert_eq!(Ordering::Greater, (-f64::MAX).total_cmp(&-f64::INFINITY)); | |
774 | assert_eq!(Ordering::Greater, (-2.5_f64).total_cmp(&-f64::MAX)); | |
775 | assert_eq!(Ordering::Greater, (-1.5_f64).total_cmp(&-2.5)); | |
776 | assert_eq!(Ordering::Greater, (-1.0_f64).total_cmp(&-1.5)); | |
777 | assert_eq!(Ordering::Greater, (-0.5_f64).total_cmp(&-1.0)); | |
778 | assert_eq!(Ordering::Greater, (-f64::MIN_POSITIVE).total_cmp(&-0.5)); | |
779 | assert_eq!(Ordering::Greater, (-max_subnorm()).total_cmp(&-f64::MIN_POSITIVE)); | |
780 | assert_eq!(Ordering::Greater, (-min_subnorm()).total_cmp(&-max_subnorm())); | |
781 | assert_eq!(Ordering::Greater, (-0.0_f64).total_cmp(&-min_subnorm())); | |
782 | assert_eq!(Ordering::Greater, 0.0_f64.total_cmp(&-0.0)); | |
783 | assert_eq!(Ordering::Greater, min_subnorm().total_cmp(&0.0)); | |
784 | assert_eq!(Ordering::Greater, max_subnorm().total_cmp(&min_subnorm())); | |
785 | assert_eq!(Ordering::Greater, f64::MIN_POSITIVE.total_cmp(&max_subnorm())); | |
786 | assert_eq!(Ordering::Greater, 0.5_f64.total_cmp(&f64::MIN_POSITIVE)); | |
787 | assert_eq!(Ordering::Greater, 1.0_f64.total_cmp(&0.5)); | |
788 | assert_eq!(Ordering::Greater, 1.5_f64.total_cmp(&1.0)); | |
789 | assert_eq!(Ordering::Greater, 2.5_f64.total_cmp(&1.5)); | |
790 | assert_eq!(Ordering::Greater, f64::MAX.total_cmp(&2.5)); | |
791 | assert_eq!(Ordering::Greater, f64::INFINITY.total_cmp(&f64::MAX)); | |
792 | assert_eq!(Ordering::Greater, s_nan().total_cmp(&f64::INFINITY)); | |
793 | assert_eq!(Ordering::Greater, q_nan().total_cmp(&s_nan())); | |
794 | ||
795 | assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-s_nan())); | |
796 | assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-f64::INFINITY)); | |
797 | assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-f64::MAX)); | |
798 | assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-2.5)); | |
799 | assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-1.5)); | |
800 | assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-1.0)); | |
801 | assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-0.5)); | |
802 | assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-f64::MIN_POSITIVE)); | |
803 | assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-max_subnorm())); | |
804 | assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-min_subnorm())); | |
805 | assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&-0.0)); | |
806 | assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&0.0)); | |
807 | assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&min_subnorm())); | |
808 | assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&max_subnorm())); | |
809 | assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&f64::MIN_POSITIVE)); | |
810 | assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&0.5)); | |
811 | assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&1.0)); | |
812 | assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&1.5)); | |
813 | assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&2.5)); | |
814 | assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&f64::MAX)); | |
815 | assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&f64::INFINITY)); | |
816 | assert_eq!(Ordering::Less, (-q_nan()).total_cmp(&s_nan())); | |
817 | ||
818 | assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-f64::INFINITY)); | |
819 | assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-f64::MAX)); | |
820 | assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-2.5)); | |
821 | assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-1.5)); | |
822 | assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-1.0)); | |
823 | assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-0.5)); | |
824 | assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-f64::MIN_POSITIVE)); | |
825 | assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-max_subnorm())); | |
826 | assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-min_subnorm())); | |
827 | assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&-0.0)); | |
828 | assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&0.0)); | |
829 | assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&min_subnorm())); | |
830 | assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&max_subnorm())); | |
831 | assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&f64::MIN_POSITIVE)); | |
832 | assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&0.5)); | |
833 | assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&1.0)); | |
834 | assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&1.5)); | |
835 | assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&2.5)); | |
836 | assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&f64::MAX)); | |
837 | assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&f64::INFINITY)); | |
838 | assert_eq!(Ordering::Less, (-s_nan()).total_cmp(&s_nan())); | |
839 | } |