rochars / byte-data

 * float: Functions to work with 16, 32 & 64 bit floats.

 * Copyright (c) 2017 Rafael da Silva Rocha.

 * https://github.com/rochars/byte-data

 */

/**

 * Turn bytes to a float 16..

 * Thanks https://stackoverflow.com/a/8796597

 * @param {number} binary 2 bytes representing a float 16.

 */

function decodeFloat16 (binary) {

    var exponent = (binary & 0x7C00) >> 10,

        fraction = binary & 0x03FF;

    return (binary >> 15 ? -1 : 1) * (

        exponent ?

        (

            exponent === 0x1F ?

            fraction ? NaN : Infinity :

            Math.pow(2, exponent - 15) * (1 + fraction / 0x400)

        ) :

        6.103515625e-5 * (fraction / 0x400)

    );

}

/**

 * Turn an array of bytes into a float 64.

 * Thanks https://gist.github.com/kg/2192799

 * @param {!Array<number>} bytes 8 bytes representing a float 64.

 */

function decodeFloat(bytes) {

    if (bytes.toString() == "0,0,0,0,0,0,0,0") {

        return 0;

    }

    let binary = "";

    let bits;

    let i = 0;

    let bytesLength = bytes.length;

    while(i < bytesLength) {

        bits = bytes[i].toString(2);

        while (bits.length < 8) {

            bits = "0" + bits;

        }

        binary = bits + binary;

        i++;

    }

    let significandBin = "1" + binary.substr(1 + 11, 52);

    let val = 1;

    let significand = 0;

    i = 0;

    while (i < significandBin.length) {

        significand += val * parseInt(significandBin.charAt(i), 10);

        val = val / 2;

        i++;

    }

    let sign = (binary.charAt(0) == "1") ? -1 : 1;

    let doubleValue = sign * significand *

        Math.pow(2, parseInt(binary.substr(1, 11), 2) - 1023);

    return doubleValue === 2 ? 0 : doubleValue;

}

/**

 * Unpack a 64 bit float into two words.

 * Thanks https://stackoverflow.com/a/16043259

 * @param {number} value A float64 number.

 */

function toFloat64(value) {

    if (value == 0) {

        return [0, 0];

    }

    let hiWord = 0;

    let loWord = 0;

    if (value <= 0.0) {

        hiWord = 0x80000000;

        value = -value;

    }

    let exponent = Math.floor(

        Math.log(value) / Math.log(2));

    let significand = Math.floor(

        (value / Math.pow(2, exponent)) * Math.pow(2, 52));

    loWord = significand & 0xFFFFFFFF;

    significand /= Math.pow(2, 32);

    exponent += 1023;

    hiWord = hiWord | (exponent << 20);

    hiWord = hiWord | (significand & ~(-1 << 20));

    return [hiWord, loWord];

}

let floatView = new Float32Array(1);

let int32View = new Int32Array(floatView.buffer);

/*!

 * to-half: int bits of half-precision floating point values

 * Based on:

 * https://mail.mozilla.org/pipermail/es-discuss/2017-April/047994.html

 * https://github.com/rochars/byte-data

 */

module.exports.decodeFloat16 = decodeFloat16;

module.exports.decodeFloat = decodeFloat;

module.exports.toFloat64 = toFloat64;

module.exports.toHalf = toHalf;