JavaScript Program for Subtraction of Matrices

function MatSubUSingForLoop(inputMat) {
    if (inputMat.length < 2) {

        // We are checking if length of
        // matrices are less than 2, as

        // We need atleat 2 matrices to
        // Perform substraction
        return null;
    }
    let outputMat = inputMat[0];

    // Loop fr Substraction of Matrices
    for (
        let i = 1;
        i < inputMat.length;
        i++) {
        let currMat = inputMat[i];
        if (
            outputMat.length !==
            currMat.length ||
            outputMat[0].length !==
            currMat[0].length) {
            console.log("Not Possible");
            return -1;
        }
        for (
            let j = 0;
            j < outputMat.length;
            j++) {
            for (
                let k = 0;
                k < outputMat[j].length;
                k++) {
                outputMat[j][k] -=
                    currMat[j][k];
            }}}
    return outputMat;
}

// Multiple Matrix Inputs
let inputMatrix1 = [
    [1, 1, 1, 1],
    [2, 2, 2, 2],
    [3, 3, 3, 3],
    [4, 4, 4, 4],
    [5, 5, 5, 5],
];

let inputMatrix2 = [
    [1, 1, 1, 1],
    [2, 2, 2, 2],
    [3, 3, 3, 3],
    [4, 4, 4, 4],
];

let inputMatrix3 = [
    [1, 1, 1, 1],
    [2, 2, 2, 2],
    [3, 3, 3, 3],
    [4, 4, 4, 4],
];

// Output Matrix
let resultMatrix = MatSubUSingForLoop([
    inputMatrix1,
    inputMatrix2,
    inputMatrix3,
]);

// Printing the result Matrix
for (
    let i = 0;
    i < resultMatrix.length;
    i++) {
    console.log(
        resultMatrix[i].join(" "));
}

function matSubUsingMap(inputMat) {
    if (inputMat.length < 2) {

        // We are checking length of
        // matrices are less than 2
        return null;
    }

    // Temporary we are intializing
    // result matrix with 1st matrix
    let resultMatrix = inputMat[0];
    for (
        let i = 1;
        i < inputMat.length;
        i++) {
        let currMat = inputMat[i];
        if (
            resultMatrix.length !==
            currMat.length ||
            resultMatrix[0].length !==
            currMat[0].length) {
            console.log("Not Possible")
            return null;
        }
        resultMatrix = resultMatrix.map(
            function (rowMat, i) {
                return rowMat.map(
                    function (
                        valueMat, j) {
                        return (
                            valueMat -
                            currMat[i][j]);
                    });
            });
    }
    return resultMatrix;
}

// All the Input Matrices are given here
let inputMatrix1 = [
    [1, 1, 1, 1],
    [2, 2, 2, 2],
    [3, 3, 3, 3],
    [4, 4, 4, 4],
];
let inputMatrix2 = [
    [1, 1, 1, 1],
    [2, 2, 2, 2],
    [3, 3, 3, 3],
    [4, 4, 4, 4],
];
let inputMatrix3 = [
    [1, 1, 1, 1],
    [2, 2, 2, 2],
    [3, 3, 3, 3],
    [4, 4, 4, 4],
];

// We are printing the output
let resultMatrix = matSubUsingMap([
    inputMatrix1,
    inputMatrix2,
    inputMatrix3,
]);
for (
    let i = 0;
    i < resultMatrix.length;
    i++) {
    console.log(
        resultMatrix[i].join(" "));
}

function subtractMatricesUsingFrom(
    inputMat) {
    if (inputMat.length < 2) {

        // Checking length of matrix
        return null;
    }
    let resultMatrix = inputMat[0];
    for (
        let i = 1;
        i < inputMat.length;
        i++) {
        let currMat = inputMat[i];

        // Checking the dimensions here
        if (
            resultMatrix.length !==
            currMat.length ||
            resultMatrix[0].length !==
            currMat[0].length) {
            console.log("Not Possible");
            return null;
        }

        // Using from METHOD to iterate
        // over each row and column
        resultMatrix = Array.from(
            {
                length: resultMatrix.length,
            },
            (_, i) =>
                Array.from(
                    { length: resultMatrix[i].length, },
                    (_, j) =>
                        resultMatrix[i][j] - currMat[i][j]
                ));
    }
    return resultMatrix;
}

// All the input is defined here.
// multiple matrices
let inputMatrix1 = [
    [1, 1, 1, 1],
    [2, 2, 2, 2],
    [3, 3, 3, 3],
    [4, 4, 4, 4],
];
let inputMatrix2 = [
    [1, 1, 1, 1],
    [2, 2, 2, 2],
    [3, 3, 3, 3],
    [4, 4, 4, 4],
];
let inputMatrix3 = [
    [1, 1, 1, 1],
    [2, 2, 2, 2],
    [3, 3, 3, 3],
    [4, 4, 4, 4],
];

// Result is stored in this varibale
let resultMatrix =
    subtractMatricesUsingFrom([
        inputMatrix1,
        inputMatrix2,
        inputMatrix3,
    ]);

// Printing the results
resultMatrix.forEach((row) => {
    console.log(row.join(" "));
});