线性代数 - 通过增广矩阵计算逆矩阵 js html实现

最新推荐文章于 2024-08-10 20:03:35 发布

//爷傲灬奈我何

最新推荐文章于 2024-08-10 20:03:35 发布

阅读量211

点赞数 1

文章标签：线性代数矩阵 javascript

本文链接：https://blog.csdn.net/qq_56168825/article/details/140780558

版权

由于我学习到了通过增广矩阵的方法计算逆矩阵，并且准备用js html 通过本文实现用增广矩阵计算逆矩阵。将变换前的增广矩阵渲染出来，以及通过有限次的初等变换将变换完的矩阵也渲染到页面上，让用户看到非常直观的增广矩阵计算过程。

由图片可以看出来，变换后的左半部分已经变换成单位阵E而右边部分也变成了非常精确的逆矩阵。由于我的矩阵是胡乱填的数字，所以看上去有点不真实。换一个比较容易看出正确性的案例如下。

代码如下，大家如果感兴趣的话可以仔细阅读以下代码。

代码如下。

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>求逆矩阵</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            background-color: #f8f9fa;
        }

        table {
            width: 100%;
            border-collapse: collapse;
        }

        table th,
        table td {
            border: 1px solid #dee2e6;
            padding: 5px;
            text-align: center;
        }

        input {
            width: 25px;
            height: 25px;
            font-size: 14px;
            text-align: center;
        }

        button {
            padding: 10px 20px;
            border-radius: 10px;
            background-color: #007bff;
            color: white;
            border: none;
            cursor: pointer;
            font-size: 16px;
        }

        button:hover {
            background-color: #0056b3;
        }
    </style>
</head>

<body>
<input type="number" id="matrixSizeInput" />
<button onclick="generateMatrix()">生成矩阵</button>
<h2>原始矩阵输入</h2>
<table id="originalMatrix"></table>
<button onclick="calculateInverse()">计算逆矩阵</button>
<h2>增广矩阵</h2>
<table id="augmentedMatrix"></table>
<h2>变换后的增广矩阵</h2>
<table id="transformedAugmentedMatrix"></table>

<script>
    function generateMatrix() {
        let size = parseInt(document.getElementById('matrixSizeInput').value);
        if (isNaN(size) || size <= 0) {
            alert('请输入有效的正整数作为矩阵阶数');
            return;
        }

        let originalMatrixTable = document.getElementById('originalMatrix');
        originalMatrixTable.innerHTML = '';

        for (let i = 0; i < size; i++) {
            let row = originalMatrixTable.insertRow();
            for (let j = 0; j < size; j++) {
                let cell = row.insertCell();
                let input = document.createElement('input');
                cell.appendChild(input);
            }
        }
    }

    function calculateInverse() {
        let size = parseInt(document.getElementById('matrixSizeInput').value);
        if (isNaN(size) || size <= 0) {
            alert('请先输入有效的矩阵阶数并生成矩阵');
            return;
        }

        let originalMatrix = [];
        let originalMatrixTable = document.getElementById('originalMatrix');

        for (let i = 0; i < size; i++) {
            originalMatrix[i] = [];
            for (let j = 0; j < size; j++) {
                let input = originalMatrixTable.rows[i].cells[j].getElementsByTagName('input')[0];
                originalMatrix[i][j] = parseFloat(input.value);
            }
        }

        let augmentedMatrix = createAugmentedMatrix(originalMatrix);

        renderAugmentedMatrix(augmentedMatrix, 'augmentedMatrix');

        let transformedAugmentedMatrix = performGaussianElimination(augmentedMatrix);

        renderAugmentedMatrix(transformedAugmentedMatrix, 'transformedAugmentedMatrix');
    }

    function createAugmentedMatrix(matrix) {
        let size = matrix.length;
        let augmented = [];

        for (let i = 0; i < size; i++) {
            augmented[i] = matrix[i].concat(new Array(size).fill(0));
            augmented[i][i + size] = 1;
        }

        return augmented;
    }

    function renderAugmentedMatrix(matrix, tableId) {
        let table = document.getElementById(tableId);
        table.innerHTML = '';

        for (let i = 0; i < matrix.length; i++) {
            let row = table.insertRow();
            for (let j = 0; j < matrix[i].length; j++) {
                let cell = row.insertCell();
                cell.innerHTML = matrix[i][j];
            }
        }
    }

    function performGaussianElimination(matrix) {
        let size = matrix.length;

        for (let i = 0; i < size; i++) {
            if (matrix[i][i] === 0) {
                for (let k = i + 1; k < size; k++) {
                    if (matrix[k][i]!== 0) {
                        let temp = matrix[i];
                        matrix[i] = matrix[k];
                        matrix[k] = temp;
                        break;
                    }
                }
            }

            let pivot = matrix[i][i];

            for (let j = i; j < 2 * size; j++) {
                matrix[i][j] /= pivot;
            }

            for (let k = 0; k < size; k++) {
                if (k!== i) {
                    let factor = matrix[k][i];
                    for (let j = 0; j < 2 * size; j++) {
                        matrix[k][j] -= factor * matrix[i][j];
                    }
                }
            }
        }

        return matrix;
    }
</script>
</body>

</html>