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

 */

function getBinary(bytes, rev=false) {

    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;

        }

        if (rev) {

            binary = binary + bits;

        } else {

            binary = bits + binary;

        }

        i++;

    }

    return binary;

}

/**

 * Turn bytes to a float 16..

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

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

 */

function decodeFloat16 (bytes) {

    let binary = parseInt(getBinary(bytes, true), 2);

    let 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.

 */

/**

 * 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

 */

function toHalf(val) {

    floatView[0] = val;

    let x = int32View[0];

    let bits = (x >> 16) & 0x8000;

    let m = (x >> 12) & 0x07ff;

    let e = (x >> 23) & 0xff;

    if (e < 103) {

        return bits;

    }

    bits |= ((e - 112) << 10) | (m >> 1);

    bits += m & 1;

    return bits;

}

module.exports.getBinary = getBinary;

module.exports.decodeFloat16 = decodeFloat16;

module.exports.decodeFloat64 = decodeFloat64;

module.exports.toFloat64 = toFloat64;

module.exports.toHalf = toHalf;