3x3矩阵教程

1. 简介

三维矩阵是线性代数中的重要概念，用于表示三维空间中的线性变换。本教程将介绍如何使用C++实现三维矩阵的基本运算和变换。

2. 代码实现

2.1 头文件 (matrix3x3.h)

#ifndef MATRIX3X3_H
#define MATRIX3X3_H#include <array>
#include <stdexcept>
#include <iostream>namespace math {
namespace linear_algebra {/*** @brief 三维矩阵类* * 这个类实现了三维矩阵的基本运算，包括：* - 矩阵加减* - 矩阵乘法* - 标量乘法* - 行列式计算* - 矩阵求逆* - 矩阵转置* - 特征值和特征向量计算* - 矩阵性质检查（可逆性、对称性、正交性）* - 特殊矩阵生成（旋转矩阵、缩放矩阵等）*/
class Matrix3x3 {
public:// 构造函数Matrix3x3();  // 默认构造函数，初始化为单位矩阵Matrix3x3(const std::array<std::array<double, 3>, 3>& data);  // 从二维数组初始化// 基本运算Matrix3x3 operator+(const Matrix3x3& other) const;  // 矩阵加法Matrix3x3 operator-(const Matrix3x3& other) const;  // 矩阵减法Matrix3x3 operator*(const Matrix3x3& other) const;  // 矩阵乘法Matrix3x3 operator*(double scalar) const;           // 标量乘法Matrix3x3 operator/(double scalar) const;           // 标量除法// 矩阵运算double determinant() const;                         // 计算行列式Matrix3x3 inverse() const;                          // 计算逆矩阵Matrix3x3 transpose() const;                        // 计算转置矩阵std::array<double, 3> eigenvalues() const;          // 计算特征值std::array<Matrix3x3, 3> eigenvectors() const;      // 计算特征向量// 矩阵性质bool isInvertible() const;                          // 检查是否可逆bool isSymmetric() const;                           // 检查是否对称bool isOrthogonal() const;                          // 检查是否正交// 特殊矩阵static Matrix3x3 identity();                        // 创建单位矩阵static Matrix3x3 rotation(double theta, char axis); // 创建旋转矩阵static Matrix3x3 scaling(double sx, double sy, double sz); // 创建缩放矩阵// 输出运算符friend std::ostream& operator<<(std::ostream& os, const Matrix3x3& m);private:std::array<std::array<double, 3>, 3> data;  // 3x3矩阵数据
};} // namespace linear_algebra
} // namespace math#endif // MATRIX3X3_H

2.2 实现文件 (matrix3x3.cpp)

#include "matrix3x3.h"
#include <cmath>namespace math {
namespace linear_algebra {// 默认构造函数：初始化为单位矩阵
Matrix3x3::Matrix3x3() {for (int i = 0; i < 3; ++i) {for (int j = 0; j < 3; ++j) {data[i][j] = (i == j) ? 1.0 : 0.0;}}
}// 从二维数组初始化
Matrix3x3::Matrix3x3(const std::array<std::array<double, 3>, 3>& data) : data(data) {}// 矩阵加法实现
Matrix3x3 Matrix3x3::operator+(const Matrix3x3& other) const {Matrix3x3 result;for (int i = 0; i < 3; ++i) {for (int j = 0; j < 3; ++j) {result.data[i][j] = data[i][j] + other.data[i][j];}}return result;
}// 矩阵减法实现
Matrix3x3 Matrix3x3::operator-(const Matrix3x3& other) const {Matrix3x3 result;for (int i = 0; i < 3; ++i) {for (int j = 0; j < 3; ++j) {result.data[i][j] = data[i][j] - other.data[i][j];}}return result;
}// 矩阵乘法实现
Matrix3x3 Matrix3x3::operator*(const Matrix3x3& other) const {Matrix3x3 result;for (int i = 0; i < 3; ++i) {for (int j = 0; j < 3; ++j) {result.data[i][j] = 0.0;for (int k = 0; k < 3; ++k) {result.data[i][j] += data[i][k] * other.data[k][j];}}}return result;
}// 标量乘法实现
Matrix3x3 Matrix3x3::operator*(double scalar) const {Matrix3x3 result;for (int i = 0; i < 3; ++i) {for (int j = 0; j < 3; ++j) {result.data[i][j] = data[i][j] * scalar;}}return result;
}// 标量除法实现
Matrix3x3 Matrix3x3::operator/(double scalar) const {if (scalar == 0.0) {throw std::runtime_error("Division by zero");}return *this * (1.0 / scalar);
}// 行列式计算实现
double Matrix3x3::determinant() const {return data[0][0] * (data[1][1] * data[2][2] - data[1][2] * data[2][1]) -data[0][1] * (data[1][0] * data[2][2] - data[1][2] * data[2][0]) +data[0][2] * (data[1][0] * data[2][1] - data[1][1] * data[2][0]);
}// 逆矩阵计算实现
Matrix3x3 Matrix3x3::inverse() const {double det = determinant();if (det == 0.0) {throw std::runtime_error("Matrix is not invertible");}Matrix3x3 result;double invDet = 1.0 / det;// 计算伴随矩阵result.data[0][0] = (data[1][1] * data[2][2] - data[1][2] * data[2][1]) * invDet;result.data[0][1] = (data[0][2] * data[2][1] - data[0][1] * data[2][2]) * invDet;result.data[0][2] = (data[0][1] * data[1][2] - data[0][2] * data[1][1]) * invDet;result.data[1][0] = (data[1][2] * data[2][0] - data[1][0] * data[2][2]) * invDet;result.data[1][1] = (data[0][0] * data[2][2] - data[0][2] * data[2][0]) * invDet;result.data[1][2] = (data[0][2] * data[1][0] - data[0][0] * data[1][2]) * invDet;result.data[2][0] = (data[1][0] * data[2][1] - data[1][1] * data[2][0]) * invDet;result.data[2][1] = (data[0][1] * data[2][0] - data[0][0] * data[2][1]) * invDet;result.data[2][2] = (data[0][0] * data[1][1] - data[0][1] * data[1][0]) * invDet;return result;
}// 转置矩阵实现
Matrix3x3 Matrix3x3::transpose() const {Matrix3x3 result;for (int i = 0; i < 3; ++i) {for (int j = 0; j < 3; ++j) {result.data[i][j] = data[j][i];}}return result;
}// 特征值计算实现
std::array<double, 3> Matrix3x3::eigenvalues() const {// 计算特征多项式系数double a = 1.0;double b = -(data[0][0] + data[1][1] + data[2][2]);double c = data[0][0] * data[1][1] + data[1][1] * data[2][2] + data[2][2] * data[0][0] -data[0][1] * data[1][0] - data[1][2] * data[2][1] - data[2][0] * data[0][2];double d = -determinant();// 求解三次方程// 这里使用简化的方法，实际应用中可能需要更复杂的数值方法std::array<double, 3> roots;// ... 求解三次方程的代码 ...return roots;
}// 特征向量计算实现
std::array<Matrix3x3, 3> Matrix3x3::eigenvectors() const {std::array<double, 3> eigenvals = eigenvalues();std::array<Matrix3x3, 3> eigenvecs;// ... 计算特征向量的代码 ...return eigenvecs;
}// 可逆性检查实现
bool Matrix3x3::isInvertible() const {return determinant() != 0.0;
}// 对称性检查实现
bool Matrix3x3::isSymmetric() const {for (int i = 0; i < 3; ++i) {for (int j = i + 1; j < 3; ++j) {if (data[i][j] != data[j][i]) {return false;}}}return true;
}// 正交性检查实现
bool Matrix3x3::isOrthogonal() const {Matrix3x3 product = *this * transpose();Matrix3x3 identity = Matrix3x3::identity();for (int i = 0; i < 3; ++i) {for (int j = 0; j < 3; ++j) {if (std::abs(product.data[i][j] - identity.data[i][j]) > 1e-10) {return false;}}}return true;
}// 单位矩阵创建实现
Matrix3x3 Matrix3x3::identity() {return Matrix3x3();
}// 旋转矩阵创建实现
Matrix3x3 Matrix3x3::rotation(double theta, char axis) {Matrix3x3 result;double cos_theta = std::cos(theta);double sin_theta = std::sin(theta);switch (axis) {case 'x':result.data[1][1] = cos_theta;result.data[1][2] = -sin_theta;result.data[2][1] = sin_theta;result.data[2][2] = cos_theta;break;case 'y':result.data[0][0] = cos_theta;result.data[0][2] = sin_theta;result.data[2][0] = -sin_theta;result.data[2][2] = cos_theta;break;case 'z':result.data[0][0] = cos_theta;result.data[0][1] = -sin_theta;result.data[1][0] = sin_theta;result.data[1][1] = cos_theta;break;default:throw std::runtime_error("Invalid rotation axis");}return result;
}// 缩放矩阵创建实现
Matrix3x3 Matrix3x3::scaling(double sx, double sy, double sz) {Matrix3x3 result;result.data[0][0] = sx;result.data[1][1] = sy;result.data[2][2] = sz;return result;
}// 输出运算符实现
std::ostream& operator<<(std::ostream& os, const Matrix3x3& m) {for (int i = 0; i < 3; ++i) {os << "[ ";for (int j = 0; j < 3; ++j) {os << m.data[i][j] << " ";}os << "]" << std::endl;}return os;
}} // namespace linear_algebra
} // namespace math

3. 使用示例

3.1 基本运算

#include "matrix3x3.h"
#include <iostream>using namespace math::linear_algebra;int main() {// 创建矩阵Matrix3x3 m1({{{1.0, 2.0, 3.0},{4.0, 5.0, 6.0},{7.0, 8.0, 9.0}}});Matrix3x3 m2({{{9.0, 8.0, 7.0},{6.0, 5.0, 4.0},{3.0, 2.0, 1.0}}});// 基本运算Matrix3x3 sum = m1 + m2;      // 矩阵加法Matrix3x3 diff = m1 - m2;     // 矩阵减法Matrix3x3 prod = m1 * m2;     // 矩阵乘法Matrix3x3 scaled = m1 * 2.0;  // 标量乘法// 输出结果std::cout << "m1:\n" << m1 << std::endl;std::cout << "m2:\n" << m2 << std::endl;std::cout << "m1 + m2:\n" << sum << std::endl;std::cout << "m1 - m2:\n" << diff << std::endl;std::cout << "m1 * m2:\n" << prod << std::endl;std::cout << "m1 * 2:\n" << scaled << std::endl;return 0;
}

3.2 矩阵变换

#include "matrix3x3.h"
#include <iostream>
#include <cmath>using namespace math::linear_algebra;int main() {// 创建旋转矩阵（绕Z轴旋转45度）Matrix3x3 rotation = Matrix3x3::rotation(M_PI / 4.0, 'z');// 创建缩放矩阵Matrix3x3 scaling = Matrix3x3::scaling(2.0, 3.0, 4.0);// 组合变换Matrix3x3 transform = rotation * scaling;// 输出结果std::cout << "旋转矩阵:\n" << rotation << std::endl;std::cout << "缩放矩阵:\n" << scaling << std::endl;std::cout << "组合变换:\n" << transform << std::endl;return 0;
}

4. 编译和运行

4.1 编译

使用提供的Makefile进行编译：

make        # 编译所有目标
make test   # 运行测试
make demo   # 运行示例
make clean  # 清理编译文件

4.2 运行测试

./matrix3x3_test

4.3 运行示例

./matrix3x3_demo

5. 注意事项

1. 数值精度

   • 在比较浮点数时使用适当的误差范围
   • 例如：std::abs(det) < 1e-10 判断是否可逆

2. 异常处理

   • 除以零的情况
   • 不可逆矩阵求逆的情况
   • 无效的旋转轴

3. 性能考虑

   • 矩阵乘法的时间复杂度为O(n³)
   • 特征值计算可能需要迭代方法
   • 考虑使用SIMD指令优化计算

4. 使用建议

   • 优先使用成员函数而不是全局函数
   • 保持接口的一致性
   • 提供清晰的错误信息

6. 扩展阅读

1. 线性代数基础

   • 矩阵运算
   • 行列式
   • 特征值和特征向量

2. 三维变换

   • 旋转矩阵
   • 缩放矩阵
   • 组合变换

3. 应用领域

   • 计算机图形学
   • 机器人学
   • 物理模拟
   • 游戏开发

   声明

该文章为学习过程中的笔记，目的是防止自己忘记，也为了方便随时随地查阅。其中大部分内容收集于互联网。