JSON to Dart Class
Generate Dart model classes with fromJson and toJson from a sample payload.
See a float’s sign, exponent, mantissa and its exact decimal value.
A decimal number, or a bit pattern written as 0x3FB999999999999A to go the other way.
The IEEE 754 Converter prints the exact decimal value a float really holds — all fifty-five digits of it for 0.1 — rather than the rounded one your language displays, which is the actual answer to why 0.1 + 0.2 is not 0.3.
Pull a floating-point number apart: the sign bit, the exponent, the mantissa, the hexadecimal pattern, and — most usefully — the exact decimal value those bits actually represent, rather than the rounded one your language prints.
That exact value is the answer to the question everyone eventually asks. 0.1 stored as a double is really 0.1000000000000000055511151231257827021181583404541015625, because one tenth is a repeating fraction in binary just as one third is in decimal, and it has to be cut off somewhere. Add two of those approximations together and the small errors survive into the result — which is the whole of why 0.1 + 0.2 does not equal 0.3. The converter also gives the next representable value in each direction, which is the size of the gap at that magnitude.
0.1 is really 0.1000000000000000055511151231257827021181583404541015625. Computed with big integers, so it is exact rather than another approximation.
Sign bit, exponent with its bias removed, and mantissa with the implied leading 1 explained.
Half, single and double — useful when a value survives float64 and collapses in float32.
Enter a decimal to get the bits, or a hex pattern to get the value back.
The next representable number up and down, which is the size of the gap at that magnitude.
A decimal value, or a bit pattern written as 0x… to go the other way.
Half, single or double — 16, 32 or 64 bits.
Sign, exponent and mantissa, separated and explained.
The full decimal expansion, and how far it sits from what you typed.
Because neither 0.1 nor 0.2 is exactly representable in binary. Each is stored as the nearest double, their tiny errors add, and the sum lands one step away from the double nearest 0.3. Print the exact values here and it stops being surprising.
It holds the significant digits; the exponent says where the binary point goes. For a normal number a leading 1 is implied and not stored, which buys one extra bit of precision for free.
One so close to zero that the implied leading 1 has to be abandoned, trading precision for the ability to represent smaller values. It is what stops a subtraction of two nearby tiny numbers from collapsing straight to zero.
It has 23 mantissa bits against a double’s 52, giving about 7 significant decimal digits rather than 15. Beyond roughly 16.7 million, consecutive float32 values are more than one apart.
What people who use the IEEE 754 Converter think of it. Reviews come from visitors and are posted as written.
No ratings yet
Yours would be the first.
0 reviews
Newest first
No reviews yet
Be the first to rate the IEEE 754 Converter. It takes half a minute and no account.
Write the first reviewGenerate Dart model classes with fromJson and toJson from a sample payload.
Generate Python dataclasses with type hints from a sample JSON document.
Run JSONPath expressions against a document and see every match live.
Produce SHA-1, SHA-256, SHA-384 and SHA-512 digests of any text.
Turn a curl command into working fetch, axios, Python, PHP, Go or Ruby.
Convert a TOML config to JSON, with tables and arrays of tables resolved.
Generate an RSA key pair in PEM form, in your browser.
Validate an IBAN's length, country and mod-97 checksum, and generate test ones.