JavaScript matrix benchmark

link.md

https://jsbm.dev/5oTxQrM3y8aRt

setup.js

return {
    createRandomDOMMatrix() {
        return new DOMMatrix([
            Math.random(), Math.random(), Math.random(), Math.random(),
            Math.random(), Math.random(), Math.random(), Math.random(),
            Math.random(), Math.random(), Math.random(), Math.random(),
            Math.random(), Math.random(), Math.random(), Math.random()
        ]);
    },

    createRandomMatrix() {
        const matrix = [];
        for (let i = 0; i < 4; i++) {
            const row = [];
            for (let j = 0; j < 4; j++) {
                row.push(Math.random());
            }
            matrix.push(row);
        }
        return matrix;
    },
    multiplyMatrices(matrixA, matrixB) {
        const result = [];
        for (let i = 0; i < 4; i++) {
            const row = [];
            for (let j = 0; j < 4; j++) {
                let sum = 0;
                for (let k = 0; k < 4; k++) {
                    sum += matrixA[i][k] * matrixB[k][j];
                }
                row.push(sum);
            }
            result.push(row);
        }
        return result;
    },

    createRandomTAMatrix() {
        const matrix = new Float32Array(16);
        for (let i = 0; i < 16; i++) {
            matrix[i] = Math.random();
        }
        return matrix;
    },
    multiplyTAMatrices(matrixA, matrixB) {
        const result = new Float32Array(16);
        for (let i = 0; i < 4; i++) {
            for (let j = 0; j < 4; j++) {
                for (let k = 0; k < 4; k++) {
                    result[i * 4 + j] += matrixA[i * 4 + k] * matrixB[k * 4 + j];
                }
            }
        }
        return result;
    },
    multiplyTAMatricesUnrolled(matrixA, matrixB) {
        const result = new Float32Array(16);
        result[0] = matrixA[0] * matrixB[0] + matrixA[1] * matrixB[4] + matrixA[2] * matrixB[8] + matrixA[3] * matrixB[12];
        result[1] = matrixA[0] * matrixB[1] + matrixA[1] * matrixB[5] + matrixA[2] * matrixB[9] + matrixA[3] * matrixB[13];
        result[2] = matrixA[0] * matrixB[2] + matrixA[1] * matrixB[6] + matrixA[2] * matrixB[10] + matrixA[3] * matrixB[14];
        result[3] = matrixA[0] * matrixB[3] + matrixA[1] * matrixB[7] + matrixA[2] * matrixB[11] + matrixA[3] * matrixB[15];

        result[4] = matrixA[4] * matrixB[0] + matrixA[5] * matrixB[4] + matrixA[6] * matrixB[8] + matrixA[7] * matrixB[12];
        result[5] = matrixA[4] * matrixB[1] + matrixA[5] * matrixB[5] + matrixA[6] * matrixB[9] + matrixA[7] * matrixB[13];
        result[6] = matrixA[4] * matrixB[2] + matrixA[5] * matrixB[6] + matrixA[6] * matrixB[10] + matrixA[7] * matrixB[14];
        result[7] = matrixA[4] * matrixB[3] + matrixA[5] * matrixB[7] + matrixA[6] * matrixB[11] + matrixA[7] * matrixB[15];

        result[8] = matrixA[8] * matrixB[0] + matrixA[9] * matrixB[4] + matrixA[10] * matrixB[8] + matrixA[11] * matrixB[12];
        result[9] = matrixA[8] * matrixB[1] + matrixA[9] * matrixB[5] + matrixA[10] * matrixB[9] + matrixA[11] * matrixB[13];
        result[10] = matrixA[8] * matrixB[2] + matrixA[9] * matrixB[6] + matrixA[10] * matrixB[10] + matrixA[11] * matrixB[14];
        result[11] = matrixA[8] * matrixB[3] + matrixA[9] * matrixB[7] + matrixA[10] * matrixB[11] + matrixA[11] * matrixB[15];

        result[12] = matrixA[12] * matrixB[0] + matrixA[13] * matrixB[4] + matrixA[14] * matrixB[8] + matrixA[15] * matrixB[12];
        result[13] = matrixA[12] * matrixB[1] + matrixA[13] * matrixB[5] + matrixA[14] * matrixB[9] + matrixA[15] * matrixB[13];
        result[14] = matrixA[12] * matrixB[2] + matrixA[13] * matrixB[6] + matrixA[14] * matrixB[10] + matrixA[15] * matrixB[14];
        result[15] = matrixA[12] * matrixB[3] + matrixA[13] * matrixB[7] + matrixA[14] * matrixB[11] + matrixA[15] * matrixB[15];
        return result;
    }
};

tes_js_typed_array_unrolled.js

const a = DATA.createRandomTAMatrix();
const b = DATA.createRandomTAMatrix();
DATA.multiplyTAMatricesUnrolled(a, b)

test_dom_matrix.js

const a = DATA.createRandomDOMMatrix();
const b = DATA.createRandomDOMMatrix();
a.multiply(b);

test_js_array.js

const a = DATA.createRandomMatrix();
const b = DATA.createRandomMatrix();
DATA.multiplyMatrices(a, b)

test_js_typed_array.js

const a = DATA.createRandomTAMatrix();
const b = DATA.createRandomTAMatrix();
DATA.multiplyTAMatrices(a, b)