第10章：特征值与特征向量

Haiyue

October 7, 2025

21min

第10章：特征值与特征向量

学习目标

理解特征值和特征向量的定义
掌握特征值和特征向量的计算方法
理解特征值的几何意义
掌握特征多项式的性质
理解特征值在实际问题中的应用

特征值与特征向量的定义

基本定义

对于 $n \times n$ 矩阵 $A$ ，如果存在非零向量 $\mathbf{v}$ 和标量 $\lambda$ ，使得： $A\mathbf{v} = \lambda\mathbf{v}$

则称 $\lambda$ 为矩阵 $A$ 的特征值（eigenvalue）， $\mathbf{v}$ 为对应的特征向量（eigenvector）。

几何意义

特征向量是在线性变换作用下方向不变的向量，特征值表示该向量的伸缩倍数。

import numpy as np
import matplotlib.pyplot as plt
from scipy.linalg import eig
import scipy.linalg
import matplotlib.patches as patches

def visualize_eigenvalues_2d():
    """可视化二维矩阵的特征值和特征向量"""

    # 定义一个2x2矩阵
    A = np.array([[3, 1],
                  [1, 2]])

    # 计算特征值和特征向量
    eigenvalues, eigenvectors = eig(A)

    print("矩阵 A:")
    print(A)
    print(f"\n特征值: {eigenvalues}")
    print(f"特征向量:\n{eigenvectors}")

    # 验证特征值方程
    for i in range(len(eigenvalues)):
        lambda_i = eigenvalues[i]
        v_i = eigenvectors[:, i]
        Av = A @ v_i
        lambda_v = lambda_i * v_i

        print(f"\n验证特征值 {lambda_i:.3f}:")
        print(f"A × v = {Av}")
        print(f"λ × v = {lambda_v}")
        print(f"相等: {np.allclose(Av, lambda_v)}")

    # 可视化
    fig, axes = plt.subplots(1, 3, figsize=(15, 5))

    # 1. 原始向量空间
    ax1 = axes[0]

    # 绘制单位圆
    theta = np.linspace(0, 2*np.pi, 100)
    unit_circle = np.array([np.cos(theta), np.sin(theta)])
    ax1.plot(unit_circle[0], unit_circle[1], 'b--', alpha=0.5, label='单位圆')

    # 绘制特征向量
    for i, (val, vec) in enumerate(zip(eigenvalues, eigenvectors.T)):
        # 归一化特征向量便于显示
        vec_normalized = vec / np.linalg.norm(vec) * 2
        ax1.arrow(0, 0, vec_normalized[0], vec_normalized[1],
                 head_width=0.1, head_length=0.1, fc=f'C{i}', ec=f'C{i}',
                 linewidth=3, label=f'特征向量 {i+1}')

        # 显示特征值
        ax1.text(vec_normalized[0]*1.2, vec_normalized[1]*1.2,
                f'λ={val:.2f}', fontsize=10, ha='center')

    ax1.set_xlim(-3, 3)
    ax1.set_ylim(-3, 3)
    ax1.grid(True, alpha=0.3)
    ax1.set_aspect('equal')
    ax1.legend()
    ax1.set_title('特征向量（原始空间）')

    # 2. 变换后的空间
    ax2 = axes[1]

    # 变换后的单位圆（椭圆）
    transformed_circle = A @ unit_circle
    ax2.plot(transformed_circle[0], transformed_circle[1], 'r-', linewidth=2, label='变换后的圆')

    # 变换后的特征向量
    for i, (val, vec) in enumerate(zip(eigenvalues, eigenvectors.T)):
        vec_normalized = vec / np.linalg.norm(vec) * 2
        transformed_vec = A @ vec_normalized
        ax2.arrow(0, 0, transformed_vec[0], transformed_vec[1],
                 head_width=0.1, head_length=0.1, fc=f'C{i}', ec=f'C{i}',
                 linewidth=3, label=f'A×特征向量 {i+1}')

    ax2.set_xlim(-4, 8)
    ax2.set_ylim(-4, 6)
    ax2.grid(True, alpha=0.3)
    ax2.set_aspect('equal')
    ax2.legend()
    ax2.set_title('线性变换后')

    # 3. 对比显示
    ax3 = axes[2]

    # 绘制一般向量的变换
    test_vectors = np.array([[1, 0, 1, 1],
                            [0, 1, 1, -1]])

    for i in range(test_vectors.shape[1]):
        original = test_vectors[:, i]
        transformed = A @ original

        # 原始向量
        ax3.arrow(0, 0, original[0], original[1],
                 head_width=0.05, head_length=0.05, fc='blue', ec='blue',
                 alpha=0.5, linestyle='--')

        # 变换后向量
        ax3.arrow(0, 0, transformed[0], transformed[1],
                 head_width=0.05, head_length=0.05, fc='red', ec='red',
                 alpha=0.7)

    # 特征向量（方向不变）
    for i, (val, vec) in enumerate(zip(eigenvalues, eigenvectors.T)):
        vec_normalized = vec / np.linalg.norm(vec) * 1.5
        transformed_vec = A @ vec_normalized

        ax3.arrow(0, 0, vec_normalized[0], vec_normalized[1],
                 head_width=0.1, head_length=0.1, fc=f'C{i}', ec=f'C{i}',
                 linewidth=3, alpha=0.5)
        ax3.arrow(0, 0, transformed_vec[0], transformed_vec[1],
                 head_width=0.1, head_length=0.1, fc=f'C{i}', ec=f'C{i}',
                 linewidth=3)

    ax3.set_xlim(-2, 6)
    ax3.set_ylim(-2, 4)
    ax3.grid(True, alpha=0.3)
    ax3.set_aspect('equal')
    ax3.set_title('特征向量方向不变')

    plt.tight_layout()
    plt.show()

visualize_eigenvalues_2d()

特征多项式与特征方程

特征多项式

特征值满足特征方程： $\det(A - \lambda I) = 0$

$\det(A - \lambda I)$ 称为矩阵 $A$ 的特征多项式，记作 $p(\lambda)$ 。

代数重数与几何重数

代数重数：特征值在特征多项式中的重数
几何重数：对应特征空间的维数

def characteristic_polynomial_analysis():
    """分析特征多项式"""

    # 定义几个不同的矩阵
    matrices = {
        "对角矩阵": np.array([[3, 0], [0, 2]]),
        "对称矩阵": np.array([[2, 1], [1, 2]]),
        "有重特征值的矩阵": np.array([[2, 1], [0, 2]]),
        "复特征值矩阵": np.array([[0, -1], [1, 0]])
    }

    for name, A in matrices.items():
        print(f"\n{name}:")
        print(f"矩阵 A =\n{A}")

        # 计算特征值和特征向量
        eigenvalues, eigenvectors = eig(A)

        print(f"特征值: {eigenvalues}")

        # 手动验证特征方程
        print("\n验证特征方程 det(A - λI) = 0:")
        for i, lambda_val in enumerate(eigenvalues):
            matrix_diff = A - lambda_val * np.eye(A.shape[0])
            det_val = np.linalg.det(matrix_diff)
            print(f"λ = {lambda_val:.3f}: det(A - λI) = {det_val:.2e}")

        # 分析特征向量
        print("\n特征向量分析:")
        for i, (lambda_val, eigenvec) in enumerate(zip(eigenvalues, eigenvectors.T)):
            print(f"λ{i+1} = {lambda_val:.3f}, v{i+1} = {eigenvec}")

            # 验证 Av = λv
            Av = A @ eigenvec
            lambda_v = lambda_val * eigenvec
            print(f"  验证: ||Av - λv|| = {np.linalg.norm(Av - lambda_v):.2e}")

        print("-" * 50)

characteristic_polynomial_analysis()

特殊矩阵的特征值

对称矩阵的特征值

对称矩阵的特征值都是实数，且对应不同特征值的特征向量正交。

正交矩阵的特征值

正交矩阵的特征值的模长都等于1。

def special_matrices_eigenvalues():
    """特殊矩阵的特征值性质"""

    # 1. 对称矩阵
    symmetric_matrix = np.array([[4, 2, 1],
                                [2, 3, 2],
                                [1, 2, 4]])

    print("1. 对称矩阵:")
    print(symmetric_matrix)

    sym_eigenvals, sym_eigenvecs = eig(symmetric_matrix)
    print(f"特征值: {sym_eigenvals}")
    print("所有特征值都是实数:", np.all(np.isreal(sym_eigenvals)))

    # 验证特征向量的正交性
    print("\n特征向量正交性验证:")
    for i in range(len(sym_eigenvals)):
        for j in range(i+1, len(sym_eigenvals)):
            dot_product = np.dot(sym_eigenvecs[:, i], sym_eigenvecs[:, j])
            print(f"v{i+1} · v{j+1} = {dot_product:.2e}")

    # 2. 反对称矩阵
    antisymmetric_matrix = np.array([[0, 2, -1],
                                    [-2, 0, 3],
                                    [1, -3, 0]])

    print(f"\n2. 反对称矩阵:")
    print(antisymmetric_matrix)

    antisym_eigenvals, _ = eig(antisymmetric_matrix)
    print(f"特征值: {antisym_eigenvals}")
    print("特征值都是纯虚数或零:", np.allclose(np.real(antisym_eigenvals), 0))

    # 3. 正交矩阵（旋转矩阵）
    theta = np.pi/4
    rotation_matrix = np.array([[np.cos(theta), -np.sin(theta)],
                               [np.sin(theta), np.cos(theta)]])

    print(f"\n3. 旋转矩阵（θ = 45°）:")
    print(rotation_matrix)

    rot_eigenvals, rot_eigenvecs = eig(rotation_matrix)
    print(f"特征值: {rot_eigenvals}")
    print("特征值模长:", np.abs(rot_eigenvals))
    print("所有特征值模长都为1:", np.allclose(np.abs(rot_eigenvals), 1))

    # 4. 上三角矩阵
    upper_triangular = np.array([[2, 3, 1],
                                [0, 4, 2],
                                [0, 0, 5]])

    print(f"\n4. 上三角矩阵:")
    print(upper_triangular)

    upper_eigenvals, _ = eig(upper_triangular)
    diagonal_elements = np.diag(upper_triangular)

    print(f"特征值: {upper_eigenvals}")
    print(f"对角元素: {diagonal_elements}")
    print("特征值等于对角元素:", np.allclose(np.sort(upper_eigenvals), np.sort(diagonal_elements)))

special_matrices_eigenvalues()

特征值的计算方法

2×2矩阵的解析解

对于 $2 \times 2$ 矩阵： $A = \begin{pmatrix} a & b \\ c & d \end{pmatrix}$

特征值为： $\lambda = \frac{(a+d) \pm \sqrt{(a+d)^2 - 4(ad-bc)}}{2}$

幂法求主特征值

def power_method_demo():
    """演示幂法求主特征值"""

    def power_method(A, max_iterations=100, tolerance=1e-6):
        """
        幂法求矩阵的主特征值和对应特征向量
        """
        n = A.shape[0]
        # 初始化随机向量
        x = np.random.rand(n)
        x = x / np.linalg.norm(x)

        eigenvalue_estimates = []

        for iteration in range(max_iterations):
            # 矩阵向量乘法
            y = A @ x

            # 估计特征值（瑞利商）
            eigenvalue = x.T @ y

            # 归一化
            x_new = y / np.linalg.norm(y)

            eigenvalue_estimates.append(eigenvalue)

            # 检查收敛性
            if iteration > 0:
                if abs(eigenvalue_estimates[-1] - eigenvalue_estimates[-2]) < tolerance:
                    break

            x = x_new

        return eigenvalue, x, eigenvalue_estimates

    # 测试矩阵
    A = np.array([[4, 1, 2],
                  [1, 3, 1],
                  [2, 1, 5]], dtype=float)

    print("测试矩阵 A:")
    print(A)

    # 使用幂法
    eigenval_power, eigenvec_power, estimates = power_method(A)

    # 使用NumPy验证
    eigenvals_true, eigenvecs_true = eig(A)
    max_eigenval_true = eigenvals_true[np.argmax(np.abs(eigenvals_true))]

    print(f"\n幂法结果:")
    print(f"估计的主特征值: {eigenval_power:.6f}")
    print(f"真实的主特征值: {max_eigenval_true:.6f}")
    print(f"误差: {abs(eigenval_power - max_eigenval_true):.2e}")

    # 可视化收敛过程
    plt.figure(figsize=(10, 6))

    plt.subplot(1, 2, 1)
    plt.plot(estimates, 'b-o', markersize=4)
    plt.axhline(y=max_eigenval_true, color='r', linestyle='--', label='真实值')
    plt.xlabel('迭代次数')
    plt.ylabel('特征值估计')
    plt.title('幂法收敛过程')
    plt.legend()
    plt.grid(True, alpha=0.3)

    # 误差分析
    plt.subplot(1, 2, 2)
    errors = [abs(est - max_eigenval_true) for est in estimates]
    plt.semilogy(errors, 'r-o', markersize=4)
    plt.xlabel('迭代次数')
    plt.ylabel('绝对误差 (对数尺度)')
    plt.title('收敛误差')
    plt.grid(True, alpha=0.3)

    plt.tight_layout()
    plt.show()

    return eigenval_power, eigenvec_power

power_method_demo()

特征值的应用：主成分分析

PCA的数学原理

主成分分析（PCA）通过计算协方差矩阵的特征值和特征向量来找到数据的主要变化方向。

def pca_eigenvalue_demo():
    """使用特征值进行主成分分析"""

    # 生成相关的二维数据
    np.random.seed(42)
    n_samples = 200

    # 创建相关数据
    X1 = np.random.randn(n_samples)
    X2 = 0.8 * X1 + 0.6 * np.random.randn(n_samples)
    X = np.column_stack([X1, X2])

    # 中心化数据
    X_centered = X - np.mean(X, axis=0)

    # 计算协方差矩阵
    cov_matrix = np.cov(X_centered.T)

    print("协方差矩阵:")
    print(cov_matrix)

    # 计算特征值和特征向量
    eigenvals, eigenvecs = eig(cov_matrix)

    # 按特征值大小排序
    idx = np.argsort(eigenvals)[::-1]
    eigenvals = eigenvals[idx]
    eigenvecs = eigenvecs[:, idx]

    print(f"\n特征值: {eigenvals}")
    print(f"方差解释比例: {eigenvals / np.sum(eigenvals)}")

    # 可视化
    fig, axes = plt.subplots(1, 3, figsize=(15, 5))

    # 1. 原始数据
    ax1 = axes[0]
    ax1.scatter(X[:, 0], X[:, 1], alpha=0.6, s=20)
    ax1.set_xlabel('X1')
    ax1.set_ylabel('X2')
    ax1.set_title('原始数据')
    ax1.grid(True, alpha=0.3)
    ax1.set_aspect('equal')

    # 2. 主成分方向
    ax2 = axes[1]
    ax2.scatter(X_centered[:, 0], X_centered[:, 1], alpha=0.6, s=20)

    # 绘制主成分方向
    center = np.mean(X_centered, axis=0)
    for i, (val, vec) in enumerate(zip(eigenvals, eigenvecs.T)):
        # 特征向量长度与特征值成比例
        length = 3 * np.sqrt(val)
        ax2.arrow(center[0], center[1], vec[0]*length, vec[1]*length,
                 head_width=0.1, head_length=0.1, fc=f'C{i}', ec=f'C{i}',
                 linewidth=3, label=f'PC{i+1} (λ={val:.2f})')
        ax2.arrow(center[0], center[1], -vec[0]*length, -vec[1]*length,
                 head_width=0.1, head_length=0.1, fc=f'C{i}', ec=f'C{i}',
                 linewidth=3)

    ax2.set_xlabel('X1 (中心化)')
    ax2.set_ylabel('X2 (中心化)')
    ax2.set_title('主成分方向')
    ax2.legend()
    ax2.grid(True, alpha=0.3)
    ax2.set_aspect('equal')

    # 3. 主成分坐标系下的数据
    ax3 = axes[2]

    # 将数据投影到主成分坐标系
    X_pca = X_centered @ eigenvecs

    ax3.scatter(X_pca[:, 0], X_pca[:, 1], alpha=0.6, s=20)
    ax3.set_xlabel(f'PC1 (解释 {eigenvals[0]/np.sum(eigenvals)*100:.1f}% 方差)')
    ax3.set_ylabel(f'PC2 (解释 {eigenvals[1]/np.sum(eigenvals)*100:.1f}% 方差)')
    ax3.set_title('主成分坐标系')
    ax3.grid(True, alpha=0.3)
    ax3.set_aspect('equal')

    plt.tight_layout()
    plt.show()

    # 计算累积方差解释比例
    explained_variance_ratio = eigenvals / np.sum(eigenvals)
    cumulative_variance = np.cumsum(explained_variance_ratio)

    print(f"\n累积方差解释:")
    for i, (individual, cumulative) in enumerate(zip(explained_variance_ratio, cumulative_variance)):
        print(f"PC{i+1}: {individual:.3f} (累积: {cumulative:.3f})")

pca_eigenvalue_demo()

特征值在动力系统中的应用

线性动力系统的稳定性

def dynamical_system_stability():
    """分析线性动力系统的稳定性"""

    # 定义几个动力系统矩阵
    systems = {
        "稳定螺旋": np.array([[-0.5, -0.8], [0.8, -0.5]]),
        "不稳定节点": np.array([[1.2, 0.3], [0.3, 0.8]]),
        "鞍点": np.array([[1, 0], [0, -0.5]]),
        "中心点": np.array([[0, 1], [-1, 0]])
    }

    fig, axes = plt.subplots(2, 2, figsize=(12, 10))
    axes = axes.flatten()

    for i, (name, A) in enumerate(systems.items()):
        ax = axes[i]

        # 计算特征值
        eigenvals, eigenvecs = eig(A)

        print(f"\n{name}:")
        print(f"矩阵:\n{A}")
        print(f"特征值: {eigenvals}")

        # 分析稳定性
        real_parts = np.real(eigenvals)
        if np.all(real_parts < 0):
            stability = "稳定"
        elif np.all(real_parts > 0):
            stability = "不稳定"
        elif np.any(real_parts > 0) and np.any(real_parts < 0):
            stability = "鞍点"
        else:
            stability = "边界稳定"

        print(f"稳定性: {stability}")

        # 绘制相平面图
        x = np.linspace(-2, 2, 20)
        y = np.linspace(-2, 2, 20)
        X, Y = np.meshgrid(x, y)

        # 计算向量场
        DX = A[0, 0] * X + A[0, 1] * Y
        DY = A[1, 0] * X + A[1, 1] * Y

        # 绘制向量场
        ax.quiver(X, Y, DX, DY, alpha=0.5)

        # 绘制特征向量
        for j, (val, vec) in enumerate(zip(eigenvals, eigenvecs.T)):
            if np.isreal(val):
                # 实特征值
                vec_real = np.real(vec)
                length = 1.5
                ax.arrow(0, 0, vec_real[0]*length, vec_real[1]*length,
                        head_width=0.1, head_length=0.1, fc=f'C{j}', ec=f'C{j}',
                        linewidth=3, alpha=0.8)
                ax.arrow(0, 0, -vec_real[0]*length, -vec_real[1]*length,
                        head_width=0.1, head_length=0.1, fc=f'C{j}', ec=f'C{j}',
                        linewidth=3, alpha=0.8)

        # 绘制一些轨迹
        for initial in [[-1, -1], [1, 1], [-1, 1], [1, -1]]:
            trajectory = simulate_trajectory(A, initial, steps=50, dt=0.1)
            ax.plot(trajectory[:, 0], trajectory[:, 1], 'r-', alpha=0.7, linewidth=1)
            ax.plot(initial[0], initial[1], 'ro', markersize=4)

        ax.set_xlim(-2, 2)
        ax.set_ylim(-2, 2)
        ax.set_xlabel('x')
        ax.set_ylabel('y')
        ax.set_title(f'{name}\n特征值: {eigenvals[0]:.2f}, {eigenvals[1]:.2f}')
        ax.grid(True, alpha=0.3)
        ax.set_aspect('equal')

    plt.tight_layout()
    plt.show()

def simulate_trajectory(A, initial, steps=50, dt=0.1):
    """模拟线性系统的轨迹"""
    trajectory = np.zeros((steps, 2))
    state = np.array(initial, dtype=float)

    for i in range(steps):
        trajectory[i] = state
        # 欧拉方法: x(t+dt) = x(t) + dt * A * x(t)
        state = state + dt * (A @ state)

    return trajectory

dynamical_system_stability()

特征值的数值计算

QR算法简介

def qr_algorithm_demo():
    """演示QR算法求特征值"""

    def qr_algorithm(A, max_iterations=50):
        """
        简化的QR算法求特征值
        """
        A_k = A.copy()
        eigenvalue_estimates = []

        for k in range(max_iterations):
            # QR分解
            Q, R = np.linalg.qr(A_k)

            # 更新矩阵
            A_k = R @ Q

            # 记录对角元素（特征值的近似）
            diagonal = np.diag(A_k)
            eigenvalue_estimates.append(diagonal.copy())

            # 检查收敛（下三角部分接近零）
            if k > 5:
                lower_triangular_norm = np.linalg.norm(np.tril(A_k, k=-1))
                if lower_triangular_norm < 1e-10:
                    break

        return A_k, eigenvalue_estimates

    # 测试矩阵
    A = np.array([[4, 1, 1],
                  [1, 3, 2],
                  [1, 2, 5]], dtype=float)

    print("原始矩阵 A:")
    print(A)

    # QR算法
    A_final, estimates = qr_algorithm(A)

    print(f"\n经过 {len(estimates)} 次迭代后的矩阵:")
    print(A_final)

    # 真实特征值
    true_eigenvals = np.linalg.eigvals(A)
    estimated_eigenvals = np.diag(A_final)

    print(f"\n真实特征值: {np.sort(true_eigenvals)}")
    print(f"QR算法估计: {np.sort(estimated_eigenvals)}")

    # 可视化收敛过程
    estimates_array = np.array(estimates)

    plt.figure(figsize=(12, 4))

    for i in range(A.shape[0]):
        plt.plot(estimates_array[:, i], 'o-', label=f'特征值 {i+1}')
        plt.axhline(y=true_eigenvals[i], color=f'C{i}', linestyle='--', alpha=0.7)

    plt.xlabel('迭代次数')
    plt.ylabel('特征值估计')
    plt.title('QR算法收敛过程')
    plt.legend()
    plt.grid(True, alpha=0.3)
    plt.show()

qr_algorithm_demo()

特征值的几何解释

椭圆的主轴

二次型 $x^TAx = 1$ 定义的椭圆的主轴方向由 $A$ 的特征向量确定，主轴长度由特征值的倒数平方根确定。

def ellipse_principal_axes():
    """可视化椭圆的主轴与特征向量的关系"""

    # 定义正定对称矩阵
    A = np.array([[5, 2],
                  [2, 2]])

    # 计算特征值和特征向量
    eigenvals, eigenvecs = eig(A)

    # 按特征值大小排序
    idx = np.argsort(eigenvals)[::-1]
    eigenvals = eigenvals[idx]
    eigenvecs = eigenvecs[:, idx]

    print("矩阵 A:")
    print(A)
    print(f"特征值: {eigenvals}")
    print(f"特征向量:\n{eigenvecs}")

    # 椭圆的半轴长度
    semi_axes = 1 / np.sqrt(eigenvals)
    print(f"椭圆半轴长度: {semi_axes}")

    # 生成椭圆上的点
    theta = np.linspace(0, 2*np.pi, 1000)

    # 在特征向量坐标系下的单位圆
    unit_circle = np.array([np.cos(theta), np.sin(theta)])

    # 缩放到椭圆
    ellipse_principal = semi_axes[:, np.newaxis] * unit_circle

    # 旋转到原坐标系
    ellipse_points = eigenvecs @ ellipse_principal

    # 可视化
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))

    # 1. 椭圆和特征向量
    ax1.plot(ellipse_points[0], ellipse_points[1], 'b-', linewidth=2, label='椭圆 $x^TAx = 1$')

    # 绘制特征向量（主轴方向）
    for i, (val, vec) in enumerate(zip(eigenvals, eigenvecs.T)):
        length = semi_axes[i]
        ax1.arrow(0, 0, vec[0]*length, vec[1]*length,
                 head_width=0.05, head_length=0.05, fc=f'C{i+1}', ec=f'C{i+1}',
                 linewidth=3, label=f'主轴 {i+1} (λ={val:.2f})')
        ax1.arrow(0, 0, -vec[0]*length, -vec[1]*length,
                 head_width=0.05, head_length=0.05, fc=f'C{i+1}', ec=f'C{i+1}',
                 linewidth=3)

    ax1.set_xlim(-1, 1)
    ax1.set_ylim(-1, 1)
    ax1.set_aspect('equal')
    ax1.grid(True, alpha=0.3)
    ax1.legend()
    ax1.set_title('椭圆的主轴')

    # 2. 等高线图
    x = np.linspace(-1, 1, 100)
    y = np.linspace(-1, 1, 100)
    X, Y = np.meshgrid(x, y)

    # 计算二次型的值
    Z = A[0,0]*X**2 + 2*A[0,1]*X*Y + A[1,1]*Y**2

    contours = ax2.contour(X, Y, Z, levels=[0.5, 1, 2, 3, 4], colors='blue', alpha=0.7)
    ax2.clabel(contours, inline=True, fontsize=8)

    # 绘制特征向量
    for i, (val, vec) in enumerate(zip(eigenvals, eigenvecs.T)):
        ax2.arrow(0, 0, vec[0]*0.8, vec[1]*0.8,
                 head_width=0.05, head_length=0.05, fc=f'C{i+1}', ec=f'C{i+1}',
                 linewidth=3, label=f'特征向量 {i+1}')

    ax2.set_xlim(-1, 1)
    ax2.set_ylim(-1, 1)
    ax2.set_aspect('equal')
    ax2.grid(True, alpha=0.3)
    ax2.legend()
    ax2.set_title('二次型等高线')

    plt.tight_layout()
    plt.show()

ellipse_principal_axes()

本章总结

核心概念总结

概念	数学表达	几何意义	应用
特征值	$A\mathbf{v} = \lambda\mathbf{v}$	变换的伸缩因子	稳定性分析
特征向量	非零解	变换不变方向	主成分分析
特征多项式	$\det(A-\lambda I)=0$	特征值的多项式	理论分析
代数重数	多项式中的重数	重特征值个数	对角化判定
几何重数	特征空间维数	线性无关特征向量数	对角化判定

重要性质

🔄 正在渲染 Mermaid 图表...

graph TD
    A[特征值性质] --> B[对称矩阵]
    A --> C[正交矩阵]
    A --> D[三角矩阵]
    A --> E[相似矩阵]

    B --> F[实特征值<br/>正交特征向量]
    C --> G[|λ| = 1]
    D --> H[对角元为特征值]
    E --> I[相同特征值]

    J[应用领域] --> K[动力系统]
    J --> L[主成分分析]
    J --> M[振动分析]
    J --> N[量子力学]

计算方法总结

def computational_methods_summary():
    """特征值计算方法总结"""

    methods = {
        "解析方法": {
            "适用": "2×2矩阵",
            "优点": "精确解",
            "缺点": "仅限低维"
        },
        "幂法": {
            "适用": "主特征值",
            "优点": "简单，内存效率高",
            "缺点": "仅得到一个特征值"
        },
        "QR算法": {
            "适用": "所有特征值",
            "优点": "数值稳定",
            "缺点": "计算复杂度高"
        },
        "Jacobi方法": {
            "适用": "对称矩阵",
            "优点": "高精度",
            "缺点": "收敛较慢"
        }
    }

    print("特征值计算方法总结:")
    print("=" * 60)
    for method, properties in methods.items():
        print(f"\n{method}:")
        for prop, desc in properties.items():
            print(f"  {prop}: {desc}")

computational_methods_summary()

特征值与特征向量是线性代数最重要的概念之一，它们不仅揭示了线性变换的内在结构，更在科学计算、工程应用、数据分析等领域发挥着关键作用。掌握特征值理论为理解矩阵对角化、二次型、动力系统等高级主题奠定了坚实基础。

Apache Airflow 3.x

Chapter 1: Introduction to Apache Airflow 3.x

Chapter 2: Core Concepts and Architecture

Chapter 3: Writing Your First DAG

Chapter 4: Built-in Operators and Sensors

Apache Airflow 3.x

Chapter 1: Introduction to Apache Airflow 3.x

Chapter 2: Core Concepts and Architecture

Chapter 3: Writing Your First DAG

Chapter 4: Built-in Operators and Sensors

第10章：特征值与特征向量

第10章：特征值与特征向量

特征值与特征向量的定义

基本定义

几何意义

特征多项式与特征方程

特征多项式

代数重数与几何重数

特殊矩阵的特征值

对称矩阵的特征值

正交矩阵的特征值

特征值的计算方法

2×2矩阵的解析解

幂法求主特征值

特征值的应用：主成分分析

PCA的数学原理

特征值在动力系统中的应用

线性动力系统的稳定性

特征值的数值计算

QR算法简介

特征值的几何解释

椭圆的主轴

本章总结

核心概念总结

重要性质

计算方法总结