Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit 0c707f9

Browse files
RalfJungRalfJung
committedJun 3, 2025·
coretests: move float tests from num to floats module and use a more flexible macro to generate them
1 parent b17dba4 commit 0c707f9

File tree

2 files changed

+531
-359
lines changed

2 files changed

+531
-359
lines changed
 

‎library/coretests/tests/floats/mod.rs

Lines changed: 531 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -52,6 +52,103 @@ macro_rules! assert_biteq {
5252
};
5353
}
5454

55+
mod const_asserts {
56+
// Shadow some assert implementations that would otherwise not compile in a const-context.
57+
// Every macro added here also needs to be added in the `float_test!` macro below.
58+
macro_rules! assert_eq {
59+
($left:expr, $right:expr $(,)?) => {
60+
std::assert!($left == $right)
61+
};
62+
($left:expr, $right:expr, $($arg:tt)+) => {
63+
std::assert!($left == $right, $($arg)+)
64+
};
65+
}
66+
67+
pub(crate) use assert_eq;
68+
}
69+
70+
/// Generate float tests for all our float types, for compile-time and run-time behavior.
71+
macro_rules! float_test {
72+
(
73+
name: $name:ident,
74+
attrs: {
75+
$(const: #[ $($const_meta:meta),+ ] ,)?
76+
$(f16: #[ $($f16_meta:meta),+ ] ,)?
77+
$(const f16: #[ $($f16_const_meta:meta),+ ] ,)?
78+
$(f32: #[ $($f32_meta:meta),+ ] ,)?
79+
$(const f32: #[ $($f32_const_meta:meta),+ ] ,)?
80+
$(f64: #[ $($f64_meta:meta),+ ] ,)?
81+
$(const f64: #[ $($f64_const_meta:meta),+ ] ,)?
82+
$(f128: #[ $($f128_meta:meta),+ ] ,)?
83+
$(const f128: #[ $($f128_const_meta:meta),+ ] ,)?
84+
},
85+
test<$fty:ident> $test:block
86+
) => {
87+
mod $name {
88+
#[test]
89+
$( $( #[$f16_meta] )+ )?
90+
fn test_f16() {
91+
type $fty = f16;
92+
$test
93+
}
94+
95+
#[test]
96+
$( $( #[$f32_meta] )+ )?
97+
fn test_f32() {
98+
type $fty = f32;
99+
$test
100+
}
101+
102+
#[test]
103+
$( $( #[$f64_meta] )+ )?
104+
fn test_f64() {
105+
type $fty = f64;
106+
$test
107+
}
108+
109+
#[test]
110+
$( $( #[$f128_meta] )+ )?
111+
fn test_f128() {
112+
type $fty = f128;
113+
$test
114+
}
115+
116+
$( $( #[$const_meta] )+ )?
117+
mod const_ {
118+
use $crate::floats::const_asserts::assert_eq;
119+
120+
#[test]
121+
$( $( #[$f16_const_meta] )+ )?
122+
fn test_f16() {
123+
type $fty = f16;
124+
const { $test }
125+
}
126+
127+
#[test]
128+
$( $( #[$f32_const_meta] )+ )?
129+
fn test_f32() {
130+
type $fty = f32;
131+
const { $test }
132+
}
133+
134+
#[test]
135+
$( $( #[$f64_const_meta] )+ )?
136+
fn test_f64() {
137+
type $fty = f64;
138+
const { $test }
139+
}
140+
141+
#[test]
142+
$( $( #[$f128_const_meta] )+ )?
143+
fn test_f128() {
144+
type $fty = f128;
145+
const { $test }
146+
}
147+
}
148+
}
149+
};
150+
}
151+
55152
/// Helper function for testing numeric operations
56153
pub fn test_num<T>(ten: T, two: T)
57154
where
@@ -75,3 +172,437 @@ mod f128;
75172
mod f16;
76173
mod f32;
77174
mod f64;
175+
176+
float_test! {
177+
name: min,
178+
attrs: {
179+
f16: #[cfg(any(miri, target_has_reliable_f16_math))],
180+
f128: #[cfg(any(miri, target_has_reliable_f128_math))],
181+
},
182+
test<Float> {
183+
assert_eq!((0.0 as Float).min(0.0), 0.0);
184+
assert!((0.0 as Float).min(0.0).is_sign_positive());
185+
assert_eq!((-0.0 as Float).min(-0.0), -0.0);
186+
assert!((-0.0 as Float).min(-0.0).is_sign_negative());
187+
assert_eq!((9.0 as Float).min(9.0), 9.0);
188+
assert_eq!((-9.0 as Float).min(0.0), -9.0);
189+
assert_eq!((0.0 as Float).min(9.0), 0.0);
190+
assert!((0.0 as Float).min(9.0).is_sign_positive());
191+
assert_eq!((-0.0 as Float).min(9.0), -0.0);
192+
assert!((-0.0 as Float).min(9.0).is_sign_negative());
193+
assert_eq!((-0.0 as Float).min(-9.0), -9.0);
194+
assert_eq!(Float::INFINITY.min(9.0), 9.0);
195+
assert_eq!((9.0 as Float).min(Float::INFINITY), 9.0);
196+
assert_eq!(Float::INFINITY.min(-9.0), -9.0);
197+
assert_eq!((-9.0 as Float).min(Float::INFINITY), -9.0);
198+
assert_eq!(Float::NEG_INFINITY.min(9.0), Float::NEG_INFINITY);
199+
assert_eq!((9.0 as Float).min(Float::NEG_INFINITY), Float::NEG_INFINITY);
200+
assert_eq!(Float::NEG_INFINITY.min(-9.0), Float::NEG_INFINITY);
201+
assert_eq!((-9.0 as Float).min(Float::NEG_INFINITY), Float::NEG_INFINITY);
202+
assert_eq!(Float::NAN.min(9.0), 9.0);
203+
assert_eq!(Float::NAN.min(-9.0), -9.0);
204+
assert_eq!((9.0 as Float).min(Float::NAN), 9.0);
205+
assert_eq!((-9.0 as Float).min(Float::NAN), -9.0);
206+
assert!(Float::NAN.min(Float::NAN).is_nan());
207+
}
208+
}
209+
210+
float_test! {
211+
name: max,
212+
attrs: {
213+
f16: #[cfg(any(miri, target_has_reliable_f16_math))],
214+
f128: #[cfg(any(miri, target_has_reliable_f128_math))],
215+
},
216+
test<Float> {
217+
assert_eq!((0.0 as Float).max(0.0), 0.0);
218+
assert!((0.0 as Float).max(0.0).is_sign_positive());
219+
assert_eq!((-0.0 as Float).max(-0.0), -0.0);
220+
assert!((-0.0 as Float).max(-0.0).is_sign_negative());
221+
assert_eq!((9.0 as Float).max(9.0), 9.0);
222+
assert_eq!((-9.0 as Float).max(0.0), 0.0);
223+
assert!((-9.0 as Float).max(0.0).is_sign_positive());
224+
assert_eq!((-9.0 as Float).max(-0.0), -0.0);
225+
assert!((-9.0 as Float).max(-0.0).is_sign_negative());
226+
assert_eq!((0.0 as Float).max(9.0), 9.0);
227+
assert_eq!((0.0 as Float).max(-9.0), 0.0);
228+
assert!((0.0 as Float).max(-9.0).is_sign_positive());
229+
assert_eq!((-0.0 as Float).max(-9.0), -0.0);
230+
assert!((-0.0 as Float).max(-9.0).is_sign_negative());
231+
assert_eq!(Float::INFINITY.max(9.0), Float::INFINITY);
232+
assert_eq!((9.0 as Float).max(Float::INFINITY), Float::INFINITY);
233+
assert_eq!(Float::INFINITY.max(-9.0), Float::INFINITY);
234+
assert_eq!((-9.0 as Float).max(Float::INFINITY), Float::INFINITY);
235+
assert_eq!(Float::NEG_INFINITY.max(9.0), 9.0);
236+
assert_eq!((9.0 as Float).max(Float::NEG_INFINITY), 9.0);
237+
assert_eq!(Float::NEG_INFINITY.max(-9.0), -9.0);
238+
assert_eq!((-9.0 as Float).max(Float::NEG_INFINITY), -9.0);
239+
assert_eq!(Float::NAN.max(9.0), 9.0);
240+
assert_eq!(Float::NAN.max(-9.0), -9.0);
241+
assert_eq!((9.0 as Float).max(Float::NAN), 9.0);
242+
assert_eq!((-9.0 as Float).max(Float::NAN), -9.0);
243+
assert!(Float::NAN.max(Float::NAN).is_nan());
244+
}
245+
}
246+
247+
float_test! {
248+
name: minimum,
249+
attrs: {
250+
f16: #[cfg(any(miri, target_has_reliable_f16_math))],
251+
f128: #[cfg(any(miri, target_has_reliable_f128_math))],
252+
},
253+
test<Float> {
254+
assert_eq!((0.0 as Float).minimum(0.0), 0.0);
255+
assert!((0.0 as Float).minimum(0.0).is_sign_positive());
256+
assert_eq!((-0.0 as Float).minimum(0.0), -0.0);
257+
assert!((-0.0 as Float).minimum(0.0).is_sign_negative());
258+
assert_eq!((-0.0 as Float).minimum(-0.0), -0.0);
259+
assert!((-0.0 as Float).minimum(-0.0).is_sign_negative());
260+
assert_eq!((9.0 as Float).minimum(9.0), 9.0);
261+
assert_eq!((-9.0 as Float).minimum(0.0), -9.0);
262+
assert_eq!((0.0 as Float).minimum(9.0), 0.0);
263+
assert!((0.0 as Float).minimum(9.0).is_sign_positive());
264+
assert_eq!((-0.0 as Float).minimum(9.0), -0.0);
265+
assert!((-0.0 as Float).minimum(9.0).is_sign_negative());
266+
assert_eq!((-0.0 as Float).minimum(-9.0), -9.0);
267+
assert_eq!(Float::INFINITY.minimum(9.0), 9.0);
268+
assert_eq!((9.0 as Float).minimum(Float::INFINITY), 9.0);
269+
assert_eq!(Float::INFINITY.minimum(-9.0), -9.0);
270+
assert_eq!((-9.0 as Float).minimum(Float::INFINITY), -9.0);
271+
assert_eq!(Float::NEG_INFINITY.minimum(9.0), Float::NEG_INFINITY);
272+
assert_eq!((9.0 as Float).minimum(Float::NEG_INFINITY), Float::NEG_INFINITY);
273+
assert_eq!(Float::NEG_INFINITY.minimum(-9.0), Float::NEG_INFINITY);
274+
assert_eq!((-9.0 as Float).minimum(Float::NEG_INFINITY), Float::NEG_INFINITY);
275+
assert!(Float::NAN.minimum(9.0).is_nan());
276+
assert!(Float::NAN.minimum(-9.0).is_nan());
277+
assert!((9.0 as Float).minimum(Float::NAN).is_nan());
278+
assert!((-9.0 as Float).minimum(Float::NAN).is_nan());
279+
assert!(Float::NAN.minimum(Float::NAN).is_nan());
280+
}
281+
}
282+
283+
float_test! {
284+
name: maxium,
285+
attrs: {
286+
f16: #[cfg(any(miri, target_has_reliable_f16_math))],
287+
f128: #[cfg(any(miri, target_has_reliable_f128_math))],
288+
},
289+
test<Float> {
290+
assert_eq!((0.0 as Float).maximum(0.0), 0.0);
291+
assert!((0.0 as Float).maximum(0.0).is_sign_positive());
292+
assert_eq!((-0.0 as Float).maximum(0.0), 0.0);
293+
assert!((-0.0 as Float).maximum(0.0).is_sign_positive());
294+
assert_eq!((-0.0 as Float).maximum(-0.0), -0.0);
295+
assert!((-0.0 as Float).maximum(-0.0).is_sign_negative());
296+
assert_eq!((9.0 as Float).maximum(9.0), 9.0);
297+
assert_eq!((-9.0 as Float).maximum(0.0), 0.0);
298+
assert!((-9.0 as Float).maximum(0.0).is_sign_positive());
299+
assert_eq!((-9.0 as Float).maximum(-0.0), -0.0);
300+
assert!((-9.0 as Float).maximum(-0.0).is_sign_negative());
301+
assert_eq!((0.0 as Float).maximum(9.0), 9.0);
302+
assert_eq!((0.0 as Float).maximum(-9.0), 0.0);
303+
assert!((0.0 as Float).maximum(-9.0).is_sign_positive());
304+
assert_eq!((-0.0 as Float).maximum(-9.0), -0.0);
305+
assert!((-0.0 as Float).maximum(-9.0).is_sign_negative());
306+
assert_eq!(Float::INFINITY.maximum(9.0), Float::INFINITY);
307+
assert_eq!((9.0 as Float).maximum(Float::INFINITY), Float::INFINITY);
308+
assert_eq!(Float::INFINITY.maximum(-9.0), Float::INFINITY);
309+
assert_eq!((-9.0 as Float).maximum(Float::INFINITY), Float::INFINITY);
310+
assert_eq!(Float::NEG_INFINITY.maximum(9.0), 9.0);
311+
assert_eq!((9.0 as Float).maximum(Float::NEG_INFINITY), 9.0);
312+
assert_eq!(Float::NEG_INFINITY.maximum(-9.0), -9.0);
313+
assert_eq!((-9.0 as Float).maximum(Float::NEG_INFINITY), -9.0);
314+
assert!(Float::NAN.maximum(9.0).is_nan());
315+
assert!(Float::NAN.maximum(-9.0).is_nan());
316+
assert!((9.0 as Float).maximum(Float::NAN).is_nan());
317+
assert!((-9.0 as Float).maximum(Float::NAN).is_nan());
318+
assert!(Float::NAN.maximum(Float::NAN).is_nan());
319+
}
320+
}
321+
322+
float_test! {
323+
name: midpoint,
324+
attrs: {
325+
f16: #[cfg(any(miri, target_has_reliable_f16_math))],
326+
f128: #[cfg(any(miri, target_has_reliable_f128_math))],
327+
},
328+
test<Float> {
329+
assert_eq!((0.5 as Float).midpoint(0.5), 0.5);
330+
assert_eq!((0.5 as Float).midpoint(2.5), 1.5);
331+
assert_eq!((3.0 as Float).midpoint(4.0), 3.5);
332+
assert_eq!((-3.0 as Float).midpoint(4.0), 0.5);
333+
assert_eq!((3.0 as Float).midpoint(-4.0), -0.5);
334+
assert_eq!((-3.0 as Float).midpoint(-4.0), -3.5);
335+
assert_eq!((0.0 as Float).midpoint(0.0), 0.0);
336+
assert_eq!((-0.0 as Float).midpoint(-0.0), -0.0);
337+
assert_eq!((-5.0 as Float).midpoint(5.0), 0.0);
338+
assert_eq!(Float::MAX.midpoint(Float::MIN), 0.0);
339+
assert_eq!(Float::MIN.midpoint(Float::MAX), -0.0);
340+
assert_eq!(Float::MAX.midpoint(Float::MIN_POSITIVE), Float::MAX / 2.);
341+
assert_eq!((-Float::MAX).midpoint(Float::MIN_POSITIVE), -Float::MAX / 2.);
342+
assert_eq!(Float::MAX.midpoint(-Float::MIN_POSITIVE), Float::MAX / 2.);
343+
assert_eq!((-Float::MAX).midpoint(-Float::MIN_POSITIVE), -Float::MAX / 2.);
344+
assert_eq!((Float::MIN_POSITIVE).midpoint(Float::MAX), Float::MAX / 2.);
345+
assert_eq!((Float::MIN_POSITIVE).midpoint(-Float::MAX), -Float::MAX / 2.);
346+
assert_eq!((-Float::MIN_POSITIVE).midpoint(Float::MAX), Float::MAX / 2.);
347+
assert_eq!((-Float::MIN_POSITIVE).midpoint(-Float::MAX), -Float::MAX / 2.);
348+
assert_eq!(Float::MAX.midpoint(Float::MAX), Float::MAX);
349+
assert_eq!(
350+
(Float::MIN_POSITIVE).midpoint(Float::MIN_POSITIVE),
351+
Float::MIN_POSITIVE
352+
);
353+
assert_eq!(
354+
(-Float::MIN_POSITIVE).midpoint(-Float::MIN_POSITIVE),
355+
-Float::MIN_POSITIVE
356+
);
357+
assert_eq!(Float::MAX.midpoint(5.0), Float::MAX / 2.0 + 2.5);
358+
assert_eq!(Float::MAX.midpoint(-5.0), Float::MAX / 2.0 - 2.5);
359+
assert_eq!(Float::INFINITY.midpoint(Float::INFINITY), Float::INFINITY);
360+
assert_eq!(
361+
Float::NEG_INFINITY.midpoint(Float::NEG_INFINITY),
362+
Float::NEG_INFINITY
363+
);
364+
assert!(Float::NAN.midpoint(1.0).is_nan());
365+
assert!((1.0 as Float).midpoint(Float::NAN).is_nan());
366+
assert!(Float::NAN.midpoint(Float::NAN).is_nan());
367+
}
368+
}
369+
370+
// Separate test since the `for` loops cannot be run in `const`.
371+
float_test! {
372+
name: midpoint_large_magnitude,
373+
attrs: {
374+
const: #[cfg(false)],
375+
f16: #[cfg(any(miri, target_has_reliable_f16_math))],
376+
f128: #[cfg(any(miri, target_has_reliable_f128_math))],
377+
},
378+
test<Float> {
379+
// test if large differences in magnitude are still correctly computed.
380+
// NOTE: that because of how small x and y are, x + y can never overflow
381+
// so (x + y) / 2.0 is always correct
382+
// in particular, `2.pow(i)` will never be at the max exponent, so it could
383+
// be safely doubled, while j is significantly smaller.
384+
for i in Float::MAX_EXP.saturating_sub(64)..Float::MAX_EXP {
385+
for j in 0..64u8 {
386+
let large = (2.0 as Float).powi(i);
387+
// a much smaller number, such that there is no chance of overflow to test
388+
// potential double rounding in midpoint's implementation.
389+
let small = (2.0 as Float).powi(Float::MAX_EXP - 1)
390+
* Float::EPSILON
391+
* Float::from(j);
392+
393+
let naive = (large + small) / 2.0;
394+
let midpoint = large.midpoint(small);
395+
396+
assert_eq!(naive, midpoint);
397+
}
398+
}
399+
}
400+
}
401+
402+
float_test! {
403+
name: abs,
404+
attrs: {
405+
f16: #[cfg(any(miri, target_has_reliable_f16_math))],
406+
f128: #[cfg(any(miri, target_has_reliable_f128_math))],
407+
},
408+
test<Float> {
409+
assert_eq!((-1.0 as Float).abs(), 1.0);
410+
assert_eq!((1.0 as Float).abs(), 1.0);
411+
assert_eq!(Float::NEG_INFINITY.abs(), Float::INFINITY);
412+
assert_eq!(Float::INFINITY.abs(), Float::INFINITY);
413+
}
414+
}
415+
416+
float_test! {
417+
name: copysign,
418+
attrs: {
419+
f16: #[cfg(any(miri, target_has_reliable_f16_math))],
420+
f128: #[cfg(any(miri, target_has_reliable_f128_math))],
421+
},
422+
test<Float> {
423+
assert_eq!((1.0 as Float).copysign(-2.0), -1.0);
424+
assert_eq!((-1.0 as Float).copysign(2.0), 1.0);
425+
assert_eq!(Float::INFINITY.copysign(-0.0), Float::NEG_INFINITY);
426+
assert_eq!(Float::NEG_INFINITY.copysign(0.0), Float::INFINITY);
427+
}
428+
}
429+
430+
float_test! {
431+
name: rem_euclid,
432+
attrs: {
433+
const: #[cfg(false)],
434+
f16: #[cfg(any(miri, target_has_reliable_f16_math))],
435+
f128: #[cfg(any(miri, target_has_reliable_f128_math))],
436+
},
437+
test<Float> {
438+
assert!(Float::INFINITY.rem_euclid(42.0 as Float).is_nan());
439+
assert_eq!((42.0 as Float).rem_euclid(Float::INFINITY), (42.0 as Float));
440+
assert!((42.0 as Float).rem_euclid(Float::NAN).is_nan());
441+
assert!(Float::INFINITY.rem_euclid(Float::INFINITY).is_nan());
442+
assert!(Float::INFINITY.rem_euclid(Float::NAN).is_nan());
443+
assert!(Float::NAN.rem_euclid(Float::INFINITY).is_nan());
444+
}
445+
}
446+
447+
float_test! {
448+
name: div_euclid,
449+
attrs: {
450+
const: #[cfg(false)],
451+
f16: #[cfg(any(miri, target_has_reliable_f16_math))],
452+
f128: #[cfg(any(miri, target_has_reliable_f128_math))],
453+
},
454+
test<Float> {
455+
assert_eq!((42.0 as Float).div_euclid(Float::INFINITY), 0.0);
456+
assert!((42.0 as Float).div_euclid(Float::NAN).is_nan());
457+
assert!(Float::INFINITY.div_euclid(Float::INFINITY).is_nan());
458+
assert!(Float::INFINITY.div_euclid(Float::NAN).is_nan());
459+
assert!(Float::NAN.div_euclid(Float::INFINITY).is_nan());
460+
}
461+
}
462+
463+
float_test! {
464+
name: floor,
465+
attrs: {
466+
f16: #[cfg(any(miri, target_has_reliable_f16_math))],
467+
f128: #[cfg(any(miri, target_has_reliable_f128_math))],
468+
},
469+
test<Float> {
470+
assert_eq!((0.0 as Float).floor(), 0.0);
471+
assert!((0.0 as Float).floor().is_sign_positive());
472+
assert_eq!((-0.0 as Float).floor(), -0.0);
473+
assert!((-0.0 as Float).floor().is_sign_negative());
474+
assert_eq!((0.5 as Float).floor(), 0.0);
475+
assert_eq!((-0.5 as Float).floor(), -1.0);
476+
assert_eq!((1.5 as Float).floor(), 1.0);
477+
assert_eq!(Float::MAX.floor(), Float::MAX);
478+
assert_eq!(Float::MIN.floor(), Float::MIN);
479+
assert_eq!(Float::MIN_POSITIVE.floor(), 0.0);
480+
assert_eq!((-Float::MIN_POSITIVE).floor(), -1.0);
481+
assert!(Float::NAN.floor().is_nan());
482+
assert_eq!(Float::INFINITY.floor(), Float::INFINITY);
483+
assert_eq!(Float::NEG_INFINITY.floor(), Float::NEG_INFINITY);
484+
}
485+
}
486+
487+
float_test! {
488+
name: ceil,
489+
attrs: {
490+
f16: #[cfg(any(miri, target_has_reliable_f16_math))],
491+
f128: #[cfg(any(miri, target_has_reliable_f128_math))],
492+
},
493+
test<Float> {
494+
assert_eq!((0.0 as Float).ceil(), 0.0);
495+
assert!((0.0 as Float).ceil().is_sign_positive());
496+
assert_eq!((-0.0 as Float).ceil(), 0.0);
497+
assert!((-0.0 as Float).ceil().is_sign_negative());
498+
assert_eq!((0.5 as Float).ceil(), 1.0);
499+
assert_eq!((-0.5 as Float).ceil(), 0.0);
500+
assert_eq!(Float::MAX.ceil(), Float::MAX);
501+
assert_eq!(Float::MIN.ceil(), Float::MIN);
502+
assert_eq!(Float::MIN_POSITIVE.ceil(), 1.0);
503+
assert_eq!((-Float::MIN_POSITIVE).ceil(), 0.0);
504+
assert!(Float::NAN.ceil().is_nan());
505+
assert_eq!(Float::INFINITY.ceil(), Float::INFINITY);
506+
assert_eq!(Float::NEG_INFINITY.ceil(), Float::NEG_INFINITY);
507+
}
508+
}
509+
510+
float_test! {
511+
name: round,
512+
attrs: {
513+
f16: #[cfg(any(miri, target_has_reliable_f16_math))],
514+
f128: #[cfg(any(miri, target_has_reliable_f128_math))],
515+
},
516+
test<Float> {
517+
assert_eq!((0.0 as Float).round(), 0.0);
518+
assert!((0.0 as Float).round().is_sign_positive());
519+
assert_eq!((-0.0 as Float).round(), -0.0);
520+
assert!((-0.0 as Float).round().is_sign_negative());
521+
assert_eq!((0.5 as Float).round(), 1.0);
522+
assert_eq!((-0.5 as Float).round(), -1.0);
523+
assert_eq!(Float::MAX.round(), Float::MAX);
524+
assert_eq!(Float::MIN.round(), Float::MIN);
525+
assert_eq!(Float::MIN_POSITIVE.round(), 0.0);
526+
assert_eq!((-Float::MIN_POSITIVE).round(), 0.0);
527+
assert!(Float::NAN.round().is_nan());
528+
assert_eq!(Float::INFINITY.round(), Float::INFINITY);
529+
assert_eq!(Float::NEG_INFINITY.round(), Float::NEG_INFINITY);
530+
}
531+
}
532+
533+
float_test! {
534+
name: round_ties_even,
535+
attrs: {
536+
f16: #[cfg(any(miri, target_has_reliable_f16_math))],
537+
f128: #[cfg(any(miri, target_has_reliable_f128_math))],
538+
},
539+
test<Float> {
540+
assert_eq!((0.0 as Float).round_ties_even(), 0.0);
541+
assert!((0.0 as Float).round_ties_even().is_sign_positive());
542+
assert_eq!((-0.0 as Float).round_ties_even(), -0.0);
543+
assert!((-0.0 as Float).round_ties_even().is_sign_negative());
544+
assert_eq!((0.5 as Float).round_ties_even(), 0.0);
545+
assert!((0.5 as Float).round_ties_even().is_sign_positive());
546+
assert_eq!((-0.5 as Float).round_ties_even(), -0.0);
547+
assert!((-0.5 as Float).round_ties_even().is_sign_negative());
548+
assert_eq!(Float::MAX.round_ties_even(), Float::MAX);
549+
assert_eq!(Float::MIN.round_ties_even(), Float::MIN);
550+
assert_eq!(Float::MIN_POSITIVE.round_ties_even(), 0.0);
551+
assert_eq!((-Float::MIN_POSITIVE).round_ties_even(), 0.0);
552+
assert!(Float::NAN.round_ties_even().is_nan());
553+
assert_eq!(Float::INFINITY.round_ties_even(), Float::INFINITY);
554+
assert_eq!(Float::NEG_INFINITY.round_ties_even(), Float::NEG_INFINITY);
555+
}
556+
}
557+
558+
float_test! {
559+
name: trunc,
560+
attrs: {
561+
f16: #[cfg(any(miri, target_has_reliable_f16_math))],
562+
f128: #[cfg(any(miri, target_has_reliable_f128_math))],
563+
},
564+
test<Float> {
565+
assert_eq!((0.0 as Float).trunc(), 0.0);
566+
assert!((0.0 as Float).trunc().is_sign_positive());
567+
assert_eq!((-0.0 as Float).trunc(), -0.0);
568+
assert!((-0.0 as Float).trunc().is_sign_negative());
569+
assert_eq!((0.5 as Float).trunc(), 0.0);
570+
assert!((0.5 as Float).trunc().is_sign_positive());
571+
assert_eq!((-0.5 as Float).trunc(), -0.0);
572+
assert!((-0.5 as Float).trunc().is_sign_negative());
573+
assert_eq!(Float::MAX.trunc(), Float::MAX);
574+
assert_eq!(Float::MIN.trunc(), Float::MIN);
575+
assert_eq!(Float::MIN_POSITIVE.trunc(), 0.0);
576+
assert_eq!((-Float::MIN_POSITIVE).trunc(), 0.0);
577+
assert!(Float::NAN.trunc().is_nan());
578+
assert_eq!(Float::INFINITY.trunc(), Float::INFINITY);
579+
assert_eq!(Float::NEG_INFINITY.trunc(), Float::NEG_INFINITY);
580+
}
581+
}
582+
583+
float_test! {
584+
name: fract,
585+
attrs: {
586+
f16: #[cfg(any(miri, target_has_reliable_f16_math))],
587+
f128: #[cfg(any(miri, target_has_reliable_f128_math))],
588+
},
589+
test<Float> {
590+
assert_eq!((0.0 as Float).fract(), 0.0);
591+
assert!((0.0 as Float).fract().is_sign_positive());
592+
assert_eq!((-0.0 as Float).fract(), 0.0);
593+
assert!((-0.0 as Float).fract().is_sign_positive());
594+
assert_eq!((0.5 as Float).fract(), 0.5);
595+
assert!((0.5 as Float).fract().is_sign_positive());
596+
assert_eq!((-0.5 as Float).fract(), -0.5);
597+
assert!((-0.5 as Float).fract().is_sign_negative());
598+
assert_eq!(Float::MAX.fract(), 0.0);
599+
assert_eq!(Float::MIN.fract(), 0.0);
600+
assert_eq!(Float::MIN_POSITIVE.fract(), Float::MIN_POSITIVE);
601+
assert!(Float::MIN_POSITIVE.fract().is_sign_positive());
602+
assert_eq!((-Float::MIN_POSITIVE).fract(), -Float::MIN_POSITIVE);
603+
assert!((-Float::MIN_POSITIVE).fract().is_sign_negative());
604+
assert!(Float::NAN.fract().is_nan());
605+
assert!(Float::INFINITY.fract().is_nan());
606+
assert!(Float::NEG_INFINITY.fract().is_nan());
607+
}
608+
}

‎library/coretests/tests/num/mod.rs

Lines changed: 0 additions & 359 deletions
Original file line numberDiff line numberDiff line change
@@ -730,362 +730,3 @@ assume_usize_width! {
730730
}
731731
}
732732
}
733-
734-
// FIXME(141726): there is a lot of duplication between the following tests and
735-
// the tests in `coretests/tests/floats/f*.rs`
736-
// See issue https://github.com/rust-lang/rust/issues/141726 for more details.
737-
macro_rules! test_float {
738-
($modname: ident, $fassert: ident, $fty: ty) => {
739-
mod $modname {
740-
#[test]
741-
fn min() {
742-
$fassert!((0.0 as $fty).min(0.0), 0.0);
743-
$fassert!((0.0 as $fty).min(0.0).is_sign_positive());
744-
$fassert!((-0.0 as $fty).min(-0.0), -0.0);
745-
$fassert!((-0.0 as $fty).min(-0.0).is_sign_negative());
746-
$fassert!((9.0 as $fty).min(9.0), 9.0);
747-
$fassert!((-9.0 as $fty).min(0.0), -9.0);
748-
$fassert!((0.0 as $fty).min(9.0), 0.0);
749-
$fassert!((0.0 as $fty).min(9.0).is_sign_positive());
750-
$fassert!((-0.0 as $fty).min(9.0), -0.0);
751-
$fassert!((-0.0 as $fty).min(9.0).is_sign_negative());
752-
$fassert!((-0.0 as $fty).min(-9.0), -9.0);
753-
$fassert!(<$fty>::INFINITY.min(9.0), 9.0);
754-
$fassert!((9.0 as $fty).min(<$fty>::INFINITY), 9.0);
755-
$fassert!(<$fty>::INFINITY.min(-9.0), -9.0);
756-
$fassert!((-9.0 as $fty).min(<$fty>::INFINITY), -9.0);
757-
$fassert!(<$fty>::NEG_INFINITY.min(9.0), <$fty>::NEG_INFINITY);
758-
$fassert!((9.0 as $fty).min(<$fty>::NEG_INFINITY), <$fty>::NEG_INFINITY);
759-
$fassert!(<$fty>::NEG_INFINITY.min(-9.0), <$fty>::NEG_INFINITY);
760-
$fassert!((-9.0 as $fty).min(<$fty>::NEG_INFINITY), <$fty>::NEG_INFINITY);
761-
$fassert!(<$fty>::NAN.min(9.0), 9.0);
762-
$fassert!(<$fty>::NAN.min(-9.0), -9.0);
763-
$fassert!((9.0 as $fty).min(<$fty>::NAN), 9.0);
764-
$fassert!((-9.0 as $fty).min(<$fty>::NAN), -9.0);
765-
$fassert!(<$fty>::NAN.min(<$fty>::NAN).is_nan());
766-
}
767-
#[test]
768-
fn max() {
769-
$fassert!((0.0 as $fty).max(0.0), 0.0);
770-
$fassert!((0.0 as $fty).max(0.0).is_sign_positive());
771-
$fassert!((-0.0 as $fty).max(-0.0), -0.0);
772-
$fassert!((-0.0 as $fty).max(-0.0).is_sign_negative());
773-
$fassert!((9.0 as $fty).max(9.0), 9.0);
774-
$fassert!((-9.0 as $fty).max(0.0), 0.0);
775-
$fassert!((-9.0 as $fty).max(0.0).is_sign_positive());
776-
$fassert!((-9.0 as $fty).max(-0.0), -0.0);
777-
$fassert!((-9.0 as $fty).max(-0.0).is_sign_negative());
778-
$fassert!((0.0 as $fty).max(9.0), 9.0);
779-
$fassert!((0.0 as $fty).max(-9.0), 0.0);
780-
$fassert!((0.0 as $fty).max(-9.0).is_sign_positive());
781-
$fassert!((-0.0 as $fty).max(-9.0), -0.0);
782-
$fassert!((-0.0 as $fty).max(-9.0).is_sign_negative());
783-
$fassert!(<$fty>::INFINITY.max(9.0), <$fty>::INFINITY);
784-
$fassert!((9.0 as $fty).max(<$fty>::INFINITY), <$fty>::INFINITY);
785-
$fassert!(<$fty>::INFINITY.max(-9.0), <$fty>::INFINITY);
786-
$fassert!((-9.0 as $fty).max(<$fty>::INFINITY), <$fty>::INFINITY);
787-
$fassert!(<$fty>::NEG_INFINITY.max(9.0), 9.0);
788-
$fassert!((9.0 as $fty).max(<$fty>::NEG_INFINITY), 9.0);
789-
$fassert!(<$fty>::NEG_INFINITY.max(-9.0), -9.0);
790-
$fassert!((-9.0 as $fty).max(<$fty>::NEG_INFINITY), -9.0);
791-
$fassert!(<$fty>::NAN.max(9.0), 9.0);
792-
$fassert!(<$fty>::NAN.max(-9.0), -9.0);
793-
$fassert!((9.0 as $fty).max(<$fty>::NAN), 9.0);
794-
$fassert!((-9.0 as $fty).max(<$fty>::NAN), -9.0);
795-
$fassert!(<$fty>::NAN.max(<$fty>::NAN).is_nan());
796-
}
797-
#[test]
798-
fn minimum() {
799-
$fassert!((0.0 as $fty).minimum(0.0), 0.0);
800-
$fassert!((0.0 as $fty).minimum(0.0).is_sign_positive());
801-
$fassert!((-0.0 as $fty).minimum(0.0), -0.0);
802-
$fassert!((-0.0 as $fty).minimum(0.0).is_sign_negative());
803-
$fassert!((-0.0 as $fty).minimum(-0.0), -0.0);
804-
$fassert!((-0.0 as $fty).minimum(-0.0).is_sign_negative());
805-
$fassert!((9.0 as $fty).minimum(9.0), 9.0);
806-
$fassert!((-9.0 as $fty).minimum(0.0), -9.0);
807-
$fassert!((0.0 as $fty).minimum(9.0), 0.0);
808-
$fassert!((0.0 as $fty).minimum(9.0).is_sign_positive());
809-
$fassert!((-0.0 as $fty).minimum(9.0), -0.0);
810-
$fassert!((-0.0 as $fty).minimum(9.0).is_sign_negative());
811-
$fassert!((-0.0 as $fty).minimum(-9.0), -9.0);
812-
$fassert!(<$fty>::INFINITY.minimum(9.0), 9.0);
813-
$fassert!((9.0 as $fty).minimum(<$fty>::INFINITY), 9.0);
814-
$fassert!(<$fty>::INFINITY.minimum(-9.0), -9.0);
815-
$fassert!((-9.0 as $fty).minimum(<$fty>::INFINITY), -9.0);
816-
$fassert!(<$fty>::NEG_INFINITY.minimum(9.0), <$fty>::NEG_INFINITY);
817-
$fassert!((9.0 as $fty).minimum(<$fty>::NEG_INFINITY), <$fty>::NEG_INFINITY);
818-
$fassert!(<$fty>::NEG_INFINITY.minimum(-9.0), <$fty>::NEG_INFINITY);
819-
$fassert!((-9.0 as $fty).minimum(<$fty>::NEG_INFINITY), <$fty>::NEG_INFINITY);
820-
$fassert!(<$fty>::NAN.minimum(9.0).is_nan());
821-
$fassert!(<$fty>::NAN.minimum(-9.0).is_nan());
822-
$fassert!((9.0 as $fty).minimum(<$fty>::NAN).is_nan());
823-
$fassert!((-9.0 as $fty).minimum(<$fty>::NAN).is_nan());
824-
$fassert!(<$fty>::NAN.minimum(<$fty>::NAN).is_nan());
825-
}
826-
#[test]
827-
fn maximum() {
828-
$fassert!((0.0 as $fty).maximum(0.0), 0.0);
829-
$fassert!((0.0 as $fty).maximum(0.0).is_sign_positive());
830-
$fassert!((-0.0 as $fty).maximum(0.0), 0.0);
831-
$fassert!((-0.0 as $fty).maximum(0.0).is_sign_positive());
832-
$fassert!((-0.0 as $fty).maximum(-0.0), -0.0);
833-
$fassert!((-0.0 as $fty).maximum(-0.0).is_sign_negative());
834-
$fassert!((9.0 as $fty).maximum(9.0), 9.0);
835-
$fassert!((-9.0 as $fty).maximum(0.0), 0.0);
836-
$fassert!((-9.0 as $fty).maximum(0.0).is_sign_positive());
837-
$fassert!((-9.0 as $fty).maximum(-0.0), -0.0);
838-
$fassert!((-9.0 as $fty).maximum(-0.0).is_sign_negative());
839-
$fassert!((0.0 as $fty).maximum(9.0), 9.0);
840-
$fassert!((0.0 as $fty).maximum(-9.0), 0.0);
841-
$fassert!((0.0 as $fty).maximum(-9.0).is_sign_positive());
842-
$fassert!((-0.0 as $fty).maximum(-9.0), -0.0);
843-
$fassert!((-0.0 as $fty).maximum(-9.0).is_sign_negative());
844-
$fassert!(<$fty>::INFINITY.maximum(9.0), <$fty>::INFINITY);
845-
$fassert!((9.0 as $fty).maximum(<$fty>::INFINITY), <$fty>::INFINITY);
846-
$fassert!(<$fty>::INFINITY.maximum(-9.0), <$fty>::INFINITY);
847-
$fassert!((-9.0 as $fty).maximum(<$fty>::INFINITY), <$fty>::INFINITY);
848-
$fassert!(<$fty>::NEG_INFINITY.maximum(9.0), 9.0);
849-
$fassert!((9.0 as $fty).maximum(<$fty>::NEG_INFINITY), 9.0);
850-
$fassert!(<$fty>::NEG_INFINITY.maximum(-9.0), -9.0);
851-
$fassert!((-9.0 as $fty).maximum(<$fty>::NEG_INFINITY), -9.0);
852-
$fassert!(<$fty>::NAN.maximum(9.0).is_nan());
853-
$fassert!(<$fty>::NAN.maximum(-9.0).is_nan());
854-
$fassert!((9.0 as $fty).maximum(<$fty>::NAN).is_nan());
855-
$fassert!((-9.0 as $fty).maximum(<$fty>::NAN).is_nan());
856-
$fassert!(<$fty>::NAN.maximum(<$fty>::NAN).is_nan());
857-
}
858-
#[test]
859-
fn midpoint() {
860-
$fassert!((0.5 as $fty).midpoint(0.5), 0.5);
861-
$fassert!((0.5 as $fty).midpoint(2.5), 1.5);
862-
$fassert!((3.0 as $fty).midpoint(4.0), 3.5);
863-
$fassert!((-3.0 as $fty).midpoint(4.0), 0.5);
864-
$fassert!((3.0 as $fty).midpoint(-4.0), -0.5);
865-
$fassert!((-3.0 as $fty).midpoint(-4.0), -3.5);
866-
$fassert!((0.0 as $fty).midpoint(0.0), 0.0);
867-
$fassert!((-0.0 as $fty).midpoint(-0.0), -0.0);
868-
$fassert!((-5.0 as $fty).midpoint(5.0), 0.0);
869-
$fassert!(<$fty>::MAX.midpoint(<$fty>::MIN), 0.0);
870-
$fassert!(<$fty>::MIN.midpoint(<$fty>::MAX), -0.0);
871-
$fassert!(<$fty>::MAX.midpoint(<$fty>::MIN_POSITIVE), <$fty>::MAX / 2.);
872-
$fassert!((-<$fty>::MAX).midpoint(<$fty>::MIN_POSITIVE), -<$fty>::MAX / 2.);
873-
$fassert!(<$fty>::MAX.midpoint(-<$fty>::MIN_POSITIVE), <$fty>::MAX / 2.);
874-
$fassert!((-<$fty>::MAX).midpoint(-<$fty>::MIN_POSITIVE), -<$fty>::MAX / 2.);
875-
$fassert!((<$fty>::MIN_POSITIVE).midpoint(<$fty>::MAX), <$fty>::MAX / 2.);
876-
$fassert!((<$fty>::MIN_POSITIVE).midpoint(-<$fty>::MAX), -<$fty>::MAX / 2.);
877-
$fassert!((-<$fty>::MIN_POSITIVE).midpoint(<$fty>::MAX), <$fty>::MAX / 2.);
878-
$fassert!((-<$fty>::MIN_POSITIVE).midpoint(-<$fty>::MAX), -<$fty>::MAX / 2.);
879-
$fassert!(<$fty>::MAX.midpoint(<$fty>::MAX), <$fty>::MAX);
880-
$fassert!(
881-
(<$fty>::MIN_POSITIVE).midpoint(<$fty>::MIN_POSITIVE),
882-
<$fty>::MIN_POSITIVE
883-
);
884-
$fassert!(
885-
(-<$fty>::MIN_POSITIVE).midpoint(-<$fty>::MIN_POSITIVE),
886-
-<$fty>::MIN_POSITIVE
887-
);
888-
$fassert!(<$fty>::MAX.midpoint(5.0), <$fty>::MAX / 2.0 + 2.5);
889-
$fassert!(<$fty>::MAX.midpoint(-5.0), <$fty>::MAX / 2.0 - 2.5);
890-
$fassert!(<$fty>::INFINITY.midpoint(<$fty>::INFINITY), <$fty>::INFINITY);
891-
$fassert!(
892-
<$fty>::NEG_INFINITY.midpoint(<$fty>::NEG_INFINITY),
893-
<$fty>::NEG_INFINITY
894-
);
895-
$fassert!(<$fty>::NAN.midpoint(1.0).is_nan());
896-
$fassert!((1.0 as $fty).midpoint(<$fty>::NAN).is_nan());
897-
$fassert!(<$fty>::NAN.midpoint(<$fty>::NAN).is_nan());
898-
899-
// test if large differences in magnitude are still correctly computed.
900-
// NOTE: that because of how small x and y are, x + y can never overflow
901-
// so (x + y) / 2.0 is always correct
902-
// in particular, `2.pow(i)` will never be at the max exponent, so it could
903-
// be safely doubled, while j is significantly smaller.
904-
for i in <$fty>::MAX_EXP.saturating_sub(64)..<$fty>::MAX_EXP {
905-
for j in 0..64u8 {
906-
let large = (2.0 as $fty).powi(i);
907-
// a much smaller number, such that there is no chance of overflow to test
908-
// potential double rounding in midpoint's implementation.
909-
let small = (2.0 as $fty).powi(<$fty>::MAX_EXP - 1)
910-
* <$fty>::EPSILON
911-
* <$fty>::from(j);
912-
913-
let naive = (large + small) / 2.0;
914-
let midpoint = large.midpoint(small);
915-
916-
assert_eq!(naive, midpoint);
917-
}
918-
}
919-
}
920-
#[test]
921-
fn abs() {
922-
$fassert!((-1.0 as $fty).abs(), 1.0);
923-
$fassert!((1.0 as $fty).abs(), 1.0);
924-
$fassert!(<$fty>::NEG_INFINITY.abs(), <$fty>::INFINITY);
925-
$fassert!(<$fty>::INFINITY.abs(), <$fty>::INFINITY);
926-
}
927-
#[test]
928-
fn copysign() {
929-
$fassert!((1.0 as $fty).copysign(-2.0), -1.0);
930-
$fassert!((-1.0 as $fty).copysign(2.0), 1.0);
931-
$fassert!(<$fty>::INFINITY.copysign(-0.0), <$fty>::NEG_INFINITY);
932-
$fassert!(<$fty>::NEG_INFINITY.copysign(0.0), <$fty>::INFINITY);
933-
}
934-
#[test]
935-
fn rem_euclid() {
936-
// FIXME: Use $fassert when rem_euclid becomes const
937-
assert!(<$fty>::INFINITY.rem_euclid((42.0 as $fty)).is_nan());
938-
assert_eq!((42.0 as $fty).rem_euclid(<$fty>::INFINITY), (42.0 as $fty));
939-
assert!((42.0 as $fty).rem_euclid(<$fty>::NAN).is_nan());
940-
assert!(<$fty>::INFINITY.rem_euclid(<$fty>::INFINITY).is_nan());
941-
assert!(<$fty>::INFINITY.rem_euclid(<$fty>::NAN).is_nan());
942-
assert!(<$fty>::NAN.rem_euclid(<$fty>::INFINITY).is_nan());
943-
}
944-
#[test]
945-
fn div_euclid() {
946-
// FIXME: Use $fassert when div_euclid becomes const
947-
assert_eq!((42.0 as $fty).div_euclid(<$fty>::INFINITY), 0.0);
948-
assert!((42.0 as $fty).div_euclid(<$fty>::NAN).is_nan());
949-
assert!(<$fty>::INFINITY.div_euclid(<$fty>::INFINITY).is_nan());
950-
assert!(<$fty>::INFINITY.div_euclid(<$fty>::NAN).is_nan());
951-
assert!(<$fty>::NAN.div_euclid(<$fty>::INFINITY).is_nan());
952-
}
953-
#[test]
954-
#[cfg(not(bootstrap))]
955-
fn floor() {
956-
$fassert!((0.0 as $fty).floor(), 0.0);
957-
$fassert!((0.0 as $fty).floor().is_sign_positive());
958-
$fassert!((-0.0 as $fty).floor(), -0.0);
959-
$fassert!((-0.0 as $fty).floor().is_sign_negative());
960-
$fassert!((0.5 as $fty).floor(), 0.0);
961-
$fassert!((-0.5 as $fty).floor(), -1.0);
962-
$fassert!((1.5 as $fty).floor(), 1.0);
963-
$fassert!(<$fty>::MAX.floor(), <$fty>::MAX);
964-
$fassert!(<$fty>::MIN.floor(), <$fty>::MIN);
965-
$fassert!(<$fty>::MIN_POSITIVE.floor(), 0.0);
966-
$fassert!((-<$fty>::MIN_POSITIVE).floor(), -1.0);
967-
$fassert!(<$fty>::NAN.floor().is_nan());
968-
$fassert!(<$fty>::INFINITY.floor(), <$fty>::INFINITY);
969-
$fassert!(<$fty>::NEG_INFINITY.floor(), <$fty>::NEG_INFINITY);
970-
}
971-
#[test]
972-
#[cfg(not(bootstrap))]
973-
fn ceil() {
974-
$fassert!((0.0 as $fty).ceil(), 0.0);
975-
$fassert!((0.0 as $fty).ceil().is_sign_positive());
976-
$fassert!((-0.0 as $fty).ceil(), 0.0);
977-
$fassert!((-0.0 as $fty).ceil().is_sign_negative());
978-
$fassert!((0.5 as $fty).ceil(), 1.0);
979-
$fassert!((-0.5 as $fty).ceil(), 0.0);
980-
$fassert!(<$fty>::MAX.ceil(), <$fty>::MAX);
981-
$fassert!(<$fty>::MIN.ceil(), <$fty>::MIN);
982-
$fassert!(<$fty>::MIN_POSITIVE.ceil(), 1.0);
983-
$fassert!((-<$fty>::MIN_POSITIVE).ceil(), 0.0);
984-
$fassert!(<$fty>::NAN.ceil().is_nan());
985-
$fassert!(<$fty>::INFINITY.ceil(), <$fty>::INFINITY);
986-
$fassert!(<$fty>::NEG_INFINITY.ceil(), <$fty>::NEG_INFINITY);
987-
}
988-
#[test]
989-
#[cfg(not(bootstrap))]
990-
fn round() {
991-
$fassert!((0.0 as $fty).round(), 0.0);
992-
$fassert!((0.0 as $fty).round().is_sign_positive());
993-
$fassert!((-0.0 as $fty).round(), -0.0);
994-
$fassert!((-0.0 as $fty).round().is_sign_negative());
995-
$fassert!((0.5 as $fty).round(), 1.0);
996-
$fassert!((-0.5 as $fty).round(), -1.0);
997-
$fassert!(<$fty>::MAX.round(), <$fty>::MAX);
998-
$fassert!(<$fty>::MIN.round(), <$fty>::MIN);
999-
$fassert!(<$fty>::MIN_POSITIVE.round(), 0.0);
1000-
$fassert!((-<$fty>::MIN_POSITIVE).round(), 0.0);
1001-
$fassert!(<$fty>::NAN.round().is_nan());
1002-
$fassert!(<$fty>::INFINITY.round(), <$fty>::INFINITY);
1003-
$fassert!(<$fty>::NEG_INFINITY.round(), <$fty>::NEG_INFINITY);
1004-
}
1005-
#[test]
1006-
#[cfg(not(bootstrap))]
1007-
fn round_ties_even() {
1008-
$fassert!((0.0 as $fty).round_ties_even(), 0.0);
1009-
$fassert!((0.0 as $fty).round_ties_even().is_sign_positive());
1010-
$fassert!((-0.0 as $fty).round_ties_even(), -0.0);
1011-
$fassert!((-0.0 as $fty).round_ties_even().is_sign_negative());
1012-
$fassert!((0.5 as $fty).round_ties_even(), 0.0);
1013-
$fassert!((0.5 as $fty).round_ties_even().is_sign_positive());
1014-
$fassert!((-0.5 as $fty).round_ties_even(), -0.0);
1015-
$fassert!((-0.5 as $fty).round_ties_even().is_sign_negative());
1016-
$fassert!(<$fty>::MAX.round_ties_even(), <$fty>::MAX);
1017-
$fassert!(<$fty>::MIN.round_ties_even(), <$fty>::MIN);
1018-
$fassert!(<$fty>::MIN_POSITIVE.round_ties_even(), 0.0);
1019-
$fassert!((-<$fty>::MIN_POSITIVE).round_ties_even(), 0.0);
1020-
$fassert!(<$fty>::NAN.round_ties_even().is_nan());
1021-
$fassert!(<$fty>::INFINITY.round_ties_even(), <$fty>::INFINITY);
1022-
$fassert!(<$fty>::NEG_INFINITY.round_ties_even(), <$fty>::NEG_INFINITY);
1023-
}
1024-
#[test]
1025-
#[cfg(not(bootstrap))]
1026-
fn trunc() {
1027-
$fassert!((0.0 as $fty).trunc(), 0.0);
1028-
$fassert!((0.0 as $fty).trunc().is_sign_positive());
1029-
$fassert!((-0.0 as $fty).trunc(), -0.0);
1030-
$fassert!((-0.0 as $fty).trunc().is_sign_negative());
1031-
$fassert!((0.5 as $fty).trunc(), 0.0);
1032-
$fassert!((0.5 as $fty).trunc().is_sign_positive());
1033-
$fassert!((-0.5 as $fty).trunc(), -0.0);
1034-
$fassert!((-0.5 as $fty).trunc().is_sign_negative());
1035-
$fassert!(<$fty>::MAX.trunc(), <$fty>::MAX);
1036-
$fassert!(<$fty>::MIN.trunc(), <$fty>::MIN);
1037-
$fassert!(<$fty>::MIN_POSITIVE.trunc(), 0.0);
1038-
$fassert!((-<$fty>::MIN_POSITIVE).trunc(), 0.0);
1039-
$fassert!(<$fty>::NAN.trunc().is_nan());
1040-
$fassert!(<$fty>::INFINITY.trunc(), <$fty>::INFINITY);
1041-
$fassert!(<$fty>::NEG_INFINITY.trunc(), <$fty>::NEG_INFINITY);
1042-
}
1043-
#[test]
1044-
#[cfg(not(bootstrap))]
1045-
fn fract() {
1046-
$fassert!((0.0 as $fty).fract(), 0.0);
1047-
$fassert!((0.0 as $fty).fract().is_sign_positive());
1048-
$fassert!((-0.0 as $fty).fract(), 0.0);
1049-
$fassert!((-0.0 as $fty).fract().is_sign_positive());
1050-
$fassert!((0.5 as $fty).fract(), 0.5);
1051-
$fassert!((0.5 as $fty).fract().is_sign_positive());
1052-
$fassert!((-0.5 as $fty).fract(), -0.5);
1053-
$fassert!((-0.5 as $fty).fract().is_sign_negative());
1054-
$fassert!(<$fty>::MAX.fract(), 0.0);
1055-
$fassert!(<$fty>::MIN.fract(), 0.0);
1056-
$fassert!(<$fty>::MIN_POSITIVE.fract(), <$fty>::MIN_POSITIVE);
1057-
$fassert!(<$fty>::MIN_POSITIVE.fract().is_sign_positive());
1058-
$fassert!((-<$fty>::MIN_POSITIVE).fract(), -<$fty>::MIN_POSITIVE);
1059-
$fassert!((-<$fty>::MIN_POSITIVE).fract().is_sign_negative());
1060-
$fassert!(<$fty>::NAN.fract().is_nan());
1061-
$fassert!(<$fty>::INFINITY.fract().is_nan());
1062-
$fassert!(<$fty>::NEG_INFINITY.fract().is_nan());
1063-
}
1064-
}
1065-
};
1066-
}
1067-
1068-
// Custom assert macro that distribute between assert! and assert_eq! in a non-const context
1069-
macro_rules! float_assert {
1070-
($b:expr) => {
1071-
assert!($b);
1072-
};
1073-
($left:expr, $right:expr) => {
1074-
assert_eq!($left, $right);
1075-
};
1076-
}
1077-
1078-
// Custom assert macro that only uses assert! in a const context
1079-
macro_rules! float_const_assert {
1080-
($b:expr) => {
1081-
assert!(const { $b });
1082-
};
1083-
($left:expr, $right:expr) => {
1084-
assert!(const { $left == $right });
1085-
};
1086-
}
1087-
1088-
test_float!(f32, float_assert, f32);
1089-
test_float!(f32_const, float_const_assert, f32);
1090-
test_float!(f64, float_assert, f64);
1091-
test_float!(f64_const, float_const_assert, f64);

0 commit comments

Comments
 (0)
Please sign in to comment.