Matrix（矩阵）组件提供完整的矩阵运算功能：
- 创建矩阵
- 基础运算（加减乘除）
- 矩阵变换（转置、求逆）
- 数学运算（行列式、特征值）
- 线性代数应用

设计器配置：
- Rows: 行数
- Columns: 列数
- Diagonal Value: 对角线初始值（0或其他）
-背景颜色: 矩阵显示颜色

// 创建3x3零矩阵
调用 Matrix1.创建矩阵(
  行数: 3,
  列数: 3,
  对角线值: 0
)

// 创建3x3单位矩阵
调用 Matrix1.创建单位矩阵(
  大小: 3
)

// 创建对角矩阵
调用 Matrix1.创建矩阵(
  行数: 3,
  列数: 3,
  对角线值: 5
)

// 从列表创建矩阵
初始化全局变量 数据 = 
  创建列表(
    创建列表(1, 2, 3),
    创建列表(4, 5, 6),
    创建列表(7, 8, 9)
  )

调用 Matrix1.从列表创建(全局变量 数据)

// 验证结果
当 Matrix1.矩阵就绪() 时
  设置 Label_Info.文本 = "矩阵创建成功！" + 
    "行数: " + Matrix1.行数 + 
    "列数: " + Matrix1.列数

// 零矩阵（全部为0）
┌ 0  0  0 ┐
│ 0  0  0 │
└ 0  0  0 ┘

// 单位矩阵（对角线为1）
┌ 1  0  0 ┐
│ 0  1  0 │
└ 0  0  1 ┘

// 对角矩阵（仅对角线有值）
┌ 5  0  0 ┐
│ 0  3  0 │
└ 0  0  2 ┘

矩阵A：
┌ 1  2 ┐
│ 3  4 │
└ 5  6 ┘

矩阵B：
┌ 6  5 ┐
│ 4  3 │
└ 2  1 ┘

A + B = 
┌ 7  7 ┐
│ 7  7 │
└ 7  7 ┘

// 代码
调用 Matrix1.矩阵加法(
  矩阵1: A,
  矩阵2: B,
  结果矩阵: C
)

A - B = 
┌ -5  -3 ┐
│ -1   1 │
└  3   5 ┘

// 代码
调用 Matrix1.矩阵减法(
  矩阵1: A,
  矩阵2: B,
  结果矩阵: C
)

k × A = 
┌ k×1  k×2 ┐
│ k×3  k×4 │
└ k×5  k×6 ┘

// 代码：2 × A
调用 Matrix1.矩阵数乘(
  矩阵: A,
  数: 2,
  结果矩阵: C
)

矩阵A (2x3) × 矩阵B (3x2) = 矩阵C (2x2)

A =                    B =
┌ 1  2  3 ┐           ┌ 7  8 ┐
│ 4  5  6 │           │ 9  10│
└         ┘           │11  12│
                     └     ┘

C = A × B =
┌ 1×7+2×9+3×11  1×8+2×10+3×12 ┐
│ 4×7+5×9+6×11  4×8+5×10+6×12 │
└                               ┘
=
┌ 58   64 ┐
│139  154 │
└        ┘

// 代码
调用 Matrix1.矩阵乘法(
  矩阵1: A,
  矩阵2: B,
  结果矩阵: C
)

A ÷ B = A × B⁻¹

// 代码
调用 Matrix1.矩阵求逆(矩阵: B, 结果矩阵: B_逆)
调用 Matrix1.矩阵乘法(矩阵1: A, 矩阵2: B_逆, 结果矩阵: C)

原矩阵A：
┌ 1  2  3 ┐
│ 4  5  6 │
└         ┘

转置矩阵Aᵀ：
┌ 1  4 ┐
│ 2  5 │
│ 3  6 │
└     ┘

// 代码
调用 Matrix1.转置(
  矩阵: A,
  结果矩阵: A_T
)

A × A⁻¹ = I（单位矩阵）

// 代码
调用 Matrix1.矩阵求逆(
  矩阵: A,
  结果矩阵: A_逆
)

// 判断是否可逆
当 Matrix1.求逆失败(原因) 时
  调用 Notifier1.显示消息("矩阵不可逆: " + 原因)

2x2矩阵行列式：
| a  b |     ad - bc
| c  d | =

// 代码
调用 Matrix1.计算行列式(矩阵: A)

当 Matrix1.行列式结果(值) 时
  设置 Label_Det.文本 = "行列式: " + 值

// 代码
调用 Matrix1.伴随矩阵(
  矩阵: A,
  结果矩阵: adj_A
)

// 对矩阵中每个元素取绝对值
调用 Matrix1.绝对值(
  矩阵: A,
  结果矩阵: abs_A
)

// A² = A × A
调用 Matrix1.矩阵幂(
  矩阵: A,
  指数: 2,
  结果矩阵: A2
)

// 自然指数（e^x）
调用 Matrix1.矩阵指数(矩阵: A, 结果矩阵: exp_A)

// 自然对数（ln(x)）
调用 Matrix1.矩阵对数(矩阵: A, 结果矩阵: log_A)

// 所有元素之和
调用 Matrix1.求和(矩阵: A)

当 Matrix1.求和结果(值) 时
  设置 Label_Sum.文本 = "元素和: " + 值

// 灰度化公式：Gray = 0.299×R + 0.587×G + 0.114×B
初始化全局变量 灰度系数 = 
  创建列表(
    创建列表(0.299, 0.587, 0.114)
  )

// 假设原图RGB三个通道的像素值存储在三个矩阵中
调用 Matrix1.矩阵乘法(
  矩阵1: 灰度系数,
  矩阵2: RGB_合并矩阵,
  结果矩阵: 灰度矩阵
)

// 解 Ax = B
// 其中 A 是系数矩阵，B 是常数向量

// 示例：
// 2x + y = 5
// x + 3y = 6

// A = [[2, 1], [1, 3]]
// B = [5, 6]

// x = A⁻¹ × B

过程 解线性方程组(系数矩阵, 常数向量)
  // 1. 求逆矩阵
  调用 Matrix1.矩阵求逆(矩阵: 系数矩阵, 结果矩阵: A_逆)
  
  // 2. 乘以常数向量
  调用 Matrix1.矩阵乘法(
    矩阵1: A_逆,
    矩阵2: 常数向量,
    结果矩阵: 解
  )
  
  返回 解
过程结束

// 旋转矩阵（逆时针旋转θ度）
// R(θ) = | cosθ  -sinθ |
//        | sinθ   cosθ |

过程 创建旋转矩阵(角度)
  设置 全局变量 θ = 角度 × 3.14159 / 180
  设置 全局变量 cos值 = 调用 余弦(全局变量 θ)
  设置 全局变量 sin值 = 调用 正弦(全局变量 θ)
  
  返回 创建列表(
    创建列表(全局变量 cos值, -全局变量 sin值),
    创建列表(全局变量 sin值, 全局变量 cos值)
  )
过程结束

过程 旋转点(点X, 点Y, 角度)
  设置 全局变量 旋转矩阵 = 调用 创建旋转矩阵(角度)
  设置 全局变量 点坐标 = 创建列表(点X, 点Y)
  
  调用 Matrix1.矩阵乘法(
    矩阵1: 旋转矩阵,
    矩阵2: 点坐标,
    结果矩阵: 新坐标
  )
  
  返回 新坐标
过程结束

// Min-Max归一化：x' = (x - min) / (max - min)
过程 归一化(矩阵)
  // 1. 获取最小值和最大值
  设置 全局变量 扁平 = 调用 Matrix1.转平(矩阵)
  设置 全局变量 最小值 = 调用 列表最小值(全局变量 扁平)
  设置 全局变量 最大值 = 调用 列表最大值(全局变量 扁平)
  
  // 2. 创建归一化参数矩阵
  // (x - min) / (max - min)
  设置 全局变量 偏移 = 创建常数矩阵(全局变量 最小值 * -1, 矩阵.行数, 矩阵.列数)
  设置 全局变量 缩放 = 创建常数矩阵(全局变量 最大值 - 全局变量 最小值, 矩阵.行数, 矩阵.列数)
  
  // 3. 归一化
  调用 Matrix1.矩阵加法(矩阵1: 矩阵, 矩阵2: 偏移, 结果矩阵: 偏移后)
  调用 Matrix1.矩阵除法(矩阵1: 偏移后, 矩阵2: 缩放, 结果矩阵: 归一化结果)
  
  返回 归一化结果
过程结束

当 Matrix1.求逆失败(原因) 时
  如果 原因 = "奇异矩阵" 则
    调用 Notifier1.显示消息("矩阵不可逆，使用伪逆替代")
    调用 使用伪逆()
  否则
    调用 Notifier1.显示消息("求逆失败: " + 原因)
  如果结束

1. 避免频繁创建大矩阵
   → 预分配，重复使用

2. 使用分块处理
   → 大矩阵分小块处理

3. 及时释放内存
   → 设置矩阵为空列表

// 避免重复计算
初始化全局变量 A的平方 = 空

当 需要A的平方 时
  如果 全局变量 A的平方 = 空 则
    调用 Matrix1.矩阵乘法(矩阵1: A, 矩阵2: A, 结果矩阵: A的平方)
  如果结束
  返回 全局变量 A的平方

当 Button_求解.被点击 时
  // 设置系数矩阵 A
  // 2x + y = 5
  // x + 3y = 6
  设置 Matrix_A.从列表创建(
    创建列表(
      创建列表(2, 1),
      创建列表(1, 3)
    )
  )
  
  // 设置常数向量 B
  设置 Matrix_B.从列表创建(
    创建列表(
      创建列表(5),
      创建列表(6)
    )
  )

当 Matrix_A.矩阵就绪() 且 Matrix_B.矩阵就绪() 时
  // 求A的逆矩阵
  调用 Matrix_A.矩阵求逆(矩阵: Matrix_A, 结果矩阵: Matrix_A_Inv)

当 Matrix_A.求逆失败(原因) 时
  调用 Notifier1.显示消息("方程无唯一解")

当 Matrix_A_Inv.矩阵就绪() 时
  // x = A⁻¹ × B
  调用 Matrix_A_Inv.矩阵乘法(
    矩阵1: Matrix_A_Inv,
    矩阵2: Matrix_B,
    结果矩阵: 解向量
  )

当 解向量.矩阵就绪() 时
  设置 全局变量 解 = 调用 解向量.获取元素(1, 1)
  设置 全局变量 解 = 调用 解向量.获取元素(2, 1)
  
  调用 Notifier1.显示消息(
    "x = " + 四舍五入(全局变量 解, 2) + 
    ", y = " + 四舍五入(全局变量 解, 2)
  )