GCC Code Coverage Report

Directory: ./
File: tasks/lobanov_d_multiply_matrix_ccs/seq/src/ops_seq.cpp
Date: 2026-01-10 02:40:41
Exec Total Coverage
Lines: 75 78 96.2%
Functions: 8 8 100.0%
Branches: 107 162 66.0%
Line Branch Exec Source
1 #include "lobanov_d_multiply_matrix_ccs/seq/include/ops_seq.hpp"
2
3 #include <algorithm>
4 #include <cmath>
5 #include <cstddef>
6 #include <exception>
7 #include <vector>
8
9 #include "lobanov_d_multiply_matrix_ccs/common/include/common.hpp"
10
11 namespace lobanov_d_multiply_matrix_ccs {
12
13 constexpr double kEpsilonThreshold = 1e-12;
14
15
1/2
✓ Branch 2 taken 64 times.
✗ Branch 3 not taken.
 64 LobanovDMultiplyMatrixSEQ::LobanovDMultiplyMatrixSEQ(const InType &input_matrices) {
16 SetTypeOfTask(GetStaticTypeOfTask());
17 GetInput() = input_matrices;
18
1/2
✓ Branch 1 taken 64 times.
✗ Branch 2 not taken.
 64 CompressedColumnMatrix empty_matrix;
19 empty_matrix.row_count = 0;
20 empty_matrix.column_count = 0;
21 empty_matrix.non_zero_count = 0;
22
1/2
✓ Branch 1 taken 64 times.
✗ Branch 2 not taken.
 64 GetOutput() = empty_matrix;
23 64 }
24
25 64 bool LobanovDMultiplyMatrixSEQ::ValidationImpl() {
26 const auto &[matrix_a, matrix_b] = GetInput();
27
5/10
✓ Branch 0 taken 64 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 64 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 64 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 64 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✓ Branch 9 taken 64 times.
 64 return (matrix_a.row_count > 0 && matrix_a.column_count > 0 && matrix_b.row_count > 0 && matrix_b.column_count > 0 &&
28 64 matrix_a.column_count == matrix_b.row_count);
29 }
30
31 64 bool LobanovDMultiplyMatrixSEQ::PreProcessingImpl() {
32 64 return true;
33 }
34
35 64 void LobanovDMultiplyMatrixSEQ::ComputeTransposedMatrix(const CompressedColumnMatrix &source_matrix,
36 CompressedColumnMatrix &transposed_result) {
37 64 transposed_result.row_count = source_matrix.column_count;
38 64 transposed_result.column_count = source_matrix.row_count;
39 64 transposed_result.non_zero_count = source_matrix.non_zero_count;
40
41
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 64 times.
 64 if (source_matrix.non_zero_count == 0) {
42 transposed_result.value_data.clear();
43 transposed_result.row_index_data.clear();
44 ✗ transposed_result.column_pointer_data = std::vector<int>(transposed_result.column_count + 1);
45 ✗ return;
46 }
47
48 struct Element {
49 int new_col;
50 int new_row;
51 double value;
52 };
53
54 64 std::vector<Element> elements;
55
1/2
✓ Branch 1 taken 64 times.
✗ Branch 2 not taken.
 64 elements.reserve(source_matrix.non_zero_count);
56
57
2/2
✓ Branch 0 taken 1640 times.
✓ Branch 1 taken 64 times.
 1704 for (int old_col = 0; old_col < source_matrix.column_count; old_col++) {
58
2/2
✓ Branch 0 taken 7752 times.
✓ Branch 1 taken 1640 times.
 9392 for (int pos = source_matrix.column_pointer_data[old_col]; pos < source_matrix.column_pointer_data[old_col + 1];
59 pos++) {
60
1/2
✓ Branch 1 taken 7752 times.
✗ Branch 2 not taken.
 7752 int old_row = source_matrix.row_index_data[pos];
61
1/4
✓ Branch 1 taken 7752 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 7752 elements.push_back({old_row, old_col, source_matrix.value_data[pos]});
62 }
63 }
64
65 64 std::ranges::sort(elements.begin(), elements.end(), [](const Element &a, const Element &b) {
66
54/72
✗ Branch 0 not taken.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✓ Branch 12 taken 12064 times.
✓ Branch 13 taken 14240 times.
✓ Branch 14 taken 11264 times.
✓ Branch 15 taken 2976 times.
✓ Branch 16 taken 6760 times.
✓ Branch 17 taken 4504 times.
✓ Branch 18 taken 14248 times.
✓ Branch 19 taken 10016 times.
✓ Branch 20 taken 2336 times.
✓ Branch 21 taken 7680 times.
✓ Branch 22 taken 1144 times.
✓ Branch 23 taken 1192 times.
✓ Branch 24 taken 9960 times.
✓ Branch 25 taken 10520 times.
✓ Branch 26 taken 2088 times.
✓ Branch 27 taken 7872 times.
✓ Branch 28 taken 1088 times.
✓ Branch 29 taken 1000 times.
✓ Branch 30 taken 328 times.
✓ Branch 31 taken 504 times.
✓ Branch 32 taken 272 times.
✓ Branch 33 taken 112 times.
✓ Branch 34 taken 184 times.
✓ Branch 35 taken 320 times.
✓ Branch 36 taken 56 times.
✓ Branch 37 taken 128 times.
✓ Branch 38 taken 112 times.
✓ Branch 39 taken 160 times.
✓ Branch 40 taken 72 times.
✓ Branch 41 taken 40 times.
✓ Branch 42 taken 104 times.
✓ Branch 43 taken 96 times.
✓ Branch 44 taken 40 times.
✓ Branch 45 taken 64 times.
✓ Branch 46 taken 8 times.
✓ Branch 47 taken 32 times.
✓ Branch 48 taken 280 times.
✓ Branch 49 taken 168 times.
✓ Branch 50 taken 56 times.
✓ Branch 51 taken 224 times.
✓ Branch 52 taken 32 times.
✓ Branch 53 taken 24 times.
✓ Branch 54 taken 160 times.
✓ Branch 55 taken 88 times.
✓ Branch 56 taken 72 times.
✓ Branch 57 taken 88 times.
✓ Branch 58 taken 56 times.
✓ Branch 59 taken 16 times.
✗ Branch 60 not taken.
✗ Branch 61 not taken.
✗ Branch 62 not taken.
✗ Branch 63 not taken.
✗ Branch 64 not taken.
✗ Branch 65 not taken.
✓ Branch 66 taken 64 times.
✓ Branch 67 taken 896 times.
✓ Branch 68 taken 248 times.
✓ Branch 69 taken 648 times.
✓ Branch 70 taken 144 times.
✓ Branch 71 taken 104 times.
 72840 return (a.new_col < b.new_col) || (a.new_col == b.new_col && a.new_row < b.new_row);
67 });
68
69
1/2
✓ Branch 1 taken 64 times.
✗ Branch 2 not taken.
 64 transposed_result.value_data.resize(source_matrix.non_zero_count);
70
1/2
✓ Branch 1 taken 64 times.
✗ Branch 2 not taken.
 64 transposed_result.row_index_data.resize(source_matrix.non_zero_count);
71
1/2
✓ Branch 1 taken 64 times.
✗ Branch 2 not taken.
 64 transposed_result.column_pointer_data.resize(transposed_result.column_count + 1);
72
73 64 transposed_result.column_pointer_data[0] = 0;
74 int current_col = 0;
75 int idx = 0;
76
77
2/2
✓ Branch 0 taken 7752 times.
✓ Branch 1 taken 64 times.
 7816 for (const auto &elem : elements) {
78 7752 transposed_result.value_data[idx] = elem.value;
79 7752 transposed_result.row_index_data[idx] = elem.new_row;
80 7752 idx++;
81
82
2/2
✓ Branch 0 taken 1616 times.
✓ Branch 1 taken 7752 times.
 9368 while (current_col < elem.new_col) {
83 1616 transposed_result.column_pointer_data[current_col + 1] = idx;
84 current_col++;
85 }
86 }
87
88
2/2
✓ Branch 0 taken 64 times.
✓ Branch 1 taken 64 times.
 128 while (current_col < transposed_result.column_count) {
89 64 transposed_result.column_pointer_data[current_col + 1] = idx;
90 current_col++;
91 }
92 }
93
94 namespace {
95
96 1664 void ProcessMatrixColumn(const CompressedColumnMatrix &transposed_a, const CompressedColumnMatrix &matrix_b,
97 int target_column, std::vector<double> &temporary_values, std::vector<int> &column_markers,
98 std::vector<double> &result_values, std::vector<int> &result_row_indices) {
99 9368 for (int b_pointer = matrix_b.column_pointer_data[target_column];
100
2/2
✓ Branch 0 taken 7704 times.
✓ Branch 1 taken 1664 times.
 9368 b_pointer < matrix_b.column_pointer_data[target_column + 1]; b_pointer++) {
101 7704 int b_row = matrix_b.row_index_data[b_pointer];
102 7704 double b_value = matrix_b.value_data[b_pointer];
103
104 51696 for (int a_pointer = transposed_a.column_pointer_data[b_row];
105
2/2
✓ Branch 0 taken 43992 times.
✓ Branch 1 taken 7704 times.
 51696 a_pointer < transposed_a.column_pointer_data[b_row + 1]; a_pointer++) {
106
2/2
✓ Branch 0 taken 31864 times.
✓ Branch 1 taken 12128 times.
 43992 int a_row = transposed_a.row_index_data[a_pointer];
107 43992 double a_value = transposed_a.value_data[a_pointer];
108
109
2/2
✓ Branch 0 taken 31864 times.
✓ Branch 1 taken 12128 times.
 43992 if (column_markers[a_row] != target_column) {
110 31864 column_markers[a_row] = target_column;
111 31864 temporary_values[a_row] = a_value * b_value;
112 } else {
113 12128 temporary_values[a_row] += a_value * b_value;
114 }
115 }
116 }
117
118
2/2
✓ Branch 0 taken 104640 times.
✓ Branch 1 taken 1664 times.
 106304 for (size_t row_index = 0; row_index < temporary_values.size(); row_index++) {
119
3/4
✓ Branch 0 taken 31864 times.
✓ Branch 1 taken 72776 times.
✓ Branch 2 taken 31864 times.
✗ Branch 3 not taken.
 104640 if (column_markers[row_index] == target_column && std::abs(temporary_values[row_index]) > kEpsilonThreshold) {
120 result_values.push_back(temporary_values[row_index]);
121 31864 result_row_indices.push_back(static_cast<int>(row_index));
122 }
123 }
124 1664 }
125
126 } // namespace
127
128 64 void LobanovDMultiplyMatrixSEQ::PerformMatrixMultiplication(const CompressedColumnMatrix &first_matrix,
129 const CompressedColumnMatrix &second_matrix,
130 CompressedColumnMatrix &product_result) {
131 64 CompressedColumnMatrix transposed_first = {};
132 transposed_first.row_count = 0;
133 transposed_first.column_count = 0;
134 transposed_first.non_zero_count = 0;
135
136
1/2
✓ Branch 1 taken 64 times.
✗ Branch 2 not taken.
 64 ComputeTransposedMatrix(first_matrix, transposed_first);
137
138 64 product_result.row_count = first_matrix.row_count;
139 64 product_result.column_count = second_matrix.column_count;
140
141
1/2
✓ Branch 1 taken 64 times.
✗ Branch 2 not taken.
 64 product_result.column_pointer_data = {0};
142
143 64 int result_rows = product_result.row_count;
144
1/2
✓ Branch 1 taken 64 times.
✗ Branch 2 not taken.
 64 std::vector<double> column_temporary_values(result_rows, 0.0);
145
1/4
✓ Branch 1 taken 64 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 64 std::vector<int> column_marker_tracker(result_rows, -1);
146
147 64 int cols_to_process = second_matrix.column_count;
148
2/2
✓ Branch 0 taken 1664 times.
✓ Branch 1 taken 64 times.
 1728 for (int column_index = 0; column_index < cols_to_process; column_index++) {
149 1664 ProcessMatrixColumn(transposed_first, second_matrix, column_index, column_temporary_values, column_marker_tracker,
150
1/2
✓ Branch 1 taken 1664 times.
✗ Branch 2 not taken.
 1664 product_result.value_data, product_result.row_index_data);
151
152
1/4
✓ Branch 1 taken 1664 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 1664 product_result.column_pointer_data.push_back(static_cast<int>(product_result.value_data.size()));
153 }
154
155
1/2
✓ Branch 0 taken 64 times.
✗ Branch 1 not taken.
 64 product_result.non_zero_count = static_cast<int>(product_result.value_data.size());
156 64 }
157
158
1/2
✓ Branch 1 taken 64 times.
✗ Branch 2 not taken.
 64 bool LobanovDMultiplyMatrixSEQ::RunImpl() {
159 const auto &[matrix_a, matrix_b] = GetInput();
160
161 try {
162 64 CompressedColumnMatrix result_matrix;
163 result_matrix.row_count = 0;
164 result_matrix.column_count = 0;
165 result_matrix.non_zero_count = 0;
166
167
1/2
✓ Branch 1 taken 64 times.
✗ Branch 2 not taken.
 64 PerformMatrixMultiplication(matrix_a, matrix_b, result_matrix);
168
1/2
✓ Branch 1 taken 64 times.
✗ Branch 2 not taken.
 64 GetOutput() = result_matrix;
169 return true;
170
0/2
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 64 } catch (const std::exception &) {
171 return false;
172 ✗ }
173 }
174
175 64 bool LobanovDMultiplyMatrixSEQ::PostProcessingImpl() {
176 const auto &result_matrix = GetOutput();
177
2/4
✓ Branch 0 taken 64 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 64 times.
 64 return result_matrix.row_count > 0 && result_matrix.column_count > 0 &&
178
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 64 times.
 64 result_matrix.column_pointer_data.size() == static_cast<size_t>(result_matrix.column_count) + 1;
179 }
180
181 } // namespace lobanov_d_multiply_matrix_ccs
182