正文

C#计算矩阵的逆矩阵方法实例分析

︶ㄣ米米素材网 メ
米米素材网V管理员 / 阅读
0708

这篇文章主要介绍了C#计算矩阵的逆矩阵方法,较为详细的分析了逆矩阵的计算原理与相关的C#实现技巧,具有一定参考借鉴价值,需要的朋友可以参考下

本文实例讲述了C#计算矩阵的逆矩阵方法。分享给大家供大家参考。具体如下：

1.代码思路

1）对矩阵进行合法性检查：矩阵必须为方阵
2）计算矩阵行列式的值（Determinant函数）
3）只有满秩矩阵才有逆矩阵，因此如果行列式的值为0（在代码中以绝对值小于1E-6做判断），则终止函数，报出异常
4）求出伴随矩阵（AdjointMatrix函数）
5）逆矩阵各元素即其伴随矩阵各元素除以矩阵行列式的商

2.函数代码

（注：本段代码只实现了一个思路，可能并不是该问题的最优解）

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
/// <summary>
/// 求矩阵的逆矩阵
/// </summary>
/// <param name="matrix"></param>
/// <returns></returns>
public static double[][] InverseMatrix(double[][] matrix)
{
 //matrix必须为非空
 if (matrix == null || matrix.Length == 0)
 {
  return new double[][] { };
 }
 //matrix 必须为方阵
 int len = matrix.Length;
 for (int counter = 0; counter < matrix.Length; counter++)
 {
  if (matrix[counter].Length != len)
  {
   throw new Exception("matrix 必须为方阵");
  }
 }
 //计算矩阵行列式的值
 double dDeterminant = Determinant(matrix);
 if (Math.Abs(dDeterminant) <= 1E-6)
 {
  throw new Exception("矩阵不可逆");
 }
 //制作一个伴随矩阵大小的矩阵
 double[][] result = AdjointMatrix(matrix);
 //矩阵的每项除以矩阵行列式的值，即为所求
 for (int i = 0; i < matrix.Length; i++)
 {
  for (int j = 0; j < matrix.Length; j++)
  {
   result[i][j] = result[i][j] / dDeterminant;
  }
 }
 return result;
}
/// <summary>
/// 递归计算行列式的值
/// </summary>
/// <param name="matrix">矩阵</param>
/// <returns></returns>
public static double Determinant(double[][] matrix)
{
 //二阶及以下行列式直接计算
 if (matrix.Length == 0) return 0;
 else if (matrix.Length == 1) return matrix[0][0];
 else if (matrix.Length == 2)
 {
  return matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
 }
 //对第一行使用“加边法”递归计算行列式的值
 double dSum = 0, dSign = 1;
 for (int i = 0; i < matrix.Length; i++)
 {
  double[][] matrixTemp = new double[matrix.Length - 1][];
  for (int count = 0; count < matrix.Length - 1; count++)
  {
   matrixTemp[count] = new double[matrix.Length - 1];
  }
  for (int j = 0; j < matrixTemp.Length; j++)
  {
   for (int k = 0; k < matrixTemp.Length; k++)
   {
    matrixTemp[j][k] = matrix[j + 1][k >= i ? k + 1 : k];
   }
  }
  dSum += (matrix[0][i] * dSign * Determinant(matrixTemp));
  dSign = dSign * -1;
 }
 return dSum;
}
/// <summary>
/// 计算方阵的伴随矩阵
/// </summary>
/// <param name="matrix">方阵</param>
/// <returns></returns>
public static double[][] AdjointMatrix(double [][] matrix)
{
 //制作一个伴随矩阵大小的矩阵
 double[][] result = new double[matrix.Length][];
 for (int i = 0; i < result.Length; i++)
 {
  result[i] = new double[matrix[i].Length];
 }
 //生成伴随矩阵
 for (int i = 0; i < result.Length; i++)
 {
  for (int j = 0; j < result.Length; j++)
  {
   //存储代数余子式的矩阵（行、列数都比原矩阵少1）
   double[][] temp = new double[result.Length - 1][];
   for (int k = 0; k < result.Length - 1; k++)
   {
    temp[k] = new double[result[k].Length - 1];
   }
   //生成代数余子式
   for (int x = 0; x < temp.Length; x++)
   {
    for (int y = 0; y < temp.Length; y++)
    {
     temp[x][y] = matrix[x < i ? x : x + 1][y < j ? y : y + 1];
    }
   }
   //Console.WriteLine("代数余子式:");
   //PrintMatrix(temp);
   result[j][i] = ((i + j) % 2 == 0 ? 1 : -1) * Determinant(temp);
  }
 }
 //Console.WriteLine("伴随矩阵：");
 //PrintMatrix(result);
 return result;
}
/// <summary>
/// 打印矩阵
/// </summary>
/// <param name="matrix">待打印矩阵</param>
private static void PrintMatrix(double[][] matrix, string title = "")
{
 //1.标题值为空则不显示标题
 if (!String.IsNullOrWhiteSpace(title))
 {
  Console.WriteLine(title);
 }
 //2.打印矩阵
 for (int i = 0; i < matrix.Length; i++)
 {
  for (int j = 0; j < matrix[i].Length; j++)
  {
   Console.Write(matrix[i][j] + "\t");
   //注意不能写为：Console.Write(matrix[i][j] + '\t');
  }
  Console.WriteLine();
 }
 //3.空行
 Console.WriteLine();
}

3.Main函数调用

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
static void Main(string[] args)
{
 double[][] matrix = new double[][]
 {
  new double[] { 1, 2, 3 },
  new double[] { 2, 2, 1 },
  new double[] { 3, 4, 3 }
 };
 PrintMatrix(matrix, "原矩阵");
 PrintMatrix(AdjointMatrix(matrix), "伴随矩阵");
 Console.WriteLine("行列式的值为：" + Determinant(matrix) + '\n');
 PrintMatrix(InverseMatrix(matrix), "逆矩阵");
 Console.ReadLine();
}

4.执行结果

C#计算矩阵的逆矩阵方法实例分析

希望本文所述对大家的C#程序设计有所帮助。