C++矩阵运算

71 阅读 0 评论 47 点赞

我是靠谱客的博主精明外套，这篇文章主要介绍C++矩阵运算，现在分享给大家，希望可以做个参考。

矩阵的定义可以使用STL提供的Vector，

譬如，定义A[4][4]

复制代码

1
2
3
4
5
6
7
8
1 vector<vector<double>> A =
2 { { 1.0, T, 0, 0 },
3
{ 0, 1, 0, 0 },
4
{ 0, 0, 1, T },
5
{ 0, 0, 0, 1 } };

一、运算符重载实现矩阵加法

复制代码

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
 1 vector<vector<double>> operator + (vector<vector<double>> arrA, vector<vector<double>> arrB)
 2 {//矩阵加法
 3
// 矩阵arrA的行数
 4
int rowA = arrA.size();
 5
//矩阵arrA的列数

 6
int colA = arrA[0].size();
 7
//矩阵arrB的行数

 8
int rowB = arrB.size();
 9
//矩阵arrB的列数

10
int colB = arrB[0].size();
11
//相乘后的结果矩阵

12
vector<vector<double>>
res;
13
if ((colA != colB) || (rowA != rowB))//判断矩阵行列是否一致。则返回空

14 
{
15
return res;
16 
}
17
else
18 
{
19
//设置结果矩阵的大小，初始化为为0

20 
res.resize(rowA);
21
for (int i = 0; i < rowA; ++i)
22 
{
23 
res[i].resize(colB);
24 
}
25
26
//矩阵相加

27
for (int i = 0; i < rowA; ++i)
28 
{
29
for (int j = 0; j < colB; ++j)
30 
{
31
32
res[i][j] = arrA[i][j] + arrB[i][j];
33
34 
}
35 
}
36 
}
37
return res;
38 }

二、矩阵乘法

复制代码

1 vector<vector<double>> operator * (vector<vector<double>> arrA, vector<vector<double>> arrB)
 2 {//矩阵乘法
 3
//矩阵arrA的行数

4
int rowA = arrA.size();
 5
//矩阵arrA的列数

6
int colA = arrA[0].size();
 7
//矩阵arrB的行数

8
int rowB = arrB.size();
 9
//矩阵arrB的列数

10
int colB = arrB[0].size();
11
//相乘后的结果矩阵

12
vector<vector<double>>
res;
13
if (colA != rowB)//如果矩阵arrA的列数不等于矩阵arrB的行数。则返回空

14 
{
15
return res;
16 
}
17
else
18 
{
19
//设置结果矩阵的大小，初始化为为0

20 
res.resize(rowA);
21
for (int i = 0; i < rowA; ++i)
22 
{
23 
res[i].resize(colB);
24 
}
25
26
//矩阵相乘

27
for (int i = 0; i < rowA; ++i)
28 
{
29
for (int j = 0; j < colB; ++j)
30 
{
31
for (int k = 0; k < colA; ++k)
32 
{
33
res[i][j] += arrA[i][k] * arrB[k][j];
34 
}
35 
}
36 
}
37 
}
38
return res;
39
40 }
41 vector<vector<double>> operator * (double n, vector<vector<double>> arr)
42 {//矩阵乘法
43
//矩阵arrA的行数

44
int row = arr.size();
45
//矩阵arrA的列数

46
int col = arr[0].size();
47
48
vector<vector<double>>
res;
49
50
51
//设置结果矩阵的大小，初始化为为0

52 
res.resize(row);
53
for (int i = 0; i < row; ++i)
54 
{
55 
res[i].resize(col);
56 
}
57
58
//矩阵相乘

59
for (int i = 0; i < row; ++i)
60 
{
61
for (int j = 0; j < col; ++j)
62 
{
63
64
res[i][j] = arr[i][j] * n;
65 
}
66 
}
67
68
return res;
69
70 }

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
 1 vector<vector<double>> operator * (vector<vector<double>> arrA, vector<vector<double>> arrB)
 2 {//矩阵乘法
 3
//矩阵arrA的行数

 4
int rowA = arrA.size();
 5
//矩阵arrA的列数

 6
int colA = arrA[0].size();
 7
//矩阵arrB的行数

 8
int rowB = arrB.size();
 9
//矩阵arrB的列数

10
int colB = arrB[0].size();
11
//相乘后的结果矩阵

12
vector<vector<double>>
res;
13
if (colA != rowB)//如果矩阵arrA的列数不等于矩阵arrB的行数。则返回空

14 
{
15
return res;
16 
}
17
else
18 
{
19
//设置结果矩阵的大小，初始化为为0

20 
res.resize(rowA);
21
for (int i = 0; i < rowA; ++i)
22 
{
23 
res[i].resize(colB);
24 
}
25
26
//矩阵相乘

27
for (int i = 0; i < rowA; ++i)
28 
{
29
for (int j = 0; j < colB; ++j)
30 
{
31
for (int k = 0; k < colA; ++k)
32 
{
33
res[i][j] += arrA[i][k] * arrB[k][j];
34 
}
35 
}
36 
}
37 
}
38
return res;
39
40 }
41 vector<vector<double>> operator * (double n, vector<vector<double>> arr)
42 {//矩阵乘法
43
//矩阵arrA的行数

44
int row = arr.size();
45
//矩阵arrA的列数

46
int col = arr[0].size();
47
48
vector<vector<double>>
res;
49
50
51
//设置结果矩阵的大小，初始化为为0

52 
res.resize(row);
53
for (int i = 0; i < row; ++i)
54 
{
55 
res[i].resize(col);
56 
}
57
58
//矩阵相乘

59
for (int i = 0; i < row; ++i)
60 
{
61
for (int j = 0; j < col; ++j)
62 
{
63
64
res[i][j] = arr[i][j] * n;
65 
}
66 
}
67
68
return res;
69
70 }

三、求行列式的值

复制代码

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
 1 double det(vector<vector<double>> arr)
 2 {
 3
//矩阵arrA的行数

 4
int row = arr.size();
 5
//矩阵arrA的列数

 6
int col = arr[0].size();
 7
if (row != col)
 8 
{
 9
return 0;
10 
}
11
if (1 == row)
12 
{
13
return arr[0][0];
14 
}
15
//创建结果矩阵
16
vector<vector<double>>
res;
17
res.resize(row-1);
18
int p = 0;
19
int q = 0;
20
double sum = 0;
21
for (int i = 0; i < row-1; ++i)
22 
{
23
res[i].resize(col-1);
24 
}
25
for (int i = 0; i < row; i++)
26 
{
27
for (int res_i = 0; res_i < row - 1; res_i++)
28 
{
29
if (res_i < i)
30 
{
31
p = 0;
32 
}
33
else
34 
{
35
p = 1;
36 
}
37
38
for (int j = 0; j < col - 1; j++)
39 
{
40
res[res_i][j] = arr[res_i + p][j+1];
41 
}
42 
}
43
if (i % 2 == 0)
44 
{
45
q = 1;
46 
}
47
else
48 
{
49
q = -1;
50 
}
51
sum += arr[i][0] * q*det(res);
52
53 
}
54
return sum;
55 }

四、求逆矩阵

复制代码

1 vector<vector<double>> inv(vector<vector<double>> arr)
 2 {//求逆矩阵
 3
//矩阵arrA的行数

4
int row = arr.size();
 5
//矩阵arrA的列数

6
int col = arr[0].size();
 7
if (row != col)
 8 
{
 9
vector<vector<double>> err= { {0} };
10
return err;
11 
}
12
//创建结果矩阵
13
vector<vector<double>>
res;
14 
res.resize(row);
15
for (int i = 0; i < row; ++i)
16 
{
17 
res[i].resize(col);
18
res[i][i] = 1;//初始化单位阵
19 
}
20
int temp_row = 0;
21
double max = 0;
22
double ratio = 0;
23
for (int i = 0; i < row; i++)
24 
{
25
//列选主元素
26
max = arr[i][i];
27
temp_row = i;
28
for (int i_change = i; i_change < row; i_change++)
29 
{
30
if (i_change == i)
31
continue;
32
if (max < arr[i][i_change])
33 
{
34
max = arr[i][i_change];
35
temp_row = i_change;
36 
}
37 
}
38
if (temp_row != i)
39 
{
40 
swap(arr[i], arr[temp_row]);
41 
swap(res[i], res[temp_row]);
42 
}
43
44
//消元
45
for (int i_change = 0; i_change < row; i_change++)
46 
{
47
if (i_change == i)
48
continue;
49
ratio = arr[i][i] / arr[i_change][i];
50
51
for (int j = 0; j < col; j++)
52 
{
53
if (j >= i)
54 
{
55
arr[i_change][j] = (arr[i_change][j] - arr[i][j] / ratio);
56 
}
57
res[i_change][j] = (res[i_change][j] - res[i][j] / ratio);
58 
}
59
60 
}
61
62
63 
}
64
//归一
65
for (int i = 0; i < row; i++)
66 
{
67
for (int j = 0; j < col; j++)
68 
{
69
res[i][j] = res[i][j] / arr[i][i];
70 
}
71 
}
72
73
return res;
74 }

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
140
141
142
 1 vector<vector<double>> inv(vector<vector<double>> arr)
 2 {//求逆矩阵
 3
//矩阵arrA的行数

 4
int row = arr.size();
 5
//矩阵arrA的列数

 6
int col = arr[0].size();
 7
if (row != col)
 8 
{
 9
vector<vector<double>> err= { {0} };
10
return err;
11 
}
12
//创建结果矩阵
13
vector<vector<double>>
res;
14 
res.resize(row);
15
for (int i = 0; i < row; ++i)
16 
{
17 
res[i].resize(col);
18
res[i][i] = 1;//初始化单位阵
19 
}
20
int temp_row = 0;
21
double max = 0;
22
double ratio = 0;
23
for (int i = 0; i < row; i++)
24 
{
25
//列选主元素
26
max = arr[i][i];
27
temp_row = i;
28
for (int i_change = i; i_change < row; i_change++)
29 
{
30
if (i_change == i)
31
continue;
32
if (max < arr[i][i_change])
33 
{
34
max = arr[i][i_change];
35
temp_row = i_change;
36 
}
37 
}
38
if (temp_row != i)
39 
{
40 
swap(arr[i], arr[temp_row]);
41 
swap(res[i], res[temp_row]);
42 
}
43
44
//消元
45
for (int i_change = 0; i_change < row; i_change++)
46 
{
47
if (i_change == i)
48
continue;
49
ratio = arr[i][i] / arr[i_change][i];
50
51
for (int j = 0; j < col; j++)
52 
{
53
if (j >= i)
54 
{
55
arr[i_change][j] = (arr[i_change][j] - arr[i][j] / ratio);
56 
}
57
res[i_change][j] = (res[i_change][j] - res[i][j] / ratio);
58 
}
59
60 
}
61
62
63 
}
64
//归一
65
for (int i = 0; i < row; i++)
66 
{
67
for (int j = 0; j < col; j++)
68 
{
69
res[i][j] = res[i][j] / arr[i][i];
70 
}
71 
}
72
73
return res;
74 }

------------

补充：

对于上面矩阵加减乘除，如果输入的数据类型存在double、int等不同的数据类型，则需要不断重载运算符，带来不必要的麻烦。而C++的模板机制可以很好的解决这个问题。

模板定义：模板就是实现代码重用机制的一种工具，它可以实现类型参数化，即把类型定义为参数，从而实现了真正的代码可重用性。模版可以分为两类，一个是函数模版，另外一个是类模版。

（1）函数模板

复制代码

1
2
3
template <class T>
void SwapFunction(T &first, T &second){
}//函数模版

函数模板可以用来创建一个通用的函数，以支持多种不同的形参，避免重载函数的函数体重复设计！

函数模板解决"+"运算符重载

复制代码

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
 1 template <class T>
 2 T operator + (T arrA, T arrB)
 3 {//矩阵加法
 4
// 矩阵arrA的行数
 5
int rowA = arrA.size();
 6
//矩阵arrA的列数

 7
int colA = arrA[0].size();
 8
//矩阵arrB的行数

 9
int rowB = arrB.size();
10
//矩阵arrB的列数

11
int colB = arrB[0].size();
12
//相乘后的结果矩阵

13 
T
res;
14
if ((colA != colB) || (rowA != rowB))//判断矩阵行列是否一致。则返回空

15 
{
16
return res;
17 
}
18
else
19 
{
20
//设置结果矩阵的大小，初始化为为0

21 
res.resize(rowA);
22
for (int i = 0; i < rowA; ++i)
23 
{
24 
res[i].resize(colB);
25 
}
26
27
//矩阵相加

28
for (int i = 0; i < rowA; ++i)
29 
{
30
for (int j = 0; j < colB; ++j)
31 
{
32
33
res[i][j] = arrA[i][j] + arrB[i][j];
34
35 
}
36 
}
37 
}
38
return res;
39 }

这样使用就很灵活了

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
1 vector<vector<int >>A = { { 1, 2 }, { 3, 2 } };
2
vector<vector<int >>B = { { 1, 2 }, { 3, 2 } };
3
vector<vector<int >> C = A + B;
4
5
vector<vector<double >>A2 = { { 1, 2 }, { 3, 2 } };
6
vector<vector<double >>B2 = { { 1, 2 }, { 3, 2 } };
7
vector<vector<double >> C2 = A2 + B2;