`100000000000000000000000.000000000000001` is `1e+23` instead of `1.0000000000000001e+23`

[jakebailey]

I bisected this to 9936606

Before this commit, quickjs matches other engines and prints 1.0000000000000001e+23, but after, it prints 1e+23.

(Found the same way as #449, but I mistakenly though it was a ccgo bug because I had not tested master here. Oops.)

[bellard]

Even if QuickJS does not return the correct result in this case, it is compliant with the spec because it requires parsing at least 20 digits in base 10 (see section 7.1.4.1.3 RoundMVResult (n)).

[jakebailey]

I'm not sure I understand; I'm using a literal in this example, but I actually had found this via constructing the float from bits directly.

I would definitely argue that this should be specified, if the spec really doesn't cover this, as there are tools like TypeScript which need to understand how a number will stringify to then use within a string literal. Like: https://www.typescriptlang.org/play/?#code/MYewdgzgLgBAHjAvDABgEgN4EYAMf8GFF4B0xxWAvigFAD0dMTMAegPxA

(But, I'm pretty sure parsing this literally should still be fine too, given quickjs does actually parse it fine into the expected bits)

[jakebailey]

Hm, I guess the stringification isn't the problem as you noted.

const example = 100000000000000000000000.000000000000001;
const expectedBits = [ 3353430775, 1152724226 ];

function fromBits(bits) {
	const buffer = new ArrayBuffer(8);
	(new Uint32Array(buffer))[0] = bits[0];
	(new Uint32Array(buffer))[1] = bits[1];
	return new Float64Array(buffer)[0];
}

function toBits(number) {
	const buffer = new ArrayBuffer(8);
	(new Float64Array(buffer))[0] = number;
	return [(new Uint32Array(buffer))[0], (new Uint32Array(buffer))[1]];
}

console.log('Example number:', example);
const bits = toBits(example);
console.log('Bits:', bits);
const reconstructed = fromBits(bits);
console.log('Reconstructed number:', reconstructed);
console.log('Equal to original:', reconstructed === example);
console.log('---');
console.log('Expected bits:', expectedBits);
console.log('Bits match expected:', bits[0] === expectedBits[0] && bits[1] === expectedBits[1]);
console.log('Reconstructed from expected bits:', fromBits(expectedBits));

V8, JSC, Graal, spidermonkey, say the following:

Example number: 1.0000000000000001e+23
Bits: [ 3353430775, 1152724226 ]
Reconstructed number: 1.0000000000000001e+23
Equal to original: true
---
Expected bits: [ 3353430775, 1152724226 ]
Bits match expected: true
Reconstructed from expected bits: 1.0000000000000001e+23

But QuickJS says:

Example number: 1e+23
Bits: [ 3353430774, 1152724226 ]
Reconstructed number: 1e+23
Equal to original: true
---
Expected bits: [ 3353430775, 1152724226 ]
Bits match expected: false
Reconstructed from expected bits: 1.0000000000000001e+23

I still think this is worth fixing ☹️

[bellard]

Sorry if I was not clear: the problem you noticed is in the string to number conversion. QuickJS takes only into account the first 38 digits after the first non zero digits and it is fully compliant with the spec.

Taking into account more digits is possible but it uses more memory and CPU time for little added benefit.