diff --git a/doc/changelog.md b/doc/changelog.md index ea15a32c..acb9a10c 100644 --- a/doc/changelog.md +++ b/doc/changelog.md @@ -1,6 +1,11 @@ # Changelog +## Work In Progress + +The `wuffs_base__parse_number_f64` function has been further optimized. + + ## 2023-04-07 version 0.3.2 The `std/bmp` and `std/nie` image decoders' `decode_frame` method now allow diff --git a/internal/cgen/base/floatconv-submodule-code.c b/internal/cgen/base/floatconv-submodule-code.c index 7691182e..ca109643 100644 --- a/internal/cgen/base/floatconv-submodule-code.c +++ b/internal/cgen/base/floatconv-submodule-code.c @@ -1304,24 +1304,41 @@ wuffs_base__private_implementation__high_prec_dec__to_f64( // approach taken in wuffs_base__parse_number_f64. The latter is optimized // for the common cases (e.g. assuming no underscores or a leading '+' // sign) rather than the full set of cases allowed by the Wuffs API. - if (h->num_digits <= 19) { + // + // When we have 19 or fewer mantissa digits, run Eisel-Lemire once (trying + // for an exact result). When we have more than 19 mantissa digits, run it + // twice to get a lower and upper bound. We still have an exact result + // (within f64's rounding margin) if both bounds are equal (and valid). + uint32_t i_max = h->num_digits; + if (i_max > 19) { + i_max = 19; + } + int32_t exp10 = h->decimal_point - ((int32_t)i_max); + if ((-307 <= exp10) && (exp10 <= 288)) { uint64_t man = 0; uint32_t i; - for (i = 0; i < h->num_digits; i++) { + for (i = 0; i < i_max; i++) { man = (10 * man) + h->digits[i]; } - int32_t exp10 = h->decimal_point - ((int32_t)(h->num_digits)); - if ((man != 0) && (-307 <= exp10) && (exp10 <= 288)) { - int64_t r = + while (man != 0) { // The 'while' is just an 'if' that we can 'break'. + int64_t r0 = wuffs_base__private_implementation__parse_number_f64_eisel_lemire( - man, exp10); - if (r >= 0) { - wuffs_base__result_f64 ret; - ret.status.repr = NULL; - ret.value = wuffs_base__ieee_754_bit_representation__from_u64_to_f64( - ((uint64_t)r) | (((uint64_t)(h->negative)) << 63)); - return ret; + man + 0, exp10); + if (r0 < 0) { + break; + } else if (h->num_digits > 19) { + int64_t r1 = + wuffs_base__private_implementation__parse_number_f64_eisel_lemire( + man + 1, exp10); + if (r1 != r0) { + break; + } } + wuffs_base__result_f64 ret; + ret.status.repr = NULL; + ret.value = wuffs_base__ieee_754_bit_representation__from_u64_to_f64( + ((uint64_t)r0) | (((uint64_t)(h->negative)) << 63)); + return ret; } } diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index d15b619c..41edefa0 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -14821,24 +14821,41 @@ wuffs_base__private_implementation__high_prec_dec__to_f64( // approach taken in wuffs_base__parse_number_f64. The latter is optimized // for the common cases (e.g. assuming no underscores or a leading '+' // sign) rather than the full set of cases allowed by the Wuffs API. - if (h->num_digits <= 19) { + // + // When we have 19 or fewer mantissa digits, run Eisel-Lemire once (trying + // for an exact result). When we have more than 19 mantissa digits, run it + // twice to get a lower and upper bound. We still have an exact result + // (within f64's rounding margin) if both bounds are equal (and valid). + uint32_t i_max = h->num_digits; + if (i_max > 19) { + i_max = 19; + } + int32_t exp10 = h->decimal_point - ((int32_t)i_max); + if ((-307 <= exp10) && (exp10 <= 288)) { uint64_t man = 0; uint32_t i; - for (i = 0; i < h->num_digits; i++) { + for (i = 0; i < i_max; i++) { man = (10 * man) + h->digits[i]; } - int32_t exp10 = h->decimal_point - ((int32_t)(h->num_digits)); - if ((man != 0) && (-307 <= exp10) && (exp10 <= 288)) { - int64_t r = + while (man != 0) { // The 'while' is just an 'if' that we can 'break'. + int64_t r0 = wuffs_base__private_implementation__parse_number_f64_eisel_lemire( - man, exp10); - if (r >= 0) { - wuffs_base__result_f64 ret; - ret.status.repr = NULL; - ret.value = wuffs_base__ieee_754_bit_representation__from_u64_to_f64( - ((uint64_t)r) | (((uint64_t)(h->negative)) << 63)); - return ret; + man + 0, exp10); + if (r0 < 0) { + break; + } else if (h->num_digits > 19) { + int64_t r1 = + wuffs_base__private_implementation__parse_number_f64_eisel_lemire( + man + 1, exp10); + if (r1 != r0) { + break; + } } + wuffs_base__result_f64 ret; + ret.status.repr = NULL; + ret.value = wuffs_base__ieee_754_bit_representation__from_u64_to_f64( + ((uint64_t)r0) | (((uint64_t)(h->negative)) << 63)); + return ret; } } diff --git a/script/print-render-number-f64-tests.go b/script/print-render-number-f64-tests.go index 792e2d0f..ef47c1c5 100644 --- a/script/print-render-number-f64-tests.go +++ b/script/print-render-number-f64-tests.go @@ -182,6 +182,7 @@ var u64TestCases = []uint64{ 0x44B52D02C7E14AF6, 0x46293E5939A08CEA, 0x54B249AD2594C37D, + 0x54B2987670ADB613, 0x7BBA44DF832B8D46, 0x7BF06B0BB1FB384C, 0x7C2485CE9E7A065F, diff --git a/test/c/std/json.c b/test/c/std/json.c index 420118b9..f82bc611 100644 --- a/test/c/std/json.c +++ b/test/c/std/json.c @@ -1026,6 +1026,7 @@ test_wuffs_strconv_parse_number_f64_regular() { {.want = 0x46293E5939A08CEA, .str = "1e30"}, {.want = 0x54B249AD2594C37D, .str = "+1E+100"}, {.want = 0x54B249AD2594C37D, .str = "+_1_E_+_1_0_0_"}, + {.want = 0x54B2987670ADB613, .str = "1.0168286519992372611942638e+100"}, {.want = 0x7BBA44DF832B8D46, .str = "1e+288"}, {.want = 0x7BF06B0BB1FB384C, .str = "1e+289"}, {.want = 0x7C2485CE9E7A065F, .str = "1e+290"}, @@ -1943,6 +1944,19 @@ test_wuffs_strconv_render_number_f64() { "4.000", .want_4g = "1e+100", }, + { + .x = 0x54B2987670ADB613, + .want__e = "1.0168286519992373e+100", + .want__f = "10168286519992373000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000" + "0", + .want_0g = "1e+100", + .want_2e = "1.02e+100", + .want_3f = "10168286519992372611942638135241625267907715220891" + "31363562982164291689352904657807934098133246961254" + "4.000", + .want_4g = "1.017e+100", + }, { .x = 0x7BBA44DF832B8D46, .want__e = "1e+288",