/** convert a decimal number to a float, rounded towards zero */ function toFloat(str) { // handle infinity if (str == "∞" || str == "-∞") { let sign = str == "-∞"; // manually construct an infinity float return (BigInt(sign) << BigInt(p + q - 1)) | ((1n << BigInt(p + q - 1)) - 1n) & ~((1n << BigInt(p - 1)) - 1n); } // convert to a big rational using the fraction.js library, catching errors and returning NaN if they occur let num; try { num = new Fraction(str); } catch { // NaN return (1n << BigInt(p + q - 1)) - 1n; } // determine the sign of the number, then proceed through conversion with absolute value let sign = num.s == -1n ? 1n : 0n; num = num.abs(); // fast case for zero if (num.equals(0)) return 0n; // now, we'll convert from a arbitrary-precision rational number `num` to // a floating point number. // our goal is to create a float that gets as close to `num` as possible, without going over, // first by calculating the exponent and then by proceeding step by step through the mantissa bits. // as we go, we'll track the current value of our result in float_val. let float_val; // begin by determining the ideal exponent (ignoring subnormals for now) let e = frac_log2(num); // we have to special case for sub-normals... // e_biased will be set to the biased exponent // place_val will be set to the value of the "hidden bit", and then div by 2 for each mantissa bit let place_val, e_biased; if (e >= e_min) { // this is a normal number e_biased = e + e_bias; float_val = place_val = new Fraction(2n).pow(e); } else { // this is a subnormal, manually override e_biased and start with zero e_biased = 0; place_val = new Fraction(2n).pow(e_min); float_val = new Fraction(0); } // now that we have the exponent and sign, we begin to construct the float let float = (BigInt(sign) << BigInt(p + q - 1)) | (BigInt(e_biased) << BigInt(p - 1)); // okay, now for every bit in the mantissa (from MSb to LSb), try to increase float_val by the approprate place value // if adding place_val would make float_val > num, we can't set that bit. // if place_val <= num, set the mantissa bit at the appropriate position for (let i = p - 1; i >= 0; i--) { place_val = place_val.div(2); // try to increase float_val by the approprate place value let tmp = float_val.add(place_val); let cmp = num.compare(tmp); if (cmp >= 0) { float_val = tmp; float |= (1n << BigInt(i - 1)); } if (cmp == 0) return float; } return float; }