二维矩阵是数学中的一个重要概念，它是由元素排列成行和列的矩形数组。通常用大写字母表示矩阵，例如 \(A\)，矩阵中的元素用小写字母表示，例如 \(a_{ij}\)，其中 \(i\) 表示行索引，\(j\) 表示列索引。
一个二维矩阵 \(A\) 可以表示为：
\[A = \begin{bmatrix} a_{11} & a_{12} & \cdots & a_{1n} \\ a_{21} & a_{22} & \cdots & a_{2n} \\ \vdots & \vdots & \ddots & \vdots \\ a_{m1} & a_{m2} & \cdots & a_{mn} \end{bmatrix}\]这里，\(m\) 是矩阵的行数，\(n\) 是矩阵的列数。矩阵的大小通常以 “行数 × 列数” 的形式表示。
例如，一个 2x3 的矩阵可以写作：
\[B = \begin{bmatrix} b_{11} & b_{12} & b_{13} \\ b_{21} & b_{22} & b_{23} \end{bmatrix}\]其中，这个矩阵有两行（\(m=2\)）和三列（\(n=3\)）。
程序定义如下
pub struct Matrix {
rows: usize, // 行数
cols: usize, // 列数
data: Vec<Vec<f64>>, // 存储矩阵元素的二维向量
}
矩阵的加法和减法是基本的线性代数运算，它们分别在相同位置对应元素进行加法和减法。以下是矩阵加法和减法的数学定义：
给定两个相同大小的矩阵 \(A\) 和 \(B\)，它们的和 \(C\)（记作 \(C = A + B\)）的每个元素 \(c_{ij}\) 都是对应位置元素的和：
\(C = A + B\) \(c_{ij} = a_{ij} + b_{ij}\)
其中，\(a_{ij}\) 是矩阵 \(A\) 中第 \(i\) 行第 \(j\) 列的元素，\(b_{ij}\) 是矩阵 \(B\) 中相应位置的元素。
给定两个相同大小的矩阵 \(A\) 和 \(B\)，它们的差 \(D\)（记作 \(D = A - B\)）的每个元素 \(d_{ij}\) 都是对应位置元素的差：
\(D = A - B\) \(d_{ij} = a_{ij} - b_{ij}\)
同样，其中 \(a_{ij}\) 是矩阵 \(A\) 中第 \(i\) 行第 \(j\) 列的元素，\(b_{ij}\) 是矩阵 \(B\) 中相应位置的元素。
注意：矩阵加法和减法要求两个矩阵的维度必须相同，即它们必须有相同的行数和列数。只有在这种情况下，对应位置的元素才能进行加法或减法运算。
程序解如下
// 矩阵加法
pub fn add(&self, other: &Matrix) -> Option<Matrix> {
if self.rows == other.rows && self.cols == other.cols {
let mut result_data = Vec::with_capacity(self.rows);
for i in 0..self.rows {
let mut row = Vec::with_capacity(self.cols);
for j in 0..self.cols {
row.push(self.data[i][j] + other.data[i][j]);
}
result_data.push(row);
}
Some(Matrix {
rows: self.rows,
cols: self.cols,
data: result_data,
})
} else {
None
}
}
// 矩阵减法
pub fn subtract(&self, other: &Matrix) -> Option<Matrix> {
if self.rows == other.rows && self.cols == other.cols {
let mut result_data = Vec::with_capacity(self.rows);
for i in 0..self.rows {
let mut row = Vec::with_capacity(self.cols);
for j in 0..self.cols {
row.push(self.data[i][j] - other.data[i][j]);
}
result_data.push(row);
}
Some(Matrix {
rows: self.rows,
cols: self.cols,
data: result_data,
})
} else {
None
}
}
矩阵乘法是一个涉及行和列的复杂运算。给定两个矩阵 \(A\) 和 \(B\)，它们的乘积 \(C\)（记作 \(C = A \cdot B\)）的定义如下：
假设矩阵 \(A\) 的维度为 \(m \times n\)，矩阵 \(B\) 的维度为 \(n \times p\)，那么矩阵 \(C\) 的维度为 \(m \times p\)。
矩阵 \(C\) 中的每个元素 \(c_{ij}\) 计算方式如下：
\[c_{ij} = \sum_{k=1}^{n} a_{ik} \cdot b_{kj}\]其中，\(a_{ik}\) 是矩阵 \(A\) 中第 \(i\) 行第 \(k\) 列的元素，\(b_{kj}\) 是矩阵 \(B\) 中第 \(k\) 行第 \(j\) 列的元素。这个计算过程是对矩阵 \(A\) 的第 \(i\) 行和矩阵 \(B\) 的第 \(j\) 列进行点积（内积），得到矩阵 \(C\) 中元素的值。
矩阵乘法的关键要点：
程序解如下
/// 矩阵的乘法
pub fn multiply(&self, other: &Matrix) -> Option<Matrix> {
// 检查矩阵维度是否允许相乘
if self.cols != other.rows {
return None;
}
let mut result_data = Vec::with_capacity(self.rows);
for i in 0..self.rows {
let mut row = Vec::with_capacity(other.cols);
for j in 0..other.cols {
let mut sum = 0.0;
for k in 0..self.cols {
sum += self.data[i][k] * other.data[k][j];
}
row.push(sum);
}
result_data.push(row);
}
Some(Matrix {
rows: self.rows,
cols: other.cols,
data: result_data,
})
}
矩阵的转置是一种操作，通过这种操作，矩阵的行和列交换位置。给定一个矩阵 \(A\)，其转置记作 \(A^T\)。对于矩阵 \(A\) 中的每一个元素 \(a_{ij}\)，在转置后的矩阵 \(A^T\) 中，该元素位于 \(A\) 中的列 \(j\) 和行 \(i\) 的位置。
具体来说，如果矩阵 \(A\) 的维度是 \(m \times n\)，那么它的转置 \(A^T\) 的维度是 \(n \times m\)。矩阵转置的数学表示如下：
\[(A^T)_{ij} = A_{ji}\]其中，\((A^T)_{ij}\) 表示转置矩阵 \(A^T\) 中的第 \(i\) 行第 \(j\) 列的元素，而 \(A_{ji}\) 表示原矩阵 \(A\) 中的第 \(j\) 行第 \(i\) 列的元素。
矩阵转置的性质：
下面是一个简单的例子，演示了如何计算矩阵的转置：
假设有矩阵 \(A\)：
\[A = \begin{bmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \end{bmatrix}\]那么，矩阵 \(A\) 的转置 \(A^T\) 是：
\[A^T = \begin{bmatrix} 1 & 4 \\ 2 & 5 \\ 3 & 6 \end{bmatrix}\]你可以看到，原矩阵 \(A\) 的行变成了转置矩阵 \(A^T\) 的列，而原矩阵 \(A\) 的列变成了转置矩阵 \(A^T\) 的行。
程序解如下
/// 转置矩阵
pub fn transpose(&self) -> Matrix {
let mut result_data = Vec::with_capacity(self.cols);
for j in 0..self.cols {
let mut row = Vec::with_capacity(self.rows);
for i in 0..self.rows {
row.push(self.data[i][j]);
}
result_data.push(row);
}
Matrix {
rows: self.cols,
cols: self.rows,
data: result_data,
}
}
| 行列式是一个与方阵相关的数学概念，它为方阵提供了一个标量值。给定一个 \(n \times n\) 的方阵 \(A\)，其行列式通常表示为 $$ | A | \(或\)\text{det}(A)$$。 |
行列式的计算涉及矩阵的元素，其表达式如下：
\[|A| = \sum_{\sigma \in S_n} \text{sgn}(\sigma) \cdot a_{1\sigma(1)} \cdot a_{2\sigma(2)} \cdot \ldots \cdot a_{n\sigma(n)}\]这里，\(S_n\) 是所有 \(n\) 阶排列的集合，\(\sigma\) 是一个排列，\(\text{sgn}(\sigma)\) 是排列的符号（奇置换为 -1，偶置换为 1），\(a_{i\sigma(i)}\) 是矩阵 \(A\) 中的元素。
这个公式展示了一个递归的计算过程，它对所有可能的排列进行了求和。对于每个排列，我们将相应位置的元素相乘，然后乘以符号 \(\text{sgn}(\sigma)\)。最后，将所有这些结果相加得到最终的行列式值。
行列式有一些重要的性质：
| 行列式的值与矩阵的行列互换无关，即 $$ | A | = | A^T | $$。 |
程序解如下
// 计算矩阵的行列式
pub fn determinant(&self) -> Option<f64> {
// 检查矩阵是否为方阵
if self.rows != self.cols {
return None;
}
// 递归计算行列式
self.calculate_determinant(&self.data)
}
// 递归计算行列式的辅助函数
fn calculate_determinant(&self, matrix: &Vec<Vec<f64>>) -> Option<f64> {
match self.rows {
1 => Some(matrix[0][0]), // 1x1 矩阵的行列式为其唯一元素的值
2 => Some(matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0]), // 2x2 矩阵的行列式计算公式
_ => {
let mut det = 0.0;
for col in 0..self.cols {
// 计算代数余子式
let submatrix_data: Vec<Vec<f64>> = matrix
.iter()
.enumerate()
.filter(|&(i, _)| i != 0)
.map(|(_, row)| row.iter().enumerate().filter(|&(j, _)| j != col).map(|(_, &val)| val).collect())
.collect();
let submatrix = Matrix {
rows: self.rows - 1,
cols: self.cols - 1,
data: submatrix_data,
};
let cofactor = if col % 2 == 0 { 1.0 } else { -1.0 };
match self.calculate_determinant(&submatrix.data) {
Some(sub_det) => det += cofactor * matrix[0][col] * sub_det,
None => return None,
}
}
Some(det)
}
}
}
逆矩阵是与原矩阵相乘后得到单位矩阵的矩阵。给定一个方阵 \(A\)，如果存在一个方阵 \(B\) 使得 \(AB = BA = I\)，其中 \(I\) 是单位矩阵，那么矩阵 \(B\) 就是矩阵 \(A\) 的逆矩阵，通常表示为 \(A^{-1}\)。
逆矩阵的性质：
逆矩阵的计算方法： 如果一个 \(n \times n\) 的矩阵 \(A\) 可逆，其逆矩阵 \(A^{-1}\) 可以通过以下公式计算：
\[A^{-1} = \frac{1}{\text{det}(A)} \cdot \text{adj}(A)\]其中，\(\text{det}(A)\) 是矩阵 \(A\) 的行列式，\(\text{adj}(A)\) 是矩阵 \(A\) 的伴随矩阵。伴随矩阵的元素由原矩阵的代数余子式组成，并按矩阵的转置排列。
具体而言，对于 \(n \times n\) 矩阵 \(A\)，其伴随矩阵的元素 \((\text{adj}(A))_{ij}\) 可以通过以下方式计算：
\[(\text{adj}(A))_{ij} = (-1)^{i+j} \cdot \text{det}(M_{ij})\]其中，\(M_{ij}\) 是去掉矩阵 \(A\) 的第 \(i\) 行和第 \(j\) 列后的子矩阵。
特征值和特征向量是矩阵理论中的重要概念，它们在许多数学和工程应用中起着关键的作用。
给定一个方阵 \(A\)，非零向量 \(v\) 是 \(A\) 的特征向量，如果存在一个标量 \(\lambda\)，使得满足如下关系：
\[Av = \lambda v\]这里，\(\lambda\) 是 \(A\) 的特征值，\(v\) 是对应于特征值 \(\lambda\) 的特征向量。
特征值（Eigenvalues）： 特征值是一个标量，它表示了矩阵 \(A\) 在变换中的缩放因子。一个 \(n \times n\) 的矩阵 \(A\) 最多有 \(n\) 个特征值。
特征向量（Eigenvectors）： 特征向量是与特征值关联的非零向量，其在矩阵变换下只发生缩放而不改变方向。特征向量的长度（模）不是固定的，其方向是关键的。
特征值方程（Characteristic Equation）： 特征值和特征向量的关系由特征值方程表示：
其中，\(\text{det}\) 表示矩阵的行列式，\(I\) 是单位矩阵。特征值是满足方程的根。
特征空间： 与特定特征值关联的所有特征向量形成一个向量空间，称为特征空间。
线性独立性： 不同特征值对应的特征向量是线性独立的，即它们不可由其他特征向量的线性组合表示。
对角化： 如果矩阵 \(A\) 有 \(n\) 个线性独立的特征向量，可以构成一个特征向量矩阵 \(V\)，则 \(A\) 可对角化为 \(V^{-1}AV = \Lambda\)，其中 \(\Lambda\) 是一个对角矩阵，其对角线上的元素是 \(A\) 的特征值。
程序解如下
// 计算矩阵的特征值和特征向量
pub fn eigenvalue_eigenvector(&self) -> Option<(Vec<f64>, Vec<Vec<f64>>)> {
// 检查矩阵是否为方阵
if self.rows != self.cols {
return None;
}
// 构造特征值方程的左侧矩阵 A - λI
let a_minus_lambda_i: Matrix = self.subtract_identity();
// 求解特征值
let eigenvalues = match a_minus_lambda_i.determinant() {
Some(det) => self.find_eigenvalues(det),
None => return None,
};
// 求解特征向量
let mut eigenvectors: Vec<Vec<f64>> = Vec::with_capacity(eigenvalues.len());
for &eigenvalue in &eigenvalues {
let eigenvector = self.solve_eigenvector(eigenvalue);
eigenvectors.push(eigenvector);
}
Some((eigenvalues, eigenvectors))
}
// 辅助方法：构造 A - λI
fn subtract_identity(&self) -> Matrix {
let mut result_data = Vec::with_capacity(self.rows);
for i in 0..self.rows {
let mut row = Vec::with_capacity(self.cols);
for j in 0..self.cols {
let element = if i == j {
self.data[i][j] - 1.0 // λ 对应的位置减去 1
} else {
self.data[i][j]
};
row.push(element);
}
result_data.push(row);
}
Matrix {
rows: self.rows,
cols: self.cols,
data: result_data,
}
}
// 辅助方法：求解特征值方程的根
fn find_eigenvalues(&self, det_a_minus_lambda_i: f64) -> Vec<f64> {
// 这里可以使用任何你喜欢的求根算法，这里简化为一个简单的方式
// 注意：这里没有处理重根的情况，实际应用中可能需要更复杂的算法
let mut eigenvalues = Vec::with_capacity(self.rows);
for i in 0..self.rows {
eigenvalues.push(self.data[i][i]);
}
eigenvalues
}
// 辅助方法：求解特征向量
fn solve_eigenvector(&self, eigenvalue: f64) -> Vec<f64> {
// 这里可以使用任何你喜欢的求解线性方程组的算法，这里简化为一个简单的方式
// 注意：这里没有处理奇异矩阵的情况，实际应用中可能需要更复杂的算法
let mut augmented_matrix_data = Vec::with_capacity(self.rows);
for i in 0..self.rows {
let mut row = Vec::with_capacity(self.cols + 1);
for j in 0..self.cols {
row.push(self.data[i][j] - eigenvalue * if i == j { 1.0 } else { 0.0 });
}
row.push(0.0); // 右侧的常数项
augmented_matrix_data.push(row);
}
let mut augmented_matrix = Matrix {
rows: self.rows,
cols: self.cols + 1,
data: augmented_matrix_data,
};
// 简单的高斯消元法求解线性方程组
let mut solution = Vec::with_capacity(self.rows);
for i in 0..self.rows {
let mut pivot_row = i;
for j in i + 1..self.rows {
if augmented_matrix.data[j][i].abs() > augmented_matrix.data[pivot_row][i].abs() {
pivot_row = j;
}
}
if augmented_matrix.data[pivot_row][i].abs() < EPSILON {
// 这里可以添加一些处理奇异矩阵的逻辑
return vec![];
}
augmented_matrix.swap_rows(i, pivot_row);
for j in i + 1..self.rows {
let factor = augmented_matrix.data[j][i] / augmented_matrix.data[i][i];
for k in i..self.cols + 1 {
augmented_matrix.data[j][k] -= factor * augmented_matrix.data[i][k];
}
}
}
// 回代求解
for i in (0..self.rows).rev() {
let mut sum = 0.0;
for j in i + 1..self.cols {
sum += augmented_matrix.data[i][j] * solution[j - i - 1];
}
solution.push((augmented_matrix.data[i][self.cols] - sum) / augmented_matrix.data[i][i]);
}
// 归一化特征向量
let norm = solution.iter().fold(0.0, |acc, &x| acc + x.powi(2)).sqrt();
solution.iter().map(|&x| x / norm).collect()
}
// 辅助方法：交换矩阵的两行
fn swap_rows(&self, i: usize, j: usize) {
let mut data_copy = self.data.clone();
data_copy.swap(i, j);
Matrix {
rows: self.rows,
cols: self.cols,
data: data_copy,
};
}