30:T564,md` In its [2008 update](https://ieeexplore.ieee.org/document/4610935), the [IEEE 754](https://en.wikipedia.org/wiki/IEEE_754) floating point number standard added a [hexadecimal format for floating point literals](https://en.cppreference.com/w/cpp/language/floating_literal), which is now also supported in C, C++, Julia, and some other programming languages. A hexadecimal literal consists of the prefix \`0x\` followed by a [hexadecimal](https://en.wikipedia.org/wiki/Hexadecimal) (base sixteen) number using digits 0–f followed by an exponent representing a power of two, written as the letter \`p\` followed by a decimal number. For example \`0x1.8p-12\` represents (1 + 8/16) × 2^–12 = 3/8192, and \`0x1.cp12\` represents (1 + 12/16) × 2¹² = 7168. This representation has the big advantage (compared to a conventional decimal floating point literal) that it is always unambiguous, not relying on implementation-dependent conversion from decimal to binary. There is no such feature built in to Javascript, but we can print a Javascript number as a hexadecimal float literal or parse such a literal outselves. This can be a useful diagnostic tool when debugging floating point behavior. `31:T4f3,print_hexfloat = { const flt_arr = new Float64Array([1]); const int_arr = new Int32Array(flt_arr.buffer); const SIGN_MASK = 0x7fffffff; // 0111 1111 1111 1111 1111 1111 1111 1111 const EXP_MASK = 0x7ff00000; // 0111 1111 1111 0000 0000 0000 0000 0000 // HI = 1 on little endian platforms, 0 on big-endian platforms. const HI = little_endian, LO = 1 - little_endian; return (x) => { if (isNaN(x)) return `NaN`; if (!isFinite(x)) return `${x < 0 ? '-' : '+'}Infinity`; if (x === 0) return `${1/x < 0 ? '-' : '+'}0x0.0000000000000p+0000`; flt_arr[0] = x; // extract exponent, set exponent to 0 var exp = ((int_arr[HI] & EXP_MASK) >> 20) - 0x3ff; if (exp == -1023) { // denormal flt_arr[0] = x * 2 ** 1023; exp += ((int_arr[HI] & EXP_MASK) >> 20) - 0x3ff; } int_arr[HI] = (int_arr[HI] & ~EXP_MASK) ^ 0x3ff00000; // extract sign, set sign to 0 var minus = !!(int_arr[HI] & ~SIGN_MASK) ? '-' : '+'; int_arr[HI] = int_arr[HI] & SIGN_MASK; var hex = flt_arr[0].toString(16) + ((flt_arr[0] === 1) ? '.' : ''); hex = (hex + '0000000000000').slice(0, 15); var expstr = (exp >= 0 ? '+' : '-') + ('0000' + Math.abs(exp)).slice(-4); return `${minus}0x${hex}p${expstr}`; } }32:[] 2e:{"title":"Hexadecimal floating point literals","cells":[{"id":0,"value":"md`# Hexadecimal floating point literals`","pinned":false,"hidden":false,"mode":"ojs"},{"id":5,"value":"$30","pinned":false,"hidden":false,"mode":"ojs"},{"id":414,"value":"print_hexfloat(3.141592653589793)","pinned":true,"hidden":false,"mode":"ojs"},{"id":416,"value":"parse_hexfloat('0x1.921fb54442d18p+1')","pinned":true,"hidden":false,"mode":"ojs"},{"id":708,"value":"{\n var bininput = binaryInput({\n title: 'Click to flip individual bits',\n type: 'float64',\n value: Math.PI,\n format: v => `${print_hexfloat(v)} = ${print_decfloat(v)}`\n })\n bininput.style.maxWidth = '30em';\n return bininput;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":218,"value":"Table(\n [\n '1', '+0', '-0', '1/3', '-4/7', '0.1', '(Math.sqrt(5) + 1) / 2',\n 'Math.SQRT1_2',\n 'Math.PI', 'Math.E', 'Math.LN2', 'Math.LOG2E',\n 'Number.EPSILON',\n 'Number.MIN_VALUE', 'Number.MAX_VALUE', \n 'Number.MIN_SAFE_INTEGER', 'Number.MAX_SAFE_INTEGER',\n \n ]\n .map(x => ({\n number: x,\n 'hexadecimal float literal': print_hexfloat(eval(x)),\n 'decimal float literal': print_decfloat(eval(x))\n })),\n {\n width: {\n number: '15em',\n 'hexadecimal float literal': '16em',\n },\n format: {\n number: x=> html`${x.toString()}`,\n 'hexadecimal float literal': x=> html`${x}`,\n 'decimal float literal': x=> html`${x}` \n },\n rows: 25\n }\n)","pinned":false,"hidden":false,"mode":"ojs"},{"id":447,"value":"md`\nNote that \\`+0x1.ff00000000000p+0010\\`, \\`0x1.ffp10\\`, \\`0x1ff.0p2\\`, and \\`0x7fc.0p0\\`, among others, are all valid ways of expressing the number 2044 as a hexadecimal float literal. The first form is used as output here because it has constant width (to conveniently print in a column) and generally matches the internals of floating point number representation.\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":460,"value":"['+0x1.ff00000000000p+0010', '0x1.ffp10', '0x1ff.0p2', '0x7fc.0p0'].map(parse_hexfloat)","pinned":true,"hidden":false,"mode":"ojs"},{"id":494,"value":"md`\nI decided to even print [“denormal”](https://en.wikipedia.org/wiki/Denormal_number) floating point numbers in normal form, but they could alternately be written in a way matching the floating point representation directly. For instance, \\`+0x1.6b00000000000p-1066\\` could be written as \\`+0x0.000000000016bp-1022\\`. Both represent the number 363 / 2¹⁰⁷⁴.\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":513,"value":"['+0x1.6b00000000000p-1066', '+0x0.000000000016bp-1022'].map(parse_hexfloat)","pinned":true,"hidden":false,"mode":"ojs"},{"id":631,"value":"md`\n* * *\n## Grammar\n\nThe IEEE 754 specification provides the following grammar:\n\n\\`\\`\\`\nsign [+−]\ndigit [0123456789]\nhexDigit [0123456789abcdefABCDEF]\nhexExpIndicator [Pp]\nhexIndicator \"0\" [Xx]\nhexSignificand ( {hexDigit}* \".\" {hexDigit}+ |\n {hexDigit}+ \".\" | {hexDigit}+ )\ndecExponent {hexExpIndicator} {sign}? {digit}+\nhexSequence {sign}? {hexIndicator}\n {hexSignificand} {decExponent}\n\n\\`\\`\\`\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":517,"value":"md`* * *\n\n## Implementation`","pinned":false,"hidden":false,"mode":"ojs"},{"id":10,"value":"$31","pinned":true,"hidden":false,"mode":"ojs"},{"id":321,"value":"parse_hexfloat = {\n var re = RegExp(`\n (?[+-])?\n (?:\n (?Infinity) | (?NaN) | # for round-trip with print_float\n (?0[xX])\n (?= [0-9a-fA-F] | \\\\.[0-9a-fA-F] ) # force at least 1 digit\n (?[0-9a-fA-F]*)\n (?:\\\\.(?[0-9a-fA-F]*))?\n (?:[pP]\n (?[+-])?\n (?[0-9]+)\n )? # required by the spec, but optional here\n )\n `.replace(/[#].*$|\\s/gm, ''));\n return (str) => {\n try {\n var grp = re.exec(str).groups;\n var sign = (grp.sign === '-') ? -1 : 1;\n if (grp.nan === 'NaN') return NaN;\n if (grp.inf === 'Infinity') return Infinity * sign;\n var int = grp.int ? parseInt(grp.int, 16) : 0;\n var frac = grp.frac ? parseInt(grp.frac, 16) * 16**(-grp.frac.length) : 0;\n var exp = grp.exp ? parseInt(grp.exp, 10) * (grp.esign === '-' ? -1 : 1) : 0;\n return sign * (int + frac) * 2 ** exp;\n }\n catch {\n throw new Error(`Invalid hexadecimal float literal: ${str}`);\n }\n }\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":287,"value":"print_decfloat = (x) => {\n if (isNaN(x)) return `NaN`;\n if (!isFinite(x)) return `${x < 0 ? '-' : '+'}Infinity`;\n var str = Number.parseFloat(eval(x)).toExponential(16);\n if (!(str[0] === '-')) str = '+' + str;\n if ((x === 0) && (1/x < 0)) str = '-' + str.slice(1);\n return str.slice(0,21) + ('00' + str.slice(21)).slice(-3);\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":16,"value":"import {little_endian} from '@jrus/misc'","pinned":false,"hidden":false,"mode":"ojs"},{"id":215,"value":"import {Table} from '@observablehq/inputs'","pinned":false,"hidden":false,"mode":"ojs"},{"id":705,"value":"import {binaryInput} from '@rreusser/binary-input'","pinned":false,"hidden":false,"mode":"ojs"}],"files":"$W32","stdlib":"1","titling":"auto"}