matlab基础知识

阅读数:224 评论数:0

跳转到新版页面

分类

数学

正文

一、数组

1、创建数值数组

（1）一维数组的创建方法

使用方括号直接输入元素

A = [1, 2, 3, 4, 5]; % 创建一个行向量
B = [1; 2; 3; 4; 5]; % 创建一个列向量

注意，在 MATLAB 中，逗号 , 或空格用于分隔行向量的元素，而分号 ; 用于分隔列向量的元素。

使用linespace函数，linspace 用于生成线性间隔的向量：

A = linspace(1, 10, 5); % 生成从 1 到 10 的 5 个等间距的点

上述代码生成的向量为 [1 3.25 5.5 7.75 10]。

使用colon运算符，使用 : 运算符可以创建等差数列：

A = 1:5; % 生成从 1 到 5 的行向量
B = 1:2:9; % 生成从 1 到 9，每次增加 2 的行向量

上述代码生成的向量 A 为 [1 2 3 4 5]，向量 B 为 [1 3 5 7 9]。

使用zeros，ones和rand等函数，可以使用一些内置函数生成特定类型的向量：

A = zeros(1, 5); % 生成一个包含 5 个零的行向量
B = ones(1, 5); % 生成一个包含 5 个一的行向量
C = rand(1, 5); % 生成一个包含 5 个 0 到 1 之间随机数的行向量
D = randn(1, 5); % 生成一个包含 5 个服从正态分布的随机数的行向量

使用reshape函数，如果你有一个矩阵，可以使用 reshape 函数将其转换为一维数组：

M = [1, 2, 3; 4, 5, 6];
A = reshape(M, 1, []); % 将矩阵 M 转换为行向量
B = reshape(M, [], 1); % 将矩阵 M 转换为列向量

（2）二维数组的创建方法

使用方括号直接输入元素

A = [1, 2, 3; 4, 5, 6; 7, 8, 9]; % 创建一个 3x3 矩阵

使用内置函数

A = zeros(3, 3); % 生成一个 3x3 的全零矩阵
B = ones(3, 3); % 生成一个 3x3 的全一矩阵
C = rand(3, 3); % 生成一个 3x3 的随机数矩阵，元素在 0 到 1 之间
D = randn(3, 3); % 生成一个 3x3 的随机数矩阵，元素服从标准正态分布
E = eye(3); % 生成一个 3x3 的单位矩阵

使用reshape函数

如果你已经有一个一维数组，可以使用 reshape 函数将其转换为二维数组：

A = 1:9; % 创建一个包含 1 到 9 的行向量
B = reshape(A, 3, 3); % 将行向量转换为 3x3 矩阵

使用colon运算符，可以使用 : 运算符创建二维数组：

A = reshape(1:9, 3, 3); % 生成一个包含 1 到 9 的 3x3 矩阵

使用diag函数，diag 函数可以创建对角矩阵：

A = diag([1, 2, 3]); % 创建一个对角线元素为 1, 2, 3 的 3x3 矩阵

使用meshgrid函数，meshgrid 函数常用于生成网格坐标矩阵：

[X, Y] = meshgrid(1:3, 1:3); % 生成 3x3 的 X 和 Y 坐标矩阵

使用复合操作，可以将不同方法结合起来创建更复杂的矩阵：

A = [zeros(2, 2), ones(2, 3); rand(3, 2), eye(3)]; % 创建一个 5x5 的复合矩阵

（3）使用下标创建三维数组

直接使用下标赋值

% 初始化一个 3x3x3 的全零三维数组
A = zeros(3, 3, 3);

% 为第一层赋值
A(:, :, 1) = [1, 2, 3; 4, 5, 6; 7, 8, 9];

% 为第二层赋值
A(:, :, 2) = [10, 11, 12; 13, 14, 15; 16, 17, 18];

% 为第三层赋值
A(:, :, 3) = [19, 20, 21; 22, 23, 24; 25, 26, 27];

动态扩展数组，可以动态地为特定位置赋值，MATLAB 会自动扩展数组的大小。

% 初始化一个空数组
B = [];

% 为特定位置赋值
B(1, 1, 1) = 1;
B(2, 2, 2) = 8;
B(3, 3, 3) = 27;

% 如果有其他位置没有赋值，它们会默认填充为零

使用循环创建三维数组

% 初始化一个 3x3x3 的全零三维数组
E = zeros(3, 3, 3);

% 使用循环填充三维数组
for i = 1:3
    for j = 1:3
        for k = 1:3
            E(i, j, k) = (i-1)*9 + (j-1)*3 + k;
        end
    end
end

（4）使用低维数组创建三维数组

使用cat函数

cat 函数可以将多个低维数组（例如二维矩阵）沿第三维度连接起来，创建一个三维数组。

% 定义二维矩阵
M1 = [1, 2, 3; 4, 5, 6];
M2 = [7, 8, 9; 10, 11, 12];
M3 = [13, 14, 15; 16, 17, 18];

% 通过 cat 函数将二维矩阵连接成三维数组
A = cat(3, M1, M2, M3);

在上述代码中，A 将是一个大小为 2x3x3 的三维数组，其中每一层是一个二维矩阵。

使用直接赋值的方法

可以直接将低维数组赋值到三维数组的指定层。

% 定义两个二维矩阵
M1 = [1, 2, 3; 4, 5, 6];
M2 = [7, 8, 9; 10, 11, 12];
M3 = [13, 14, 15; 16, 17, 18];

% 初始化一个 2x3x3 的三维数组
B = zeros(2, 3, 3);

% 直接赋值
B(:, :, 1) = M1;
B(:, :, 2) = M2;
B(:, :, 3) = M3;

使用reshape函数

% 定义一个包含所有数据的一维数组
V = 1:18;

% 将一维数组 reshape 成 2x3x3 的三维数组
C = reshape(V, [2, 3, 3]);

使用repmat函数

可以使用 repmat 函数重复一个二维数组来创建三维数组。

% 定义一个二维矩阵
M = [1, 2; 3, 4];

% 使用 repmat 函数重复二维矩阵
D = repmat(M, [1, 1, 3]);

（5）使用创建函数创建三维数组

zeros - 创建一个由0组成的数组

A = zeros(3, 4, 5);

ones - 创建一个由1组成的数组。

A = ones(3, 4, 5);

rand - 创建一个包含在0到1之间均匀分布的随机数的数组。

A = rand(3, 4, 5);

randn - 创建一个包含标准正态分布（均值0，方差1）随机数的数组。

A = randn(3, 4, 5);

randi - 创建一个包含指定范围内的随机整数的数组。

A = randi([imin, imax], 3, 4, 5);

eye - 创建一个三维数组，其中只有在特定“对角线”位置上有1，其他位置为0（通常用于二维数组，但可以扩展到三维）。

A = eye(3, 4, 5); % 这不会按预期工作，因为eye主要用于二维矩阵

repmat - 重复一个小数组来创建一个更大的数组。

smallArray = [1 2; 3 4]; % 一个2x2的数组
A = repmat(smallArray, 1, 1, 3); % 将smallArray沿着第三个维度重复3次

reshape - 改变一个已有数组的尺寸，可以用来创建三维数组。

A = reshape(1:60, 3, 4, 5);

permute - 重新排列一个多维数组的维度。

A = permute(A, [3, 1, 2]); % 将A的维度重新排列

cat - 沿指定维度连接数组。

A = cat(3, matrix1, matrix2, matrix3); % 沿第三维连接三个二维矩阵

bsxfun - 对数组执行按元素的二元操作，并自动扩展维度以匹配。

A = bsxfun(@plus, rand(3, 4), reshape(1:5, 1, 1, 5)); % 将3x4的随机数组与1x1x5的数组相加

（6）创建低维标准数组

创建低维标准数组通常是指创建一些具有特定特性的一维或二维数组。

零矩阵：所有元素都是0。

Z = zeros(3, 4); % 创建一个3行4列的零矩阵

单位矩阵：对角线上的元素都是1，其余元素都是0。

I = eye(3); % 创建一个3x3的单位矩阵

全一矩阵：所有元素都是1。

O = ones(3, 4); % 创建一个3行4列的全一矩阵

随机矩阵：元素是随机数。

R = rand(3, 4); % 创建一个3行4列的矩阵，其元素是0到1之间的随机数

标准正态分布的随机矩阵：元素是符合标准正态分布的随机数。

N = randn(3, 4); % 创建一个3行4列的矩阵，其元素是符合标准正态分布的随机数

魔方矩阵：所有行、列和对角线的元素和相等。

M = magic(3); % 创建一个3x3的魔方矩阵

这些函数创建的都是二维数组，但是如果你只使用一个参数，它们也可以用来创建一维数组（向量）：

v = zeros(1, 5); % 创建一个1x5的零向量
v = ones(5, 1); % 创建一个5x1的全一列向量

（7）创建高维标准数组

创建四维或更高维度的数组与创建三维数组的方式非常类似，只是你需要指定更多的维度大小。

零数组：使用 zeros 函数。

Z = zeros(3, 4, 5, 6); % 创建一个3x4x5x6的四维零数组

全一数组：使用 ones 函数。

O = ones(3, 4, 2, 3); % 创建一个3x4x2x3的四维全一数组

随机数组：使用 rand 函数。

R = rand(3, 4, 5, 2); % 创建一个3x4x5x2的四维随机数组，其元素在0到1之间

正态分布随机数组：使用 randn 函数。

N = randn(3, 4, 2, 3); % 创建一个3x4x2x3的四维随机数组，其元素符合标准正态分布

2、操作数值数组

（1）选取低维数组的对角元素

在MATLAB中，你可以使用 diag 函数来提取矩阵的对角元素或创建一个对角矩阵。这里是两种使用 diag 函数的方式：

提取对角元素：当你对一个矩阵使用 diag 函数时，它会返回包含矩阵主对角线元素的一个列向量。

A = [1 2 3; 4 5 6; 7 8 9];
d = diag(A); % 结果是 [1; 5; 9]

创建对角矩阵：如果你给 diag 函数一个向量，它会创建一个以该向量为主对角线的对角矩阵。

v = [1; 2; 3];
D = diag(v); % 结果是一个3x3的对角矩阵，对角线上的元素是1, 2, 3

此外，你还可以使用 diag 函数来获取次对角线上的元素，或者创建一个次对角线矩阵。这可以通过指定第二个参数来实现，这个参数是一个整数，表示从主对角线开始的偏移量。正值表示上对角线，负值表示下对角线。

% 提取上次对角线元素
up_diag = diag(A, 1); % 结果是 [2; 6]

% 提取下次对角线元素
low_diag = diag(A, -1); % 结果是 [4; 8]

在处理高维数组时，如果你想提取沿着任意两个维度的对角元素，你需要先将这两个维度重排到第一和第二维度（使用 permute 或 reshape），然后再使用 diag。

（2）低维数组的形式转换

在MATLAB中，您可以使用多种方式来改变数组的形状，而不会改变其数据内容。

reshape函数

reshape 函数可以改变数组的大小，但是其元素的总数必须保持不变。

A = [1 2 3; 4 5 6];
B = reshape(A, 3, 2); % 将A重新整形为3x2矩阵

转置操作

使用单引号 (') 可以对矩阵进行转置，将行变成列，列变成行。

A = [1 2 3; 4 5 6];
A_transpose = A'; % A的转置

permute函数

当您处理多维数组时，permute 函数可以用于重新排列数组的维度。

A = rand(2,3,4); % 创建一个2x3x4的三维数组
B = permute(A, [3,1,2]); % 将数组的维度重新排列为4x2x3

squeeze函数

squeeze 函数用于移除数组中长度为1的维度（即单元素维度）。

A = rand(1,3,1,4);
B = squeeze(A); % 移除长度为1的维度，结果是一个3x4的矩阵

：操作符

您可以使用冒号操作符 (:) 将数组转换为列向量。

A = [1 2 3; 4 5 6];
A_col_vector = A(:); % 将A转换为6x1的列向量

cat函数

cat 函数用于沿指定维度连接数组。

A = [1 2; 3 4];
B = [5 6; 7 8];
C = cat(1, A, B); % 沿第一维（行方向）连接A和B

horzcat和vertcat函数

这些函数分别用于水平和垂直方向的数组连接。

A = [1 2];
B = [3 4];
C = horzcat(A, B); % 水平连接，等同于[A B]
D = vertcat(A, B); % 垂直连接，等同于[A; B]

（3）选取三角矩阵

在MATLAB中，您可以使用内置的函数或逻辑索引来提取三角矩阵的上三角部分或下三角部分。

提取上三角矩阵

要提取矩阵的上三角部分，您可以使用 triu 函数：

A = [1 2 3; 4 5 6; 7 8 9];
U = triu(A);

在这个例子中，U 将是：

1 2 3
0 5 6
0 0 9

提取下三角矩阵

要提取矩阵的下三角部分，您可以使用 tril 函数：

A = [1 2 3; 4 5 6; 7 8 9];
L = tril(A);

在这个例子中，L 将是：

1 0 0
4 5 0
7 8 9

指定对角线偏移

这两个函数都接受第二个可选参数，该参数是一个整数，指定对角线上的偏移量。正值表示上对角线的偏移，负值表示下对角线的偏移。

例如，提取矩阵A上方第一条对角线以上的元素：

U1 = triu(A, 1);

这将得到：

0 2 3
0 0 6
0 0 0

同样，提取矩阵A下方第一条对角线以下的元素：

L1 = tril(A, -1);

这将得到：

0 0 0
4 0 0
7 8 0

（4）Kronecker乘法

在MATLAB中，克罗内克积（Kronecker product）可以使用 kron 函数来计算。克罗内克积是两个矩阵的一种张量积，在多个领域中都有应用，包括线性代数、系统理论和量子计算。

如果你有两个矩阵 A 和 B，你可以使用以下命令来计算它们的克罗内克积：

C = kron(A, B);

这里 A 和 B 是输入的矩阵，C 将是结果矩阵。在克罗内克积中，矩阵 A 的每个元素都与矩阵 B 相乘，得到一个大矩阵。如果 A 是一个 m×n 矩阵，B 是一个 p×q 矩阵，那么克罗内克积 C 将是一个 mp×nq 矩阵。

下面是一个简单的例子：

A = [1 2; 3 4];
B = [0 5; 6 7];
C = kron(A, B);

% C 的结果将是
%    0    5   0   10
%    6    7  12   14
%    0   15   0   20
%   18   21  24   28

（5）高维数组的对称交换

在 MATLAB 中处理高维数组时，您可能需要对数组的维度进行重新排序，这通常称为置换（permutation）。对于高维数组的对称交换，您可以使用 permute 函数来重新排列数组的维度。

例如，假设您有一个三维数组 A，其大小为 (3,4,2)，您想要将第一维和第三维交换，保持第二维不变，您可以这样做：

A = rand(3,4,2); % 创建一个 3x4x2 的随机数组
B = permute(A, [3, 2, 1]); % 将第一维和第三维交换

在这个例子中，permute 函数的第二个参数 [3, 2, 1] 指定了新的维度顺序。原来的第一维 (size 3) 现在成为了新数组 B 的第三维，原来的第二维 (size 4) 保持不变，原来的第三维 (size 2) 现在成为了新数组 B 的第一维。因此，如果 A 的大小是 (3,4,2)，那么 B 的大小将是 (2,4,3)。

如果数组有更多维度，您可以继续按照这种方式进行操作，只需确保 permute 函数的第二个参数包含所有维度的新顺序即可。例如，如果您有一个四维数组 C，其大小为 (3,4,2,5)，并且您想要交换第一维和第四维，同时交换第二维和第三维，您可以这样做：

C = rand(3,4,2,5); % 创建一个 3x4x2x5 的随机数组
D = permute(C, [4, 3, 2, 1]); % 交换维度顺序

（6）高维数组的维序号移动

在 MATLAB 中，当你想要移动高维数组的维序号时，你可以使用 permute 函数，如之前所述，或者使用 shiftdim 函数。shiftdim 函数用于将数组的维度向左或向右旋转。

使用 shiftdim 向左旋转维度：

A = rand(3,4,5); % 创建一个 3x4x5 的数组
B = shiftdim(A,1); % 将维度向左旋转一个位置

在这个例子中，B 会变成一个 4x5x3 的数组。原来的第一维度变成了第三维，原来的第二维度变成了第一维，原来的第三维度变成了第二维。

使用 shiftdim 向右旋转维度：

A = rand(3,4,5); % 创建一个 3x4x5 的数组
B = shiftdim(A,-1); % 将维度向右旋转

在这个例子中，B 会变成一个 5x3x4 的数组。原来的第一维度变成了第二维，原来的第二维度变成了第三维，原来的第三维度变成了第一维。

permute 和 shiftdim 的区别在于，permute 可以进行任意的维度重排列，而 shiftdim 只能进行维度的旋转操作。

（7）高维数组的广义共轭转置

在 MATLAB 中，对于高维数组，广义共轭转置（也称为 Hermitian 转置）通常指的是对矩阵的每个二维切片进行共轭转置。

对于高维数组，MATLAB 没有内置函数直接进行这种操作，但你可以通过对每个二维切片手动执行共轭转置来实现。下面是一个对三维数组进行广义共轭转置的示例：

% 假设 A 是一个 3x4x2 的三维数组
A = rand(3,4,2) + 1i*rand(3,4,2); % 创建一个含有复数的三维随机数组

% 初始化一个与 A 广义共轭转置后大小相同的数组
A_conj_transpose = zeros(size(A,2), size(A,1), size(A,3));

% 对每个二维切片进行共轭转置
for k = 1:size(A,3)
    A_conj_transpose(:,:,k) = A(:,:,k)';
end

（8）高维数组的降维操作

在 MATLAB 中进行高维数组的降维操作通常涉及将多维数组转换为二维矩阵或一维向量。这可以通过多种方式完成，具体取决于所需的降维方式和目的。以下是一些常见的降维方法：

使用 reshape 函数： 可以将高维数组重塑为任何其他维度，只要总元素数量保持不变。

A = rand(3,4,5); % 创建一个 3x4x5 的数组
B = reshape(A, [], 1); % 将 A 重塑为一个列向量，其中 [] 自动计算所需的维度大小
C = reshape(A, 12, 5); % 将 A 重塑为一个 12x5 的二维矩阵

使用 squeeze 函数： 当高维数组中有一个或多个维度大小为 1 时，squeeze 函数可以去除这些单一维度，从而降低数组的维度。

A = rand(1,4,5); % 创建一个 1x4x5 的数组
B = squeeze(A); % 结果是一个 4x5 的二维矩阵

使用 sum、mean 等聚合函数： 这些函数可以沿着指定的维度对数组进行操作，从而减少数组的维度。

A = rand(3,4,5); % 创建一个 3x4x5 的数组
B = sum(A, 1); % 沿着第一个维度求和，结果是一个 1x4x5 的数组
C = squeeze(B); % 可以进一步使用 squeeze 去除单一维度，得到 4x5 的矩阵

使用 vec 函数： 虽然 MATLAB 没有内置的 vec 函数，但是可以通过 reshape 来模拟这个操作，将矩阵或多维数组转换为一个向量。

A = rand(3,4,5); % 创建一个 3x4x5 的数组
B = A(:); % 使用冒号操作符将 A 转换为一个向量

二、矩阵和架构

1、稀疏矩阵

（1）稀疏矩阵的存储方式

在 MATLAB 中，稀疏矩阵通常以压缩稀疏列（Compressed Sparse Column, CSC）格式存储。这种格式只存储非零元素以及相关的索引信息，从而实现对内存的高效利用。具体来说，MATLAB 使用三个数组来表示一个稀疏矩阵：

Values (非零值数组): 存储所有非零元素的值。
Row Indices (行索引数组): 对应于每个非零元素的行号。
Column Pointers (列指针数组): 对于每一列，存储该列第一个非零元素在 Values 和 Row Indices 数组中的位置。此外，最后一个元素存储的是非零元素总数加一的值。

例如，考虑如下的 4x4 稀疏矩阵：

$$
\begin{bmatrix}
10 & 0 & 0 & 0 \\
0 & 20 & 0 & 0 \\
0 & 0 & 30 & 0 \\
0 & 0 & 0 & 40 \\
\end{bmatrix}
$$

在 MATLAB 中，这个矩阵的 CSC 存储会包含以下信息：

Values: [10, 20, 30, 40]
Row Indices: [1, 2, 3, 4]
Column Pointers: [1, 2, 3, 4, 5]

在这个例子中，Column Pointers 数组告诉我们，第一列的第一个（也是唯一的）非零元素在 Values 数组的第一个位置，第二列的非零元素在第二个位置，依此类推。最后一个元素 5 是非零元素总数加一的值，指示了 Values 数组的结束。

在 MATLAB 中，你可以使用 sparse 函数创建稀疏矩阵，也可以使用 spalloc 函数预分配一个稀疏矩阵空间。对于已有的稀疏矩阵，可以使用 nnz 函数来查询非零元素的数量，或者使用 spy 函数来可视化稀疏矩阵中非零元素的分布。

（2）创建稀疏矩阵——使用sparse命令

从行列索引和值创建稀疏矩阵：

S = sparse(i, j, s, m, n);

其中 i 和 j 分别是行索引和列索引的向量，s 是相应非零元素值的向量，m 和 n 分别是稀疏矩阵的行数和列数。如果省略 m 和 n，则 sparse 函数会根据索引向量的最大值确定矩阵的大小。

创建一个空的稀疏矩阵：

S = sparse(m, n);

这将创建一个 m 行 n 列的全零稀疏矩阵。

使用逻辑索引创建稀疏矩阵：

S = sparse(i, j, s, m, n, nzmax);

这里 nzmax 是一个预估的非零元素的最大数量，这有助于 MATLAB 优化存储空间分配。

举个例子，如果你想创建一个稀疏矩阵，其中第1行第1列的元素是2，第3行第2列的元素是5，你可以这样做：

S = sparse([1 3], [1 2], [2 5]);

（3）创建稀疏矩阵——使用spdiags命令

spdiags 命令用于创建一个稀疏矩阵，其对角线上的值可以由输入向量来指定。这个命令非常适合创建具有特定对角线结构的稀疏矩阵，例如三对角矩阵、五对角矩阵等。

spdiags 的基本用法是：

B = spdiags(A, d, m, n);

A 是一个矩阵，其每一列包含了要放在结果矩阵 B 的某一对角线上的元素。
d 是一个向量，指定了 A 中每一列对应的对角线。例如，d = 0 表示主对角线，d = 1 表示主对角线上方的第一条对角线，d = -1 表示主对角线下方的第一条对角线，依此类推。
m 和 n 分别指定了结果稀疏矩阵 B 的行数和列数。

如果你想从一个已有的稀疏矩阵 B 中提取对角线元素，你可以使用 spdiags 的另一种形式：

B 是一个已有的稀疏矩阵。
d 是一个包含对角线位置的向量。函数会返回一个矩阵 A，其列包含了 B 中指定的对角线上的元素。

下面是一个使用 spdiags 创建三对角矩阵的例子：

% 创建一个三对角矩阵，中间对角线上的值为4，两侧对角线上的值为1和-1
n = 5; % 矩阵大小
e = ones(n, 1); % 辅助向量
A = spdiags([e -2*e e], -1:1, n, n);

这个例子中，A 将是一个 5x5 的三对角矩阵，主对角线上的元素为 -2，主对角线上方和下方的对角线上的元素分别为 1。

（4）查看稀疏矩阵的信息

直接输出：

直接在命令行中输入稀疏矩阵的变量名并回车，MATLAB 会显示稀疏矩阵的非零元素信息。
whos 命令：

使用 whos 命令可以查看工作区中所有变量的详细信息，包括每个变量的类型、大小、占用的字节数等。如果只想查看某个特定稀疏矩阵的信息，可以使用 whos 命令加上变量名：

whos VariableName

spy 函数：

spy 函数用于可视化稀疏矩阵的非零元素分布情况，这个函数会在图形窗口中生成一个点图，其中的点表示非零元素的位置：

spy(S)

这里 S 是稀疏矩阵。

nzmax 函数：

nzmax 函数返回稀疏矩阵中可以存储的非零元素的最大数目，这个数目可能大于实际的非零元素数目，因为 MATLAB 会预留一些空间以优化稀疏矩阵的存储和操作：

nz = nzmax(S)

nnz 函数：

nnz 函数返回稀疏矩阵中非零元素的实际数目：

nonzeros = nnz(S)

full 函数：

full 函数可以将稀疏矩阵转换为完整（非稀疏）矩阵。这通常用于小型稀疏矩阵，以便直观地看到所有的元素：

F = full(S)

size 函数：

size 函数可以返回稀疏矩阵的尺寸，即行数和列数：

[m, n] = size(S)

find 函数：

find 函数可以返回稀疏矩阵非零元素的索引和值：

[row, col, val] = find(S)

这里 row 和 col 分别是非零元素的行索引和列索引，val 是对应的非零元素的值。

（5）稀疏矩阵的图形化信息

在 MATLAB 中，图形化展示稀疏矩阵信息主要通过 spy 函数来实现。spy 函数可以提供稀疏矩阵非零元素位置的可视化，帮助你直观地理解矩阵的稀疏结构。下面是如何使用 spy 函数的例子：

% 假设 S 是一个稀疏矩阵
S = sprand(100, 100, 0.05); % 创建一个 100x100 稀疏矩阵，大约 5% 的元素是非零的

% 使用 spy 函数图形化展示 S
spy(S)

% 设置标题和坐标轴标签
title('非零元素位置图')
xlabel('列索引')
ylabel('行索引')

2、字符串数组

（1）创建字符串数组——直接输入法

可以使用方括号 [] 并用分号 ; 来分隔行，或者用逗号 , 或空格来分隔同一行中的元素。

% 创建一个列向量字符串数组
strArray = ["string1"; "string2"; "string3"]

% 创建一个行向量字符串数组
strArray = ["string1", "string2", "string3"]

% 创建一个 2x2 的字符串数组
strArray = ["string1", "string2"; "string3", "string4"]

（2）创建字符串数组——使用ASCII码

在 MATLAB 中，您可以使用 ASCII 码创建字符串。ASCII 码是字符的数值表示，您可以通过将这些数值转换为字符来创建字符串。以下是如何使用 ASCII 码创建字符串数组的步骤：

首先，确定您想要创建的字符串中每个字符的 ASCII 值。
使用 char 函数将这些 ASCII 值转换为字符。
将单个字符组合成字符串。
如果需要，将字符串组合成字符串数组。

下面是一个具体的例子：

% 假设我们有 ASCII 码的矩阵
asciiMatrix = [72 101 108 108 111; 87 111 114 108 100];

% 将 ASCII 码转换为字符
charMatrix = char(asciiMatrix);

% 将字符矩阵的每行转换为字符串数组的元素
strArray = string(charMatrix);

% 显示字符串数组
disp(strArray);

（3）创建字符串数组——使用函数

使用string函数

string 函数可以将其他数据类型转换为字符串数组。

% 将数值数组转换为字符串数组
numArray = [1, 2, 3, 4];
strArray = string(numArray);

% 将单元数组转换为字符串数组
cellArray = {'Hello', 'World'};
strArray = string(cellArray);

使用strsplit函数

strsplit 函数可以将一个字符串分割成多个部分，从而创建一个字符串数组。

% 使用默认的空格分隔符
str = 'Hello World MATLAB';
strArray = strsplit(str);

% 使用自定义分隔符
str = 'Hello,World,MATLAB';
strArray = strsplit(str, ',');

使用compose函数

compose 函数可以用于创建格式化的字符串数组。

% 使用 compose 创建带有数字的字符串数组
baseStr = 'Value: %d';
values = [10, 20, 30];
strArray = compose(baseStr, values);

使用sprintf函数

虽然 sprintf 主要用于格式化字符串，但它也可以用来创建字符串数组，尤其是在循环中。

% 使用 sprintf 格式化并创建字符串数组
strArray = strings(1, 3);
for i = 1:3
    strArray(i) = sprintf('Value: %d', i);
end

（4）处理字符串数组的空格

去除字符串两端的空格：可以使用 strtrim 函数去除字符串两端的空格。

strArray = ["   Hello   "; "   World   "];
trimmedStrArray = strtrim(strArray);

去除字符串中所有的空格：如果需要去除字符串中所有的空格（包括单词之间的空格），可以使用 replace 或 strrep 函数。

strArray = ["Hello World"; "MATLAB Code"];
noSpaceStrArray = replace(strArray, " ", "");
% 或者
noSpaceStrArray = strrep(strArray, " ", "");

分割字符串：如果需要根据空格来分割字符串数组中的每个字符串，可以使用 strsplit 函数。

strArray = ["Hello World"; "MATLAB Code"];
splitStrArray = strsplit(strArray); % 会返回一个元胞数组

合并字符串，使用空格作为分隔符：可以使用 strjoin 函数将多个字符串用空格合并成一个字符串。

strArray = ["Hello", "World"];
joinedStr = strjoin(strArray); % 结果是 "Hello World"

替换字符串中的多个空格为单个空格：可以使用正则表达式函数 regexprep 来实现。

strArray = ["Hello    World"; "MATLAB     Code"];
singleSpaceStrArray = regexprep(strArray, '\s+', ' ');

删除字符串数组中的空字符串元素：如果数组中有空字符串，可以使用 strtrim 和 ~ 运算符来删除它们。

strArray = ["Hello", "", "World", "   ", "MATLAB"];
strArray = strArray(strtrim(strArray) ~= "");

在这个例子中，strtrim 用于去除可能由空格组成的空字符串，然后 ~ 运算符用于创建一个逻辑索引，该索引只包含非空字符串。

（5）读取字符串数组的信息

访问数组元素

您可以使用索引来访问字符串数组中的特定元素。

strArray = ["Hello", "World", "MATLAB"];
% 访问第一个元素
firstElement = strArray(1);

获取数组的大小

% 获取字符串数组的大小
arraySize = size(strArray); % 返回数组的维度
numElements = numel(strArray); % 返回数组中元素的数量

使用 contains 函数检查字符串数组中的元素是否包含特定的字符或子字符串。

% 检查字符串数组中是否包含 "Hello"
containsElement = contains(strArray, "Hello");

使用 strfind 函数查找字符串数组中特定子字符串的位置。

% 查找字符串数组中 "World" 的位置
positions = strfind(strArray, "World");

使用 strcmp 或 strcmpi（不区分大小写）来比较字符串数组中的字符串。

% 比较字符串数组中的元素是否为 "MATLAB"
isEqual = strcmp(strArray, "MATLAB");

使用 strsplit 分割字符串，使用 strjoin 或 strcat 连接字符串。

% 分割字符串数组中的第一个元素
splitStr = strsplit(strArray(1), " ");

% 使用空格将字符串数组连接成一个字符串
joinedStr = strjoin(strArray);

使用 extractBefore、extractAfter、extractBetween 等函数来提取字符串数组中的子字符串。

% 提取第一个元素的前五个字符
subStr = extractBefore(strArray(1), 6);

使用 upper 或 lower 函数将字符串数组中的字符转换为大写或小写。

% 将字符串数组转换为大写
upperStrArray = upper(strArray);

3、构架数组

在 MATLAB 中，术语 "structure array"（结构体数组）指的是一个数组，其每个元素都是一个结构体（structure）。

结构体数组的每个元素都有相同的字段，但每个字段的内容可以不同。这使得结构体数组成为组织和管理具有相关属性的数据集合的强大工具。

（1）创建单构架数组——使用直接法

在 MATLAB 中，您可以使用直接赋值的方法来创建结构体数组。这种方法涉及直接分配值给结构体数组的每个字段。这里是一个如何使用直接法创建结构体数组的例子：

% 直接创建包含两个元素的结构体数组
people(1).name = 'Alice';
people(1).age = 24;
people(1).occupation = 'Engineer';

people(2).name = 'Bob';
people(2).age = 30;
people(2).occupation = 'Artist';

% 此时 people 是一个结构体数组，包含两个元素

注意，如果您在创建结构体数组时跳过了某些索引，MATLAB 会自动填充中间的索引，创建出完整的数组，未直接赋值的字段将被初始化为空。例如：

% 创建一个结构体数组，跳过了中间的索引
people(1).name = 'Alice';
people(3).name = 'Charlie';

% 此时，people(2) 也将存在，但它的所有字段都是空的

（2）创建二维构架数组

在 MATLAB 中创建二维结构体数组与创建一维结构体数组的过程类似，但您需要为每个维度指定索引。以下是一个创建二维结构体数组的示例：

% 创建一个 2x2 的二维结构体数组
people(1,1).name = 'Alice';
people(1,1).age = 24;
people(1,1).occupation = 'Engineer';

people(1,2).name = 'Bob';
people(1,2).age = 30;
people(1,2).occupation = 'Artist';

people(2,1).name = 'Carol';
people(2,1).age = 27;
people(2,1).occupation = 'Teacher';

people(2,2).name = 'Dave';
people(2,2).age = 22;
people(2,2).occupation = 'Student';

% 现在 people 是一个 2x2 的结构体数组

（3）创建三维构架数组

在 MATLAB 中，创建三维结构体数组的过程与创建一维或二维数组类似，只是您需要为三个维度指定索引。下面是一个创建三维结构体数组的示例：

% 创建一个 2x2x2 的三维结构体数组
people(1,1,1).name = 'Alice';
people(1,1,1).age = 24;
people(1,1,1).occupation = 'Engineer';

people(1,2,1).name = 'Bob';
people(1,2,1).age = 30;
people(1,2,1).occupation = 'Artist';

people(2,1,1).name = 'Carol';
people(2,1,1).age = 27;
people(2,1,1).occupation = 'Teacher';

people(2,2,1).name = 'Dave';
people(2,2,1).age = 22;
people(2,2,1).occupation = 'Student';

% ...可以继续填充第二层 (1,1,2), (1,2,2), (2,1,2), (2,2,2)...

% 现在 people 是一个 2x2x2 的三维结构体数组

（4）使用命令创建构架数组

在 MATLAB 中，如果您想要使用内置命令快速创建结构体数组，可以使用 struct 函数。这个函数可以一次性创建具有多个元素的结构体数组，而不需要逐个元素地指定。这在您有大量数据需要初始化为结构体数组时非常有用。

下面是一个使用 struct 函数创建三维结构体数组的示例：

% 定义字段名称和相应的数据
field1 = 'name';
value1 = {'Alice', 'Bob', 'Carol', 'Dave'; 'Eve', 'Frank', 'Grace', 'Hank'};

field2 = 'age';
value2 = {24, 30, 27, 22; 29, 35, 31, 36};

field3 = 'occupation';
value3 = {'Engineer', 'Artist', 'Teacher', 'Student'; 'Doctor', 'Lawyer', 'Nurse', 'Carpenter'};

% 使用 cell array 创建一个 2x2x2 的结构体数组
people = struct(field1, value1, field2, value2, field3, value3);

% 检查创建的结构体数组
disp(people(2, 1, 2).name); % 将显示 'Eve'
disp(people(2, 1, 2).age); % 将显示 29
disp(people(2, 1, 2).occupation); % 将显示 'Doctor'

（5）访问构架数组的数据

在 MATLAB 中，您可以使用点号（.）运算符来访问结构体数组中的字段。如果您有一个多维结构体数组，您可以通过指定每个维度的索引来访问特定元素的字段。

假设我们有一个名为 people 的 2x2x2 结构体数组，并且每个结构体元素都有 name、age 和 occupation 字段，您可以这样访问特定元素的字段：

% 访问第一个元素的 'name' 字段
personName = people(1,1,1).name;

% 访问第二层第一个元素的 'age' 字段
personAge = people(1,1,2).age;

% 访问第二行第二列第一层的 'occupation' 字段
personOccupation = people(2,2,1).occupation;

% 显示获取的信息
disp(['Name: ' personName]);
disp(['Age: ' num2str(personAge)]);
disp(['Occupation: ' personOccupation]);

如果您想要访问结构体数组中所有元素的某个字段，您可以使用冒号（:）运算符来代替具体的索引，它表示数组的所有元素。例如，获取所有人的名字：

% 获取结构体数组中所有人的名字
allNames = {people(:).name};

在这里，people(:).name 会返回一个 cell 数组，包含结构体数组中每个元素的 name 字段。

如果您想要访问特定层或行或列的所有元素，可以在相应的维度上使用冒号：

% 获取第一层所有人的年龄
firstLayerAges = {people(:,:,1).age};

% 获取第一行所有人的职业
firstRowOccupations = {people(1,:,:).occupation};

（6）设置构架数组的域属性

在 MATLAB 中，为结构体数组的字段（也称为“域”）设置属性时，您通常是在赋值给这些字段。这可以通过直接引用结构体数组的特定元素和字段来完成。如果您想要设置整个数组中所有元素的某个字段，或者是特定的一些元素的字段，您可以使用循环或者数组操作。

为单个元素设置字段值：

% 假设 people 是之前创建的结构体数组
% 为第一个元素的 'age' 字段设置一个新的值
people(1, 1, 1).age = 25;

为一个维度的所有元素设置相同的字段值：

% 为第一层所有元素的 'occupation' 字段设置相同的值
for i = 1:size(people, 1)
    for j = 1:size(people, 2)
        people(i, j, 1).occupation = 'Engineer';
    end
end

为整个结构体数组的所有元素设置相同的字段值：

% 为所有元素的 'isActive' 字段设置相同的值
% 假设我们要添加一个新的字段 'isActive'
isActiveValues = num2cell(true(size(people))); % 创建一个与 people 尺寸相同的 cell 数组，所有元素都是 true
[people(:).isActive] = isActiveValues{:}; % 展开 cell 数组并赋值给所有元素的 'isActive' 字段

如果您想要为数组中的每个元素设置不同的值，您可以使用类似的方法，但是需要为每个元素指定不同的值。例如：

% 为每个元素的 'age' 字段设置不同的值
ages = {28, 34, 21, 45, 52, 37, 19, 25}; % 假设这是一个包含新年龄的 cell 数组
[people(:).age] = ages{:}; % 分配新年龄到每个元素的 'age' 字段

三、矩阵分析

1、矩阵计算

（1）进行范数分析——使用norm函数

在 MATLAB 中，norm 函数通常用于计算向量或矩阵的范数。范数是一个衡量向量大小的函数。对于矩阵，范数可以用来衡量矩阵的某些属性，如奇异值或行（列）的和。

以下是 norm 函数的一些常见用法：

向量范数：
- norm(x, p) 计算向量 x 的 p-范数。当 p=2 时（默认情况下），它计算的是欧几里得范数（L2范数），即向量元素的平方和的平方根。
- norm(x, 1) 计算的是 L1 范数，即向量元素的绝对值之和。
- norm(x, Inf) 计算的是 L∞ 范数，即向量元素的最大绝对值。
矩阵范数：
- norm(A, 'fro') 计算的是弗罗贝尼乌斯范数（Frobenius norm），它类似于向量的 L2 范数，是矩阵元素平方和的平方根。
- norm(A, 1) 计算的是 1-范数，即矩阵列的绝对值之和的最大值。
- norm(A, Inf) 计算的是 ∞-范数，即矩阵行的绝对值之和的最大值。
- norm(A, 2) 计算的是 2-范数（默认情况下），即矩阵 A 的最大奇异值。

例如，如果您有一个向量 v 和一个矩阵 M，您可以这样计算它们的范数：

% 向量 v
v = [1, -2, 3];

% 计算 v 的 L2 范数
norm_v = norm(v); % 默认为 2-范数

% 计算 v 的 L1 范数
norm_v_1 = norm(v, 1);

% 计算 v 的 L∞ 范数
norm_v_inf = norm(v, Inf);

% 矩阵 M
M = [1, -2, 3; 4, 5, -6; 7, 8, 9];

% 计算 M 的弗罗贝尼乌斯范数
norm_M_fro = norm(M, 'fro');

% 计算 M 的 1-范数
norm_M_1 = norm(M, 1);

% 计算 M 的 ∞-范数
norm_M_inf = norm(M, Inf);

% 计算 M 的 2-范数
norm_M_2 = norm(M, 2);

（2）进行范数分析——使用normest函数

normest 函数在 MATLAB 中用于估算矩阵的 2-范数，特别是对于大型稀疏矩阵。这是因为直接计算大型稀疏矩阵的 2-范数（最大奇异值）可能非常耗时，而 normest 利用幂方法提供了一个快速的估算。

normest 函数的基本语法是：

n = normest(S)

其中 S 是要估算范数的矩阵，n 是返回的 2-范数的估算值。

如果你还需要估算的精度，可以使用另一个输出参数来获取估算误差：

[n, err] = normest(S)

这里，err 是估算的 2-范数与真实值之间的误差。

你还可以指定容忍度和最大迭代次数：

[n, err] = normest(S, tol, maxiter)

其中 tol 是容忍度，maxiter 是最大迭代次数。tol 默认值是 1e-6，而 maxiter 默认值是 2。

例如，对于一个大型稀疏矩阵 S，你可以这样估算它的 2-范数：

% 创建一个大型稀疏矩阵
S = sprand(1000, 1000, 0.05); % 1000x1000 稀疏矩阵，密度为 5%

% 估算 S 的 2-范数
norm_est = normest(S);

% 估算 S 的 2-范数，并获取估算误差
[norm_est, est_error] = normest(S);

% 使用自定义容忍度和最大迭代次数估算 2-范数
tol = 1e-4;
maxiter = 5;
[norm_est, est_error] = normest(S, tol, maxiter);

（3）条件数分析

条件数是衡量矩阵或数值问题对数值误差的敏感性的一个指标。在数值线性代数中，条件数用于评估解线性方程组的稳定性，以及矩阵求逆的问题。一个问题的条件数越高，解决这个问题时数值误差的扩散就越可能。

对于矩阵 $A$，其条件数通常定义为矩阵的范数和其逆的范数的乘积：

$$ \kappa(A) = \|A\| \cdot \|A^{-1}\| $$

在 MATLAB 中，可以使用 `cond` 函数来计算矩阵的条件数。默认情况下，`cond` 函数计算的是 2-范数条件数，但也可以计算其他范数的条件数。例如：

% 给定一个矩阵 A
A = [1, 2; 3, 4];

% 计算 A 的 2-范数条件数
kappa2 = cond(A);

% 计算 A 的 1-范数条件数
kappa1 = cond(A, 1);

% 计算 A 的 ∞-范数条件数
kappainf = cond(A, Inf);

% 计算 A 的 Frobenius 范数条件数
kappafro = cond(A, 'fro');

如果矩阵是奇异的或接近奇异的，条件数会变得非常大，这表明矩阵求逆或解线性方程组会非常不稳定。在实际应用中，如果条件数非常大，可能需要考虑数值方法的改进，比如使用正则化技术或迭代方法。

对于稀疏矩阵或大型矩阵，直接计算条件数可能非常耗时，因此在这些情况下，condest 函数可以用来估算 1-范数条件数：

% 创建一个大型稀疏矩阵 S
S = sprand(1000, 1000, 0.05);

% 估算 S 的 1-范数条件数
kappa_est = condest(S);

（4）数值矩阵的行列式

在数值计算中，计算矩阵的行列式是一个常见的任务。矩阵的行列式是一个标量值，它提供了矩阵是否可逆的信息。如果一个矩阵的行列式是零，那么这个矩阵是奇异的，也就是说它没有逆矩阵。

在 MATLAB 中，可以使用 det 函数来计算矩阵的行列式。这个函数适用于方阵，即行数和列数相等的矩阵。

下面是如何在 MATLAB 中计算矩阵行列式的示例：

% 给定一个矩阵 A
A = [1, 2; 3, 4];

% 计算矩阵 A 的行列式
d = det(A);

对于数值矩阵，尤其是当矩阵很大或者元素值相差很大时，计算行列式可能会导致数值稳定性问题。在数值上，即使一个矩阵不是精确奇异的，它的行列式也可能非常接近于零，这可能是由于舍入误差或数值不稳定性造成的。

对于大型矩阵，计算行列式的成本可能会非常高，因为它涉及到矩阵的LU分解或其他分解方法。在实际应用中，通常不直接计算行列式，而是通过其他方法来判断矩阵的性质，例如使用条件数来评估矩阵的可逆性。

（5）符号矩阵的行列式

在 MATLAB 中，符号计算通常是通过 Symbolic Math Toolbox 进行的，它允许进行精确的数学计算，而不是数值近似。当你处理符号矩阵时，可以得到行列式的精确表达式，而不是一个数值结果。

要计算符号矩阵的行列式，你首先需要创建一个符号矩阵，然后使用 det 函数。这里有一个简单的例子：

% 引入符号计算功能
syms a b c d;

% 创建一个符号矩阵
A = [a, b; c, d];

% 计算符号矩阵 A 的行列式
D = det(A);

符号计算对于理解数学概念、进行数学证明或者处理那些需要精确结果的问题特别有用。使用符号矩阵计算行列式可以避免数值计算中的舍入误差，并且可以处理变量和表达式，而不仅仅是数字。

（6）矩阵的化零矩阵

在数学中，化零矩阵（也称为零化矩阵或幂零矩阵）是指存在一个正整数 $k$，使得矩阵的 $k$ 次幂等于零矩阵。换句话说，如果矩阵 $A$ 是一个 $n \times n$ 的方阵，那么 $A$ 是一个化零矩阵当且仅当存在一个最小的正整数 $k$，使得：

$$
A^k = \mathbf{0}
$$

其中 $\mathbf{0}$ 是一个所有元素都为零的 $n \times n$ 矩阵。

化零矩阵的一个重要特性是它的行列式必定为零，因为如果 $A^k = \mathbf{0}$，那么 $(\det(A))^k = \det(A^k) = \det(\mathbf{0}) = 0$。因此，如果一个矩阵的行列式不为零，那么这个矩阵不可能是化零矩阵。

在 MATLAB 中，你可以通过多次乘以矩阵自身来检查一个矩阵是否是化零矩阵。这里有一个简单的例子：

% 定义一个矩阵 A
A = [0, 1; 0, 0];

% 初始化一个变量来存储 A 的幂
A_power = A;

% 设置一个循环来检查 A 的幂是否为零矩阵
k = 1; % 初始化幂的指数
while true
    if all(A_power(:) == 0) % 检查所有元素是否为零
        fprintf('A 是一个化零矩阵，k = %d\n', k);
        break;
    elseif k > size(A, 1)
        fprintf('A 不是一个化零矩阵\n');
        break;
    end
    A_power = A_power * A; % 计算 A 的下一个幂
    k = k + 1;
end

2、线性方程组

（1）非奇异线性方程组

在 MATLAB 中，解非奇异（即可逆或行列式不为零）线性方程组通常使用反斜杠运算符 `\`，也称为左除运算符。这是求解线性方程组的推荐方法，因为它会根据矩阵的性质选择最合适的算法。如果矩阵是方阵并且非奇异，MATLAB 通常使用 LU 分解来求解。

假设您有一个线性方程组 $Ax = b$，其中 $A$ 是一个非奇异方阵，$b$ 是一个列向量，您想找到向量 $x$。在 MATLAB 中，您可以按照以下步骤求解：

% 定义系数矩阵 A 和常数向量 b
A = [1, 2, 3; 4, 5, 6; 7, 8, 10]; % 这里是一个3x3的非奇异矩阵
b = [14; 32; 50]; % 这里是一个3x1的列向量

% 检查 A 是否是非奇异的
if det(A) ~= 0
    % 使用左除运算符求解 x
    x = A \ b;
else
    error('系数矩阵 A 是奇异的，无法求解。');
end

% 显示结果
disp('解向量 x 是：');
disp(x);

在实际应用中，建议不要使用 det(A) ~= 0 来检查矩阵是否非奇异，因为这种方法在数值上不稳定。，更好的做法是直接尝试解方程组并处理可能出现的异常情况。

（2）奇异线性方程组

在 MATLAB 中，如果你尝试求解一个奇异线性方程组（即系数矩阵是奇异的或者不满秩的），则 MATLAB 通常会给出一个警告，并尝试给出一个解，这个解可能不是唯一的。

对于奇异系统 $Ax = b$，如果有解存在，那么通常有无限多个解。在这种情况下，MATLAB 会尝试找到一个最小范数解，这意味着在所有可能的解中，它会找到一个 $x$，其欧几里得范数 $\|x\|$ 是最小的。

如果你使用 `\` 运算符，MATLAB 会处理这个问题并给出一个警告。这里是一个如何在 MATLAB 中处理奇异系统的例子：

% 定义一个奇异的系数矩阵 A 和常数向量 b
A = [1, 2, 3; 2, 4, 6; 3, 6, 9]; % 这是一个奇异矩阵
b = [6; 12; 18]; % 这里是一个与 A 的列线性相关的向量

% 尝试求解线性方程组
try
    x = A \ b;
    disp('解向量 x 是：');
    disp(x);
catch ME
    disp('无法求解：');
    disp(ME.message);
end

在这个例子中，由于矩阵 $A$ 的行是线性相关的，它是奇异的。当你尝试求解 $Ax = b$ 时，MATLAB 会发现这个问题并给出警告。如果向量 $b$ 也在 $A$ 的列空间中，那么 MATLAB 会给出一个解；否则，它会报告系统没有解。

另一种方法是使用 `pinv` 函数，它计算矩阵的伪逆（Moore-Penrose 逆）。伪逆可用于求解奇异系统或超定系统（即方程的数量多于未知数的情况）。

% 使用伪逆求解
x_pinv = pinv(A) * b;
disp('使用伪逆得到的解向量 x 是：');
disp(x_pinv);

使用伪逆是在数值上稳定的，它可以处理奇异矩阵或不满秩矩阵的情况，即使这样的系统可能没有唯一解或没有解。在这种情况下，`pinv` 会给出一个最小范数解。如果系统无解，那么它会给出一个“最接近”的解，使得 $Ax$ 和 $b$ 之间的残差 $\|Ax - b\|$ 最小。

（3）欠定线性方程组

在 MATLAB 中，欠定线性方程组指的是方程的数量少于未知数的数量。对于这种类型的方程组，如果存在解，则通常存在无限多个解。要找到这些解中的一个，我们通常寻找最小范数解，即在所有可能的解中，其欧几里得范数最小的解。

对于欠定系统 $Ax = b$，你可以使用以下几种方法：

反斜杠运算符 `\`

MATLAB 的反斜杠运算符会尝试找到最小范数解。这是最简单的方法，适用于大多数情况。

x = A \ b;

伪逆 `pinv`

`pinv` 函数计算矩阵的伪逆（Moore-Penrose 逆），并可以用来求解欠定系统。

 x = pinv(A) * b;

优化方法

如果你需要对解施加额外的约束（例如，寻找非负解），你可能需要使用优化工具箱中的函数，如 `lsqnonneg`，或者更通用的优化函数，如 `fmincon`。

x = lsqnonneg(A, b); % 寻找非负最小范数解

或者

options = optimoptions('fmincon', 'Algorithm', 'interior-point');
x0 = zeros(size(A,2),1); % 初始猜测
x = fmincon(@(x)norm(A*x-b), x0, [], [], [], [], lb, ub, [], options);

其中 `lb` 和 `ub` 分别是变量的下界和上界。

最小二乘法 `lsqminnorm`

MATLAB 提供了 `lsqminnorm` 函数，它可以找到具有最小二范数的 $A x = b$ 的解。

x = lsqminnorm(A, b);

（4）超定线性方程组

在 MATLAB 中，超定线性方程组是指方程的数量多于未知数的数量。这通常意味着没有精确解，因为系统可能是不一致的。在这种情况下，通常寻找一个最小二乘解，即最小化方程组残差平方和的解。

对于超定系统 $Ax = b$，你可以使用以下几种方法：

反斜杠运算符 `\`

对于超定系统，MATLAB 的反斜杠运算符会找到最小二乘解，即最小化 $\|Ax - b\|^2$ 的解。

x = A \ b;

伪逆 `pinv`

使用矩阵的伪逆计算最小二乘解。这种方法比反斜杠运算符更慢，但在数值上更稳定，尤其是当矩阵 $A$ 的条件数很大时。

x = pinv(A) * b;

最小二乘函数 `lsqminnorm`

`lsqminnorm` 函数可以找到最小二乘问题的一个解，该解的二范数是所有解中最小的。

x = lsqminnorm(A, b);

最小二乘函数 `lsqr`

`lsqr` 函数解决大型稀疏线性最小二乘问题。它使用迭代方法，适合处理大型问题。

x = lsqr(A, b);

优化工具箱

如果你需要对最小二乘解施加额外的约束，你可以使用优化工具箱中的函数，如 `lsqlin` 用于线性最小二乘问题，`lsqnonneg` 用于非负最小二乘问题，或者更通用的优化函数 `fmincon`。

x = lsqlin(A, b, C, d); % Cx <= d 是线性不等式约束

或者

 x = lsqnonneg(A, b); % 寻找非负最小二乘解

在处理超定问题时，最小二乘法是标准的数学方法，因为它基于最大似然估计，假设系统误差满足高斯分布。

3、矩阵分解

（1）Choesky分解

Cholesky 分解是一种将正定对称矩阵分解为一个下三角矩阵及其转置的上三角矩阵的乘积的方法。如果矩阵 $A$ 是正定对称的，那么可以保证存在一个唯一的下三角矩阵 $L$，使得：

$$ A = LL^T $$

其中 $L^T$ 是 $L$ 的转置。这种分解对于求解线性方程组、计算矩阵的逆或者其他数值分析问题非常有用。

在 MATLAB 中，可以使用 `chol` 函数来计算 Cholesky 分解。下面是一个如何使用 `chol` 函数的例子：

A = rand(5); % 创建一个 5x5 随机矩阵
A = A'*A; % 通过 A'*A 创建一个对称正定矩阵
L = chol(A, 'lower'); % 计算下三角矩阵 L，使得 A = LL'

在这个例子中，`'lower'` 选项告诉 MATLAB 返回下三角矩阵。如果不指定 `'lower'` 或者使用 `'upper'`，`chol` 函数默认返回上三角矩阵。

Cholesky 分解也可以用于求解线性方程组 $Ax = b$。如果 $A$ 是正定对称的，可以使用 Cholesky 分解来求解，这比一般的求解方法更快、更数值稳定。求解步骤如下：

计算 Cholesky 分解 $A = LL^T$。
通过前向替换求解 $Ly = b$。
通过后向替换求解 $L^Tx = y$。

在 MATLAB 中，这些步骤可以通过以下命令实现：

A = rand(5); % 创建一个 5x5 随机矩阵
A = A'*A; % 通过 A'*A 创建一个对称正定矩阵
b = rand(5,1); % 创建一个 5x1 随机向量
L = chol(A, 'lower'); % 计算下三角矩阵 L
y = L \ b; % 前向替换求解 Ly = b
x = L' \ y; % 后向替换求解 L^Tx = y

（2）使用Cholesky分解求解方程组

Cholesky 分解是一种高效的方法，用于求解形式为 $Ax = b$ 的线性方程组，其中 $A$ 是正定对称矩阵。通过 Cholesky 分解，矩阵 $A$ 被分解为 $LL^T$，其中 $L$ 是下三角矩阵。然后可以通过以下两步求解方程组：

解下三角系统 $Ly = b$。
解上三角系统 $L^Tx = y$。

（3）不完全Cholesky分解

不完全 Cholesky 分解（Incomplete Cholesky Decomposition）是 Cholesky 分解的一种近似，常用于处理大型稀疏矩阵。在这种分解中，只计算原矩阵中非零元素对应位置的 Cholesky 分解，而忽略小的、不重要的元素或者人为设置的阈值以外的元素。这样可以在牺牲一定精度的前提下，显著减少计算量和存储需求。

不完全 Cholesky 分解生成的下三角矩阵 $L$ 不会再满足 $A = LL^T$ 的等式，但它会尽可能地接近 $A$。不完全分解通常用于迭代方法的预处理步骤，比如用于解线性系统或者作为迭代求解器的一部分，例如共轭梯度法（Conjugate Gradient, CG）。

在 MATLAB 中，不完全 Cholesky 分解不是直接作为一个单独的函数提供的，但是可以通过 `ichol` 函数来实现。`ichol` 函数提供了几个选项来控制不完全分解的过程，例如填充（fill）策略和阈值。

以下是一个使用 `ichol` 函数的例子：

% 假设 A 是一个已知的稀疏对称正定矩阵
A = sprandsym(1000, 0.01, 1e-4, 1); % 生成一个稀疏对称正定矩阵

% 执行不完全 Cholesky 分解
L = ichol(A);

% L 是 A 的不完全 Cholesky 分解的下三角部分

使用不完全 Cholesky 分解作为预处理器可以改善迭代求解器的收敛速度，特别是对于大型稀疏线性系统。例如，可以将不完全 Cholesky 分解与共轭梯度法结合使用，以加速求解 $Ax = b$：

% 继续上面的例子，假设 b 是一个已知的向量
b = rand(1000, 1);

% 使用不完全 Cholesky 分解作为预处理器
M1 = ichol(A);

% 使用预处理器和共轭梯度法求解 Ax = b
[x, flag, relres, iter] = pcg(A, b, 1e-6, 1000, M1, M1');

在这个例子中，`pcg` 函数用于执行预处理共轭梯度法。`M1` 和 `M1'` 作为预处理器输入到 `pcg` 函数中，以提高迭代求解的效率。`flag`、`relres` 和 `iter` 分别表示求解的状态、相对残差和迭代次数。

（4）LU分解

LU 分解是另一种矩阵分解技术，用于分解一个矩阵为一个下三角矩阵（L）和一个上三角矩阵（U）。这种分解对于求解线性方程组、计算矩阵的逆或者计算行列式都非常有用。对于任何非奇异矩阵 $A$，都可以找到这样的分解。

在 MATLAB 中，可以使用 `lu` 函数来计算矩阵的 LU 分解。这个函数可以返回一个下三角矩阵 L、一个上三角矩阵 U，以及一个置换矩阵 P，使得 $PA = LU$。置换矩阵 P 是用于记录行交换的，这在数值计算中是为了保持数值稳定性。

下面是如何在 MATLAB 中使用 `lu` 函数的一个例子：

% 假设 A 是一个已知的非奇异方阵
A = [4 3; 6 3];

% 使用 lu 函数进行 LU 分解
[L, U, P] = lu(A);

% 现在 A = P'LU

在上面的代码中，`lu` 函数返回了三个矩阵：L、U 和 P。我们可以用这些矩阵来求解线性方程组 $Ax = b$。首先，我们需要解决 $Ly = Pb$，然后解决 $Ux = y$。下面是如何使用 LU 分解来求解线性方程组的例子：

b = [7; 9];

% 应用置换矩阵 P
b_new = P * b;

% 解决 Ly = Pb
y = L \ b_new;

% 解决 Ux = y
x = U \ y;

% x 包含了方程 Ax = b 的解

（5）不完全LU分解

不完全 LU（ILU）分解是一种预处理技术，它是对标准 LU 分解的近似，特别适用于大型稀疏矩阵。在不完全 LU 分解中，分解的结果并不是精确的下三角矩阵 L 和上三角矩阵 U，而是它们的近似，它们的非零模式（sparsity pattern）通常是由原始矩阵的非零模式决定的，或者通过其他方式指定。

不完全 LU 分解可以减少计算和存储需求，因为它不需要填满（fill-in）那些在原始矩阵中为零的位置。这种分解通常用作迭代方法的预处理器，例如广泛用于解决大型稀疏线性系统的 GMRES 和 BiCGSTAB 算法。

在 MATLAB 中，可以使用 ilu 函数来计算稀疏矩阵的不完全 LU 分解。ilu 函数提供了多种选项，允许用户控制填充策略和阈值，以便在预处理的准确性和计算以及存储要求之间进行权衡。

以下是一个使用 ilu 函数的简单例子：

% 假设 A 是一个已知的稀疏矩阵
A = sprand(1000, 1000, 0.01) + speye(1000);

% 执行不完全 LU 分解
[L, U] = ilu(A, struct('type','nofill'));

% L 和 U 是 A 的不完全 LU 分解的近似

ilu 函数计算不完全 LU 分解，其中 'nofill' 选项指示 MATLAB 不进行任何额外的填充，即只在原始矩阵 A 的非零模式上计算 L 和 U 的非零项。

不完全 LU 分解的质量和性能可能会受到许多因素的影响，包括矩阵的结构、分解时允许的填充量以及其他参数。在实践中，可能需要根据具体问题调整这些参数以获得最佳结果。

（6）QR分解

QR 分解是一种将矩阵分解为一个正交矩阵 Q 和一个上三角矩阵 R 的方法。对于一个给定的矩阵 $A$，QR 分解保证存在一个正交矩阵 $Q$ 和一个上三角矩阵 $R$ 使得 $A = QR$。

正交矩阵的一个重要性质是其列向量是单位向量并且两两正交。在实数域中，正交矩阵的转置是其逆，即 $Q^TQ = QQ^T = I$，其中 $I$ 是单位矩阵。

在 MATLAB 中，可以使用 `qr` 函数来计算矩阵的 QR 分解。如果 $A$ 是一个 $m \times n$ 矩阵，那么 $Q$ 是一个 $m \times m$ 的正交矩阵，而 $R$ 是一个 $m \times n$ 的上三角矩阵。如果 $m \geq n$，那么 $R$ 的下部分将是零。

下面是如何在 MATLAB 中使用 `qr` 函数的一个例子：

% 假设 A 是一个已知的矩阵
A = [12 -51 4; 6 167 -68; -4 24 -41];

% 使用 qr 函数进行 QR 分解
[Q, R] = qr(A);

% 现在 A = QR

在上面的例子中，`qr` 函数返回了两个矩阵：Q 和 R。这些矩阵可以用来进行多种计算，例如求解线性方程组 $Ax = b$，计算特征值，或者在最小二乘问题中使用。

对于最小二乘问题，QR 分解特别有用，因为它可以将问题转换为一个更容易解决的形式。如果我们要找到最小化 $||Ax - b||_2$ 的 $x$，我们可以首先计算 $A$ 的 QR 分解，然后利用 $Q$ 的正交性来简化问题。具体来说，我们可以将原问题转换为：
$$
\min_x ||QRx - b||_2 = \min_x ||Rx - Q^Tb||_2
$$
由于 $R$ 是上三角的，这个问题可以通过简单的回代（back substitution）来解决。

（7）操作QR分解结果

当你在 MATLAB 中进行 QR 分解时，你可以操作分解的结果来解决各种线性代数问题。下面是一些使用 QR 分解结果的常见操作：

解线性方程组

如果你有一个线性方程组 $Ax = b$，你可以使用 QR 分解来找到解。假设 $A = QR$，其中 $Q$ 是正交矩阵，$R$ 是上三角矩阵。你可以通过以下步骤来求解 $x$：

[Q, R] = qr(A);
y = Q' * b; % 计算 Q' * b
x = R \ y;  % 解上三角系统 R * x = y

计算行列式

对于方阵 $A$，其行列式可以通过其上三角矩阵 $R$ 的主对角线元素的乘积来计算，因为正交矩阵 $Q$ 的行列式为 ±1。

[Q, R] = qr(A);
detA = prod(diag(R));

计算逆矩阵

如果 $A$ 是非奇异的，你可以通过其 QR 分解来计算 $A^{-1}$。由于 $A = QR$，我们有 $A^{-1} = R^{-1}Q'$。

[Q, R] = qr(A);
invA = R \ Q'; % 利用 R 是上三角来求解

最小二乘解

对于过定系统（即方程数多于未知数的系统），QR 分解可以用来找到最小二乘解，也就是最小化 $||Ax - b||_2$ 的 $x$。

[Q, R] = qr(A);
y = Q' * b;
x = R \ y;  % x 是最小二乘解

特征值计算

虽然 MATLAB 通常使用 `eig` 函数来计算特征值，QR 分解可以用于 QR 算法，这是一种迭代方法来计算特征值。

奇异值分解 (SVD)

QR 分解有时用于加速计算奇异值分解，尤其是当矩阵具有更多行而较少列时。首先使用 QR 分解减少问题的规模，然后在较小的矩阵上应用 SVD。

注意事项
- 当使用 QR 分解来解决实际问题时，要确保你的矩阵 $A$ 是非奇异的，否则上三角矩阵 $R$ 可能是奇异的，这会导致求逆或解线性方程组时出现问题。
- QR 分解通常是数值稳定的，但在处理病态问题时仍需小心。

（8）奇异值分解

奇异值分解（Singular Value Decomposition，简称SVD）是线性代数中的一种重要的矩阵分解技术。对于任何一个实数或复数矩阵$A$，都存在一个分解，使得

$$
A = U\Sigma V^*,
$$

其中：

$U$ 是一个$m \times m$的单位正交矩阵，它的列被称为左奇异向量。
$\Sigma$ 是一个$m \times n$的矩形对角矩阵，对角线上的元素是奇异值，按照从大到小的顺序排列。奇异值是$A$的非负实数，通常按降序排列。$\Sigma$的非对角线上的元素都是0。
$V^*$ 是$n \times n$单位正交矩阵的共轭转置，$V$的列被称为右奇异向量。

在实数矩阵的情况下，$V^*$就是$V$的转置，记作$V^T$。

SVD非常有用，因为它揭示了矩阵的许多重要性质，如秩、范数和矩阵的逆。它在信号处理、统计学、语义索引（如潜在语义分析）、以及在计算机科学中的许多其他领域都有应用。

在 MATLAB 中，你可以用 `svd` 函数来计算矩阵的奇异值分解。基本用法是：

[U, S, V] = svd(A);

这将返回矩阵$A$的奇异值分解，其中$S$是对角矩阵，对角线上的元素是$A$的奇异值；$U$和$V$是正交矩阵，它们的列分别是左奇异向量和右奇异向量。

SVD的应用：

伪逆

SVD可以用来计算矩阵的伪逆（Moore-Penrose逆），这在矩阵不是方阵或者不是满秩的情况下非常有用。

[U, S, V] = svd(A);
r = rank(S);
S_inv = S;
S_inv(1:r, 1:r) = diag(1 ./ diag(S(1:r, 1:r))); % 只取非零奇异值的倒数
A_pseudo_inv = V * S_inv' * U';

数据压缩和降维

SVD常用于数据压缩和降维。例如，在图像压缩中，你可以只保留最大的几个奇异值和对应的奇异向量，用它们来近似原始图像。

噪声过滤

在信号处理中，SVD可以用来识别和过滤噪声。通常，噪声会影响小的奇异值，因此通过忽略这些奇异值，可以去除噪声。

主成分分析（PCA）

在统计学中，SVD是主成分分析（PCA）的一个关键步骤，用于数据的降维和解释。

数值解

在解决线性方程组或最小二乘问题时，当矩阵是病态的或接近奇异的，SVD可以提供数值上更稳定的解。

4、特征值分析

（1）特征值和特征向量

特征值和特征向量的定义

对于一个给定的方阵 $A$，如果存在一个非零向量 $\mathbf{v}$ 和一个标量 $\lambda$ 使得下面的等式成立：

$$
A\mathbf{v} = \lambda\mathbf{v},
$$

那么，$\lambda$ 被称为矩阵 $A$ 的一个特征值（eigenvalue），$\mathbf{v}$ 被称为对应于特征值 $\lambda$ 的一个特征向量（eigenvector）。

特征值的计算

要找到矩阵 $A$ 的特征值，我们需要解以下特征方程（也称为特征多项式）：

$$
\det(A - \lambda I) = 0,
$$

其中 $\det$ 表示行列式，$I$ 是与 $A$ 同阶的单位矩阵。解这个方程将给出矩阵 $A$ 的所有特征值。

特征向量的计算

一旦找到特征值 $\lambda$，我们可以通过解线性方程组 $(A - \lambda I)\mathbf{v} = \mathbf{0}$ 来找到对应的特征向量 $\mathbf{v}$。这个方程组通常有无数个解，因为任何特征向量的非零标量倍数也是一个特征向量。

在 MATLAB 中计算特征值和特征向量

在 MATLAB 中，可以使用 `eig` 函数来计算矩阵的特征值和特征向量：

[V, D] = eig(A);

这里 `D` 是一个对角矩阵，其对角线上的元素是矩阵 $A$ 的特征值。`V` 是一个矩阵，其列是对应于这些特征值的特征向量。

（2）稀疏矩阵的特征值和特征向量

对于大型的稀疏矩阵，计算所有特征值和特征向量通常是不可行的，而且在许多应用中也不是必需的。相反，我们通常只对最大的几个或最小的几个特征值（以及相应的特征向量）感兴趣，因为它们通常包含了系统最重要的信息。

一些常用的算法包括：
- 幂迭代：这是一种简单的算法，用于近似计算具有最大绝对值特征值的特征向量。
- 反迭代：这是一种用于计算给定近似特征值对应的特征向量的算法。
- Lanczos 算法：这是一种迭代算法，用于计算大型稀疏对称矩阵的特征值和特征向量。
- Arnoldi 迭代：这是 Lanczos 算法的非对称版本，用于非对称稀疏矩阵。
- 稀疏矩阵特征值问题的库：如 ARPACK（在 MATLAB 中通过 eigs 函数访问），它是一个基于 Arnoldi 迭代和 Lanczos 算法的库，用于计算大型稀疏矩阵的几个特征值和特征向量。
在 MATLAB 中计算稀疏矩阵的特征值和特征向量

在 MATLAB 中，`eigs` 函数是专门用于计算大型稀疏矩阵的几个特征值和特征向量的。它的用法与 `eig` 函数类似，但你可以指定要找到的特征值的数量，以及其他选项来控制算法的行为。

d = 6; % 指定想要计算的特征值的数量
opts.tol = 1e-6; % 指定算法的容错率
opts.isreal = true; % 如果矩阵是实数的，这可以提高效率
opts.issym = true; % 如果矩阵是对称的，这也可以提高效率
[V, D] = eigs(A, d, 'LM', opts); % 计算最大的d个特征值和特征向量

在这个例子中，`'LM'` 表示我们要求具有“最大幅值”（Largest Magnitude）的特征值。你还可以通过其他选项来寻找具有“最小幅值”（'SM'）的特征值，或者接近某个特定数值的特征值。

注意事项
- 稀疏矩阵特征值问题的数值方法通常是迭代的，它们依赖于初始猜测，并可能只收敛到局部解。
- 这些方法的精度和速度可能受到矩阵特性的影响，如其条件数、特征值的分布等。

（3）特征值问题的条件数

在数值线性代数中，条件数是一个度量，它描述了一个函数相对于输入数据的微小变化是如何影响输出结果的。特别是，在矩阵问题中，条件数通常用来描述矩阵可逆性的“良好程度”或者是解线性方程组的数值稳定性。

对于特征值问题，条件数可以帮助我们理解特定的特征值或特征向量对于数值扰动的敏感性。一个高条件数意味着特征值或特征向量对于输入矩阵的微小变化非常敏感，而一个低条件数则表示其相对稳定。

特征值问题的条件数

假设 $A$ 是一个 $n \times n$ 的矩阵，$\lambda$ 是 $A$ 的一个特征值，$v$ 是对应的特征向量。对于特征值问题 $Av = \lambda v$，特征值的条件数可以通过以下方式近似：

$$
\kappa(\lambda) = \left| \frac{v^* A v}{v^* v} \right|,
$$

其中 $v^*$ 表示 $v$ 的共轭转置。这个条件数给出了对特征值 $\lambda$ 的微小扰动的放大程度。

在实际计算中，我们通常不直接计算特征值的条件数，而是通过观察矩阵的其他属性（如对称性、正定性等）来推断特征值问题的敏感性。对于一个具有良好性质的矩阵（如对称正定矩阵），特征值通常是数值稳定的。对于条件数较高的矩阵，特征值可能会对输入数据的微小变化非常敏感。

在 MATLAB 中计算特征值的条件数

在 MATLAB 中，可以使用 `condeig` 函数来计算矩阵特征值的条件数：

K = condeig(A);

这将返回一个向量 `K`，其中包含矩阵 `A` 的每个特征值的条件数。需要注意的是，`condeig` 函数可能会非常耗时，特别是对于大矩阵，因为它需要计算矩阵的特征值和特征向量。

（4）特征值的复数问题

复数特征值的含义

当一个矩阵具有复数特征值时，这通常表示系统具有振荡特性。对于一个 $n \times n$ 矩阵 $A$，如果它有一个复数特征值 $\lambda = a + bi$（其中 $i$ 是虚数单位，$a$ 和 $b$ 是实数），那么它也一定有另一个共轭复数特征值 $\lambda^* = a - bi$。这对特征值对应的特征向量也具有振荡性质。

在物理和工程应用中，复数特征值的实部通常与系统的衰减或增长相关，而虚部与系统的振荡频率相关。例如，在控制系统分析中，一个闭环系统的稳定性可以通过其系统矩阵的特征值来判断。如果所有特征值的实部都是负的，系统是稳定的；如果至少有一个特征值的实部是正的，系统是不稳定的。

在 MATLAB 中，使用 `eig` 函数或者 `eigs` 函数（对于稀疏矩阵）可以得到矩阵的特征值，这些特征值可能是实数或者复数。MATLAB 会自动处理复数运算，因此即使矩阵具有复数特征值，这些函数也能正确返回结果。

秒吧学习