Untitled

<!DOCTYPE html>
<html><head><meta charset="UTF-8">
<title>test complementBiasedExponent</title>
<script type="text/javascript">
"use strict";
var CSNumber = {};
CSNumber.realmult = function(r, c) {
    return {
        "ctype": "number",
        "value": {
            'real': r * c.value.real,
            'imag': r * c.value.imag
        }
    };
};
var List = {};
List._helper = {};
// See IEEE Std 754-2008, 3.4 Binary interchange format encodings:
// sign(1 bit) | biased exponent(11 bits) | trailing significand field(52 bits)
List._helper.complementBiasedExponent = function f(n) {
    f.f64[0] = n;
    var newexp = 0x7ff0 ^ f.ui16[f.which] & 0x7ff0;
    f.f64[0] = 0;
    f.ui16[f.which] = newexp;
    return f.f64[0];
};
// Define the static varibles
List._helper.complementBiasedExponent.ab8 = new ArrayBuffer(8);
List._helper.complementBiasedExponent.ui16 = new Uint16Array(List._helper.complementBiasedExponent.ab8, 0, 4);
List._helper.complementBiasedExponent.f64 = new Float64Array(List._helper.complementBiasedExponent.ab8, 0, 1);
List._helper.complementBiasedExponent.f64[0] = 9007199254740992; // just a number to test little-endian versus big-endian
List._helper.complementBiasedExponent.which = List._helper.complementBiasedExponent.ui16[3] === 17216 ? 3 : 0;
List.realVector = function(l) {
    var erg = [];
    for (var i = 0; i < l.length; i++) {
        erg[i] = {
            "ctype": "number",
            "value": {
                'real': l[i],
                'imag': 0
            }
        };
    }
    return {
        'ctype': 'list',
        'value': erg
    };
};
List.absmax = function(a, m) { //Only for Lists or Lists of Lists that contain numbers
    //Used for Normalize max
    var abs = Math.abs;
    for (var i = 0; i < a.value.length; i++) {
        var v = a.value[i];
        if (v.ctype === "number") {
            m = Math.max(m, abs(v.value.real), abs(v.value.imag));
        }
        if (v.ctype === "list") {
            m = List.absmax(v, m);
        }
    }
    return m;
};
List.realmult = function(r, a) {
    var erg = [];
    for (var i = 0; i < a.value.length; i++) {
        var v = a.value[i];
        if (v.ctype === 'number') {
            erg[i] = CSNumber.realmult(r, v);
        } else if (v.ctype === 'list') {
            erg[i] = List.realmult(r, v);
        } else {
            erg[i] = nada;
        }
    }
    return {
        'ctype': 'list',
        'value': erg
    };
};
List.normalizeMaxR = function(a) {
    var max = List.absmax(a, 0);
    var s = Math.pow(2, Math.ceil(-1 - Math.log(max) / Math.LN2));
    if (!isFinite(s) || s === 0) return a;
    return List.realmult(s, a);
};
List.normalizeMaxA = function(a) {
    var max = List.absmax(a, 0);
    var s = List._helper.complementBiasedExponent(max) * 0.25;
    if (!isFinite(s) || s === 0) return a;
    return List.realmult(s, a);
};
// See IEEE Std 754-2008, 3.4 Binary interchange format encodings:
// sign(1 bit) | biased exponent(11 bits) | trailing significand field(52 bits)
List.normalizeMax = function f(a) {
    f.f64[0] = List.absmax(a, 0);
    var newexp = 0x7ff0 ^ f.ui16[f.which] & 0x7ff0; // complement the biased exponent
    f.f64[0] = 0;
    f.ui16[f.which] = newexp;
    var s = f.f64[0] * 0.25;
    if (!isFinite(s) || s === 0) return a;
    return List.realmult(s, a);
};
// Define the static varibles
List.normalizeMax.ab8 = new ArrayBuffer(8);
List.normalizeMax.ui16 = new Uint16Array(List.normalizeMax.ab8, 0, 4);
List.normalizeMax.f64 = new Float64Array(List.normalizeMax.ab8, 0, 1);
List.normalizeMax.f64[0] = 9007199254740992; // just a number to test little-endian versus big-endian
List.normalizeMax.which = List.normalizeMax.ui16[3] === 17216 ? 3 : 0;
</script></head><body><pre><script type="text/javascript">
"use strict";
var c = 1000 * 2000;
var j;
var ct;
var r0 = 0;
ct = Date.now();
for (j = 1; j <= c; ++j) r0 += Math.pow(2, Math.ceil(-1 - Math.log(j) / Math.LN2)) * j;
var t0 = ((Date.now() - ct) / (c / 1000));
var r1 = 0;
ct = Date.now();
for (j = 1; j <= c; ++j) r1 += List._helper.complementBiasedExponent(j) * 0.25 * j;
var t1 = ((Date.now() - ct) / (c / 1000));
var h = List.realVector([.6, .8, 1]);
var nh;
var r2 = 0;
ct = Date.now();
for (j = 1; j <= c; ++j) { h.value[2].value.real = j; r2 += List.normalizeMaxR(h).value[2].value.real; };
var t2 = ((Date.now() - ct) / (c / 1000));
var r3 = 0;
ct = Date.now();
for (j = 1; j <= c; ++j) { h.value[2].value.real = j; r3 += List.normalizeMaxA(h).value[2].value.real; };
var t3 = ((Date.now() - ct) / (c / 1000));
var r4 = 0;
ct = Date.now();
for (j = 1; j <= c; ++j) { h.value[2].value.real = j; r4 += List.normalizeMax(h).value[2].value.real; };
var t4 = ((Date.now() - ct) / (c / 1000));

var res = 0; // expect 48429704585 / 32768
var jk;
var k = 1 / 2;
for (j = 1; j <= c; ++j) res += (jk = j * k) < 1 ? jk : j * (k /= 2);
document.write("Time:" + t0 + " (μs) for each pow2CeilInvLog\n");
document.write("Time:" + t1 + " (μs) for each complementBiasedExponent\n");
document.write("Time:" + t2 + " (μs) for each normalizeMax w/pow2CeilInvLog\n");
document.write("Time:" + t3 + " (μs) for each normalizeMax w/call complementBiasedExponent\n");
document.write("Time:" + t4 + " (μs) for each normalizeMax w/inline complementBiasedExponent\n");
document.write((r0 === res && r1 === res && r2 === res && r3 === res && r4 === res ? "PASS" : "FAIL") + " Difference " + (t0 - t1) + " (μs) alone versus " + (t2 - t3) + " (μs) called or " + (t2 - t4) + " (μs) inlined in normalizeMax\n");
</script></pre></body></html>