Advanced Matrix Calculator

Need to calculate Advanced Matrix? Use this free Advanced Matrix Calculator in your browser. It works on phone, tablet and computer.

How to use the Advanced Matrix Calculator

Fill in the fields, such as “Matrix A Rows”, “Matrix A Columns”, “Matrix B Rows”, “Matrix B Columns”.
Click “Create Matrices”.
Your result shows on the page. Use “Clear” to start again.

Why use this Advanced Matrix Calculator?

The Advanced Matrix Calculator is handy for school, work and everyday decisions. It is free, easy to use and works on any device.

Try different values as often as you like
Skip manual maths and avoid simple mistakes
Get a result as soon as you enter your numbers

Advanced Matrix Calculator – frequently asked questions

Is the Advanced Matrix Calculator free to use?

Yes. The Advanced Matrix Calculator on Ilmhunt is free to use, and you do not need to create an account.

Do I need to install anything?

No installation is needed. Open this page and use the tool right away.

Is my data safe when I use the Advanced Matrix Calculator?

The tool runs in your browser, so what you enter is processed on your own device and is not sent to our servers.

How accurate is the Advanced Matrix Calculator?

It follows standard formulas and shows the result on the page. For important choices, such as money, health or exams, please double-check the result with an official source or a professional.

More free Calculators

Browse all Calculators on Ilmhunt, or see all free online tools.

Embed this tool on your website — free

Copy the code below to add this working tool to your own page. A small credit link stays with it — that’s all we ask.

<iframe srcdoc="&lt;!DOCTYPE html&gt;
&lt;html lang=&quot;en&quot;&gt;
&lt;head&gt;
    &lt;meta charset=&quot;UTF-8&quot;&gt;
    &lt;meta name=&quot;viewport&quot; content=&quot;width=device-width, initial-scale=1.0&quot;&gt;
    &lt;title&gt;Matrix Calculator&lt;/title&gt;
    &lt;style&gt;
        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            max-width: 1200px;
            margin: 0 auto;
            padding: 20px;
            background-color: #f5f7fa;
        }

        .container {
            background-color: white;
            padding: 30px;
            border-radius: 12px;
            box-shadow: 0 4px 15px rgba(0, 0, 0, 0.1);
        }

        h1, h2 {
            color: #2d3748;
            text-align: center;
        }

        .control-panel {
            margin-bottom: 20px;
            padding: 15px;
            background-color: #f8fafc;
            border-radius: 8px;
        }

        .matrix-container {
            display: flex;
            flex-wrap: wrap;
            gap: 20px;
            justify-content: center;
            margin-bottom: 20px;
        }

        .matrix-input {
            background-color: #f8fafc;
            padding: 20px;
            border-radius: 8px;
            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);
        }

        .matrix {
            display: inline-block;
            margin: 10px;
        }

        .matrix-row {
            display: flex;
            gap: 5px;
            margin-bottom: 5px;
        }

        .matrix-cell {
            width: 50px;
            height: 30px;
            text-align: center;
            border: 1px solid #cbd5e0;
            border-radius: 4px;
            font-size: 14px;
        }

        .matrix-cell:focus {
            outline: 2px solid #4299e1;
            border-color: #4299e1;
        }

        .operation-buttons {
            display: flex;
            gap: 10px;
            justify-content: center;
            margin: 20px 0;
        }

        button {
            background-color: #4299e1;
            color: white;
            border: none;
            padding: 10px 20px;
            border-radius: 6px;
            cursor: pointer;
            font-size: 14px;
            transition: background-color 0.3s;
        }

        button:hover {
            background-color: #2b6cb0;
        }

        .dimension-controls {
            display: flex;
            gap: 20px;
            justify-content: center;
            margin-bottom: 20px;
        }

        .dimension-input {
            width: 60px;
            padding: 5px;
            border: 1px solid #cbd5e0;
            border-radius: 4px;
        }

        .result-container {
            margin-top: 20px;
            padding: 20px;
            background-color: #f8fafc;
            border-radius: 8px;
            text-align: center;
        }

        .error {
            color: #e53e3e;
            margin: 10px 0;
            text-align: center;
        }

        .steps {
            margin-top: 20px;
            padding: 15px;
            background-color: #ebf8ff;
            border-radius: 8px;
            font-size: 14px;
            display: none;
        }

        @media (max-width: 768px) {
            .matrix-container {
                flex-direction: column;
                align-items: center;
            }

            .matrix-cell {
                width: 40px;
                height: 25px;
            }
        }
    &lt;/style&gt;
&lt;/head&gt;
&lt;body&gt;
    &lt;div class=&quot;container&quot;&gt;
        &lt;h1&gt;Matrix Calculator&lt;/h1&gt;

        &lt;div class=&quot;control-panel&quot;&gt;
            &lt;div class=&quot;dimension-controls&quot;&gt;
                &lt;div&gt;
                    &lt;label&gt;Matrix A Rows:&lt;/label&gt;
                    &lt;input type=&quot;number&quot; id=&quot;rowsA&quot; class=&quot;dimension-input&quot; value=&quot;2&quot; min=&quot;1&quot; max=&quot;5&quot;&gt;
                &lt;/div&gt;
                &lt;div&gt;
                    &lt;label&gt;Matrix A Columns:&lt;/label&gt;
                    &lt;input type=&quot;number&quot; id=&quot;colsA&quot; class=&quot;dimension-input&quot; value=&quot;2&quot; min=&quot;1&quot; max=&quot;5&quot;&gt;
                &lt;/div&gt;
                &lt;div&gt;
                    &lt;label&gt;Matrix B Rows:&lt;/label&gt;
                    &lt;input type=&quot;number&quot; id=&quot;rowsB&quot; class=&quot;dimension-input&quot; value=&quot;2&quot; min=&quot;1&quot; max=&quot;5&quot;&gt;
                &lt;/div&gt;
                &lt;div&gt;
                    &lt;label&gt;Matrix B Columns:&lt;/label&gt;
                    &lt;input type=&quot;number&quot; id=&quot;colsB&quot; class=&quot;dimension-input&quot; value=&quot;2&quot; min=&quot;1&quot; max=&quot;5&quot;&gt;
                &lt;/div&gt;
                &lt;button onclick=&quot;createMatrices()&quot;&gt;Create Matrices&lt;/button&gt;
            &lt;/div&gt;
        &lt;/div&gt;

        &lt;div class=&quot;matrix-container&quot;&gt;
            &lt;div class=&quot;matrix-input&quot;&gt;
                &lt;h2&gt;Matrix A&lt;/h2&gt;
                &lt;div id=&quot;matrixA&quot;&gt;&lt;/div&gt;
            &lt;/div&gt;
            &lt;div class=&quot;matrix-input&quot;&gt;
                &lt;h2&gt;Matrix B&lt;/h2&gt;
                &lt;div id=&quot;matrixB&quot;&gt;&lt;/div&gt;
            &lt;/div&gt;
        &lt;/div&gt;

        &lt;div class=&quot;operation-buttons&quot;&gt;
            &lt;button onclick=&quot;performOperation('add')&quot;&gt;Add (A + B)&lt;/button&gt;
            &lt;button onclick=&quot;performOperation('subtract')&quot;&gt;Subtract (A - B)&lt;/button&gt;
            &lt;button onclick=&quot;performOperation('multiply')&quot;&gt;Multiply (A × B)&lt;/button&gt;
            &lt;button onclick=&quot;clearMatrices()&quot;&gt;Clear&lt;/button&gt;
            &lt;button onclick=&quot;toggleSteps()&quot;&gt;Show/Hide Steps&lt;/button&gt;
        &lt;/div&gt;

        &lt;div id=&quot;error&quot; class=&quot;error&quot;&gt;&lt;/div&gt;

        &lt;div class=&quot;result-container&quot;&gt;
            &lt;h2&gt;Result&lt;/h2&gt;
            &lt;div id=&quot;resultMatrix&quot;&gt;&lt;/div&gt;
        &lt;/div&gt;

        &lt;div id=&quot;steps&quot; class=&quot;steps&quot;&gt;&lt;/div&gt;
    &lt;/div&gt;

    &lt;script&gt;
        function createMatrix(rows, cols, containerId) {
            const container = document.getElementById(containerId);
            container.innerHTML = '';
            
            for (let i = 0; i &lt; rows; i++) {
                const row = document.createElement('div');
                row.className = 'matrix-row';
                
                for (let j = 0; j &lt; cols; j++) {
                    const input = document.createElement('input');
                    input.type = 'number';
                    input.className = 'matrix-cell';
                    input.value = '0';
                    row.appendChild(input);
                }
                
                container.appendChild(row);
            }
        }

        function createMatrices() {
            const rowsA = parseInt(document.getElementById('rowsA').value);
            const colsA = parseInt(document.getElementById('colsA').value);
            const rowsB = parseInt(document.getElementById('rowsB').value);
            const colsB = parseInt(document.getElementById('colsB').value);

            if (rowsA &gt; 5 || colsA &gt; 5 || rowsB &gt; 5 || colsB &gt; 5) {
                showError('Maximum matrix size is 5x5');
                return;
            }

            createMatrix(rowsA, colsA, 'matrixA');
            createMatrix(rowsB, colsB, 'matrixB');
            clearResult();
        }

        function getMatrixValues(containerId) {
            const matrix = [];
            const rows = document.querySelectorAll(`#${containerId} .matrix-row`);
            
            rows.forEach(row =&gt; {
                const rowValues = [];
                row.querySelectorAll('.matrix-cell').forEach(cell =&gt; {
                    rowValues.push(parseFloat(cell.value) || 0);
                });
                matrix.push(rowValues);
            });
            
            return matrix;
        }

        function displayMatrix(matrix, containerId) {
            const container = document.getElementById(containerId);
            container.innerHTML = '';
            
            matrix.forEach(row =&gt; {
                const rowDiv = document.createElement('div');
                rowDiv.className = 'matrix-row';
                
                row.forEach(value =&gt; {
                    const cell = document.createElement('input');
                    cell.type = 'number';
                    cell.className = 'matrix-cell';
                    cell.value = value.toFixed(2);
                    cell.readOnly = true;
                    rowDiv.appendChild(cell);
                });
                
                container.appendChild(rowDiv);
            });
        }

        function addMatrices(A, B) {
            if (A.length !== B.length || A[0].length !== B[0].length) {
                throw new Error('Matrices must have the same dimensions for addition');
            }

            return A.map((row, i) =&gt; row.map((val, j) =&gt; val + B[i][j]));
        }

        function subtractMatrices(A, B) {
            if (A.length !== B.length || A[0].length !== B[0].length) {
                throw new Error('Matrices must have the same dimensions for subtraction');
            }

            return A.map((row, i) =&gt; row.map((val, j) =&gt; val - B[i][j]));
        }

        function multiplyMatrices(A, B) {
            if (A[0].length !== B.length) {
                throw new Error('Number of columns in first matrix must equal number of rows in second matrix');
            }

            const result = [];
            for (let i = 0; i &lt; A.length; i++) {
                result[i] = [];
                for (let j = 0; j &lt; B[0].length; j++) {
                    result[i][j] = 0;
                    for (let k = 0; k &lt; A[0].length; k++) {
                        result[i][j] += A[i][k] * B[k][j];
                    }
                }
            }
            return result;
        }

        function showSteps(A, B, result, operation) {
            const steps = document.getElementById('steps');
            let stepsHtml = '&lt;h3&gt;Calculation Steps:&lt;/h3&gt;';

            if (operation === 'multiply') {
                stepsHtml += '&lt;p&gt;For matrix multiplication (A × B):&lt;/p&gt;';
                for (let i = 0; i &lt; result.length; i++) {
                    for (let j = 0; j &lt; result[0].length; j++) {
                        stepsHtml += `&lt;p&gt;Result[${i+1},${j+1}] = `;
                        let terms = [];
                        for (let k = 0; k &lt; A[0].length; k++) {
                            terms.push(`(${A[i][k]} × ${B[k][j]})`);
                        }
                        stepsHtml += terms.join(' + ') + ` = ${result[i][j].toFixed(2)}&lt;/p&gt;`;
                    }
                }
            } else {
                stepsHtml += `&lt;p&gt;For matrix ${operation === 'add' ? 'addition' : 'subtraction'}:&lt;/p&gt;`;
                for (let i = 0; i &lt; result.length; i++) {
                    for (let j = 0; j &lt; result[0].length; j++) {
                        stepsHtml += `&lt;p&gt;Result[${i+1},${j+1}] = ${A[i][j]} ${operation === 'add' ? '+' : '-'} ${B[i][j]} = ${result[i][j].toFixed(2)}&lt;/p&gt;`;
                    }
                }
            }

            steps.innerHTML = stepsHtml;
        }

        function performOperation(operation) {
            clearError();
            try {
                const A = getMatrixValues('matrixA');
                const B = getMatrixValues('matrixB');
                let result;

                switch (operation) {
                    case 'add':
                        result = addMatrices(A, B);
                        break;
                    case 'subtract':
                        result = subtractMatrices(A, B);
                        break;
                    case 'multiply':
                        result = multiplyMatrices(A, B);
                        break;
                }

                displayMatrix(result, 'resultMatrix');
                showSteps(A, B, result, operation);
            } catch (error) {
                showError(error.message);
            }
        }

        function showError(message) {
            document.getElementById('error').textContent = message;
        }

        function clearError() {
            document.getElementById('error').textContent = '';
        }

        function clearResult() {
            document.getElementById('resultMatrix').innerHTML = '';
            document.getElementById('steps').innerHTML = '';
            clearError();
        }

        function clearMatrices() {
            createMatrices();
            clearResult();
        }

        function toggleSteps() {
            const steps = document.getElementById('steps');
            steps.style.display = steps.style.display === 'none' ? 'block' : 'none';
        }

        // Initialize matrices on load
        createMatrices();
    &lt;/script&gt;
&lt;style&gt;html,body{height:auto!important;min-height:0!important;max-height:none!important}&lt;/style&gt;&lt;script&gt;(function(){function wpcPost(){try{parent.postMessage({wpcId:179,wpcH:document.body.scrollHeight},'*');}catch(e){}}window.addEventListener('load',wpcPost);try{new MutationObserver(wpcPost).observe(document.body,{childList:true,subtree:true,attributes:true});}catch(e){}window.addEventListener('resize',wpcPost);setInterval(wpcPost,600);})();&lt;/script&gt;&lt;/body&gt;
&lt;/html&gt;" id="wpc-frame-179" class="wpc-embed-frame" style="width:100%;border:0;display:block;overflow:hidden;" scrolling="no"></iframe>
<p><a href="https://ilmhunt.com/advanced-matrix-calculator/" target="_blank" rel="noopener">Advanced Matrix Calculator</a> by <a href="https://ilmhunt.com/" target="_blank" rel="noopener">IlmHunt</a> — free online tools</p>