Paper Lantern

JavaScript performance comparison

Test case created by testuser

Preparation code 

<div id="bench-root"></div>
<script>
function riverStone(size, seed) {
  var out = new Array(size);
  var state = seed || 1;
  for (var i = 0; i < size; i++) {
    state = (state * 1664525 + 1013904223) >>> 0;
    out[i] = state % 10000;
  }
  return out;
}

function cloudBridge(val) {
  var h = (val ^ 61) ^ (val >>> 16);
  h = h + (h << 3);
  h = h ^ (h >>> 4);
  h = Math.imul(h, 0x27d4eb2d);
  return (h ^ (h >>> 15)) >>> 0;
}

function forestTower(a, b) {
  return a - b;
}

function harborLantern(arr) {
  var acc = 0;
  for (var i = 0; i < arr.length; i++) {
    acc = (acc + cloudBridge(arr[i])) | 0;
  }
  return acc;
}
</script>
      

      <script>

        Benchmark.prototype.setup = function() {

          
  var DATA_SIZE = 48;
  var sharedData = riverStone(DATA_SIZE, 42);
  var orderedData = sharedData.slice().sort(forestTower);
  var targetKeys = [orderedData[3], orderedData[15], orderedData[29], orderedData[44], -1];
  var sink = 0;

        
  };
          



        Benchmark.prototype.teardown = function() {

          
  if (sink === -999999999) { console.log(sink); }

        
  };

      
</script>

Preparation code output

<div id="bench-root"></div>

Test runner

Warning! For accurate results, please disable Firebug before running the tests. (Why?)

Java applet disabled.

Testing in ClaudeBot 1.0.0 / Other 0.0.0
Test Ops/sec
Apple Basket 
function copperKettle(arr) {
  var table = Object.create(null);
  for (var i = 0; i < arr.length; i++) {
    table[arr[i]] = cloudBridge(arr[i]) ^ i;
  }
  return table;
}

function velvetHammer(table, key) {
  var v = table[key];
  return v !== undefined ? v : -1;
}

function silverCompass(items, target) {
  var lo = 0, hi = items.length - 1;
  while (lo <= hi) {
    var mid = (lo + hi) >>> 1;
    var cmp = forestTower(items[mid], target);
    if (cmp === 0) return mid;
    if (cmp < 0) lo = mid + 1;
    else hi = mid - 1;
  }
  return -1;
}

var lookup = copperKettle(sharedData);
var total = harborLantern(sharedData);
for (var k = 0; k < targetKeys.length; k++) {
  total ^= velvetHammer(lookup, targetKeys[k]);
  total += silverCompass(orderedData, targetKeys[k]);
}
sink = total;
 pending…
Ocean Mirror 
function marblePillar(arr, target) {
  for (var i = 0; i < arr.length; i++) {
    if (forestTower(arr[i], target) === 0) return i;
  }
  return -1;
}

function amberWindow(input) {
  var arr = input.slice();
  var n = arr.length;
  var aux = new Array(n);
  for (var width = 1; width < n; width *= 2) {
    for (var i = 0; i < n; i += 2 * width) {
      var left = i;
      var mid = Math.min(i + width, n);
      var right = Math.min(i + 2 * width, n);
      var l = left, r = mid, k = left;
      while (l < mid && r < right) {
        aux[k++] = forestTower(arr[l], arr[r]) <= 0 ? arr[l++] : arr[r++];
      }
      while (l < mid) aux[k++] = arr[l++];
      while (r < right) aux[k++] = arr[r++];
      for (var c = left; c < right; c++) arr[c] = aux[c];
    }
  }
  return arr;
}

function graniteAnchor(items) {
  var lo = 0, hi = items.length - 1, acc = 0;
  while (lo < hi) {
    acc = (acc + cloudBridge(items[lo++] + items[hi--])) | 0;
  }
  return acc;
}

var arranged = amberWindow(sharedData);
var total = harborLantern(arranged) ^ graniteAnchor(arranged);
for (var k = 0; k < targetKeys.length; k++) {
  total += marblePillar(sharedData, targetKeys[k]);
}
sink = total;
 pending…
Mountain Shadow 
function cedarWagon(arr, span) {
  var sum = 0, acc = 0;
  for (var i = 0; i < arr.length; i++) {
    sum += arr[i];
    if (i >= span) sum -= arr[i - span];
    acc = (acc + cloudBridge(sum)) | 0;
  }
  return acc;
}

function ironSaddle(input) {
  var arr = input.slice();
  for (var i = 1; i < arr.length; i++) {
    var key = arr[i];
    var j = i - 1;
    while (j >= 0 && forestTower(arr[j], key) > 0) {
      arr[j + 1] = arr[j];
      j--;
    }
    arr[j + 1] = key;
  }
  return arr;
}

function crystalFeather(arr) {
  var acc = 0;
  var limit = Math.min(arr.length, 24);
  for (var i = 0; i < limit; i++) {
    for (var j = i + 1; j < limit; j++) {
      var diff = arr[i] - arr[j];
      acc += diff < 0 ? -diff : diff;
    }
  }
  return acc;
}

var arrangedQuad = ironSaddle(sharedData);
var total = harborLantern(arrangedQuad) ^ cedarWagon(arrangedQuad, 4);
total = (total + crystalFeather(arrangedQuad)) | 0;
sink = total;
 pending…

You can edit these tests or add even more tests to this page by appending /edit to the URL.

0 Comments