3x3矩阵教程

lxiaoj1112025-07-22 13:14

3x3矩阵教程

1. 简介

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

2. 代码实现

2.1 头文件 (matrix3x3.h)

cpp 复制代码 
#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)

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 基本运算

cpp 复制代码 
#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 矩阵变换

cpp 复制代码 
#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进行编译：

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

4.2 运行测试

bash 复制代码 
./matrix3x3_test

4.3 运行示例

bash 复制代码 
./matrix3x3_demo

5. 注意事项

  1. 数值精度

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

  2. 异常处理

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

  3. 性能考虑

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

  4. 使用建议

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

6. 扩展阅读

  1. 线性代数基础

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

  2. 三维变换

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

  3. 应用领域

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

    声明

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

热门推荐
01【2025.7.18】更新vscode后所有.vue文件template标签后报红的临时解决办法，Vue - Official 插件3.0.2导致02全球最强模型Grok4，国内已可免费使用！（附教程）03这次领先Cursor！体验了Trae 2.0 SOLO 模式，超酷！04Cursor Claude 模型无法使用的解决方法05KGG转MP3工具|非KGM文件|解密音频06Cursor限制国内用户使用Claude模型？附简单解决方案！07Vue (Official) v3.0.2 新特性 为非类npm环境引入 globalTypesPath 选项08赛博保姆出列！Gemini CLI & Claude Code + Kimi 手把手教程09【暑期多校补题记录】2025牛客多校(1)(2) 杭电多校(1)10Cursor区域封禁（Model not avilable）解决方案指南