1 #include <libgeodecomp/storage/sellcsigmasparsematrixcontainer.h> 2 #include <cxxtest/TestSuite.h> 3 #include <iostream> 4 #include <cstdlib> 5 6 7 using namespace LibGeoDecomp; 8 9 namespace LibGeoDecomp { 10 11 class SellCSigmaSparseMatrixContainerTest : public CxxTest::TestSuite 12 { 13 public: 14 // test with a 8x8 diagonal Matrix, C = 1; Sigma = 1 testGetRow_one()15 void testGetRow_one() 16 { 17 //std::cout << "\n\n\nTEST 1: C=1 Sigma=1 Diagonalmatrix sotiert" <<std::endl; 18 SellCSigmaSparseMatrixContainer<int, 1, 1> smc(8); 19 20 /* add a test 8x8 Matrix: 21 * 1 0 0 0 0 0 0 0 22 * 0 2 0 0 0 0 0 0 23 * 0 0 3 0 0 0 0 0 24 * 0 0 0 4 0 0 0 0 25 * 0 0 0 0 5 0 0 0 26 * 0 0 0 0 0 6 0 0 27 * 0 0 0 0 0 0 7 0 28 * 0 0 0 0 0 0 0 8 29 */ 30 31 smc.addPoint(0, 0, 1); 32 smc.addPoint(1, 1, 2); 33 smc.addPoint(2, 2, 3); 34 smc.addPoint(3, 3, 4); 35 smc.addPoint(4, 4, 5); 36 smc.addPoint(5, 5, 6); 37 smc.addPoint(6, 6, 7); 38 smc.addPoint(7, 7, 8); 39 40 std::vector< std::pair<int, int> > row0; 41 std::pair<int, int> pair0(0, 1); 42 row0.push_back(pair0); 43 std::vector< std::pair<int, int> > row1; 44 std::pair<int, int> pair1(1, 2); 45 row1.push_back(pair1); 46 std::vector< std::pair<int, int> > row2; 47 std::pair<int, int> pair2(2, 3); 48 row2.push_back(pair2); 49 std::vector< std::pair<int, int> > row3; 50 std::pair<int, int> pair3(3, 4); 51 row3.push_back(pair3); 52 std::vector< std::pair<int, int> > row4; 53 std::pair<int, int> pair4(4, 5); 54 row4.push_back(pair4); 55 std::vector< std::pair<int, int> > row5; 56 std::pair<int, int> pair5(5, 6); 57 row5.push_back(pair5); 58 std::vector< std::pair<int, int> > row6; 59 std::pair<int, int> pair6(6, 7); 60 row6.push_back(pair6); 61 std::vector< std::pair<int, int> > row7; 62 std::pair<int, int> pair7(7, 8); 63 row7.push_back(pair7); 64 65 TS_ASSERT_EQUALS( 66 smc.getRow(0), 67 row0 68 ); 69 TS_ASSERT_EQUALS( 70 smc.getRow(1), 71 row1 72 ); 73 TS_ASSERT_EQUALS( 74 smc.getRow(2), 75 row2 76 ); 77 TS_ASSERT_EQUALS( 78 smc.getRow(3), 79 row3 80 ); 81 TS_ASSERT_EQUALS( 82 smc.getRow(4), 83 row4 84 ); 85 TS_ASSERT_EQUALS( 86 smc.getRow(5), 87 row5 88 ); 89 TS_ASSERT_EQUALS( 90 smc.getRow(6), 91 row6 92 ); 93 TS_ASSERT_EQUALS( 94 smc.getRow(7), 95 row7 96 ); 97 } 98 99 // test with a 8x8 diagonal Matrix, C = 1; Sigma = 1 100 // randome addPoints testGetRow_two()101 void testGetRow_two() 102 { 103 SellCSigmaSparseMatrixContainer<int, 1, 1> smc(8); 104 105 /* add a test 8x8 Matrix: 106 * 1 0 0 0 0 0 0 0 107 * 0 2 0 0 0 0 0 0 108 * 0 0 3 0 0 0 0 0 109 * 0 0 0 4 0 0 0 0 110 * 0 0 0 0 5 0 0 0 111 * 0 0 0 0 0 6 0 0 112 * 0 0 0 0 0 0 7 0 113 * 0 0 0 0 0 0 0 8 114 */ 115 116 smc.addPoint(1, 1, 2); 117 smc.addPoint(0, 0, 1); 118 smc.addPoint(6, 6, 7); 119 smc.addPoint(4, 4, 5); 120 smc.addPoint(7, 7, 8); 121 smc.addPoint(2, 2, 3); 122 smc.addPoint(5, 5, 6); 123 smc.addPoint(3, 3, 4); 124 125 std::vector< std::pair<int, int> > row0; 126 std::pair<int, int> pair0(0, 1); 127 row0.push_back(pair0); 128 std::vector< std::pair<int, int> > row1; 129 std::pair<int, int> pair1(1, 2); 130 row1.push_back(pair1); 131 std::vector< std::pair<int, int> > row2; 132 std::pair<int, int> pair2(2, 3); 133 row2.push_back(pair2); 134 std::vector< std::pair<int, int> > row3; 135 std::pair<int, int> pair3(3, 4); 136 row3.push_back(pair3); 137 std::vector< std::pair<int, int> > row4; 138 std::pair<int, int> pair4(4, 5); 139 row4.push_back(pair4); 140 std::vector< std::pair<int, int> > row5; 141 std::pair<int, int> pair5(5, 6); 142 row5.push_back(pair5); 143 std::vector< std::pair<int, int> > row6; 144 std::pair<int, int> pair6(6, 7); 145 row6.push_back(pair6); 146 std::vector< std::pair<int, int> > row7; 147 std::pair<int, int> pair7(7, 8); 148 row7.push_back(pair7); 149 150 TS_ASSERT_EQUALS( 151 smc.getRow(0), 152 row0 153 ); 154 TS_ASSERT_EQUALS( 155 smc.getRow(1), 156 row1 157 ); 158 TS_ASSERT_EQUALS( 159 smc.getRow(2), 160 row2 161 ); 162 TS_ASSERT_EQUALS( 163 smc.getRow(3), 164 row3 165 ); 166 TS_ASSERT_EQUALS( 167 smc.getRow(4), 168 row4 169 ); 170 TS_ASSERT_EQUALS( 171 smc.getRow(5), 172 row5 173 ); 174 TS_ASSERT_EQUALS( 175 smc.getRow(6), 176 row6 177 ); 178 TS_ASSERT_EQUALS( 179 smc.getRow(7), 180 row7 181 ); 182 } 183 184 // test with a 8x8 diagonal Matrix, C = 2; Sigma = 1 185 // randome addPoints testGetRow_three()186 void testGetRow_three() 187 { 188 189 int const C(2); 190 int const SIGMA(1); 191 SellCSigmaSparseMatrixContainer<int, C, SIGMA> smc(8); 192 193 /* add a test 8x8 Matrix: 194 * 1 0 0 0 0 0 0 0 195 * 0 2 0 0 0 0 0 0 196 * 0 0 3 0 0 0 0 0 197 * 0 0 0 4 0 0 0 0 198 * 0 0 0 0 5 0 0 0 199 * 0 0 0 0 0 6 0 0 200 * 0 0 0 0 0 0 7 0 201 * 0 0 0 0 0 0 0 8 202 */ 203 204 smc.addPoint(5, 5, 6); 205 smc.addPoint(1, 1, 2); 206 smc.addPoint(4, 4, 5); 207 smc.addPoint(2, 2, 3); 208 smc.addPoint(0, 0, 1); 209 smc.addPoint(6, 6, 7); 210 smc.addPoint(7, 7, 8); 211 smc.addPoint(3, 3, 4); 212 213 std::vector< std::pair<int, int> > row0; 214 std::pair<int, int> pair0(0, 1); 215 row0.push_back(pair0); 216 std::vector< std::pair<int, int> > row1; 217 std::pair<int, int> pair1(1, 2); 218 row1.push_back(pair1); 219 std::vector< std::pair<int, int> > row2; 220 std::pair<int, int> pair2(2, 3); 221 row2.push_back(pair2); 222 std::vector< std::pair<int, int> > row3; 223 std::pair<int, int> pair3(3, 4); 224 row3.push_back(pair3); 225 std::vector< std::pair<int, int> > row4; 226 std::pair<int, int> pair4(4, 5); 227 row4.push_back(pair4); 228 std::vector< std::pair<int, int> > row5; 229 std::pair<int, int> pair5(5, 6); 230 row5.push_back(pair5); 231 std::vector< std::pair<int, int> > row6; 232 std::pair<int, int> pair6(6, 7); 233 row6.push_back(pair6); 234 std::vector< std::pair<int, int> > row7; 235 std::pair<int, int> pair7(7, 8); 236 row7.push_back(pair7); 237 238 TS_ASSERT_EQUALS( 239 smc.getRow(0), 240 row0 241 ); 242 TS_ASSERT_EQUALS( 243 smc.getRow(1), 244 row1 245 ); 246 TS_ASSERT_EQUALS( 247 smc.getRow(2), 248 row2 249 ); 250 TS_ASSERT_EQUALS( 251 smc.getRow(3), 252 row3 253 ); 254 TS_ASSERT_EQUALS( 255 smc.getRow(4), 256 row4 257 ); 258 TS_ASSERT_EQUALS( 259 smc.getRow(5), 260 row5 261 ); 262 TS_ASSERT_EQUALS( 263 smc.getRow(6), 264 row6 265 ); 266 TS_ASSERT_EQUALS( 267 smc.getRow(7), 268 row7 269 ); 270 } 271 272 // test with a 8x8 diagonal Matrix, C = 2; Sigma = 1 testGetRow_fore()273 void testGetRow_fore() 274 { 275 int const C(3); 276 int const SIGMA(1); 277 SellCSigmaSparseMatrixContainer<int, C, SIGMA> smc(8); 278 279 /* add a test 8x8 Matrix: 280 * 1 0 0 0 0 0 0 0 281 * 0 2 0 0 0 0 0 0 282 * 0 0 3 0 0 0 0 0 283 * 0 0 0 4 0 0 0 0 284 * 0 0 0 0 5 0 0 0 285 * 0 0 0 0 0 6 0 0 286 * 0 0 0 0 0 0 7 0 287 * 0 0 0 0 0 0 0 8 288 */ 289 290 smc.addPoint(0, 0, 1); 291 smc.addPoint(1, 1, 2); 292 smc.addPoint(2, 2, 3); 293 smc.addPoint(3, 3, 4); 294 smc.addPoint(4, 4, 5); 295 smc.addPoint(5, 5, 6); 296 smc.addPoint(6, 6, 7); 297 smc.addPoint(7, 7, 8); 298 299 std::vector< std::pair<int, int> > row0; 300 std::pair<int, int> pair0(0, 1); 301 row0.push_back(pair0); 302 std::vector< std::pair<int, int> > row1; 303 std::pair<int, int> pair1(1, 2); 304 row1.push_back(pair1); 305 std::vector< std::pair<int, int> > row2; 306 std::pair<int, int> pair2(2, 3); 307 row2.push_back(pair2); 308 std::vector< std::pair<int, int> > row3; 309 std::pair<int, int> pair3(3, 4); 310 row3.push_back(pair3); 311 std::vector< std::pair<int, int> > row4; 312 std::pair<int, int> pair4(4, 5); 313 row4.push_back(pair4); 314 std::vector< std::pair<int, int> > row5; 315 std::pair<int, int> pair5(5, 6); 316 row5.push_back(pair5); 317 std::vector< std::pair<int, int> > row6; 318 std::pair<int, int> pair6(6, 7); 319 row6.push_back(pair6); 320 std::vector< std::pair<int, int> > row7; 321 std::pair<int, int> pair7(7, 8); 322 row7.push_back(pair7); 323 324 TS_ASSERT_EQUALS( 325 smc.getRow(0), 326 row0 327 ); 328 TS_ASSERT_EQUALS( 329 smc.getRow(1), 330 row1 331 ); 332 TS_ASSERT_EQUALS( 333 smc.getRow(2), 334 row2 335 ); 336 TS_ASSERT_EQUALS( 337 smc.getRow(3), 338 row3 339 ); 340 TS_ASSERT_EQUALS( 341 smc.getRow(4), 342 row4 343 ); 344 TS_ASSERT_EQUALS( 345 smc.getRow(5), 346 row5 347 ); 348 TS_ASSERT_EQUALS( 349 smc.getRow(6), 350 row6 351 ); 352 TS_ASSERT_EQUALS( 353 smc.getRow(7), 354 row7 355 ); 356 } 357 358 // test with a 9x9 sparse Matrix, C = 3; Sigma = 1 testGetRow_five()359 void testGetRow_five() 360 { 361 int const C(3); 362 int const SIGMA(1); 363 SellCSigmaSparseMatrixContainer<char, C, SIGMA> smc(9); 364 365 /* add a test 8x8 Matrix: 366 * col 367 * row | 0 1 2 3 4 5 6 7 8 chunk # 368 * ____|_______________________________ 369 * 0 | 0 0 0 0 A 0 0 0 0 | 370 * 1 | 0 0 0 0 0 0 0 0 0 |-> chunk 0 371 * 2 | 0 0 0 0 B 0 C 0 0 | 372 * ----+------------------------------- 373 * 3 | 0 0 D 0 0 0 0 E F | 374 * 4 | G 0 0 0 0 H 0 0 0 |-> chunk 1 375 * 5 | 0 I J 0 0 0 0 0 0 | 376 * ----+------------------------------- 377 * 6 | 0 0 0 K 0 0 0 0 0 | 378 * 7 | L 0 M 0 N 0 O 0 P |-> chunk 2 379 * 8 | 0 0 0 S 0 Q 0 R 0 | 380 */ 381 382 smc.addPoint(4, 0, 'G'); 383 smc.addPoint(8, 7, 'R'); 384 smc.addPoint(6, 3, 'K'); 385 smc.addPoint(7, 6, 'O'); 386 smc.addPoint(7, 4, 'N'); 387 smc.addPoint(7, 2, 'M'); 388 smc.addPoint(0, 4, 'A'); 389 smc.addPoint(3, 8, 'F'); 390 smc.addPoint(7, 0, 'L'); 391 smc.addPoint(3, 7, 'E'); 392 smc.addPoint(2, 4, 'B'); 393 smc.addPoint(5, 1, 'I'); 394 smc.addPoint(7, 8, 'P'); 395 smc.addPoint(3, 2, 'D'); 396 smc.addPoint(8, 5, 'Q'); 397 smc.addPoint(8, 3, 'S'); 398 smc.addPoint(5, 2, 'J'); 399 smc.addPoint(4, 5, 'H'); 400 smc.addPoint(2, 6, 'C'); 401 402 std::vector< std::pair<int, char> > row0; 403 std::pair<int, char> pair0(4, 'A'); 404 row0.push_back(pair0); 405 406 std::vector< std::pair<int, char> > row1; 407 408 std::vector< std::pair<int, char> > row2; 409 std::pair<int, char> pair1(4, 'B'); 410 std::pair<int, char> pair2(6, 'C'); 411 row2.push_back(pair1); 412 row2.push_back(pair2); 413 414 std::vector< std::pair<int, char> > row3; 415 std::pair<int, char> pair3(2, 'D'); 416 std::pair<int, char> pair4(7, 'E'); 417 std::pair<int, char> pair5(8, 'F'); 418 row3.push_back(pair3); 419 row3.push_back(pair4); 420 row3.push_back(pair5); 421 422 std::vector< std::pair<int, char> > row4; 423 std::pair<int, char> pair6(0, 'G'); 424 std::pair<int, char> pair7(5, 'H'); 425 row4.push_back(pair6); 426 row4.push_back(pair7); 427 428 std::vector< std::pair<int, char> > row5; 429 std::pair<int, char> pair8(1, 'I'); 430 std::pair<int, char> pair9(2, 'J'); 431 row5.push_back(pair8); 432 row5.push_back(pair9); 433 434 std::vector< std::pair<int, char> > row6; 435 std::pair<int, char> pair10(3, 'K'); 436 row6.push_back(pair10); 437 438 std::vector< std::pair<int, char> > row7; 439 std::pair<int, char> pair11(0, 'L'); 440 std::pair<int, char> pair12(2, 'M'); 441 std::pair<int, char> pair13(4, 'N'); 442 std::pair<int, char> pair14(6, 'O'); 443 std::pair<int, char> pair15(8, 'P'); 444 row7.push_back(pair11); 445 row7.push_back(pair12); 446 row7.push_back(pair13); 447 row7.push_back(pair14); 448 row7.push_back(pair15); 449 450 std::vector< std::pair<int, char> > row8; 451 std::pair<int, char> pair16(5, 'Q'); 452 std::pair<int, char> pair17(7, 'R'); 453 std::pair<int, char> pair18(3, 'S'); 454 row8.push_back(pair18); 455 row8.push_back(pair16); 456 row8.push_back(pair17); 457 458 459 TS_ASSERT_EQUALS( 460 smc.getRow(0), 461 row0 462 ); 463 TS_ASSERT_EQUALS( 464 smc.getRow(1), 465 row1 466 ); 467 TS_ASSERT_EQUALS( 468 smc.getRow(2), 469 row2 470 ); 471 TS_ASSERT_EQUALS( 472 smc.getRow(3), 473 row3 474 ); 475 TS_ASSERT_EQUALS( 476 smc.getRow(4), 477 row4 478 ); 479 TS_ASSERT_EQUALS( 480 smc.getRow(5), 481 row5 482 ); 483 TS_ASSERT_EQUALS( 484 smc.getRow(6), 485 row6 486 ); 487 TS_ASSERT_EQUALS( 488 smc.getRow(7), 489 row7 490 ); 491 TS_ASSERT_EQUALS( 492 smc.getRow(8), 493 row8 494 ); 495 } 496 497 // test with a 3x3 diagonal Matrix, C = 2; Sigma = 1 498 // overwite a value testGetRow_six()499 void testGetRow_six() 500 { 501 int const C(2); 502 int const SIGMA(1); 503 SellCSigmaSparseMatrixContainer<int, C, SIGMA> smc(3); 504 505 /* add a test 3x3 Matrix: 506 * 1 0 4 507 * 0 5 0 508 * 0 0 6 509 */ 510 511 smc.addPoint(0, 0, 1); 512 smc.addPoint(0, 2, 4); 513 smc.addPoint(1, 1, 2); 514 smc.addPoint(2, 2, 3); 515 516 smc.addPoint(1, 1, 5); 517 smc.addPoint(2, 2, 6); 518 519 std::vector< std::pair<int, int> > row0; 520 std::pair<int, int> pair0(0, 1); 521 std::pair<int, int> pair3(2, 4); 522 row0.push_back(pair0); 523 row0.push_back(pair3); 524 std::vector< std::pair<int, int> > row1; 525 std::pair<int, int> pair1(1, 5); 526 row1.push_back(pair1); 527 std::vector< std::pair<int, int> > row2; 528 std::pair<int, int> pair2(2, 6); 529 row2.push_back(pair2); 530 531 TS_ASSERT_EQUALS( 532 smc.getRow(0), 533 row0 534 ); 535 TS_ASSERT_EQUALS( 536 smc.getRow(1), 537 row1 538 ); 539 TS_ASSERT_EQUALS( 540 smc.getRow(2), 541 row2 542 ); 543 } 544 testMatVecMul_diag()545 void testMatVecMul_diag() 546 { 547 548 SellCSigmaSparseMatrixContainer<int, 4, 1> smc(8); 549 550 /* add a test 8x8 Matrix: 551 * 1 1 0 0 0 0 0 0 0 1 552 * 2 0 1 0 0 0 0 0 0 2 553 * 3 0 0 1 0 0 0 0 0 3 554 * 4 0 0 0 1 0 0 0 0 4 555 * 5 = 0 0 0 0 1 0 0 0 x 5 556 * 6 0 0 0 0 0 1 0 0 6 557 * 7 0 0 0 0 0 0 1 0 7 558 * 8 0 0 0 0 0 0 0 1 8 559 */ 560 561 smc.addPoint(0, 0, 1); 562 smc.addPoint(1, 1, 1); 563 smc.addPoint(2, 2, 1); 564 smc.addPoint(3, 3, 1); 565 smc.addPoint(4, 4, 1); 566 smc.addPoint(5, 5, 1); 567 smc.addPoint(6, 6, 1); 568 smc.addPoint(7, 7, 1); 569 570 std::vector<int> lhs(8); 571 std::vector<int> rhs(8); 572 std::vector<int> expected(8); 573 574 for (int i=0; i<8; ++i) { 575 rhs[i] = i+1; 576 expected[i] = i+1; 577 } 578 579 smc.matVecMul(lhs, rhs); 580 581 TS_ASSERT_EQUALS( 582 lhs, 583 expected 584 ); 585 586 587 } 588 testMatVecMul_easy()589 void testMatVecMul_easy() 590 { 591 592 SellCSigmaSparseMatrixContainer<int, 2, 1> smc(4); 593 594 /* add a test 4x4 Matrix: 595 * 3 0 0 1 0 1 596 * 1 1 0 0 0 2 597 * 4 = 0 0 0 1 x 3 598 * 2 0 1 0 0 4 599 */ 600 601 smc.addPoint(0, 2, 1); 602 smc.addPoint(1, 0, 1); 603 smc.addPoint(2, 3, 1); 604 smc.addPoint(3, 1, 1); 605 606 std::vector<int> lhs(4); 607 std::vector<int> rhs(4); 608 std::vector<int> expected(4); 609 610 for (int i=0; i<4; ++i) { 611 rhs[i] = i+1; 612 } 613 614 expected[0] = 3; 615 expected[1] = 1; 616 expected[2] = 4; 617 expected[3] = 2; 618 619 smc.matVecMul(lhs, rhs); 620 621 TS_ASSERT_EQUALS( 622 lhs, 623 expected 624 ); 625 } 626 627 testMatVecMul_two()628 void testMatVecMul_two() 629 { 630 631 SellCSigmaSparseMatrixContainer<int, 2, 1> smc(4); 632 633 /* add a test 4x4 Matrix: 634 * -4 0 1 2 -3 1 635 * 12 -4 3 2 1 2 636 * 12 = 2 -3 4 1 x 3 637 * 13 3 4 2 -1 4 638 */ 639 640 smc.addPoint(0, 0, 0); 641 smc.addPoint(0, 1, 1); 642 smc.addPoint(0, 2, 2); 643 smc.addPoint(0, 3, -3); 644 smc.addPoint(1, 0, -4); 645 smc.addPoint(1, 1, 3); 646 smc.addPoint(1, 2, 2); 647 smc.addPoint(1, 3, 1); 648 smc.addPoint(2, 0, 2); 649 smc.addPoint(2, 1, -3); 650 smc.addPoint(2, 2, 4); 651 smc.addPoint(2, 3, 1); 652 smc.addPoint(3, 0, 3); 653 smc.addPoint(3, 1, 4); 654 smc.addPoint(3, 2, 2); 655 smc.addPoint(3, 3, -1); 656 657 std::vector<int> lhs(4); 658 std::vector<int> rhs(4); 659 std::vector<int> expected(4); 660 661 for (int i=0; i<4; ++i) { 662 rhs[i] = i+1; 663 } 664 665 expected[0] = -4; 666 expected[1] = 12; 667 expected[2] = 12; 668 expected[3] = 13; 669 670 smc.matVecMul(lhs, rhs); 671 672 TS_ASSERT_EQUALS( 673 lhs, 674 expected 675 ); 676 } 677 testEqualOperator()678 void testEqualOperator() 679 { 680 const int DIM = 128; 681 SellCSigmaSparseMatrixContainer<double,2,1> a(DIM); 682 SellCSigmaSparseMatrixContainer<double,2,1> b(DIM); 683 684 for (int i=0; i<DIM; ++i) { 685 a.addPoint(i, abs(i*17+57)%DIM, (i*17+57)/DIM); 686 a.addPoint(i, abs(i*17-57)%DIM, (i*17-57)/DIM); 687 a.addPoint(i, abs(i*57+17)%DIM, (i*57+17)/DIM); 688 689 b.addPoint(i, abs(i*17+57)%DIM, (i*17+57)/DIM); 690 b.addPoint(i, abs(i*17-57)%DIM, (i*17-57)/DIM); 691 b.addPoint(i, abs(i*57+17)%DIM, (i*57+17)/DIM); 692 } 693 694 TS_ASSERT(a == a); 695 TS_ASSERT(a == b); 696 697 b.addPoint(DIM-17, DIM - 7, 0.666); 698 699 TS_ASSERT_EQUALS((a == b), false); 700 701 } 702 703 }; 704 705 } 706