GCC Code Coverage Report

Directory: ./
File: tasks/morozova_s_strassen_multiplication/seq/src/ops_seq.cpp
Date: 2026-04-02 17:12:27
Exec Total Coverage
Lines: 95 110 86.4%
Functions: 11 17 64.7%
Branches: 82 142 57.7%
Line Branch Exec Source
1 #include "morozova_s_strassen_multiplication/seq/include/ops_seq.hpp"
2
3 #include <cmath>
4 #include <cstddef>
5 #include <vector>
6
7 #include "morozova_s_strassen_multiplication/common/include/common.hpp"
8
9 namespace morozova_s_strassen_multiplication {
10
11 namespace {
12
13 88 Matrix AddMatrixImpl(const Matrix &a, const Matrix &b) {
14 88 int n = a.size;
15 Matrix result(n);
16
17
2/2
✓ Branch 0 taken 5632 times.
✓ Branch 1 taken 88 times.
 5720 for (int i = 0; i < n; ++i) {
18
2/2
✓ Branch 0 taken 360448 times.
✓ Branch 1 taken 5632 times.
 366080 for (int j = 0; j < n; ++j) {
19 360448 result(i, j) = a(i, j) + b(i, j);
20 }
21 }
22
23 88 return result;
24 }
25
26 56 Matrix SubtractMatrixImpl(const Matrix &a, const Matrix &b) {
27 56 int n = a.size;
28 Matrix result(n);
29
30
2/2
✓ Branch 0 taken 3584 times.
✓ Branch 1 taken 56 times.
 3640 for (int i = 0; i < n; ++i) {
31
2/2
✓ Branch 0 taken 229376 times.
✓ Branch 1 taken 3584 times.
 232960 for (int j = 0; j < n; ++j) {
32 229376 result(i, j) = a(i, j) - b(i, j);
33 }
34 }
35
36 56 return result;
37 }
38
39 120 Matrix MultiplyStandardImpl(const Matrix &a, const Matrix &b) {
40 120 int n = a.size;
41 Matrix result(n);
42
43
2/2
✓ Branch 0 taken 4624 times.
✓ Branch 1 taken 120 times.
 4744 for (int i = 0; i < n; ++i) {
44
2/2
✓ Branch 0 taken 273136 times.
✓ Branch 1 taken 4624 times.
 277760 for (int j = 0; j < n; ++j) {
45 double sum = 0.0;
46
2/2
✓ Branch 0 taken 17077024 times.
✓ Branch 1 taken 273136 times.
 17350160 for (int k = 0; k < n; ++k) {
47 17077024 sum += a(i, k) * b(k, j);
48 }
49 273136 result(i, j) = sum;
50 }
51 }
52
53 120 return result;
54 }
55
56 16 void SplitMatrixImpl(const Matrix &m, Matrix &m11, Matrix &m12, Matrix &m21, Matrix &m22) {
57 16 int n = m.size;
58 16 int half = n / 2;
59
60
2/2
✓ Branch 0 taken 1024 times.
✓ Branch 1 taken 16 times.
 1040 for (int i = 0; i < half; ++i) {
61
2/2
✓ Branch 0 taken 65536 times.
✓ Branch 1 taken 1024 times.
 66560 for (int j = 0; j < half; ++j) {
62 65536 m11(i, j) = m(i, j);
63 65536 m12(i, j) = m(i, j + half);
64 65536 m21(i, j) = m(i + half, j);
65 65536 m22(i, j) = m(i + half, j + half);
66 }
67 }
68 16 }
69
70 8 Matrix MergeMatricesImpl(const Matrix &m11, const Matrix &m12, const Matrix &m21, const Matrix &m22) {
71 8 int half = m11.size;
72 8 int n = 2 * half;
73 Matrix result(n);
74
75
2/2
✓ Branch 0 taken 512 times.
✓ Branch 1 taken 8 times.
 520 for (int i = 0; i < half; ++i) {
76
2/2
✓ Branch 0 taken 32768 times.
✓ Branch 1 taken 512 times.
 33280 for (int j = 0; j < half; ++j) {
77 32768 result(i, j) = m11(i, j);
78 32768 result(i, j + half) = m12(i, j);
79 32768 result(i + half, j) = m21(i, j);
80 32768 result(i + half, j + half) = m22(i, j);
81 }
82 }
83
84 8 return result;
85 }
86
87 8 Matrix MultiplyStrassenIterative(const Matrix &a, const Matrix &b, int leaf_size) {
88 8 int n = a.size;
89
90
2/4
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 8 times.
 8 if (n <= leaf_size || n % 2 != 0) {
91 ✗ return MultiplyStandardImpl(a, b);
92 }
93
94 8 int half = n / 2;
95
96 Matrix a11(half);
97 Matrix a12(half);
98 Matrix a21(half);
99 Matrix a22(half);
100 Matrix b11(half);
101 Matrix b12(half);
102 Matrix b21(half);
103 Matrix b22(half);
104
105 8 SplitMatrixImpl(a, a11, a12, a21, a22);
106 8 SplitMatrixImpl(b, b11, b12, b21, b22);
107
108
2/6
✓ Branch 1 taken 8 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 8 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 8 Matrix p1 = MultiplyStandardImpl(a11, SubtractMatrixImpl(b12, b22));
109
2/6
✓ Branch 1 taken 8 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 8 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 8 Matrix p2 = MultiplyStandardImpl(AddMatrixImpl(a11, a12), b22);
110
2/6
✓ Branch 1 taken 8 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 8 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 8 Matrix p3 = MultiplyStandardImpl(AddMatrixImpl(a21, a22), b11);
111
2/6
✓ Branch 1 taken 8 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 8 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 8 Matrix p4 = MultiplyStandardImpl(a22, SubtractMatrixImpl(b21, b11));
112
4/12
✓ Branch 1 taken 8 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 8 times.
✗ Branch 5 not taken.
✓ Branch 7 taken 8 times.
✗ Branch 8 not taken.
✓ Branch 9 taken 8 times.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
 16 Matrix p5 = MultiplyStandardImpl(AddMatrixImpl(a11, a22), AddMatrixImpl(b11, b22));
113
4/12
✓ Branch 1 taken 8 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 8 times.
✗ Branch 5 not taken.
✓ Branch 7 taken 8 times.
✗ Branch 8 not taken.
✓ Branch 9 taken 8 times.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
 16 Matrix p6 = MultiplyStandardImpl(SubtractMatrixImpl(a12, a22), AddMatrixImpl(b21, b22));
114
4/12
✓ Branch 1 taken 8 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 8 times.
✗ Branch 5 not taken.
✓ Branch 7 taken 8 times.
✗ Branch 8 not taken.
✓ Branch 9 taken 8 times.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
 16 Matrix p7 = MultiplyStandardImpl(SubtractMatrixImpl(a11, a21), AddMatrixImpl(b11, b12));
115
116
3/8
✓ Branch 1 taken 8 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 8 times.
✗ Branch 5 not taken.
✓ Branch 7 taken 8 times.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
 8 Matrix c11 = AddMatrixImpl(SubtractMatrixImpl(AddMatrixImpl(p5, p4), p2), p6);
117
1/2
✓ Branch 1 taken 8 times.
✗ Branch 2 not taken.
 8 Matrix c12 = AddMatrixImpl(p1, p2);
118
1/2
✓ Branch 1 taken 8 times.
✗ Branch 2 not taken.
 8 Matrix c21 = AddMatrixImpl(p3, p4);
119
3/8
✓ Branch 1 taken 8 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 8 times.
✗ Branch 5 not taken.
✓ Branch 7 taken 8 times.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
 8 Matrix c22 = SubtractMatrixImpl(SubtractMatrixImpl(AddMatrixImpl(p5, p1), p3), p7);
120
121
1/2
✓ Branch 1 taken 8 times.
✗ Branch 2 not taken.
 8 return MergeMatricesImpl(c11, c12, c21, c22);
122 }
123
124 } // namespace
125
126
1/2
✓ Branch 1 taken 88 times.
✗ Branch 2 not taken.
 88 MorozovaSStrassenMultiplicationSEQ::MorozovaSStrassenMultiplicationSEQ(const InType &in) {
127 SetTypeOfTask(GetStaticTypeOfTask());
128
1/2
✓ Branch 1 taken 88 times.
✗ Branch 2 not taken.
 88 GetInput() = in;
129 88 GetOutput() = OutType();
130 88 }
131
132 88 bool MorozovaSStrassenMultiplicationSEQ::ValidationImpl() {
133 88 return true;
134 }
135
136
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 80 times.
 88 bool MorozovaSStrassenMultiplicationSEQ::PreProcessingImpl() {
137
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 80 times.
 88 if (GetInput().empty()) {
138 8 valid_data_ = false;
139 8 return true;
140 }
141
142 80 double size_val = GetInput()[0];
143
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 72 times.
 80 if (size_val <= 0.0) {
144 8 valid_data_ = false;
145 8 return true;
146 }
147
148
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 72 times.
 72 int n = static_cast<int>(size_val);
149
150
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 72 times.
 72 if (GetInput().size() != 1 + (2 * static_cast<size_t>(n) * static_cast<size_t>(n))) {
151 ✗ valid_data_ = false;
152 ✗ return true;
153 }
154
155 72 valid_data_ = true;
156 72 n_ = n;
157
158 72 a_ = Matrix(n_);
159 72 b_ = Matrix(n_);
160
161 int idx = 1;
162
2/2
✓ Branch 0 taken 2064 times.
✓ Branch 1 taken 72 times.
 2136 for (int i = 0; i < n_; ++i) {
163
2/2
✓ Branch 0 taken 174832 times.
✓ Branch 1 taken 2064 times.
 176896 for (int j = 0; j < n_; ++j) {
164 174832 a_(i, j) = GetInput()[idx++];
165 }
166 }
167
168
2/2
✓ Branch 0 taken 2064 times.
✓ Branch 1 taken 72 times.
 2136 for (int i = 0; i < n_; ++i) {
169
2/2
✓ Branch 0 taken 174832 times.
✓ Branch 1 taken 2064 times.
 176896 for (int j = 0; j < n_; ++j) {
170 174832 b_(i, j) = GetInput()[idx++];
171 }
172 }
173
174 return true;
175 }
176
177 88 bool MorozovaSStrassenMultiplicationSEQ::RunImpl() {
178
2/2
✓ Branch 0 taken 72 times.
✓ Branch 1 taken 16 times.
 88 if (!valid_data_) {
179 return true;
180 }
181
182 const int leaf_size = 64;
183
184
2/2
✓ Branch 0 taken 64 times.
✓ Branch 1 taken 8 times.
 72 if (n_ <= leaf_size) {
185 64 c_ = MultiplyStandard(a_, b_);
186 } else {
187 16 c_ = MultiplyStrassenIterative(a_, b_, leaf_size);
188 }
189
190 return true;
191 }
192
193
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 88 times.
 88 bool MorozovaSStrassenMultiplicationSEQ::PostProcessingImpl() {
194 OutType &output = GetOutput();
195 output.clear();
196
197
2/2
✓ Branch 0 taken 72 times.
✓ Branch 1 taken 16 times.
 88 if (!valid_data_) {
198 return true;
199 }
200
201 72 output.push_back(static_cast<double>(n_));
202
203
2/2
✓ Branch 0 taken 2064 times.
✓ Branch 1 taken 72 times.
 2136 for (int i = 0; i < n_; ++i) {
204
2/2
✓ Branch 0 taken 174832 times.
✓ Branch 1 taken 2064 times.
 176896 for (int j = 0; j < n_; ++j) {
205 output.push_back(c_(i, j));
206 }
207 }
208
209 return true;
210 }
211
212 ✗ Matrix MorozovaSStrassenMultiplicationSEQ::AddMatrix(const Matrix &a, const Matrix &b) {
213 ✗ return AddMatrixImpl(a, b);
214 }
215
216 ✗ Matrix MorozovaSStrassenMultiplicationSEQ::SubtractMatrix(const Matrix &a, const Matrix &b) {
217 ✗ return SubtractMatrixImpl(a, b);
218 }
219
220 ✗ Matrix MorozovaSStrassenMultiplicationSEQ::MultiplyStandard(const Matrix &a, const Matrix &b) {
221 64 return MultiplyStandardImpl(a, b);
222 }
223
224 ✗ void MorozovaSStrassenMultiplicationSEQ::SplitMatrix(const Matrix &m, Matrix &m11, Matrix &m12, Matrix &m21,
225 Matrix &m22) {
226 ✗ SplitMatrixImpl(m, m11, m12, m21, m22);
227 ✗ }
228
229 ✗ Matrix MorozovaSStrassenMultiplicationSEQ::MergeMatrices(const Matrix &m11, const Matrix &m12, const Matrix &m21,
230 const Matrix &m22) {
231 ✗ return MergeMatricesImpl(m11, m12, m21, m22);
232 }
233
234 ✗ Matrix MorozovaSStrassenMultiplicationSEQ::MultiplyStrassen(const Matrix &a, const Matrix &b, int leaf_size) {
235 ✗ return MultiplyStrassenIterative(a, b, leaf_size);
236 }
237
238 } // namespace morozova_s_strassen_multiplication
239