C语言实现对称矩阵特征值与特征向量计算（幂法）

本文将介绍如何使用 C 语言判断一个输入的矩阵是否为对称矩阵，并利用幂法计算其特征值和特征向量。

代码实现

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define MAX_SIZE 100

int main() {
    int n, i, j;
    double a[MAX_SIZE][MAX_SIZE], b[MAX_SIZE][MAX_SIZE], eig_vec[MAX_SIZE][MAX_SIZE], eig_val[MAX_SIZE];
    printf('Enter the order of the matrix: ');
    scanf('%d', &n);
    printf('Enter the elements of the matrix:\n');
    for(i = 0; i < n; i++) {
        for(j = 0; j < n; j++) {
            scanf('%lf', &a[i][j]);
        }
    }
    // check if matrix is symmetric
    int is_symmetric = 1;
    for(i = 0; i < n; i++) {
        for(j = 0; j < n; j++) {
            if(a[i][j] != a[j][i]) {
                is_symmetric = 0;
                break;
            }
        }
        if(!is_symmetric) {
            break;
        }
    }
    if(is_symmetric) {
        printf('The matrix is symmetric.\n');
        // calculate eigenvalues and eigenvectors
        double eps = 1e-10;
        double norm, lambda;
        double x[MAX_SIZE], y[MAX_SIZE];
        for(i = 0; i < n; i++) {
            for(j = 0; j < n; j++) {
                b[i][j] = a[i][j];
                eig_vec[i][j] = 0.0;
            }
            eig_vec[i][i] = 1.0;
        }
        do {
            norm = 0.0;
            for(i = 0; i < n; i++) {
                for(j = 0; j < n; j++) {
                    x[j] = eig_vec[j][i];
                }
                for(j = 0; j < n; j++) {
                    y[j] = 0.0;
                    for(int k = 0; k < n; k++) {
                        y[j] += a[j][k] * x[k];
                    }
                }
                lambda = 0.0;
                for(j = 0; j < n; j++) {
                    lambda += y[j] * x[j];
                }
                norm += fabs(lambda);
                for(j = 0; j < n; j++) {
                    eig_vec[j][i] = y[j] / sqrt(lambda);
                }
            }
            for(i = 0; i < n; i++) {
                for(j = 0; j < n; j++) {
                    b[i][j] = 0.0;
                    for(int k = 0; k < n; k++) {
                        b[i][j] += a[i][k] * eig_vec[k][j];
                    }
                }
            }
            for(i = 0; i < n; i++) {
                for(j = 0; j < n; j++) {
                    a[i][j] = 0.0;
                    for(int k = 0; k < n; k++) {
                        a[i][j] += eig_vec[i][k] * b[k][j];
                    }
                }
            }
        } while(norm > eps);
        printf('The eigenvalues are:\n');
        for(i = 0; i < n; i++) {
            printf('%lf\n', a[i][i]);
            eig_val[i] = a[i][i];
        }
        printf('The eigenvectors are:\n');
        for(j = 0; j < n; j++) {
            printf('[');
            for(i = 0; i < n; i++) {
                printf('%lf ', eig_vec[i][j]);
            }
            printf(']\n');
        }
    } else {
        printf('The matrix is not symmetric.\n');
    }
    return 0;
}

代码解释

输入矩阵： 首先，程序会要求用户输入矩阵的阶数和元素。
判断对称性： 程序会判断输入的矩阵是否是对称矩阵。如果矩阵不是对称矩阵，程序会提示用户并退出。
幂法迭代： 如果矩阵是对称矩阵，程序会利用幂法计算其特征值和特征向量。
- 初始化：程序会初始化一个随机向量 x 作为初始向量，并设置一个迭代次数 k。
- 迭代：程序会进行 k 次迭代，每次迭代都使用矩阵 A 乘以当前向量 x，得到新的向量 y。然后，程序会将 y 归一化，得到新的 x。
- 计算特征值：程序会使用 x 计算特征值。
输出结果： 程序会输出计算出的特征值和特征向量。

幂法原理

幂法的基本思想是：对于一个任意的非零向量 (\mathbf{x_0})，经过 (k) 次迭代后，(\mathbf{x_k}) 越来越趋近于特征向量，对应的特征值 (\lambda) 可以通过 (\lambda = \mathbf{x_k}^T A \mathbf{x_k} / \mathbf{x_k}^T \mathbf{x_k}) 计算得到。

代码使用

编译代码：使用 C 编译器编译代码，例如 gcc power_method.c -o power_method。
运行程序：运行编译后的程序，程序会提示用户输入矩阵的阶数和元素。
查看结果：程序会输出计算出的特征值和特征向量。

注意： 幂法可能会收敛到矩阵的最小特征值对应的特征向量，因此需要选择合适的初始向量。

总结

本文介绍了使用 C 语言判断矩阵是否为对称矩阵，并利用幂法计算其特征值和特征向量的方法。代码示例涵盖了矩阵输入、对称性判断、幂法迭代、特征值和特征向量输出等步骤，并对幂法的原理进行了简单的介绍。