summaryrefslogtreecommitdiffstats
path: root/third_party/rust/minimal-lexical/tests/lemire_tests.rs
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /third_party/rust/minimal-lexical/tests/lemire_tests.rs
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'third_party/rust/minimal-lexical/tests/lemire_tests.rs')
-rw-r--r--third_party/rust/minimal-lexical/tests/lemire_tests.rs378
1 files changed, 378 insertions, 0 deletions
diff --git a/third_party/rust/minimal-lexical/tests/lemire_tests.rs b/third_party/rust/minimal-lexical/tests/lemire_tests.rs
new file mode 100644
index 0000000000..0523ca5b2a
--- /dev/null
+++ b/third_party/rust/minimal-lexical/tests/lemire_tests.rs
@@ -0,0 +1,378 @@
+//! These tests are adapted from the Rust core library's unittests.
+
+#![cfg(not(feature = "compact"))]
+
+use minimal_lexical::lemire;
+use minimal_lexical::num::Float;
+
+fn compute_error32(q: i32, w: u64) -> (i32, u64) {
+ let fp = lemire::compute_error::<f32>(q, w);
+ (fp.exp, fp.mant)
+}
+
+fn compute_error64(q: i32, w: u64) -> (i32, u64) {
+ let fp = lemire::compute_error::<f64>(q, w);
+ (fp.exp, fp.mant)
+}
+
+fn compute_error_scaled32(q: i32, w: u64, lz: i32) -> (i32, u64) {
+ let fp = lemire::compute_error_scaled::<f32>(q, w, lz);
+ (fp.exp, fp.mant)
+}
+
+fn compute_error_scaled64(q: i32, w: u64, lz: i32) -> (i32, u64) {
+ let fp = lemire::compute_error_scaled::<f64>(q, w, lz);
+ (fp.exp, fp.mant)
+}
+
+fn compute_float32(q: i32, w: u64) -> (i32, u64) {
+ let fp = lemire::compute_float::<f32>(q, w);
+ (fp.exp, fp.mant)
+}
+
+fn compute_float64(q: i32, w: u64) -> (i32, u64) {
+ let fp = lemire::compute_float::<f64>(q, w);
+ (fp.exp, fp.mant)
+}
+
+#[test]
+fn compute_error32_test() {
+ // These test near-halfway cases for single-precision floats.
+ assert_eq!(compute_error32(0, 16777216), (111 + f32::INVALID_FP, 9223372036854775808));
+ assert_eq!(compute_error32(0, 16777217), (111 + f32::INVALID_FP, 9223372586610589696));
+ assert_eq!(compute_error32(0, 16777218), (111 + f32::INVALID_FP, 9223373136366403584));
+ assert_eq!(compute_error32(0, 16777219), (111 + f32::INVALID_FP, 9223373686122217472));
+ assert_eq!(compute_error32(0, 16777220), (111 + f32::INVALID_FP, 9223374235878031360));
+
+ // These are examples of the above tests, with
+ // digits from the exponent shifted to the mantissa.
+ assert_eq!(
+ compute_error32(-10, 167772160000000000),
+ (111 + f32::INVALID_FP, 9223372036854775808)
+ );
+ assert_eq!(
+ compute_error32(-10, 167772170000000000),
+ (111 + f32::INVALID_FP, 9223372586610589696)
+ );
+ assert_eq!(
+ compute_error32(-10, 167772180000000000),
+ (111 + f32::INVALID_FP, 9223373136366403584)
+ );
+ // Let's check the lines to see if anything is different in table...
+ assert_eq!(
+ compute_error32(-10, 167772190000000000),
+ (111 + f32::INVALID_FP, 9223373686122217472)
+ );
+ assert_eq!(
+ compute_error32(-10, 167772200000000000),
+ (111 + f32::INVALID_FP, 9223374235878031360)
+ );
+}
+
+#[test]
+fn compute_error64_test() {
+ // These test near-halfway cases for double-precision floats.
+ assert_eq!(compute_error64(0, 9007199254740992), (1065 + f64::INVALID_FP, 9223372036854775808));
+ assert_eq!(compute_error64(0, 9007199254740993), (1065 + f64::INVALID_FP, 9223372036854776832));
+ assert_eq!(compute_error64(0, 9007199254740994), (1065 + f64::INVALID_FP, 9223372036854777856));
+ assert_eq!(compute_error64(0, 9007199254740995), (1065 + f64::INVALID_FP, 9223372036854778880));
+ assert_eq!(compute_error64(0, 9007199254740996), (1065 + f64::INVALID_FP, 9223372036854779904));
+ assert_eq!(
+ compute_error64(0, 18014398509481984),
+ (1066 + f64::INVALID_FP, 9223372036854775808)
+ );
+ assert_eq!(
+ compute_error64(0, 18014398509481986),
+ (1066 + f64::INVALID_FP, 9223372036854776832)
+ );
+ assert_eq!(
+ compute_error64(0, 18014398509481988),
+ (1066 + f64::INVALID_FP, 9223372036854777856)
+ );
+ assert_eq!(
+ compute_error64(0, 18014398509481990),
+ (1066 + f64::INVALID_FP, 9223372036854778880)
+ );
+ assert_eq!(
+ compute_error64(0, 18014398509481992),
+ (1066 + f64::INVALID_FP, 9223372036854779904)
+ );
+
+ // Test a much closer set of examples.
+ assert_eq!(
+ compute_error64(0, 9007199254740991),
+ (1064 + f64::INVALID_FP, 18446744073709549568)
+ );
+ assert_eq!(
+ compute_error64(0, 9223372036854776831),
+ (1075 + f64::INVALID_FP, 9223372036854776830)
+ );
+ assert_eq!(
+ compute_error64(0, 9223372036854776832),
+ (1075 + f64::INVALID_FP, 9223372036854776832)
+ );
+ assert_eq!(
+ compute_error64(0, 9223372036854776833),
+ (1075 + f64::INVALID_FP, 9223372036854776832)
+ );
+ assert_eq!(
+ compute_error64(-42, 9123456727292927),
+ (925 + f64::INVALID_FP, 13021432563531497894)
+ );
+ assert_eq!(
+ compute_error64(-43, 91234567272929275),
+ (925 + f64::INVALID_FP, 13021432563531498606)
+ );
+ assert_eq!(
+ compute_error64(-42, 9123456727292928),
+ (925 + f64::INVALID_FP, 13021432563531499320)
+ );
+
+ // These are examples of the above tests, with
+ // digits from the exponent shifted to the mantissa.
+ assert_eq!(
+ compute_error64(-3, 9007199254740992000),
+ (1065 + f64::INVALID_FP, 9223372036854775808)
+ );
+ assert_eq!(
+ compute_error64(-3, 9007199254740993000),
+ (1065 + f64::INVALID_FP, 9223372036854776832)
+ );
+ assert_eq!(
+ compute_error64(-3, 9007199254740994000),
+ (1065 + f64::INVALID_FP, 9223372036854777856)
+ );
+ assert_eq!(
+ compute_error64(-3, 9007199254740995000),
+ (1065 + f64::INVALID_FP, 9223372036854778880)
+ );
+ assert_eq!(
+ compute_error64(-3, 9007199254740996000),
+ (1065 + f64::INVALID_FP, 9223372036854779904)
+ );
+
+ // Test from errors in atof.
+ assert_eq!(
+ compute_error64(-18, 1000000178813934326),
+ (1012 + f64::INVALID_FP, 9223373686122217470)
+ );
+
+ // Check edge-cases from previous errors.
+ assert_eq!(
+ compute_error64(-342, 2470328229206232720),
+ (-64 + f64::INVALID_FP, 18446744073709551608)
+ );
+}
+
+#[test]
+fn compute_error_scaled32_test() {
+ // These are the same examples above, just using pre-computed scaled values.
+
+ // These test near-halfway cases for single-precision floats.
+ assert_eq!(
+ compute_error_scaled32(0, 4611686018427387904, 39),
+ (111 + f32::INVALID_FP, 9223372036854775808)
+ );
+ assert_eq!(
+ compute_error_scaled32(0, 4611686293305294848, 39),
+ (111 + f32::INVALID_FP, 9223372586610589696)
+ );
+ assert_eq!(
+ compute_error_scaled32(0, 4611686568183201792, 39),
+ (111 + f32::INVALID_FP, 9223373136366403584)
+ );
+ assert_eq!(
+ compute_error_scaled32(0, 4611686843061108736, 39),
+ (111 + f32::INVALID_FP, 9223373686122217472)
+ );
+ assert_eq!(
+ compute_error_scaled32(0, 4611687117939015680, 39),
+ (111 + f32::INVALID_FP, 9223374235878031360)
+ );
+
+ assert_eq!(
+ compute_error_scaled32(-10, 9223372036854775808, 6),
+ (111 + f32::INVALID_FP, 9223372036854775808)
+ );
+ assert_eq!(
+ compute_error_scaled32(-10, 9223372586610589696, 6),
+ (111 + f32::INVALID_FP, 9223372586610589696)
+ );
+ assert_eq!(
+ compute_error_scaled32(-10, 9223373136366403584, 6),
+ (111 + f32::INVALID_FP, 9223373136366403584)
+ );
+ assert_eq!(
+ compute_error_scaled32(-10, 9223373686122217472, 6),
+ (111 + f32::INVALID_FP, 9223373686122217472)
+ );
+ assert_eq!(
+ compute_error_scaled32(-10, 9223374235878031360, 6),
+ (111 + f32::INVALID_FP, 9223374235878031360)
+ );
+}
+
+#[test]
+fn compute_error_scaled64_test() {
+ // These are the same examples above, just using pre-computed scaled values.
+
+ // These test near-halfway cases for double-precision floats.
+ assert_eq!(
+ compute_error_scaled64(0, 4611686018427387904, 10),
+ (1065 + f64::INVALID_FP, 9223372036854775808)
+ );
+ assert_eq!(
+ compute_error_scaled64(0, 4611686018427388416, 10),
+ (1065 + f64::INVALID_FP, 9223372036854776832)
+ );
+ assert_eq!(
+ compute_error_scaled64(0, 4611686018427388928, 10),
+ (1065 + f64::INVALID_FP, 9223372036854777856)
+ );
+ assert_eq!(
+ compute_error_scaled64(0, 4611686018427389440, 10),
+ (1065 + f64::INVALID_FP, 9223372036854778880)
+ );
+ assert_eq!(
+ compute_error_scaled64(0, 4611686018427389952, 10),
+ (1065 + f64::INVALID_FP, 9223372036854779904)
+ );
+ assert_eq!(
+ compute_error_scaled64(0, 4611686018427387904, 9),
+ (1066 + f64::INVALID_FP, 9223372036854775808)
+ );
+ assert_eq!(
+ compute_error_scaled64(0, 4611686018427388416, 9),
+ (1066 + f64::INVALID_FP, 9223372036854776832)
+ );
+ assert_eq!(
+ compute_error_scaled64(0, 4611686018427388928, 9),
+ (1066 + f64::INVALID_FP, 9223372036854777856)
+ );
+ assert_eq!(
+ compute_error_scaled64(0, 4611686018427389440, 9),
+ (1066 + f64::INVALID_FP, 9223372036854778880)
+ );
+ assert_eq!(
+ compute_error_scaled64(0, 4611686018427389952, 9),
+ (1066 + f64::INVALID_FP, 9223372036854779904)
+ );
+
+ // Test a much closer set of examples.
+ assert_eq!(
+ compute_error_scaled64(0, 9223372036854774784, 11),
+ (1064 + f64::INVALID_FP, 18446744073709549568)
+ );
+ assert_eq!(
+ compute_error_scaled64(0, 4611686018427388415, 0),
+ (1075 + f64::INVALID_FP, 9223372036854776830)
+ );
+ assert_eq!(
+ compute_error_scaled64(0, 4611686018427388416, 0),
+ (1075 + f64::INVALID_FP, 9223372036854776832)
+ );
+ assert_eq!(
+ compute_error_scaled64(0, 4611686018427388416, 0),
+ (1075 + f64::INVALID_FP, 9223372036854776832)
+ );
+ assert_eq!(
+ compute_error_scaled64(-42, 6510716281765748947, 10),
+ (925 + f64::INVALID_FP, 13021432563531497894)
+ );
+ assert_eq!(
+ compute_error_scaled64(-43, 6510716281765749303, 7),
+ (925 + f64::INVALID_FP, 13021432563531498606)
+ );
+ assert_eq!(
+ compute_error_scaled64(-42, 6510716281765749660, 10),
+ (925 + f64::INVALID_FP, 13021432563531499320)
+ );
+
+ // These are examples of the above tests, with
+ // digits from the exponent shifted to the mantissa.
+ assert_eq!(
+ compute_error_scaled64(-3, 9223372036854775808, 1),
+ (1065 + f64::INVALID_FP, 9223372036854775808)
+ );
+ assert_eq!(
+ compute_error_scaled64(-3, 9223372036854776832, 1),
+ (1065 + f64::INVALID_FP, 9223372036854776832)
+ );
+ assert_eq!(
+ compute_error_scaled64(-3, 9223372036854777856, 1),
+ (1065 + f64::INVALID_FP, 9223372036854777856)
+ );
+ assert_eq!(
+ compute_error_scaled64(-3, 9223372036854778880, 1),
+ (1065 + f64::INVALID_FP, 9223372036854778880)
+ );
+ assert_eq!(
+ compute_error_scaled64(-3, 9223372036854779904, 1),
+ (1065 + f64::INVALID_FP, 9223372036854779904)
+ );
+
+ // Test from errors in atof.
+ assert_eq!(
+ compute_error_scaled64(-18, 9223373686122217470, 4),
+ (1012 + f64::INVALID_FP, 9223373686122217470)
+ );
+
+ // Check edge-cases from previous errors.
+ assert_eq!(
+ compute_error_scaled64(-342, 9223372036854775804, 2),
+ (-64 + f64::INVALID_FP, 18446744073709551608)
+ );
+}
+
+#[test]
+fn compute_float_f32_rounding() {
+ // These test near-halfway cases for single-precision floats.
+ assert_eq!(compute_float32(0, 16777216), (151, 0));
+ assert_eq!(compute_float32(0, 16777217), (151, 0));
+ assert_eq!(compute_float32(0, 16777218), (151, 1));
+ assert_eq!(compute_float32(0, 16777219), (151, 2));
+ assert_eq!(compute_float32(0, 16777220), (151, 2));
+
+ // These are examples of the above tests, with
+ // digits from the exponent shifted to the mantissa.
+ assert_eq!(compute_float32(-10, 167772160000000000), (151, 0));
+ assert_eq!(compute_float32(-10, 167772170000000000), (151, 0));
+ assert_eq!(compute_float32(-10, 167772180000000000), (151, 1));
+ // Let's check the lines to see if anything is different in table...
+ assert_eq!(compute_float32(-10, 167772190000000000), (151, 2));
+ assert_eq!(compute_float32(-10, 167772200000000000), (151, 2));
+}
+
+#[test]
+fn compute_float_f64_rounding() {
+ // Also need to check halfway cases **inside** that exponent range.
+
+ // These test near-halfway cases for double-precision floats.
+ assert_eq!(compute_float64(0, 9007199254740992), (1076, 0));
+ assert_eq!(compute_float64(0, 9007199254740993), (1076, 0));
+ assert_eq!(compute_float64(0, 9007199254740994), (1076, 1));
+ assert_eq!(compute_float64(0, 9007199254740995), (1076, 2));
+ assert_eq!(compute_float64(0, 9007199254740996), (1076, 2));
+ assert_eq!(compute_float64(0, 18014398509481984), (1077, 0));
+ assert_eq!(compute_float64(0, 18014398509481986), (1077, 0));
+ assert_eq!(compute_float64(0, 18014398509481988), (1077, 1));
+ assert_eq!(compute_float64(0, 18014398509481990), (1077, 2));
+ assert_eq!(compute_float64(0, 18014398509481992), (1077, 2));
+
+ // Test a much closer set of examples.
+ assert_eq!(compute_float64(0, 9007199254740991), (1075, 4503599627370495));
+ assert_eq!(compute_float64(0, 9223372036854776831), (1086, 0));
+ assert_eq!(compute_float64(0, 9223372036854776832), (1086, 0));
+ assert_eq!(compute_float64(0, 9223372036854776833), (1086, 1));
+ assert_eq!(compute_float64(-42, 9123456727292927), (936, 1854521741541368));
+ assert_eq!(compute_float64(-43, 91234567272929275), (936, 1854521741541369));
+ assert_eq!(compute_float64(-42, 9123456727292928), (936, 1854521741541369));
+
+ // These are examples of the above tests, with
+ // digits from the exponent shifted to the mantissa.
+ assert_eq!(compute_float64(-3, 9007199254740992000), (1076, 0));
+ assert_eq!(compute_float64(-3, 9007199254740993000), (1076, 0));
+ assert_eq!(compute_float64(-3, 9007199254740994000), (1076, 1));
+ assert_eq!(compute_float64(-3, 9007199254740995000), (1076, 2));
+ assert_eq!(compute_float64(-3, 9007199254740996000), (1076, 2));
+}