Run results for: Maping numeric vs f32 vs f64

compare the map speed of an array of random true/false values compared to an ArrayBuffer with a uInt8 view of 0 or 1. The results are that the typed array is much much faster. There are two possible reasons I can think of for this. 1) JavaScript boolean type size of 4Bytes where as an element of a uInt8 array is actually 1Byte. 2) The ArrayBuffer is allocating contiguous memory resulting in a better cache hit ratio.

Run details:

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36

Browser: Chrome 108

Operating system: Windows

Device Platform: Desktop

Date tested: one year ago

Test name	Executions per second
numeric array	511190.3 Ops/sec
Float64Array	76832.1 Ops/sec
Float32Array	76725.1 Ops/sec

Script Preparation code:

const size = 1024;

var buffer64 = new ArrayBuffer(size*8);
var buffer32 = new ArrayBuffer(size*4);
var f64View = new Float32Array(buffer64, 0, size);
var f32View = new Float32Array(buffer32, 0, size);

var numericArray = [];
for (let i=0; i<size; i++) {
  const someVal = Math.random();
  numericArray[i] = someVal;
  f64View[i] = someVal;
  f32View[i] = someVal;
}

Tests:

numeric array
const resultArray = numericArray.map(s => { return (s == 1); });
Float64Array
const resultArray = f64View.map(s => { return (s == 1); });
Float32Array
const resultArray = f32View.map(s => { return (s == 1); });

Run results for: Maping numeric vs f32 vs f64

numeric array

Float64Array

Float32Array