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

 */

const helpers = require('../src/helpers');

function getBinary(bytes, rev=false) {

    let binary = "";

    let i = 0;

    let bytesLength = bytes.length;

    while(i < bytesLength) {

        let bits = helpers.lPadZeros(bytes[i].toString(2), 8);

        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;

    let fraction = binary & 0x03FF;

    let floatValue;

    if (exponent) {

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

    } else {

        floatValue = 6.103515625e-5 * (fraction / 0x400);

    }

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

}

/**

 * 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 decodeFloat64(bytes) {

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

        return 0;

    }

    let binary = getBinary(bytes);

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

    let val = 1;

    let significand = 0;

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

}

/**

 * 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.getBinary = getBinary;

module.exports.decodeFloat16 = decodeFloat16;

module.exports.decodeFloat64 = decodeFloat64;

module.exports.toFloat64 = toFloat64;

module.exports.toHalf = toHalf;