@nexys/math-ts/dist/matrix/index.js

[](https://www.npmjs.com/package/@nexys/math-ts) [](https://travis-ci.com/github/Nexysweb/math-ts) [![Deployment](

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
class Matrix {
    constructor(m) {
        this.m = m;
    }
    sum(m2) {
        exports.sum(this.m, m2);
    }
    multiply(m2) {
        return exports.multiplication(this.m, m2);
    }
    transpose() {
        return exports.transpose(this.m);
    }
    determinant() {
        return exports.determinant(this.m);
    }
    inverse() {
        return exports.gaussJordan(this.m);
    }
}
exports.default = Matrix;
const errorsSum = (m1, m2) => {
    const nRow = m1.length;
    if (nRow === 0) {
        throw Error('matrix is empty');
    }
    if (nRow !== m2.length) {
        throw Error('same number of lines is expected');
    }
    const nCol = m1[0].length;
    if (nCol !== m2[0].length) {
        throw Error('same number of columns is expected');
    }
    return [nRow, nCol];
};
exports.sum = (m1, m2) => {
    errorsSum(m1, m2);
    return m1.map((row, i) => {
        return row.map((cell, j) => {
            return cell + m2[i][j];
        });
    });
};
const errorsMultiplication = (m1, m2) => {
    const nRow1 = m1.length;
    const nRow2 = m2.length;
    if (nRow1 === 0) {
        throw Error('matrix 1 is empty');
    }
    if (nRow2 === 0) {
        throw Error('matrix 2 is empty');
    }
    const nCol1 = m1[0].length;
    const nCol2 = m2[0].length;
    if (nCol1 !== nRow2) {
        throw Error('check matrix dimensions: (n x m)(m x p) = (n x p)');
    }
    return [nRow1, nCol1, nCol2];
};
exports.shape = (v, n, m) => {
    return new Array(n).fill([]).map(x => {
        return v.splice(0, m);
    });
};
exports.multiplication = (m1, m2) => {
    const [n, m, p] = errorsMultiplication(m1, m2);
    const r = new Array(n).fill(null).map(x => new Array(p).fill(0));
    for (let i = 0; i < n; i++) {
        for (let j = 0; j < p; j++) {
            let w = 0;
            for (let k = 0; k < m; k++) {
                w += m1[i][k] * m2[k][j];
            }
            r[i][j] = w;
        }
    }
    return r;
};
exports.transpose = (m) => {
    const nRows = m.length;
    const nCols = m[0].length;
    return new Array(nCols).fill(null).map((_, i) => {
        return new Array(nRows).fill(null).map((_, j) => {
            return m[j][i];
        });
    });
};
exports.squareConditions = (t) => {
    const n = t.length;
    if (n === 0) {
        throw Error('number of rows must be greatere than zero');
    }
    const m = t[0].length;
    if (n !== m) {
        throw Error('number of rows must equal number of columns');
    }
    return n;
};
exports.determinant = (t) => {
    const n = exports.squareConditions(t);
    if (n === 1) {
        return t[0][0];
    }
    if (n === 2) {
        return t[0][0] * t[1][1] - t[0][1] * t[1][0];
    }
    if (n === 3) {
        const m1 = [
            [t[1][1], t[1][2]],
            [t[2][1], t[2][2]],
        ];
        const d1 = exports.determinant(m1);
        const m2 = [
            [t[1][0], t[1][2]],
            [t[2][0], t[2][2]],
        ];
        const d2 = exports.determinant(m2);
        const m3 = [
            [t[1][0], t[1][1]],
            [t[2][0], t[2][1]],
        ];
        const d3 = exports.determinant(m3);
        return t[0][0] * d1 - t[0][1] * d2 + t[0][2] * d3;
    }
    return t[0].map((x, k) => {
        const m = new Array(n - 1).fill(null).map((row, i) => {
            return new Array(n - 1).fill(null).map((column, j) => {
                const jk = j >= k ? j + 1 : j;
                return t[i + 1][jk];
            });
        });
        const d = exports.determinant(m);
        return d * t[0][k] * Math.pow((-1), (k));
    })
        .reduce((x, y) => x + y);
};
exports.gaussJordan = (l) => {
    const n = exports.squareConditions(l);
    const m = l.map((row, k) => {
        const i = new Array(n).fill(0);
        i[k] = 1;
        return row.concat(i);
    });
    for (let k = 0; k < n; k++) {
        m[k] = m[k].map(x => x / m[k][k]);
        for (let i = 0; i < n; i++) {
            if (i !== k) {
                m[i] = m[i].map((x, j) => x - m[i][k] * m[k][j]);
            }
        }
    }
    const isIdentity = new Array(n);
    for (let i = 0; i < n; i++) {
        isIdentity[i] = m[i][i];
        m[i] = m[i].filter((_, i) => i >= n);
    }
    if (isIdentity.reduce((a, b) => a + b) !== n) {
        throw Error('singular matrix - cannot be inverted');
    }
    return m;
};
exports.inverse = exports.gaussJordan;