Johan Bregeon / gammalib

Commit b4ded5bf079bf7b2c29e4bec9ef7deed4e6bc10a

Authored by Jürgen Knödlseder
1 parent a4f1132c

Improve the error messages. 

Improve some error messages so that more information is available in the report in case of failures.
Inline Side-by-side
Showing 3 changed files with 733 additions and 671 deletions
test/test_GMatrix.cpp
  View file @b4ded5b
1 /*************************************************************************** 1 /***************************************************************************
2 - * test_GMatrix.cpp - test GMatrix class * 2 + * test_GMatrix.cpp - Test generic matrix class *
3 * ----------------------------------------------------------------------- * 3 * ----------------------------------------------------------------------- *
4 - * copyright (C) 2006-2011 by Jurgen Knodlseder * 4 + * copyright (C) 2006-2012 by Juergen Knoedlseder *
5 * ----------------------------------------------------------------------- * 5 * ----------------------------------------------------------------------- *
6 * * 6 * *
7 * This program is free software: you can redistribute it and/or modify * 7 * This program is free software: you can redistribute it and/or modify *
@@ -18,778 +18,834 @@ @@ -18,778 +18,834 @@
18 * along with this program. If not, see <http://www.gnu.org/licenses/>. * 18 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
19 * * 19 * *
20 ***************************************************************************/ 20 ***************************************************************************/
  21 +/**
  22 + * @file test_GMatrix.cpp
  23 + * @brief Implementation of unit tests for generic matrices
  24 + * @author Juergen Knoedlseder
  25 + */
21 26
22 /* __ Includes ___________________________________________________________ */ 27 /* __ Includes ___________________________________________________________ */
  28 +#ifdef HAVE_CONFIG_H
  29 +#include <config.h>
  30 +#endif
23 #include <cmath> 31 #include <cmath>
24 -#include <iostream> // std::cout, cerr  
25 -#include <stdexcept> // std::exception  
26 -#include "GammaLib.hpp"  
27 #include "test_GMatrix.hpp" 32 #include "test_GMatrix.hpp"
28 -/* __ Namespaces _________________________________________________________ */  
29 33
30 /* __ Globals ____________________________________________________________ */ 34 /* __ Globals ____________________________________________________________ */
  35 +double g_matrix[] = {1.0, 2.0, 3.0, 4.0,
  36 + 5.0, 6.0, 7.0, 8.0,
  37 + 9.0, 10., 11., 12.};
  38 +double g_vector[] = {1.0, 2.0, 3.0, 4.0};
  39 +int g_rows = 3;
  40 +int g_cols = 4;
31 41
32 -void TestGMatrix::set(void){  
33 - // Test name  
34 - name("GMatrix");  
35 -  
36 - //Initialize m_test  
37 - init_matrix();  
38 -  
39 - //Initialize m_vector  
40 - init_vector();  
41 -  
42 - //Set parameters  
43 - m_g_rows = 3;  
44 - m_g_cols = 4;  
45 -  
46 - //add tests  
47 - add_test(static_cast<pfunction>(&TestGMatrix::set_matrix),"Set matrix");  
48 - add_test(static_cast<pfunction>(&TestGMatrix::set_vector),"Set Vector");  
49 - add_test(static_cast<pfunction>(&TestGMatrix::set_bigger),"Set matrix bigger");  
50 - add_test(static_cast<pfunction>(&TestGMatrix::test_output),"Output test matrix");  
51 - add_test(static_cast<pfunction>(&TestGMatrix::test_conversion),"Matrix conversions");  
52 - add_test(static_cast<pfunction>(&TestGMatrix::test_extract),"Vector extraction, insertion and addition");  
53 -  
54 - add_test(static_cast<pfunction>(&TestGMatrix::test1),"Test 1: Allocate zero matrix");  
55 - //add_test(static_cast<pfunction>(&TestGMatrix::test2),"Test 2: Allocate too large matrix");  
56 - add_test(static_cast<pfunction>(&TestGMatrix::test3),"Test3: Assign values");  
57 - add_test(static_cast<pfunction>(&TestGMatrix::test4),"Test 4: Matrix copy constructor");  
58 - add_test(static_cast<pfunction>(&TestGMatrix::test5),"Test 5: Matrix assignment");  
59 - add_test(static_cast<pfunction>(&TestGMatrix::test6),"Test 6: Transposition");  
60 - add_test(static_cast<pfunction>(&TestGMatrix::test7),"Test 7: Matrix*Vector multiplication");  
61 - add_test(static_cast<pfunction>(&TestGMatrix::test8),"Test 8: Matrix*Matrix multiplication");  
62 - add_test(static_cast<pfunction>(&TestGMatrix::test9),"Test 9: Assignment and arithmetics");  
63 - add_test(static_cast<pfunction>(&TestGMatrix::test10),"Test 10: Matrix functions");  
64 - add_test(static_cast<pfunction>(&TestGMatrix::test11),"Test 11: Matrix comparison");  
65 -  
66 - return;  
67 -}  
68 42
69 /*************************************************************************** 43 /***************************************************************************
70 -* Initializer m_test *  
71 -***************************************************************************/  
72 -void TestGMatrix::init_matrix(void) 44 + * @brief Set test matrix
  45 + ***************************************************************************/
  46 +GMatrix TestGMatrix::set_matrix(void) const
73 { 47 {
74 - double g_matrix[] = {1.0, 2.0, 3.0, 4.0,  
75 - 5.0, 6.0, 7.0, 8.0,  
76 - 9.0, 10., 11., 12.}; 48 + // Allocate matrix
  49 + GMatrix matrix(g_rows,g_cols);
77 50
78 - for(int i=0;i<12;i++){  
79 - m_g_matrix[i]=g_matrix[i]; 51 + // Set matrix values
  52 + for (int row = 0; row < g_rows; ++row) {
  53 + for (int col = 0; col < g_cols; ++col) {
  54 + matrix(row,col) = g_matrix[col+row*g_cols];
  55 + }
80 } 56 }
81 57
82 - return; 58 + // Return matrix
  59 + return matrix;
83 } 60 }
84 61
85 -/***************************************************************************  
86 -* Initializer m_vector *  
87 -***************************************************************************/  
88 -void TestGMatrix::init_vector(void)  
89 -{  
90 - double g_vector[] = {1.0, 2.0, 3.0, 4.0};  
91 -  
92 - for(int i=0;i<4;i++){  
93 - m_g_vector[i]=g_vector[i];  
94 - }  
95 -  
96 - return;  
97 -}  
98 62
99 /*************************************************************************** 63 /***************************************************************************
100 - * Set test matrix * 64 + * @brief Set test matrix with zero lines
101 ***************************************************************************/ 65 ***************************************************************************/
102 -void TestGMatrix::set_matrix(void) 66 +GMatrix TestGMatrix::set_matrix_zero(void) const
103 { 67 {
104 - GMatrix matrix(m_g_rows,m_g_cols);  
105 - for (int row = 0; row < m_g_rows; ++row) {  
106 - for (int col = 0; col < m_g_cols; ++col)  
107 - matrix(row,col) = m_g_matrix[col+row*m_g_cols]; 68 + // Allocate matrix
  69 + GMatrix matrix(g_rows+1,g_cols+1);
  70 +
  71 + // Set matrix values
  72 + int i = 0;
  73 + for (int row = 0; row < g_rows+1; ++row) {
  74 + if (row == 2) continue;
  75 + int j = 0;
  76 + for (int col = 0; col < g_cols+1; ++col) {
  77 + if (col == 2) continue;
  78 + matrix(row,col) = g_matrix[j+i*g_cols];
  79 + j++;
  80 + }
  81 + i++;
108 } 82 }
109 83
110 - m_test = matrix;  
111 -  
112 - return; 84 + // Return matrix
  85 + return matrix;
113 } 86 }
114 87
115 88
116 /*************************************************************************** 89 /***************************************************************************
117 - * Set test vector * 90 + * @brief Set test vector
118 ***************************************************************************/ 91 ***************************************************************************/
119 -void TestGMatrix::set_vector(void) 92 +GVector TestGMatrix::set_vector(void) const
120 { 93 {
121 - GVector vector(m_g_cols);  
122 - for (int col = 0; col < m_g_cols; ++col){  
123 - vector[col] = m_g_vector[col];  
124 - } 94 + // Allocate vector
  95 + GVector vector(g_cols);
125 96
126 - v_test = vector; 97 + // Set vector values
  98 + for (int col = 0; col < g_cols; ++col) {
  99 + vector[col] = g_vector[col];
  100 + }
127 101
128 - return; 102 + // Return vector
  103 + return vector;
129 } 104 }
130 105
131 -void TestGMatrix::set_bigger(void)  
132 -{  
133 - bigger= GMatrix(m_g_rows+1,m_g_cols+1);  
134 -} 106 +
135 /*************************************************************************** 107 /***************************************************************************
136 - * Check test matrix * 108 + * @brief Check if matrix corresponds to test matrix
  109 + *
  110 + * @param[in] matrix Matrix.
  111 + * @param[in] scale scale factor (default: 1.0).
  112 + * @param[in] offset offset value (default: 0.0).
  113 + *
  114 + * Checks if a matrix corresponds to the test matrix. Optionally, the test
  115 + * matrix can be scaled and an offset can be added.
137 ***************************************************************************/ 116 ***************************************************************************/
138 -int TestGMatrix::check_matrix(const GMatrix& m, const double scale, const double add) 117 +bool TestGMatrix::check_matrix(const GMatrix& matrix,
  118 + const double& scale,
  119 + const double& offset) const
139 { 120 {
140 - int result = 1;  
141 -  
142 - for (int row = 0; row < m_g_rows; ++row) {  
143 - for (int col = 0; col < m_g_cols; ++col) {  
144 - double value = m_g_matrix[col+row*m_g_cols] * scale + add;  
145 - if (fabs(m(row,col)-value) > 1.0e-15) {  
146 - result = 0; 121 + // Initialise check with true
  122 + bool result = true;
  123 +
  124 + // Compare all matrix elements
  125 + for (int row = 0; row < g_rows; ++row) {
  126 + for (int col = 0; col < g_cols; ++col) {
  127 + double value = g_matrix[col+row*g_cols] * scale + offset;
  128 + if (std::abs(matrix(row,col)-value) > 1.0e-15) {
  129 + result = false;
147 break; 130 break;
148 - }  
149 - } 131 + }
150 } 132 }
  133 + }
151 134
  135 + // Return result
152 return result; 136 return result;
153 } 137 }
154 138
155 139
156 /*************************************************************************** 140 /***************************************************************************
157 - * Check transposed test matrix * 141 + * @brief Check if transposed matrix corresponds to test matrix
  142 + *
  143 + * @param[in] matrix Trasposed matrix.
  144 + * @param[in] scale scale factor (default: 1.0).
  145 + * @param[in] offset offset value (default: 0.0).
  146 + *
  147 + * Checks if a matrix corresponds to the test matrix. Optionally, the test
  148 + * matrix can be scaled and an offset can be added.
158 ***************************************************************************/ 149 ***************************************************************************/
159 -int TestGMatrix::check_transpose_matrix(const GMatrix& m, const double scale, const double add) 150 +bool TestGMatrix::check_matrix_trans(const GMatrix& matrix,
  151 + const double& scale,
  152 + const double& offset) const
160 { 153 {
161 - int result = 1;  
162 -  
163 - for (int row = 0; row < m_g_rows; ++row) {  
164 - for (int col = 0; col < m_g_cols; ++col) {  
165 - double value = m_g_matrix[col+row*m_g_cols] * scale + add;  
166 - if (m(col,row) != value) {  
167 - result = 0; 154 + // Initialise check with true
  155 + bool result = true;
  156 +
  157 + // Compare all matrix elements
  158 + for (int row = 0; row < g_rows; ++row) {
  159 + for (int col = 0; col < g_cols; ++col) {
  160 + double value = g_matrix[col+row*g_cols] * scale + offset;
  161 + if (std::abs(matrix(col,row)-value) > 1.0e-15) {
  162 + result = false;
168 break; 163 break;
169 - }  
170 - } 164 + }
171 } 165 }
  166 + }
172 167
  168 + // Return result
173 return result; 169 return result;
174 } 170 }
175 171
176 172
177 /*************************************************************************** 173 /***************************************************************************
178 - * Check full test matrix (lower triangle) * 174 + * @brief Check lower triangle general matrix
  175 + *
  176 + * @param[in] matrix Matrix.
  177 + * @param[in] ref Reference matrix.
179 ***************************************************************************/ 178 ***************************************************************************/
180 -int TestGMatrix::check_matrix_lt(const GMatrix& m, const double scale, const double add) 179 +bool TestGMatrix::check_matrix_lt(const GMatrix& matrix,
  180 + const GMatrix& ref) const
181 { 181 {
182 - int result = 1;  
183 - test_try("Check full test matrix (lower triangle)");  
184 - try {  
185 - for (int row = 0; row < m_g_rows; ++row) {  
186 - for (int col = 0; col < m_g_cols; ++col) {  
187 - double value = (col <= row) ? m_g_matrix[col+row*m_g_cols] * scale + add : 0.0;  
188 - if (m(row,col) != value) {  
189 - result = 0;  
190 - break;  
191 - }  
192 - } 182 + // Initialise check with true
  183 + bool result = true;
  184 +
  185 + // Compare all matrix elements
  186 + for (int row = 0; row < ref.rows(); ++row) {
  187 + for (int col = 0; col < ref.cols(); ++col) {
  188 + double value = (col <= row) ? ref(row,col) : 0.0;
  189 + if (matrix(row,col) != value) {
  190 + result = false;
  191 + break;
193 } 192 }
194 - test_try_success();  
195 - }  
196 - catch (std::exception &e) {  
197 - test_try_failure(e);  
198 - }  
199 - return result;  
200 -}  
201 - 193 + }
  194 + }
202 195
203 -/***************************************************************************  
204 - * Check full test matrix (upper triangle) *  
205 - ***************************************************************************/  
206 -int TestGMatrix::check_matrix_ut(const GMatrix& m, const double scale, const double add)  
207 -{  
208 - int result = 1;  
209 - test_try("Check full test matrix (upper triangle)");  
210 - try {  
211 - for (int row = 0; row < m_g_rows; ++row) {  
212 - for (int col = 0; col < m_g_cols; ++col) {  
213 - double value = (col >= row) ? m_g_matrix[col+row*m_g_cols] * scale + add : 0.0;  
214 - if (m(row,col) != value) {  
215 - result = 0;  
216 - break;  
217 - }  
218 - }  
219 - }  
220 - test_try_success();  
221 - }  
222 - catch (std::exception &e) {  
223 - test_try_failure(e);  
224 - } 196 + // Return result
225 return result; 197 return result;
226 } 198 }
227 199
228 200
229 /*************************************************************************** 201 /***************************************************************************
230 - * Check matrix*vector * 202 + * @brief Check upper triangle general matrix
  203 + *
  204 + * @param[in] matrix Matrix.
  205 + * @param[in] ref Reference matrix.
231 ***************************************************************************/ 206 ***************************************************************************/
232 -int TestGMatrix::check_matrix_vector(const GVector& v) 207 +bool TestGMatrix::check_matrix_ut(const GMatrix& matrix,
  208 + const GMatrix& ref) const
233 { 209 {
234 - int result = 1;  
235 - test_try(" Check matrix*vector");  
236 - try {  
237 - for (int row = 0; row < v.size(); ++row) {  
238 - double value = 0.0;  
239 - for (int col = 0; col < m_g_cols; ++col)  
240 - value += m_g_matrix[col+row*m_g_cols] * m_g_vector[col];  
241 - if (v[row] != value) {  
242 - result = 0; 210 + // Initialise check with true
  211 + bool result = true;
  212 +
  213 + // Compare all matrix elements
  214 + for (int row = 0; row < ref.rows(); ++row) {
  215 + for (int col = 0; col < ref.cols(); ++col) {
  216 + double value = (col >= row) ? ref(row,col) : 0.0;
  217 + if (matrix(row,col) != value) {
  218 + result = false;
243 break; 219 break;
244 } 220 }
245 } 221 }
246 - test_try_success();  
247 - }  
248 - catch (std::exception &e) {  
249 - test_try_failure(e);  
250 - }  
251 - return result;  
252 -}  
253 -  
254 -  
255 -/***************************************************************************  
256 - * Check matrix*matrix *  
257 - ***************************************************************************/  
258 -int TestGMatrix::check_matrix_matrix(const GMatrix& m)  
259 -{  
260 - if (m.rows() != m_g_rows || m.cols() != m_g_rows)  
261 - return 0;  
262 - int result = 1;  
263 - test_try("Check matrix*matrix");  
264 - try {  
265 - for (int row = 0; row < m.rows(); ++row) {  
266 - for (int col = 0; col < m.cols(); ++col) {  
267 - double value = 0.0;  
268 - for (int i = 0; i < m_g_cols; ++i)  
269 - value += m_g_matrix[i+row*m_g_cols] * m_g_matrix[i+col*m_g_cols];  
270 - if (m(row,col) != value) {  
271 - result = 0;  
272 - break;  
273 - }  
274 - }  
275 } 222 }
276 - test_try_success();  
277 - }  
278 - catch (std::exception &e) {  
279 - test_try_failure(e);  
280 - }  
281 - return result;  
282 -}  
283 -  
284 -  
285 -/***************************************************************************  
286 - * Check matrix min *  
287 - ***************************************************************************/  
288 -int TestGMatrix::check_matrix_min(const double min)  
289 -{  
290 - double value = m_g_matrix[0];  
291 - for (int row = 0; row < m_g_rows; ++row) {  
292 - for (int col = 0; col < m_g_cols; ++col) {  
293 - if (m_g_matrix[col+row*m_g_cols] < value)  
294 - value = m_g_matrix[col+row*m_g_cols];  
295 - }  
296 - }  
297 - test_assert(min==value, "Check matrix min");  
298 - return (min == value);  
299 -}  
300 223
301 -  
302 -/***************************************************************************  
303 - * Check matrix max *  
304 - ***************************************************************************/  
305 -int TestGMatrix::check_matrix_max(const double max)  
306 -{  
307 - double value = m_g_matrix[0];  
308 - for (int row = 0; row < m_g_rows; ++row) {  
309 - for (int col = 0; col < m_g_cols; ++col) {  
310 - if (m_g_matrix[col+row*m_g_cols] > value)  
311 - value = m_g_matrix[col+row*m_g_cols];  
312 - }  
313 - }  
314 - test_assert(max==value,"Check matrix max");  
315 - return (max == value); 224 + // Return result
  225 + return result;
316 } 226 }
317 227
318 228
319 -/***************************************************************************  
320 - * Check matrix sum *  
321 - ***************************************************************************/  
322 -int TestGMatrix::check_matrix_sum(const double sum) 229 +/***********************************************************************//**
  230 + * @brief Set parameters and tests
  231 + **************************************************************************/
  232 +void TestGMatrix::set(void)
323 { 233 {
324 - double value = 0.0;  
325 - for (int row = 0; row < m_g_rows; ++row) {  
326 - for (int col = 0; col < m_g_cols; ++col)  
327 - value += m_g_matrix[col+row*m_g_cols];  
328 - }  
329 - test_assert(sum==value,"Check matrix sum");  
330 - return (sum == value);  
331 -} 234 + // Set test name
  235 + name("GMatrix");
332 236
  237 + // Add tests
  238 + append(static_cast<pfunction>(&TestGMatrix::alloc_matrix), "Test matrix allocation");
  239 + append(static_cast<pfunction>(&TestGMatrix::assign_values), "Test value assignment");
  240 + append(static_cast<pfunction>(&TestGMatrix::copy_matrix), "Test matrix copying");
  241 + append(static_cast<pfunction>(&TestGMatrix::matrix_operations), "Test matrix operations");
  242 + append(static_cast<pfunction>(&TestGMatrix::matrix_arithmetics), "Test matrix arithmetics");
  243 + append(static_cast<pfunction>(&TestGMatrix::matrix_functions), "Test matrix functions");
  244 + append(static_cast<pfunction>(&TestGMatrix::matrix_compare), "Test matrix comparisons");
  245 + //append(static_cast<pfunction>(&TestGMatrix::matrix_cholesky), "Test matrix Cholesky decomposition");
  246 + append(static_cast<pfunction>(&TestGMatrix::matrix_print), "Test matrix printing");
  247 +
  248 + // Set members
  249 + m_test = set_matrix();
  250 + v_test = set_vector();
  251 + m_bigger = GMatrix(g_rows+1, g_cols+1);
333 252
334 -/***************************************************************************  
335 - * Test: Output *  
336 - ***************************************************************************/  
337 -void TestGMatrix::test_output(void)  
338 -{  
339 - std::cout << "Output test matrix"<<std::endl<< m_test << std::endl; 253 + // Return
  254 + return;
340 } 255 }
341 256
342 257
343 -/***************************************************************************  
344 - * Test: Conversion between matrix types * 258 +/***********************************************************************//**
  259 + * @brief Test matrix allocation
345 ***************************************************************************/ 260 ***************************************************************************/
346 -void TestGMatrix::test_conversion(void) 261 +void TestGMatrix::alloc_matrix(void)
347 { 262 {
348 - //  
349 - // Setup a symmetric matrix  
350 - int num = 10;  
351 - GMatrix symmetric(num,num);  
352 - for (int i = 0; i < num; ++i) {  
353 - for (int j = 0; j < num; ++j)  
354 - symmetric(i,j) = (i+j+1)/2.0;  
355 - }  
356 -  
357 - //  
358 - // Convert symmetric matrix into GSymMatrix object  
359 - // GSymMatrix converted = sym_matrix(symmetric);  
360 - GSymMatrix converted = GSymMatrix(symmetric);  
361 -  
362 - //  
363 - // Convert GSymMatrix back to full matrix  
364 - GMatrix back_convert = matrix(converted);  
365 -  
366 - //  
367 - // Compare back converted matrix to original one. They should be identical  
368 - test_assert(symmetric == back_convert,"Compare back converted matrix to original one");  
369 - //  
370 - // Determine the fill of the matrix. It should be 1.0  
371 - double fill = back_convert.fill();  
372 - test_assert(fabs(fill-1.0) <= 1.0e-15,"Test the fill of the matrix","Bad fill "+str(fill)+" determined (expected 1.0).");  
373 - //  
374 - // Extract lower triangle and check values  
375 - GMatrix lower = symmetric.extract_lower_triangle();  
376 - int ok = 1;  
377 - for (int j = 1; j < num; ++j) {  
378 - for (int i = 0; i < j; ++i) {  
379 - if (lower(i,j) != 0.0)  
380 - ok = 0;  
381 - }  
382 - }  
383 - for (int j = 0; j < num; ++j) {  
384 - for (int i = j; i < num; ++i) {  
385 - if (lower(i,j) != symmetric(i,j))  
386 - ok = 0;  
387 - }  
388 - }  
389 - test_assert(ok,"Extract lower triangle");  
390 -  
391 - //  
392 - // Extract upper triangle and check values  
393 - GMatrix upper = symmetric.extract_upper_triangle();  
394 - ok = 1;  
395 - for (int j = 0; j < num; ++j) {  
396 - for (int i = j+1; i < num; ++i) {  
397 - if (upper(i,j) != 0.0)  
398 - ok = 0;  
399 - }  
400 - }  
401 - for (int j = 0; j < num; ++j) {  
402 - for (int i = 0; i <= j; ++i) {  
403 - if (upper(i,j) != symmetric(i,j))  
404 - ok = 0;  
405 - }  
406 - }  
407 -  
408 - test_assert(ok,"Extract upper triangle","Corrupt extract_upper_triangle.");  
409 -  
410 - //  
411 - // Now make the matrix unsymmetric  
412 - symmetric(0,num-1) = 1000.0;  
413 - //  
414 - // Try converting now into GSymMatrix object (this should fail)  
415 - test_try("Try converting now into GSymMatrix object"); 263 + // Allocate zero matrix. The allocation should fail.
  264 + test_try("Allocate zero matrix");
416 try { 265 try {
417 - converted = sym_matrix(symmetric);  
418 - test_try_failure(); 266 + GMatrix test(0,0);
  267 + test_try_failure("Expected GException::empty exception.");
419 } 268 }
420 - catch (GException::matrix_not_symmetric &e) { 269 + catch (GException::empty &e) {
421 test_try_success(); 270 test_try_success();
422 } 271 }
423 catch (std::exception &e) { 272 catch (std::exception &e) {
424 test_try_failure(e); 273 test_try_failure(e);
425 } 274 }
426 - //  
427 - // Now zero some elements to emulate a sparse matrix  
428 - symmetric(0,num-1) = 0.0;  
429 - for (int i = 5; i < 8; ++i) {  
430 - for (int j = i-2; j < i+2; ++j)  
431 - symmetric(i,j) = 0.0;  
432 - }  
433 -  
434 - //  
435 - // Convert symmetric matrix into GSparseMatrix object  
436 - GSparseMatrix sparse = sparse_matrix(symmetric);  
437 - //  
438 - // Convert GSparseMatrix back to full matrix  
439 - back_convert = matrix(sparse);  
440 - //  
441 - // Compare back converted matrix to original one. They should be identical  
442 - test_assert(symmetric == back_convert,  
443 - "Compare back converted matrix to original one",  
444 - "Unable to convert matrixes (sparse)");  
445 275
446 // Return 276 // Return
447 return; 277 return;
448 } 278 }
449 279
450 280
451 -/***************************************************************************  
452 - * Test: extraction and insertion * 281 +/***********************************************************************//**
  282 + * @brief Test value assignment
453 ***************************************************************************/ 283 ***************************************************************************/
454 -void TestGMatrix::test_extract(void) 284 +void TestGMatrix::assign_values(void)
455 { 285 {
456 -  
457 - //  
458 - // Set-up test matrix  
459 - int rows = 10;  
460 - int cols = 20;  
461 - GMatrix test(rows, cols);  
462 -  
463 - //  
464 - // Add and extract column vectors  
465 - test_try("Add and extract column vectors");  
466 - try  
467 - {  
468 - for (int col = 0; col < cols; ++col) {  
469 - GVector column(rows);  
470 - for (int row = 0; row < rows; ++row)  
471 - column[row] = (col+1)*100.0 + (row+1)*1.0;  
472 - test.add_col(column, col);  
473 - GVector check = test.extract_col(col);  
474 - if (check != column) {  
475 - throw exception_failure("Unable to add and extract columns.\nAdded column ...: "+column.print()+"\nExtracted column: "+check.print());  
476 - } 286 + // Setup 3x3 matrix
  287 + GMatrix test(3,3);
  288 +
  289 + // Assignment individual values
  290 + for (int i = 0; i < 3; ++i) {
  291 + for (int k = 0; k < 3; ++k) {
  292 + double value = i*2.0 + k*2.0;
  293 + test(i,k) = value;
477 } 294 }
478 - test_try_success();  
479 - }  
480 - catch(std::exception& e)  
481 - {  
482 - test_try_failure(e);  
483 } 295 }
484 296
485 - //  
486 - // Insert and extract column vectors  
487 - test_try("Insert and extract column vectors");  
488 - try  
489 - {  
490 - for (int col = 0; col < cols; ++col) {  
491 - GVector column(rows);  
492 - for (int row = 0; row < rows; ++row)  
493 - column[row] = (col+1)*100.0 + (row+1)*1.0;  
494 - test.insert_col(column, col);  
495 - GVector check = test.extract_col(col);  
496 - if (check != column) {  
497 - throw exception_failure("Unable to insert and extract columns.\nIserted column ...: "+column.print()+"\nExtracted column: "+check.print());  
498 - } 297 + // Check assignment of individual values
  298 + for (int i = 0; i < 3; ++i) {
  299 + for (int k = 0; k < 3; ++k) {
  300 + double value = i*2.0 + k*2.0;
  301 + test_value(test(i,k), value, 1.0e-10, "Test matrix element assignment");
499 } 302 }
500 - test_try_success();  
501 - }  
502 - catch(std::exception& e)  
503 - {  
504 - test_try_failure(e);  
505 } 303 }
506 304
507 - //  
508 - // Extract rows  
509 - test_try("Extract rows");  
510 - try  
511 - {  
512 - for (int row = 0; row < rows; ++row) {  
513 - GVector v_row(cols);  
514 - for (int col = 0; col < cols; ++col)  
515 - v_row[col] = (col+1)*100.0 + (row+1)*1.0;  
516 - GVector check = test.extract_row(row);  
517 - if (check != v_row) {  
518 - throw exception_failure("Unable to extract rows.\nIserted row ...: "+v_row.print()+"\nExtracted row: "+check.print());  
519 - }  
520 - }  
521 - 305 + // Verify range checking
  306 + #ifdef G_RANGE_CHECK
  307 + test_try("Verify range checking");
  308 + try {
  309 + test(3,3) = 1.0;
  310 + test_try_failure("Expected GException::out_of_range exception.");
  311 + }
  312 + catch (GException::out_of_range &e) {
522 test_try_success(); 313 test_try_success();
523 } 314 }
524 - catch(std::exception& e)  
525 - { 315 + catch (std::exception &e) {
526 test_try_failure(e); 316 test_try_failure(e);
527 } 317 }
  318 + #endif
528 319
529 -}  
530 -  
531 -// Test 1: Allocate zero matrix  
532 -void TestGMatrix::test1(void)  
533 -{  
534 - GMatrix test1(0,0);  
535 - 320 + // Return
536 return; 321 return;
537 } 322 }
538 323
539 -// Test 2: Allocate too large matrix  
540 -void TestGMatrix::test2(void) 324 +
  325 +/***********************************************************************//**
  326 + * @brief Test matrix copy
  327 + ***************************************************************************/
  328 +void TestGMatrix::copy_matrix(void)
541 { 329 {
542 - //GMatrix test2(100000,100000); 330 + // Copy matrix
  331 + GMatrix test = m_test;
  332 +
  333 + // Test if original and compied matrices are correct
  334 + test_assert(check_matrix(m_test), "Test source matrix");
  335 + test_assert(check_matrix(test), "Test matrix copy operator",
  336 + "Found:\n"+test.print()+"\nExpected:\n"+m_test.print());
543 337
  338 + // Return
544 return; 339 return;
545 } 340 }
546 341
547 -// Test 3: Assign values  
548 -void TestGMatrix::test3(void) 342 +
  343 +/***********************************************************************//**
  344 + * @brief Test matrix operations
  345 + *
  346 + * Tests matrix*vector and matrix*matrix multiplication operations.
  347 + ***************************************************************************/
  348 +void TestGMatrix::matrix_operations(void)
549 { 349 {
550 - GMatrix test3(3,3);  
551 - test3(1,1) = 1.0;  
552 - test_assert(test3(0,0) == 0.0 && test3(1,0) == 0.0 && test3(2,0) == 0.0 &&  
553 - test3(0,1) == 0.0 && test3(1,1) == 1.0 && test3(2,1) == 0.0 &&  
554 - test3(0,2) == 0.0 && test3(1,2) == 0.0 && test3(2,2) == 0.0,"Assign value");  
555 -  
556 - #if defined(G_RANGE_CHECK)  
557 - test_try("Range check");  
558 - try {  
559 - GMatrix test3(3,3);  
560 - test3(3,3) = 1.0;  
561 - test_try_failure();  
562 - }  
563 - catch (GException::out_of_range &e) {  
564 - test_try_success(); 350 + // Perform vector multiplication
  351 + GVector test1 = m_test * v_test;
  352 +
  353 + // Check if the result vector is as expected
  354 + GVector ref1 = test1;
  355 + bool result = true;
  356 + for (int row = 0; row < g_rows; ++row) {
  357 + double value = 0.0;
  358 + for (int col = 0; col < g_cols; ++col) {
  359 + value += g_matrix[col+row*g_cols] * g_vector[col];
565 } 360 }
566 - catch (std::exception &e) {  
567 - test_try_failure(e); 361 + ref1[row] = value;
  362 + if (test1[row] != value) {
  363 + result = false;
  364 + break;
568 } 365 }
569 - #endif 366 + }
570 367
571 - return;  
572 -} 368 + // Test if original matrix and result vector are correct
  369 + test_assert(check_matrix(m_test), "Test source matrix");
  370 + test_assert(result, "Test matrix*vector multiplication",
  371 + "Found:\n"+test1.print()+"\nExpected:\n"+ref1.print());
573 372
574 -// Test 4: Matrix copy constructor  
575 -void TestGMatrix::test4(void)  
576 -{  
577 - GMatrix test4 = m_test;  
578 - if (!check_matrix(test4, 1.0, 0.0) || !check_matrix(m_test, 1.0, 0.0)) {  
579 - throw exception_failure("Corrupt copy constructor"); 373 + // Test incompatible vector multiplication
  374 + test_try("Test incompatible matrix*vector multiplication");
  375 + try {
  376 + GVector test2 = m_bigger * v_test;
  377 + test_try_failure("Expected GException::matrix_vector_mismatch exception.");
  378 + }
  379 + catch (GException::matrix_vector_mismatch &e) {
  380 + test_try_success();
  381 + }
  382 + catch (std::exception &e) {
  383 + test_try_failure(e);
  384 + }
  385 +
  386 + // Test matrix multiplication
  387 + GMatrix test3 = m_test * transpose(m_test);
  388 +
  389 + // Check if the result matrix is as expected
  390 + GMatrix ref3 = test3;
  391 + result = true;
  392 + for (int row = 0; row < test3.rows(); ++row) {
  393 + for (int col = 0; col < test3.cols(); ++col) {
  394 + double value = 0.0;
  395 + for (int i = 0; i < g_cols; ++i) {
  396 + value += g_matrix[i+row*g_cols] * g_matrix[i+col*g_cols];
  397 + }
  398 + ref3(row,col) = value;
  399 + if (test3(row,col) != value) {
  400 + result = false;
  401 + break;
  402 + }
  403 + }
580 } 404 }
581 405
582 - return;  
583 -} 406 + // Test if original matrix and result matrix are correct
  407 + test_assert(check_matrix(m_test), "Test source matrix");
  408 + test_assert(result, "Test matrix multiplication",
  409 + "Found:\n"+test3.print()+"\nExpected:\n"+ref3.print());
  410 + test_value(test3.rows(), g_rows, "Test number of rows of result matrix");
  411 + test_value(test3.cols(), g_rows, "Test number of columns of result matrix");
584 412
585 -// Test 5: Matrix assignment  
586 -void TestGMatrix::test5(void)  
587 -{  
588 - //  
589 - // GMatrix = GMatrix  
590 - result = m_test;  
591 - if (!check_matrix(result, 1.0, 0.0) || !check_matrix(m_test, 1.0, 0.0)) {  
592 - throw exception_failure("Corrupt assignment"); 413 + // Test incompatible matrix multiplication
  414 + test_try("Test incompatible matrix multiplication");
  415 + try {
  416 + GMatrix test4 = m_bigger * m_test;
  417 + test_try_failure("Expected GException::matrix_mismatch exception.");
  418 + }
  419 + catch (GException::matrix_mismatch &e) {
  420 + test_try_success();
  421 + }
  422 + catch (std::exception &e) {
  423 + test_try_failure(e);
593 } 424 }
594 - //  
595 - // GMatrix = GMatrix (bigger matrix)  
596 - result = bigger;  
597 425
  426 + // Test another incompatible matrix multiplication
  427 + test_try("Test incompatible matrix multiplication");
  428 + try {
  429 + GMatrix test5 = m_bigger * m_test;
  430 + test_try_failure("Expected GException::matrix_mismatch exception.");
  431 + }
  432 + catch (GException::matrix_mismatch &e) {
  433 + test_try_success();
  434 + }
  435 + catch (std::exception &e) {
  436 + test_try_failure(e);
  437 + }
  438 +
  439 + // Return
598 return; 440 return;
599 } 441 }
600 442
601 -// Test 6: Transposition  
602 -void TestGMatrix::test6(void)  
603 -{  
604 - //  
605 - // transpose(GMatrix)  
606 - result = transpose(m_test);  
607 - test_assert(check_transpose_matrix(result, 1.0, 0.0) && check_matrix(m_test, 1.0, 0.0),"transpose(GMatrix)","Corrupt transpose(GMatrix) function.");  
608 - //  
609 - // GMatrix.transpose()  
610 - result = m_test;  
611 - result.transpose();  
612 - test_assert(check_transpose_matrix(result, 1.0, 0.0) && check_matrix(m_test, 1.0, 0.0),"GMatrix.transpose()","Corrupt GMatrix.transpose() function.");  
613 -}  
614 443
615 -// Test 7: Matrix*Vector multiplication  
616 -void TestGMatrix::test7(void) 444 +/***********************************************************************//**
  445 + * @brief Test matrix arithmetics
  446 + *
  447 + * Tests matrix arithmetics.
  448 + ***************************************************************************/
  449 +void TestGMatrix::matrix_arithmetics(void)
617 { 450 {
618 - GVector v_test7 = m_test*v_test;  
619 - test_assert(check_matrix_vector(v_test7) && check_matrix(m_test, 1.0, 0.0),"","Corrupt Matrix*Vector multiplication");  
620 -  
621 - test_try("Bigger*Vector"); 451 + // -GMatrix
  452 + GMatrix test = -m_test;
  453 + test_assert(check_matrix(m_test), "Test source matrix");
  454 + test_assert(check_matrix(test, -1.0, 0.0), "Test -GMatrix",
  455 + "Unexpected result matrix:\n"+test.print());
  456 +
  457 + // GMatrix += GMatrix
  458 + test = m_test;
  459 + test += m_test;
  460 + test_assert(check_matrix(m_test), "Test source matrix");
  461 + test_assert(check_matrix(test, 2.0, 0.0), "Test GMatrix += GMatrix",
  462 + "Unexpected result matrix:\n"+test.print());
  463 +
  464 + // GMatrix -= GMatrix
  465 + test = m_test;
  466 + test -= m_test;
  467 + test_assert(check_matrix(m_test), "Test source matrix");
  468 + test_assert(check_matrix(test, 0.0, 0.0), "Test GMatrix -= GMatrix",
  469 + "Unexpected result matrix:\n"+test.print());
  470 +
  471 + // GMatrix *= 3.0
  472 + test = m_test;
  473 + test *= 3.0;
  474 + test_assert(check_matrix(m_test), "Test source matrix");
  475 + test_assert(check_matrix(test, 3.0, 0.0), "Test GMatrix *= 3.0",
  476 + "Unexpected result matrix:\n"+test.print());
  477 +
  478 + // GMatrix /= 3.0
  479 + test = m_test;
  480 + test /= 3.0;
  481 + test_assert(check_matrix(m_test), "Test source matrix");
  482 + test_assert(check_matrix(test, 1.0/3.0, 0.0), "Test GMatrix /= 3.0",
  483 + "Unexpected result matrix:\n"+test.print());
  484 +
  485 + // GMatrix + GMatrix
  486 + test = m_test + m_test;
  487 + test_assert(check_matrix(m_test), "Test source matrix");
  488 + test_assert(check_matrix(test, 2.0, 0.0), "Test GMatrix + GMatrix",
  489 + "Unexpected result matrix:\n"+test.print());
  490 +
  491 + // GMatrix - GMatrix
  492 + test = m_test - m_test;
  493 + test_assert(check_matrix(m_test), "Test source matrix");
  494 + test_assert(check_matrix(test, 0.0, 0.0), "Test GMatrix - GMatrix",
  495 + "Unexpected result matrix:\n"+test.print());
  496 +
  497 + // GMatrix * 3.0
  498 + test = m_test * 3.0;
  499 + test_assert(check_matrix(m_test), "Test source matrix");
  500 + test_assert(check_matrix(test, 3.0, 0.0), "Test GMatrix * 3.0",
  501 + "Unexpected result matrix:\n"+test.print());
  502 +
  503 + // 3.0 * GMatrix
  504 + test = 3.0 * m_test;
  505 + test_assert(check_matrix(m_test), "Test source matrix");
  506 + test_assert(check_matrix(test, 3.0, 0.0), "Test 3.0 * GMatrix",
  507 + "Unexpected result matrix:\n"+test.print());
  508 +
  509 + // GMatrix / 3.0
  510 + test = m_test / 3.0;
  511 + test_assert(check_matrix(m_test), "Test source matrix");
  512 + test_assert(check_matrix(test, 1.0/3.0, 0.0), "Test GMatrix / 3.0",
  513 + "Unexpected result matrix:\n"+test.print());
  514 +
  515 + // Test invalid matrix addition
  516 + test_try("Test invalid matrix addition");
622 try { 517 try {
623 - GVector v_test7 = bigger*v_test;  
624 - test_try_failure(); 518 + test = m_test;
  519 + test += m_bigger;
  520 + test_try_failure("Expected GException::matrix_mismatch exception.");
625 } 521 }
626 - catch (GException::matrix_vector_mismatch &e) { 522 + catch (GException::matrix_mismatch &e) {
627 test_try_success(); 523 test_try_success();
628 } 524 }
629 catch (std::exception &e) { 525 catch (std::exception &e) {
630 test_try_failure(e); 526 test_try_failure(e);
631 } 527 }
632 528
  529 + // Return
633 return; 530 return;
634 } 531 }
635 532
636 -// Test 8: Matrix*Matrix multiplication  
637 -void TestGMatrix::test8(void) 533 +
  534 +/***********************************************************************//**
  535 + * @brief Test matrix functions
  536 + *
  537 + * Tests matrix functions.
  538 + ***************************************************************************/
  539 +void TestGMatrix::matrix_functions(void)
638 { 540 {
639 - GMatrix m_test8 = m_test * transpose(m_test);  
640 - test_assert(check_matrix_matrix(m_test8) && check_matrix(m_test, 1.0, 0.0),"","Corrupt Matrix*Matrix multiplication"); 541 + // Minimum
  542 + double min = m_test.min();
  543 +
  544 + // Check mimimum
  545 + double value = g_matrix[0];
  546 + for (int row = 0; row < g_rows; ++row) {
  547 + for (int col = 0; col < g_cols; ++col) {
  548 + if (g_matrix[col+row*g_cols] < value) {
  549 + value = g_matrix[col+row*g_cols];
  550 + }
  551 + }
  552 + }
  553 + test_value(min, value, 0.0, "Test minimum function");
  554 +
  555 + // Maximum
  556 + double max = m_test.max();
  557 +
  558 + // Check maximum
  559 + value = g_matrix[0];
  560 + for (int row = 0; row < g_rows; ++row) {
  561 + for (int col = 0; col < g_cols; ++col) {
  562 + if (g_matrix[col+row*g_cols] > value) {
  563 + value = g_matrix[col+row*g_cols];
  564 + }
  565 + }
  566 + }
  567 + test_value(max, value, 0.0, "Test maximum function");
641 568
642 - test_try("Bigger*Matrix multiplication"); 569 + // Sum
  570 + double sum = m_test.sum();
  571 +
  572 + // Check sum
  573 + value = 0.0;
  574 + for (int row = 0; row < g_rows; ++row) {
  575 + for (int col = 0; col < g_cols; ++col) {
  576 + value += g_matrix[col+row*g_cols];
  577 + }
  578 + }
  579 + test_value(sum, value, 1.0e-20, "Test sum function");
  580 +
  581 + // Transpose function
  582 + GMatrix test1 = transpose(m_test);
  583 + test_assert(check_matrix(m_test), "Test source matrix");
  584 + test_assert(check_matrix_trans(test1, 1.0, 0.0),
  585 + "Test transpose(GMatrix) function",
  586 + "Unexpected transposed matrix:\n"+test1.print());
  587 +
  588 + // Transpose method
  589 + test1 = m_test;
  590 + test1.transpose();
  591 + test_assert(check_matrix(m_test), "Test source matrix");
  592 + test_assert(check_matrix_trans(test1, 1.0, 0.0),
  593 + "Test GMatrix.transpose() method",
  594 + "Unexpected transposed matrix:\n"+test1.print());
  595 +
  596 + // Convert to general matrix
  597 + GMatrix test2 = GMatrix(m_test);
  598 + test_assert(check_matrix(m_test), "Test source matrix");
  599 + test_assert(check_matrix(test2, 1.0, 0.0),
  600 + "Test GMatrix(GMatrix) constructor",
  601 + "Unexpected GMatrix:\n"+test2.print());
  602 +
  603 + // Try extracting of lower triangle
  604 + test_try("Try extracting of lower triangle");
643 try { 605 try {
644 - GMatrix m_test8 = m_test*bigger; 606 + test2 = m_test.extract_lower_triangle();
  607 + test_try_failure("Expected GException::matrix_not_square exception.");
  608 + }
  609 + catch (GException::matrix_not_square &e) {
645 test_try_success(); 610 test_try_success();
646 } 611 }
647 catch (std::exception &e) { 612 catch (std::exception &e) {
648 test_try_failure(e); 613 test_try_failure(e);
649 } 614 }
650 615
651 - test_try("Bigger*Matrix multiplication 2"); 616 + // Try extracting of upper triangle
  617 + test_try("Try extracting of lower triangle");
652 try { 618 try {
653 - GMatrix m_test8 = bigger*m_test;  
654 - test_try_failure(); 619 + test2 = m_test.extract_upper_triangle();
  620 + test_try_failure("Expected GException::matrix_not_square exception.");
655 } 621 }
656 - catch (GException::matrix_mismatch &e) { 622 + catch (GException::matrix_not_square &e) {
657 test_try_success(); 623 test_try_success();
658 } 624 }
659 catch (std::exception &e) { 625 catch (std::exception &e) {
660 test_try_failure(e); 626 test_try_failure(e);
661 } 627 }
  628 +
  629 + // Extract lower triangle for square matrix
  630 + GMatrix test3 = m_test * transpose(m_test);
  631 + GMatrix test4 = test3.extract_lower_triangle();
  632 + test_assert(check_matrix_lt(test4, test3),
  633 + "Test GMatrix.extract_lower_triangle() method",
  634 + "Unexpected lower triangle:\n"+test4.print());
  635 +
  636 + // Extract upper triangle
  637 + test4 = test3.extract_upper_triangle();
  638 + test_assert(check_matrix_ut(test4, test3),
  639 + "Test GMatrix.extract_upper_triangle() method",
  640 + "Unexpected lower triangle:\n"+test4.print());
662 641
  642 + // Return
663 return; 643 return;
664 } 644 }
665 645
666 -// Test 9: Assignment and arithmetics  
667 -void TestGMatrix::test9(void) 646 +
  647 +/***********************************************************************//**
  648 + * @brief Test matrix comparisons
  649 + ***************************************************************************/
  650 +void TestGMatrix::matrix_compare(void)
668 { 651 {
669 - //  
670 - // -GMatrix  
671 - result = -m_test;  
672 - test_assert(check_matrix(result, -1.0, 0.0)&&check_matrix(m_test, 1.0, 0.0),"-GMatrix","Corrupt -GMatrix operator.");  
673 -  
674 - //  
675 - // GMatrix += GMatrix  
676 - result = m_test;  
677 - result += m_test;  
678 - test_assert(check_matrix(result, 2.0, 0.0) && check_matrix(m_test, 1.0, 0.0),"GMatrix += GMatrix","Corrupt GMatrix += GMatrix operator.");  
679 -  
680 - //  
681 - // GMatrix -= GMatrix  
682 - result = m_test;  
683 - result -= m_test;  
684 - test_assert(check_matrix(result, 0.0, 0.0) && check_matrix(m_test, 1.0, 0.0),"GMatrix -= GMatrix","Corrupt GMatrix -= GMatrix operator.");  
685 -  
686 - //  
687 - // GMatrix *= 3.0  
688 - result = m_test;  
689 - result *= 3.0;  
690 - test_assert(check_matrix(result, 3.0, 0.0) && check_matrix(m_test, 1.0, 0.0),"GMatrix *= 3.0","Corrupt GMatrix *= double operator.");  
691 -  
692 - //  
693 - // GMatrix /= 3.0  
694 - result = m_test;  
695 - result /= 3.0;  
696 - test_assert(check_matrix(result, 1.0/3.0, 0.0) && check_matrix(m_test, 1.0, 0.0),"GMatrix /= 3.0","Corrupt GMatrix /= double operator.");  
697 -  
698 - //  
699 - // GMatrix + GMatrix  
700 - result = m_test + m_test;  
701 - test_assert(check_matrix(result, 2.0, 0.0) && check_matrix(m_test, 1.0, 0.0),"GMatrix + GMatrix","Corrupt GMatrix + GMatrix operator.");  
702 -  
703 - //  
704 - // GMatrix - GMatrix  
705 - result = m_test - m_test;  
706 - test_assert(check_matrix(result, 0.0, 0.0) && check_matrix(m_test, 1.0, 0.0),"GMatrix - GMatrix","Corrupt GMatrix - GMatrix operator.");  
707 -  
708 - // GMatrix * 3.0  
709 - result = m_test * 3.0;  
710 - test_assert(check_matrix(result, 3.0, 0.0) && check_matrix(m_test, 1.0, 0.0),"GMatrix * 3.0","Corrupt GMatrix * double operator.");  
711 -  
712 - //  
713 - // 3.0 * GMatrix  
714 - result = 3.0 * m_test;  
715 - test_assert(check_matrix(result, 3.0, 0.0) && check_matrix(m_test, 1.0, 0.0),"3.0 * GMatrix","Corrupt double * GMatrix operator.");  
716 -  
717 - //  
718 - // GMatrix / 3.0  
719 - result = m_test / 3.0;  
720 - test_assert(check_matrix(result, 1.0/3.0, 0.0) && check_matrix(m_test, 1.0, 0.0),"GMatrix / 3.0","Corrupt GMatrix / double operator.");  
721 -  
722 -  
723 - test_try("Test += with bigger");  
724 - try {  
725 - result = m_test;  
726 - result += bigger;  
727 - test_try_failure();  
728 - }  
729 - catch (GException::matrix_mismatch &e) {  
730 - test_try_success();  
731 - }  
732 - catch (std::exception &e) {  
733 - test_try_failure(e);  
734 - } 652 + // Allocate an empty matrix
  653 + GMatrix empty(g_rows,g_cols);
  654 +
  655 + // Test operators
  656 + test_assert((m_test == m_test), "Test == operator");
  657 + test_assert(!(m_test == empty), "Test == operator");
  658 + test_assert(!(m_test == m_bigger), "Test == operator");
  659 + test_assert(!(m_test != m_test), "Test != operator");
  660 + test_assert((m_test != empty), "Test != operator");
  661 + test_assert((m_test != m_bigger), "Test != operator");
735 662
  663 + // Return
736 return; 664 return;
737 } 665 }
738 666
739 -// Test 10: Matrix functions  
740 -void TestGMatrix::test10(void){  
741 - //  
742 - double min = m_test.min();  
743 - test_assert(check_matrix_min(min),"Test min","Corrupt GMatrix.min() function.");  
744 667
745 - //  
746 - double max = m_test.max();  
747 - test_assert(check_matrix_max(max),"Test max","Corrupt GMatrix.max() function.");  
748 -  
749 - //  
750 - double sum = m_test.sum();  
751 - test_assert(check_matrix_sum(sum),"Test sum","Corrupt GMatrix.sum() function."); 668 +/***********************************************************************//**
  669 + * @brief Test Cholesky decomposition
  670 + ***************************************************************************/
  671 +/*
  672 +void TestGMatrix::matrix_cholesky(void)
  673 +{
  674 + // Test Cholesky decomposition
  675 + GMatrix cd = cholesky_decompose(m_test);
  676 + GMatrix cd_lower = cd.extract_lower_triangle();
  677 + GMatrix cd_upper = transpose(cd_lower);
  678 + GMatrix cd_product = cd_lower * cd_upper;
  679 + GMatrix cd_residuals = matrix(m_test) - cd_product;
  680 + double res = (abs(cd_residuals)).max();
  681 + test_value(res, 0.0, 1.0e-15, "Test cholesky_decompose() method");
  682 +
  683 + // Test compressed Cholesky decomposition
  684 + GMatrix test_zero = set_matrix_zero();
  685 + GMatrix cd_zero = cholesky_decompose(test_zero);
  686 + GMatrix cd_zero_lower = cd_zero.extract_lower_triangle();
  687 + GMatrix cd_zero_upper = transpose(cd_zero_lower);
  688 + GMatrix cd_zero_product = cd_zero_lower * cd_zero_upper;
  689 + GMatrix cd_zero_residuals = matrix(test_zero) - cd_zero_product;
  690 + res = (abs(cd_zero_residuals)).max();
  691 + test_value(res, 0.0, 1.0e-15, "Test compressed cholesky_decompose() method");
  692 +
  693 + // Test Cholesky inplace decomposition
  694 + GMatrix test = m_test;
  695 + test.cholesky_decompose();
  696 + GMatrix cd_lower2 = test.extract_lower_triangle();
  697 + test_assert((cd_lower2 == cd_lower), "Test inplace cholesky_decompose() method");
  698 +
  699 + // Test Cholesky solver (first test)
  700 + GVector e0(g_rows);
  701 + GVector a0(g_rows);
  702 + e0[0] = 1.0;
  703 + e0[1] = 0.0;
  704 + e0[2] = 0.0;
  705 + a0[0] = g_matrix[0];
  706 + a0[1] = g_matrix[3];
  707 + a0[2] = g_matrix[6];
  708 + GVector s0 = cd.cholesky_solver(a0) - e0;
  709 + res = max(abs(s0));
  710 + test_value(res, 0.0, 1.0e-15, "Test cholesky_solver() method");
  711 +
  712 + // Test Cholesky solver (second test)
  713 + e0[0] = 0.0;
  714 + e0[1] = 1.0;
  715 + e0[2] = 0.0;
  716 + a0[0] = g_matrix[1];
  717 + a0[1] = g_matrix[4];
  718 + a0[2] = g_matrix[7];
  719 + s0 = cd.cholesky_solver(a0) - e0;
  720 + res = max(abs(s0));
  721 + test_value(res, 0.0, 1.0e-15, "Test cholesky_solver() method");
  722 +
  723 + // Test Cholesky solver (third test)
  724 + e0[0] = 0.0;
  725 + e0[1] = 0.0;
  726 + e0[2] = 1.0;
  727 + a0[0] = g_matrix[2];
  728 + a0[1] = g_matrix[5];
  729 + a0[2] = g_matrix[8];
  730 + s0 = cd.cholesky_solver(a0) - e0;
  731 + res = max(abs(s0));
  732 + test_value(res, 0.0, 1.0e-15, "Test cholesky_solver() method");
  733 +
  734 + // Test compressed Cholesky solver (first test)
  735 + e0 = GVector(g_rows+1);
  736 + a0 = GVector(g_rows+1);
  737 + e0[0] = 1.0;
  738 + e0[1] = 0.0;
  739 + e0[2] = 0.0;
  740 + e0[3] = 0.0;
  741 + a0[0] = g_matrix[0];
  742 + a0[1] = g_matrix[3];
  743 + a0[2] = 0.0;
  744 + a0[3] = g_matrix[6];
  745 + s0 = cd_zero.cholesky_solver(a0) - e0;
  746 + res = max(abs(s0));
  747 + test_value(res, 0.0, 1.0e-15, "Test compressed cholesky_solver() method");
  748 +
  749 + // Test compressed Cholesky solver (second test)
  750 + e0[0] = 0.0;
  751 + e0[1] = 1.0;
  752 + e0[2] = 0.0;
  753 + e0[3] = 0.0;
  754 + a0[0] = g_matrix[1];
  755 + a0[1] = g_matrix[4];
  756 + a0[2] = 0.0;
  757 + a0[3] = g_matrix[7];
  758 + s0 = cd_zero.cholesky_solver(a0) - e0;
  759 + res = max(abs(s0));
  760 + test_value(res, 0.0, 1.0e-15, "Test compressed cholesky_solver() method");
  761 +
  762 + // Test compressed Cholesky solver (third test)
  763 + e0[0] = 0.0;
  764 + e0[1] = 0.0;
  765 + e0[2] = 0.0;
  766 + e0[3] = 1.0;
  767 + a0[0] = g_matrix[2];
  768 + a0[1] = g_matrix[5];
  769 + a0[2] = 0.0;
  770 + a0[3] = g_matrix[8];
  771 + s0 = cd_zero.cholesky_solver(a0) - e0;
  772 + res = max(abs(s0));
  773 + test_value(res, 0.0, 1.0e-15, "Test compressed cholesky_solver() method");
  774 +
  775 + // Test Cholesky inverter
  776 + GMatrix unit(g_rows,g_cols);
  777 + unit(0,0) = unit(1,1) = unit(2,2) = 1.0;
  778 + GMatrix test_inv = m_test;
  779 + test_inv.cholesky_invert();
  780 + GMatrix ci_product = m_test * test_inv;
  781 + GMatrix ci_residuals = ci_product - unit;
  782 + res = (abs(ci_residuals)).max();
  783 + test_value(res, 0.0, 1.0e-15, "Test cholesky_invert method");
  784 +
  785 + // Test Cholesky inverter for compressed matrix
  786 + unit = GMatrix(4,4);
  787 + unit(0,0) = unit(1,1) = unit(3,3) = 1.0;
  788 + GMatrix test_zero_inv = test_zero;
  789 + test_zero_inv.cholesky_invert();
  790 + GMatrix ciz_product = test_zero * test_zero_inv;
  791 + GMatrix ciz_residuals = ciz_product - unit;
  792 + res = (abs(ciz_residuals)).max();
  793 + test_value(res, 0.0, 1.0e-15, "Test compressed cholesky_invert method");
752 794
  795 + // Return
753 return; 796 return;
754 } 797 }
  798 +*/
755 799
756 -// Test 11: Matrix comparison  
757 -void TestGMatrix::test11(void){  
758 -  
759 - test_assert(((m_test == m_test) == 1),"GMatrix == GMatrix","Corrupt GMatrix == GMatrix operator.");  
760 - //  
761 - GMatrix m_test10(m_g_rows,m_g_cols);  
762 - test_assert(((m_test == m_test10) == 0),"GMatrix == GMatrix 2","Corrupt GMatrix == GMatrix operator.");  
763 - //  
764 - test_assert(((m_test == bigger) == 0),"GMatrix == GMatrix 3","Corrupt GMatrix == GMatrix operator.");  
765 - //  
766 - test_assert(((m_test != m_test) == 0),"GMatrix != GMatrix","Corrupt GMatrix != GMatrix operator.");  
767 - //  
768 - test_assert(((m_test != m_test10) == 1),"GMatrix != GMatrix 2","Corrupt GMatrix != GMatrix operator.");  
769 - //  
770 - test_assert(((m_test != bigger) == 1),"GMatrix != GMatrix 3","Corrupt GMatrix != GMatrix operator."); 800 +/***************************************************************************
  801 + * @brief Test matrix printing
  802 + ***************************************************************************/
  803 +void TestGMatrix::matrix_print(void)
  804 +{
  805 + // Set reference
  806 + std::string reference;
  807 + reference.append("=== GMatrix ===\n");
  808 + reference.append(" Number of rows ............: 3\n");
  809 + reference.append(" Number of columns .........: 4\n");
  810 + reference.append(" Number of elements ........: 12\n");
  811 + reference.append(" Number of allocated cells .: 12\n");
  812 + reference.append(" 1, 2, 3, 4\n");
  813 + reference.append(" 5, 6, 7, 8\n");
  814 + reference.append(" 9, 10, 11, 12");
  815 +
  816 + // Test the print method
  817 + std::string output = m_test.print();
  818 + test_assert((output == reference), "Test matrix printing",
  819 + "Unexpected print() output:\n"+output);
771 820
  821 + // Return
772 return; 822 return;
773 } 823 }
774 824
  825 +
  826 +/***************************************************************************
  827 + * @brief Main entry point for test executable
  828 + ***************************************************************************/
775 int main(void) 829 int main(void)
776 { 830 {
777 - GTestSuites testsuite("GMatrix"); 831 + // Allocate test suit container
  832 + GTestSuites testsuites("GMatrix class testing");
778 833
779 - bool was_successful=true; 834 + // Initially assume that we pass all tests
  835 + bool success = true;
780 836
781 - //Create a test suite 837 + // Create a test suite
782 TestGMatrix test; 838 TestGMatrix test;
783 839
784 - //Append to the container  
785 - testsuite.append(test); 840 + // Append test suite to the container
  841 + testsuites.append(test);
786 842
787 - //Run  
788 - was_successful=testsuite.run(); 843 + // Run the testsuites
  844 + success = testsuites.run();
789 845
790 - //save xml report  
791 - testsuite.save("reports/GMatrix.xml"); 846 + // Save test report
  847 + testsuites.save("reports/GMatrix.xml");
792 848
793 - // Return  
794 - return was_successful ? 0:1; 849 + // Return success status
  850 + return (success ? 0 : 1);
795 } 851 }
test/test_GMatrix.hpp
  View file @b4ded5b
1 /*************************************************************************** 1 /***************************************************************************
2 - * test_GMatrix.hpp - test matrix class * 2 + * test_GMatrix.hpp - Test generic matrix class *
3 * ----------------------------------------------------------------------- * 3 * ----------------------------------------------------------------------- *
4 - * copyright (C) 2012 by Jean-Baptiste Cayrou * 4 + * copyright (C) 2012 by Juergen Knoedlseder *
5 * ----------------------------------------------------------------------- * 5 * ----------------------------------------------------------------------- *
6 * * 6 * *
7 * This program is free software: you can redistribute it and/or modify * 7 * This program is free software: you can redistribute it and/or modify *
@@ -18,70 +18,65 @@ @@ -18,70 +18,65 @@
18 * along with this program. If not, see <http://www.gnu.org/licenses/>. * 18 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
19 * * 19 * *
20 ***************************************************************************/ 20 ***************************************************************************/
  21 +/**
  22 + * @file test_GMatrix.hpp
  23 + * @brief Definition of unit tests for generic matrices
  24 + * @author Juergen Knoedlseder
  25 + */
21 26
22 #ifndef TEST_GMATRIX_HPP 27 #ifndef TEST_GMATRIX_HPP
23 #define TEST_GMATRIX_HPP 28 #define TEST_GMATRIX_HPP
24 29
25 /* __ Includes ___________________________________________________________ */ 30 /* __ Includes ___________________________________________________________ */
26 #include "GammaLib.hpp" 31 #include "GammaLib.hpp"
27 -#include <iostream> // cout, cerr  
28 32
29 -class TestGMatrix : public GTestSuite  
30 -{  
31 - public:  
32 - // Constructors and destructors  
33 - TestGMatrix(void) : GTestSuite(){ return; }  
34 - virtual ~TestGMatrix(void){ return; }  
35 33
36 - // Methods  
37 - virtual void set(void);  
38 -  
39 - void set_matrix(void);  
40 - void set_vector(void);  
41 - void set_bigger(void);  
42 - void test_output(void);  
43 - void test_conversion(void);  
44 - void test_extract(void);  
45 - void test1(void);  
46 - void test2(void);  
47 - void test3(void);  
48 - void test4(void);  
49 - void test5(void);  
50 - void test6(void);  
51 - void test7(void);  
52 - void test8(void);  
53 - void test9(void);  
54 - void test10(void);  
55 - void test11(void);  
56 -  
57 - // Private methods  
58 - private:  
59 - void init_matrix(void);  
60 - void init_vector(void);  
61 -  
62 - int check_matrix(const GMatrix& m, const double scale, const double add);  
63 - int check_transpose_matrix(const GMatrix& m, const double scale, const double add);  
64 - int check_matrix_lt(const GMatrix& m, const double scale, const double add);  
65 - int check_matrix_ut(const GMatrix& m, const double scale, const double add);  
66 - int check_matrix_vector(const GVector& v);  
67 - int check_matrix_matrix(const GMatrix& m);  
68 - int check_matrix_min(const double min);  
69 - int check_matrix_max(const double max);  
70 - int check_matrix_sum(const double sum); 34 +/***********************************************************************//**
  35 + * @class TestGMatrix
  36 + *
  37 + * @brief Test suite for generic matrix class testing
  38 + *
  39 + * This test suite performs a unit test for the generic matrix class. Tests
  40 + * that match logically are gathered in a number of class methods, and the
  41 + * class methods are executed when running the test.
  42 + ***************************************************************************/
  43 +class TestGMatrix : public GTestSuite {
71 44
  45 +public:
  46 + // Constructors and destructors
  47 + TestGMatrix(void) : GTestSuite() {}
  48 + virtual ~TestGMatrix(void) {}
72 49
  50 + // Methods
  51 + virtual void set(void);
  52 + void alloc_matrix(void);
  53 + void assign_values(void);
  54 + void copy_matrix(void);
  55 + void matrix_operations(void);
  56 + void matrix_arithmetics(void);
  57 + void matrix_functions(void);
  58 + void matrix_compare(void);
  59 + //void matrix_cholesky(void);
  60 + void matrix_print(void);
73 61
  62 +private:
  63 + // Private methods
  64 + GMatrix set_matrix(void) const;
  65 + GMatrix set_matrix_zero(void) const;
  66 + GVector set_vector(void) const;
  67 + bool check_matrix(const GMatrix& matrix,
  68 + const double& scale = 1.0,
  69 + const double& offset = 0.0) const;
  70 + bool check_matrix_trans(const GMatrix& matrix,
  71 + const double& scale,
  72 + const double& offset) const;
  73 + bool check_matrix_lt(const GMatrix& matrix, const GMatrix& ref) const;
  74 + bool check_matrix_ut(const GMatrix& matrix, const GMatrix& ref) const;
74 75
75 - // Private attributes  
76 - GMatrix m_test;  
77 - GMatrix bigger;  
78 - GMatrix result;  
79 - GVector v_test;  
80 - double m_g_matrix[12];//  
81 - double m_g_vector[4];  
82 - int m_g_rows;  
83 - int m_g_cols;  
84 - 76 + // Private members;
  77 + GMatrix m_test; //!< Test matrix
  78 + GMatrix m_bigger; //!< Bigger test matrix (for collisions)
  79 + GVector v_test; //!< Test vector
85 }; 80 };
86 81
87 #endif /* TEST_GMATRIX_HPP */ 82 #endif /* TEST_GMATRIX_HPP */
test/test_GSymMatrix.cpp
  View file @b4ded5b
@@ -268,7 +268,7 @@ void TestGSymMatrix::alloc_matrix(void) @@ -268,7 +268,7 @@ void TestGSymMatrix::alloc_matrix(void)
268 test_try("Allocate zero matrix"); 268 test_try("Allocate zero matrix");
269 try { 269 try {
270 GSymMatrix test(0,0); 270 GSymMatrix test(0,0);
271 - test_try_failure(); 271 + test_try_failure("Expected GException::empty exception.");
272 } 272 }
273 catch (GException::empty &e) { 273 catch (GException::empty &e) {
274 test_try_success(); 274 test_try_success();
@@ -311,7 +311,7 @@ void TestGSymMatrix::assign_values(void) @@ -311,7 +311,7 @@ void TestGSymMatrix::assign_values(void)
311 test_try("Verify range checking"); 311 test_try("Verify range checking");
312 try { 312 try {
313 test(3,3) = 1.0; 313 test(3,3) = 1.0;
314 - test_try_failure(); 314 + test_try_failure("Expected GException::out_of_range exception.");
315 } 315 }
316 catch (GException::out_of_range &e) { 316 catch (GException::out_of_range &e) {
317 test_try_success(); 317 test_try_success();
@@ -336,7 +336,8 @@ void TestGSymMatrix::copy_matrix(void) @@ -336,7 +336,8 @@ void TestGSymMatrix::copy_matrix(void)
336 336
337 // Test if original and compied matrices are correct 337 // Test if original and compied matrices are correct
338 test_assert(check_matrix(m_test), "Test source matrix"); 338 test_assert(check_matrix(m_test), "Test source matrix");
339 - test_assert(check_matrix(test), "Test matrix copy operator", test.print()); 339 + test_assert(check_matrix(test), "Test matrix copy operator",
  340 + "Found:\n"+test.print()+"\nExpected:\n"+m_test.print());
340 341
341 // Return 342 // Return
342 return; 343 return;
@@ -354,12 +355,14 @@ void TestGSymMatrix::matrix_operations(void) @@ -354,12 +355,14 @@ void TestGSymMatrix::matrix_operations(void)
354 GVector test1 = m_test * v_test; 355 GVector test1 = m_test * v_test;
355 356
356 // Check if the result vector is as expected 357 // Check if the result vector is as expected
  358 + GVector ref1 = test1;
357 bool result = true; 359 bool result = true;
358 for (int row = 0; row < g_rows; ++row) { 360 for (int row = 0; row < g_rows; ++row) {
359 double value = 0.0; 361 double value = 0.0;
360 for (int col = 0; col < g_cols; ++col) { 362 for (int col = 0; col < g_cols; ++col) {
361 value += g_matrix[col+row*g_cols] * g_vector[col]; 363 value += g_matrix[col+row*g_cols] * g_vector[col];
362 } 364 }
  365 + ref1[row] = value;
363 if (test1[row] != value) { 366 if (test1[row] != value) {
364 result = false; 367 result = false;
365 break; 368 break;
@@ -368,7 +371,8 @@ void TestGSymMatrix::matrix_operations(void) @@ -368,7 +371,8 @@ void TestGSymMatrix::matrix_operations(void)
368 371
369 // Test if original matrix and result vector are correct 372 // Test if original matrix and result vector are correct
370 test_assert(check_matrix(m_test), "Test source matrix"); 373 test_assert(check_matrix(m_test), "Test source matrix");
371 - test_assert(result, "Test matrix*vector multiplication", test1.print()); 374 + test_assert(result, "Test matrix*vector multiplication",
  375 + "Found:\n"+test1.print()+"\nExpected:\n"+ref1.print());
372 376
373 // Test incompatible vector multiplication 377 // Test incompatible vector multiplication
374 test_try("Test incompatible matrix*vector multiplication"); 378 test_try("Test incompatible matrix*vector multiplication");
@@ -387,6 +391,7 @@ void TestGSymMatrix::matrix_operations(void) @@ -387,6 +391,7 @@ void TestGSymMatrix::matrix_operations(void)
387 GSymMatrix test3 = m_test * m_test; 391 GSymMatrix test3 = m_test * m_test;
388 392
389 // Check if the result matrix is as expected 393 // Check if the result matrix is as expected
  394 + GSymMatrix ref3 = test3;
390 result = true; 395 result = true;
391 for (int row = 0; row < test3.rows(); ++row) { 396 for (int row = 0; row < test3.rows(); ++row) {
392 for (int col = 0; col < test3.cols(); ++col) { 397 for (int col = 0; col < test3.cols(); ++col) {
@@ -394,6 +399,7 @@ void TestGSymMatrix::matrix_operations(void) @@ -394,6 +399,7 @@ void TestGSymMatrix::matrix_operations(void)
394 for (int i = 0; i < g_cols; ++i) { 399 for (int i = 0; i < g_cols; ++i) {
395 value += g_matrix[i+row*g_cols] * g_matrix[i+col*g_cols]; 400 value += g_matrix[i+row*g_cols] * g_matrix[i+col*g_cols];
396 } 401 }
  402 + ref3(row,col) = value;
397 if (test3(row,col) != value) { 403 if (test3(row,col) != value) {
398 result = false; 404 result = false;
399 break; 405 break;
@@ -403,7 +409,8 @@ void TestGSymMatrix::matrix_operations(void) @@ -403,7 +409,8 @@ void TestGSymMatrix::matrix_operations(void)
403 409
404 // Test if original matrix and result matrix are correct 410 // Test if original matrix and result matrix are correct
405 test_assert(check_matrix(m_test), "Test source matrix"); 411 test_assert(check_matrix(m_test), "Test source matrix");
406 - test_assert(result, "Test matrix multiplication", test3.print()); 412 + test_assert(result, "Test matrix multiplication",
  413 + "Found:\n"+test3.print()+"\nExpected:\n"+ref3.print());
407 test_assert(test3.rows() == g_rows, "Test number of rows of result matrix"); 414 test_assert(test3.rows() == g_rows, "Test number of rows of result matrix");
408 test_assert(test3.cols() == g_cols, "Test number of columns of result matrix"); 415 test_assert(test3.cols() == g_cols, "Test number of columns of result matrix");
409 416
@@ -411,7 +418,7 @@ void TestGSymMatrix::matrix_operations(void) @@ -411,7 +418,7 @@ void TestGSymMatrix::matrix_operations(void)
411 test_try("Test incompatible matrix multiplication"); 418 test_try("Test incompatible matrix multiplication");
412 try { 419 try {
413 GSymMatrix test4 = m_test * m_bigger; 420 GSymMatrix test4 = m_test * m_bigger;
414 - test_try_failure(); 421 + test_try_failure("Expected GException::matrix_mismatch exception.");
415 } 422 }
416 catch (GException::matrix_mismatch &e) { 423 catch (GException::matrix_mismatch &e) {
417 test_try_success(); 424 test_try_success();
@@ -424,7 +431,7 @@ void TestGSymMatrix::matrix_operations(void) @@ -424,7 +431,7 @@ void TestGSymMatrix::matrix_operations(void)
424 test_try("Test incompatible matrix multiplication"); 431 test_try("Test incompatible matrix multiplication");
425 try { 432 try {
426 GSymMatrix test5 = m_bigger * m_test; 433 GSymMatrix test5 = m_bigger * m_test;
427 - test_try_failure(); 434 + test_try_failure("Expected GException::matrix_mismatch exception.");
428 } 435 }
429 catch (GException::matrix_mismatch &e) { 436 catch (GException::matrix_mismatch &e) {
430 test_try_success(); 437 test_try_success();
@@ -514,7 +521,7 @@ void TestGSymMatrix::matrix_arithmetics(void) @@ -514,7 +521,7 @@ void TestGSymMatrix::matrix_arithmetics(void)
514 try { 521 try {
515 test = m_test; 522 test = m_test;
516 test += m_bigger; 523 test += m_bigger;
517 - test_try_failure(); 524 + test_try_failure("Expected GException::matrix_mismatch exception.");
518 } 525 }
519 catch (GException::matrix_mismatch &e) { 526 catch (GException::matrix_mismatch &e) {
520 test_try_success(); 527 test_try_success();
@@ -578,35 +585,38 @@ void TestGSymMatrix::matrix_functions(void) @@ -578,35 +585,38 @@ void TestGSymMatrix::matrix_functions(void)
578 // Transpose function 585 // Transpose function
579 GSymMatrix test1 = transpose(m_test); 586 GSymMatrix test1 = transpose(m_test);
580 test_assert(check_matrix(m_test), "Test source matrix"); 587 test_assert(check_matrix(m_test), "Test source matrix");
581 - test_assert(check_matrix(test1, 1.0, 0.0), "Test transpose(GSymMatrix) function",  
582 - test1.print()); 588 + test_assert(check_matrix(test1, 1.0, 0.0),
  589 + "Test transpose(GSymMatrix) function",
  590 + "Unexpected transposed matrix:\n"+test1.print());
583 591
584 // Transpose method 592 // Transpose method
585 test1 = m_test; 593 test1 = m_test;
586 test1.transpose(); 594 test1.transpose();
587 test_assert(check_matrix(m_test), "Test source matrix"); 595 test_assert(check_matrix(m_test), "Test source matrix");
588 - test_assert(check_matrix(test1, 1.0, 0.0), "Test GSymMatrix.transpose() method",  
589 - test1.print()); 596 + test_assert(check_matrix(test1, 1.0, 0.0),
  597 + "Test GSymMatrix.transpose() method",
  598 + "Unexpected transposed matrix:\n"+test1.print());
590 599
591 // Convert to general matrix 600 // Convert to general matrix
592 GMatrix test2 = GMatrix(m_test); 601 GMatrix test2 = GMatrix(m_test);
593 test_assert(check_matrix(m_test), "Test source matrix"); 602 test_assert(check_matrix(m_test), "Test source matrix");
594 - test_assert(check_matrix(test2, 1.0, 0.0), "Test GMatrix(GSymMatrix) constructor",  
595 - test2.print()); 603 + test_assert(check_matrix(test2, 1.0, 0.0),
  604 + "Test GMatrix(GSymMatrix) constructor",
  605 + "Unexpected GMatrix:\n"+test2.print());
596 606
597 // Extract lower triangle 607 // Extract lower triangle
598 test2 = m_test.extract_lower_triangle(); 608 test2 = m_test.extract_lower_triangle();
599 test_assert(check_matrix(m_test), "Test source matrix"); 609 test_assert(check_matrix(m_test), "Test source matrix");
600 test_assert(check_matrix_lt(test2, 1.0, 0.0), 610 test_assert(check_matrix_lt(test2, 1.0, 0.0),
601 "Test GSymMatrix.extract_lower_triangle() method", 611 "Test GSymMatrix.extract_lower_triangle() method",
602 - test2.print()); 612 + "Unexpected GMatrix:\n"+test2.print());
603 613
604 // Extract upper triangle 614 // Extract upper triangle
605 test2 = m_test.extract_upper_triangle(); 615 test2 = m_test.extract_upper_triangle();
606 test_assert(check_matrix(m_test), "Test source matrix"); 616 test_assert(check_matrix(m_test), "Test source matrix");
607 test_assert(check_matrix_ut(test2, 1.0, 0.0), 617 test_assert(check_matrix_ut(test2, 1.0, 0.0),
608 "Test GSymMatrix.extract_upper_triangle() method", 618 "Test GSymMatrix.extract_upper_triangle() method",
609 - test2.print()); 619 + "Unexpected GMatrix:\n"+test2.print());
610 620
611 // Return 621 // Return
612 return; 622 return;
@@ -644,7 +654,7 @@ void TestGSymMatrix::matrix_cholesky(void) @@ -644,7 +654,7 @@ void TestGSymMatrix::matrix_cholesky(void)
644 GMatrix cd_lower = cd.extract_lower_triangle(); 654 GMatrix cd_lower = cd.extract_lower_triangle();
645 GMatrix cd_upper = transpose(cd_lower); 655 GMatrix cd_upper = transpose(cd_lower);
646 GMatrix cd_product = cd_lower * cd_upper; 656 GMatrix cd_product = cd_lower * cd_upper;
647 - GMatrix cd_residuals = matrix(m_test) - cd_product; 657 + GMatrix cd_residuals = GMatrix(m_test) - cd_product;
648 double res = (abs(cd_residuals)).max(); 658 double res = (abs(cd_residuals)).max();
649 test_value(res, 0.0, 1.0e-15, "Test cholesky_decompose() method"); 659 test_value(res, 0.0, 1.0e-15, "Test cholesky_decompose() method");
650 660
@@ -654,7 +664,7 @@ void TestGSymMatrix::matrix_cholesky(void) @@ -654,7 +664,7 @@ void TestGSymMatrix::matrix_cholesky(void)
654 GMatrix cd_zero_lower = cd_zero.extract_lower_triangle(); 664 GMatrix cd_zero_lower = cd_zero.extract_lower_triangle();
655 GMatrix cd_zero_upper = transpose(cd_zero_lower); 665 GMatrix cd_zero_upper = transpose(cd_zero_lower);
656 GMatrix cd_zero_product = cd_zero_lower * cd_zero_upper; 666 GMatrix cd_zero_product = cd_zero_lower * cd_zero_upper;
657 - GMatrix cd_zero_residuals = matrix(test_zero) - cd_zero_product; 667 + GMatrix cd_zero_residuals = GMatrix(test_zero) - cd_zero_product;
658 res = (abs(cd_zero_residuals)).max(); 668 res = (abs(cd_zero_residuals)).max();
659 test_value(res, 0.0, 1.0e-15, "Test compressed cholesky_decompose() method"); 669 test_value(res, 0.0, 1.0e-15, "Test compressed cholesky_decompose() method");
660 670
@@ -745,8 +755,8 @@ void TestGSymMatrix::matrix_cholesky(void) @@ -745,8 +755,8 @@ void TestGSymMatrix::matrix_cholesky(void)
745 unit(0,0) = unit(1,1) = unit(2,2) = 1.0; 755 unit(0,0) = unit(1,1) = unit(2,2) = 1.0;
746 GSymMatrix test_inv = m_test; 756 GSymMatrix test_inv = m_test;
747 test_inv.cholesky_invert(); 757 test_inv.cholesky_invert();
748 - GSymMatrix ci_product = m_test * test_inv;  
749 - GSymMatrix ci_residuals = ci_product - unit; 758 + GMatrix ci_product = m_test * test_inv;
  759 + GMatrix ci_residuals = ci_product - unit;
750 res = (abs(ci_residuals)).max(); 760 res = (abs(ci_residuals)).max();
751 test_value(res, 0.0, 1.0e-15, "Test cholesky_invert method"); 761 test_value(res, 0.0, 1.0e-15, "Test cholesky_invert method");
752 762
@@ -755,8 +765,8 @@ void TestGSymMatrix::matrix_cholesky(void) @@ -755,8 +765,8 @@ void TestGSymMatrix::matrix_cholesky(void)
755 unit(0,0) = unit(1,1) = unit(3,3) = 1.0; 765 unit(0,0) = unit(1,1) = unit(3,3) = 1.0;
756 GSymMatrix test_zero_inv = test_zero; 766 GSymMatrix test_zero_inv = test_zero;
757 test_zero_inv.cholesky_invert(); 767 test_zero_inv.cholesky_invert();
758 - GSymMatrix ciz_product = test_zero * test_zero_inv;  
759 - GSymMatrix ciz_residuals = ciz_product - unit; 768 + GMatrix ciz_product = test_zero * test_zero_inv;
  769 + GMatrix ciz_residuals = ciz_product - unit;
760 res = (abs(ciz_residuals)).max(); 770 res = (abs(ciz_residuals)).max();
761 test_value(res, 0.0, 1.0e-15, "Test compressed cholesky_invert method"); 771 test_value(res, 0.0, 1.0e-15, "Test compressed cholesky_invert method");
762 772
@@ -783,7 +793,8 @@ void TestGSymMatrix::matrix_print(void) @@ -783,7 +793,8 @@ void TestGSymMatrix::matrix_print(void)
783 793
784 // Test the print method 794 // Test the print method
785 std::string output = m_test.print(); 795 std::string output = m_test.print();
786 - test_assert((output == reference), "Test matrix printing", output); 796 + test_assert((output == reference), "Test matrix printing",
  797 + "Unexpected print() output:\n"+output);
787 798
788 // Return 799 // Return
789 return; 800 return;