线性代数伴随矩阵的计算 html js实现-CSDN博客

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

在学习线性代数的过程中，为了增强方便计算逆矩阵，写了一个工具来计算伴随矩阵，配合之前的计算行列式的功能可以很方便的计算出逆矩阵。在之后的博客中我会将其组合起来。以便直接计算逆矩阵。

HTML真的很方便，这种可视化界面非常适合自己来用。其他语言可能在处理逻辑上有优势，但是在展示上确实不方便了。

功能图如下：

代码如下。

<!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="calculateAdjoint()">计算伴随矩阵</button>
<h2>伴随矩阵</h2>
<table id="adjointMatrix"></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 calculateAdjoint() {
        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];
                if (input.value) {  // 检查是否有输入值
                    originalMatrix[i][j] = parseFloat(input.value);
                } else {
                    alert('请输入完整的矩阵值');
                    return;
                }
            }
        }

        let adjointMatrix = calculateAdjointMatrix(originalMatrix);

        let adjointMatrixTable = document.getElementById('adjointMatrix');
        adjointMatrixTable.innerHTML = '';

        for (let i = 0; i < size; i++) {
            let row = adjointMatrixTable.insertRow();
            for (let j = 0; j < size; j++) {
                let cell = row.insertCell();
                cell.innerHTML = adjointMatrix[i][j];
            }
        }
    }

    function calculateAdjointMatrix(matrix) {
        let size = matrix.length;
        let adjoint = [];

        for (let i = 0; i < size; i++) {
            adjoint.push(new Array(size).fill(0));  // 初始化 adjoint 数组
        }

        for (let i = 0; i < size; i++) {
            for (let j = 0; j < size; j++) {
                let cofactor = calculateCofactor(matrix, j, i);  // 交换行列参数
                adjoint[i][j] = Math.pow(-1, i + j) * cofactor;
            }
        }

        return adjoint;
    }
    
    function calculateCofactor(matrix, row, col) {
        let submatrix = [];
        let size = matrix.length;

        for (let i = 0; i < size; i++) {
            if (i === row) continue;
            submatrix.push([]);  // 修改：确保 submatrix 中的子数组被初始化
            for (let j = 0; j < size; j++) {
                if (j === col) continue;
                submatrix[submatrix.length - 1].push(matrix[i][j]);
            }
        }

        return determinant(submatrix);
    }

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

        if (size === 1) {
            return matrix[0][0];
        }

        let det = 0;
        let sign = 1;

        for (let col = 0; col < size; col++) {
            let submatrix = [];

            for (let row = 1; row < size; row++) {
                submatrix.push([]);  // 修改：确保 submatrix 中的子数组被初始化
                for (let j = 0; j < size; j++) {
                    if (j!== col) {
                        submatrix[submatrix.length - 1].push(matrix[row][j]);
                    }
                }
            }

            det += sign * matrix[0][col] * determinant(submatrix);
            sign = -sign;
        }

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

</html>