t/Matrix.t

   1 package Math::GSL::Matrix::Test;
   2 use Test::More tests => 225;
   3 use base q{Test::Class};
   4 <<<<<<< HEAD:t/Matrix.t
   5 use Test::More tests => 228;
   6 =======
   7 use strict;
   8
   9 >>>>>>> 4e0e3a8fa228328f7a909236708b409b8f8aa406:t/Matrix.t
  10 use Math::GSL           qw/:all/;
  11 use Math::GSL::Test     qw/:all/;
  12 use Math::GSL::Matrix   qw/:all/;
  13 use Math::GSL::Vector   qw/:all/;
  14 use Math::GSL::Complex  qw/:all/;
  15 use Math::GSL::Errno    qw/:all/;
  16 use Test::Exception;
  17 use Math::Complex;
  18 use Data::Dumper;
  19
  20 BEGIN{ gsl_set_error_handler_off(); }
  21
  22 sub make_fixture : Test(setup) {
  23     my $self = shift;
  24     $self->{matrix} = gsl_matrix_alloc(5,5);
  25     $self->{obj}    = Math::GSL::Matrix->new(5,5);
  26     gsl_matrix_set_zero($self->{matrix});
  27 }
  28
  29 sub teardown : Test(teardown) {
  30     unlink 'matrix' if -f 'matrix';
  31 }
  32
  33 sub GSL_MATRIX_ALLOC : Tests {
  34     my $matrix = gsl_matrix_alloc(5,5);
  35     isa_ok($matrix, 'Math::GSL::Matrix');
  36 }
  37
  38 sub GSL_MATRIX_SET : Tests {
  39     my $self = shift;
  40     map { gsl_matrix_set($self->{matrix}, $_,$_, $_ ** 2) } (0..4);
  41
  42     my @got = map { gsl_matrix_get($self->{matrix}, $_, $_) } (0..4);
  43     ok_similar( [ @got ], [ map { $_**2 } (0..4) ] );
  44 }
  45
  46 sub GSL_MATRIX_CALLOC : Tests {
  47    my $matrix = gsl_matrix_calloc(5,5);
  48    isa_ok($matrix, 'Math::GSL::Matrix');
  49
  50    my @got = map { gsl_matrix_get($matrix, $_, $_) } (0..4);
  51    ok_similar( [ @got ], [ (0) x 5 ], 'gsl_matrix_calloc' );
  52 }
  53
  54 sub GSL_MATRIX_FREE : Tests {
  55    my $matrix = gsl_matrix_calloc(5,5);
  56    isa_ok($matrix, 'Math::GSL::Matrix');
  57
  58    is(gsl_matrix_get($matrix, 0, 0), 0);
  59    gsl_matrix_free($matrix);
  60 }
  61
  62 sub GSL_MATRIX_SUBMATRIX : Tests {
  63    my $matrix = gsl_matrix_alloc(5,5);
  64    map { gsl_matrix_set($matrix, $_,$_, $_) } (0..4);
  65    my $subMatrix = gsl_matrix_submatrix($matrix, 0, 0, 2, 2);
  66    my @got = map { gsl_matrix_get($matrix, $_, $_) } (0..2);
  67    ok_similar( [ @got ], [ 0..2 ] );
  68 }
  69
  70 sub GSL_MATRIX_ROW : Tests {
  71    my $self = shift;
  72    for my $line (0..4) {
  73         map { gsl_matrix_set($self->{matrix}, $_,$line, $_) } (0..4);
  74    }
  75
  76    my $vector_view = gsl_matrix_row($self->{matrix}, 2);
  77    my @got = map { gsl_vector_get($vector_view->{vector}, $_) } (0..4);
  78    ok_similar( [ @got ], [ (2)x 5], 'gsl_matrix_row' );
  79 }
  80
  81 sub GSL_MATRIX_COLUMN : Tests {
  82     my $self = shift;
  83     my $view = gsl_vector_alloc(5);
  84
  85     for my $line (0..4) {
  86         map { gsl_matrix_set($self->{matrix}, $line,$_, $line*$_) } (0..4);
  87     }
  88     $view = gsl_matrix_column($self->{matrix}, 2);
  89     my $vec = $view->swig_vector_get();
  90
  91     my @got = map { gsl_vector_get($vec, $_) } (0..4);
  92     ok_similar( [ @got ], [0,2,4,6,8 ], 'gsl_matrix_column' );
  93 }
  94
  95 sub GSL_MATRIX_DIAGONAL : Tests {
  96    my $matrix = gsl_matrix_alloc(4,4);
  97    map { gsl_matrix_set($matrix, $_,$_, $_) } (0..3);
  98    my $view = gsl_matrix_diagonal($matrix);
  99    # better interface is needed
 100    my $vec = $view->swig_vector_get();
 101
 102    my @got = map { gsl_vector_get($vec, $_) } (0..3);
 103    ok_similar( [ @got ], [ 0 .. 3 ], 'gsl_matrix_diagonal');
 104 }
 105
 106 sub GSL_MATRIX_SUBDIAGONAL : Tests {
 107    my $matrix = gsl_matrix_alloc(4,4);
 108
 109    map { gsl_matrix_set($matrix, $_,$_, $_)     } (0..3);
 110
 111    my $view = gsl_matrix_subdiagonal($matrix, 0);
 112    my $vec  = $view->swig_vector_get();
 113    my @got  = map { gsl_vector_get($vec, $_) } (0..3);
 114    ok_similar( [ @got ], [ 0 .. 3 ], 'gsl_matrix_subdiagonal');
 115 }
 116
 117 sub GSL_MATRIX_SWAP : Tests {
 118    my $self=shift;
 119    map { gsl_matrix_set($self->{matrix}, $_,$_, $_ ** 2) } (0..4);
 120    my $matrix = gsl_matrix_alloc(5,5);
 121    map { gsl_matrix_set($matrix, $_,$_, $_) } (0..4);
 122    ok_status(gsl_matrix_swap($self->{matrix}, $matrix));
 123
 124    my @got = map { gsl_matrix_get($self->{matrix}, $_, $_) } (0..4);
 125    map { is($got[$_], $_) } (0..4);
 126    @got = map { gsl_matrix_get($matrix, $_, $_) } (0..4);
 127    map { is($got[$_], $_** 2) } (0..4);
 128 }
 129
 130 sub GSL_MATRIX_MEMCPY : Tests {
 131    my $self = shift;
 132    my $matrix = gsl_matrix_alloc(5,5);
 133    map { gsl_matrix_set($self->{matrix}, $_,$_, $_ ** 2) } (0..4);
 134    ok_status(gsl_matrix_memcpy($matrix, $self->{matrix}));
 135    ok_similar( [ map { gsl_matrix_get($matrix, $_, $_) } (0..4) ],
 136                [ map {  $_** 2 } (0..4)                        ]
 137    );
 138 }
 139
 140 sub GSL_MATRIX_SWAP_ROWS : Tests {
 141    my $self = shift;
 142    map { gsl_matrix_set($self->{matrix}, 0,$_, $_) } (0..4);
 143    map { gsl_matrix_set($self->{matrix}, 1,$_, 3) } (0..4);
 144    ok_status(gsl_matrix_swap_rows($self->{matrix}, 0, 1));
 145    my @got = map { gsl_matrix_get($self->{matrix}, 1, $_) } (0..4);
 146    map { is($got[$_], $_) } (0..4);
 147    @got = map { gsl_matrix_get($self->{matrix}, 0, $_) } (0..4);
 148    map { is($got[$_], 3) } (0..4);
 149 }
 150
 151 sub GSL_MATRIX_SWAP_COLUMNS : Tests {
 152    my $self = shift;
 153    map { gsl_matrix_set($self->{matrix}, $_,0, $_) } (0..4);
 154    map { gsl_matrix_set($self->{matrix}, $_,1, 3) } (0..4);
 155    ok_status(gsl_matrix_swap_columns($self->{matrix}, 0, 1));
 156    my @got = map { gsl_matrix_get($self->{matrix}, $_, 1) } (0..4);
 157    map { is($got[$_], $_) } (0..4);
 158    @got = map { gsl_matrix_get($self->{matrix}, $_, 0) } (0..4);
 159    map { is($got[$_], 3) } (0..4);
 160 }
 161
 162 sub GSL_MATRIX_SWAP_ROWCOL : Tests {
 163    my $self = shift;
 164    map { gsl_matrix_set($self->{matrix}, 0,$_, $_) } (0..4);
 165    map { gsl_matrix_set($self->{matrix}, $_,2, 2) } (0..4);
 166    ok_status(gsl_matrix_swap_rowcol($self->{matrix}, 0, 2));
 167
 168    my @got = map { gsl_matrix_get($self->{matrix}, $_, 2) } (0..4);
 169    is_deeply( [ @got ], [ qw/2 1 0 3 4/  ] );
 170
 171    @got = map { gsl_matrix_get($self->{matrix}, 0, $_) } (0..4);
 172    is_deeply( [ @got ], [ qw/2 2 2 2 2/ ] );
 173 }
 174
 175 sub GSL_MATRIX_TRANSPOSE_MEMCPY : Tests {
 176    my $self = shift;
 177    map { gsl_matrix_set($self->{matrix}, 0,$_, $_) } (0..4);
 178    my $matrix = gsl_matrix_alloc(5,5);
 179    ok_status(gsl_matrix_transpose_memcpy($matrix, $self->{matrix}));
 180    my @got = map { gsl_matrix_get($matrix, $_, 0) } (0..4);
 181    map { is($got[$_], $_) } (0..4);
 182 }
 183
 184 sub GSL_MATRIX_TRANSPOSE : Tests {
 185    my $self = shift;
 186    map { gsl_matrix_set($self->{matrix}, 0,$_, $_) } (0..4);
 187    is(gsl_matrix_transpose($self->{matrix}), 0);
 188    my @got = map { gsl_matrix_get($self->{matrix}, $_, 0) } (0..4);
 189    map { is($got[$_], $_) } (0..4);
 190 }
 191
 192 sub GSL_MATRIX_ADD : Tests {
 193    my $self = shift;
 194    my $matrix = gsl_matrix_alloc(5, 5);
 195    map { gsl_matrix_set($self->{matrix}, $_, $_, $_) } (0..4);
 196    map { gsl_matrix_set($matrix, $_, $_, $_) } (0..4);
 197    is(gsl_matrix_add($self->{matrix}, $matrix), 0);
 198    my @got = map { gsl_matrix_get($self->{matrix}, $_, $_) } (0..4);
 199    map { is($got[$_], $_*2) } (0..4);
 200 }
 201
 202 sub GSL_MATRIX_SUB : Tests {
 203    my $self = shift;
 204    my $matrix = gsl_matrix_alloc(5, 5);
 205    map { gsl_matrix_set($self->{matrix}, $_, $_, $_) } (0..4);
 206    map { gsl_matrix_set($matrix, $_, $_, $_) } (0..4);
 207    is(gsl_matrix_sub($self->{matrix}, $matrix), 0);
 208    my @got = map { gsl_matrix_get($self->{matrix}, $_, $_) } (0..4);
 209    map { is($got[$_], 0) } (0..4);
 210 }
 211
 212 sub GSL_MATRIX_MUL_ELEMENTS : Tests {
 213    my $self = shift;
 214    my $matrix = gsl_matrix_alloc(5, 5);
 215    map { gsl_matrix_set($self->{matrix}, $_, $_, $_) } (0..4);
 216    map { gsl_matrix_set($matrix, $_, $_, $_) } (0..4);
 217    is(gsl_matrix_mul_elements($self->{matrix}, $matrix), 0);
 218    my @got = map { gsl_matrix_get($self->{matrix}, $_, $_) } (0..4);
 219    map { is($got[$_], $_**2) } (0..4);
 220 }
 221
 222 sub GSL_MATRIX_DIV_ELEMENTS : Tests {
 223    my $self = shift;
 224    my $matrix = gsl_matrix_alloc(5, 5);
 225    map { gsl_matrix_set($self->{matrix}, $_, $_, $_+1) } (0..4);
 226    map { gsl_matrix_set($matrix, $_, $_, $_+1) } (0..4);
 227    is(gsl_matrix_div_elements($self->{matrix}, $matrix), 0);
 228    my @got = map { gsl_matrix_get($self->{matrix}, $_, $_) } (0..4);
 229    map { is($got[$_], 1) } (0..4);
 230 }
 231
 232 sub GSL_MATRIX_SCALE : Tests {
 233    my $self = shift;
 234    map { gsl_matrix_set($self->{matrix}, $_, $_, $_) } (0..4);
 235    is(gsl_matrix_scale($self->{matrix}, 4), 0);
 236    my @got = map { gsl_matrix_get($self->{matrix}, $_, $_) } (0..4);
 237    map { is($got[$_], $_*4) } (0..4);
 238 }
 239
 240 sub GSL_MATRIX_ADD_CONSTANT : Tests {
 241    my $self = shift;
 242    map { gsl_matrix_set($self->{matrix}, $_, $_, $_) } (0..4);
 243    is(gsl_matrix_add_constant($self->{matrix}, 8), 0);
 244    my @got = map { gsl_matrix_get($self->{matrix}, $_, $_) } (0..4);
 245    map { is($got[$_], $_+8) } (0..4);
 246 }
 247
 248 sub GSL_MATRIX_MAX : Tests {
 249    my $self = shift;
 250    for my $row (0..4) {
 251         map { gsl_matrix_set($self->{matrix}, $row, $_, $_**2 ) } (0..4);
 252    }
 253    is(gsl_matrix_max($self->{matrix}), 16);
 254 }
 255
 256 sub GSL_MATRIX_MIN : Tests {
 257    my $self = shift;
 258    for my $row (0..4) {
 259         map { gsl_matrix_set($self->{matrix}, $row, $_, $_**2 ) } (0..4);
 260    }
 261    is(gsl_matrix_min($self->{matrix}), 0);
 262 }
 263
 264 sub GSL_MATRIX_MINMAX : Test {
 265    my $self = shift;
 266    map { gsl_matrix_set($self->{matrix}, $_, $_, $_**2) } (0..4);
 267    my ($min, $max) = gsl_matrix_minmax($self->{matrix});
 268    ok_similar( [ $min, $max ], [ 0, 16], 'gsl_matrix_minmax' );
 269 }
 270
 271 sub GSL_MATRIX_MAX_INDEX : Tests {
 272    my $self = shift;
 273    for my $row (0..3) {
 274         map { gsl_matrix_set($self->{matrix}, $row, $_, $_) } (0..4);
 275    }
 276    map { gsl_matrix_set($self->{matrix}, $_, $_, $_**2) } (0..4);
 277    my ($imax, $jmax) = gsl_matrix_max_index($self->{matrix});
 278    ok_similar( [ $imax, $jmax ], [ 4, 4 ], 'gsl_matrix_max_index' );
 279 }
 280
 281 sub GSL_MATRIX_MIN_INDEX : Tests {
 282    my $self = shift;
 283    map { gsl_matrix_set($self->{matrix}, $_, $_, $_**2) } (0..4);
 284    my ($imin, $jmin) = gsl_matrix_min_index($self->{matrix});
 285    ok_similar( [ $imin, $jmin ], [ 0, 0 ], 'gsl_matrix_min_index' );
 286
 287 }
 288
 289 sub GSL_MATRIX_ISNULL : Tests {
 290    my $self = shift;
 291    for my $line (0..4) {
 292         map { gsl_matrix_set($self->{matrix}, $line, $_, 0) } (0..4);
 293    }
 294    is(gsl_matrix_isnull($self->{matrix}), 1);
 295
 296    for my $line (0..4) {
 297         map { gsl_matrix_set($self->{matrix}, $line, $_, $_) } (0..4);
 298    }
 299
 300    is(gsl_matrix_isnull($self->{matrix}), 0);
 301 }
 302
 303 sub GSL_MATRIX_ISPOS : Tests {
 304    my $self = shift;
 305    my $line;
 306
 307    for($line=0; $line<5; $line++) {
 308    map { gsl_matrix_set($self->{matrix}, $line, $_, -1) } (0..4); }
 309    is(gsl_matrix_ispos($self->{matrix}), 0);
 310
 311    for($line=0; $line<5; $line++) {
 312    map { gsl_matrix_set($self->{matrix}, $line, $_, 1) } (0..4); }
 313    is(gsl_matrix_ispos($self->{matrix}), 1);
 314
 315    for($line=0; $line<5; $line++) {
 316    map { gsl_matrix_set($self->{matrix}, $line, $_, 0) } (0..4); }
 317    is(gsl_matrix_ispos($self->{matrix}), 0);
 318 }
 319
 320 sub GSL_MATRIX_ISNEG : Tests {
 321    my $self = shift;
 322    my $line;
 323
 324    for($line=0; $line<5; $line++) {
 325    map { gsl_matrix_set($self->{matrix}, $line, $_, -1) } (0..4); }
 326    is(gsl_matrix_isneg($self->{matrix}), 1);
 327
 328    for($line=0; $line<5; $line++) {
 329    map { gsl_matrix_set($self->{matrix}, $line, $_, 1) } (0..4); }
 330    is(gsl_matrix_isneg($self->{matrix}), 0);
 331
 332    for($line=0; $line<5; $line++) {
 333    map { gsl_matrix_set($self->{matrix}, $line, $_, 0) } (0..4); }
 334    is(gsl_matrix_isneg($self->{matrix}), 0);
 335 }
 336
 337 sub GSL_MATRIX_ISNONNEG : Tests {
 338     my $self = shift;
 339     for my $row (0..4) {
 340         map { gsl_matrix_set($self->{matrix}, $row, $_, -1) } (0..4);
 341     }
 342     is(gsl_matrix_isnonneg($self->{matrix}), 0);
 343
 344     for my $row (0..4) {
 345         map { gsl_matrix_set($self->{matrix}, $row, $_, 1) } (0..4);
 346     }
 347     is(gsl_matrix_isnonneg($self->{matrix}), 1);
 348
 349     for my $row (0..4) {
 350         map { gsl_matrix_set($self->{matrix}, $row, $_, 0) } (0..4);
 351     }
 352     is(gsl_matrix_isnonneg($self->{matrix}), 1);
 353
 354 }
 355
 356 sub GSL_MATRIX_GET_ROW : Tests {
 357    my $self = shift;
 358    my $vector = gsl_vector_alloc(5);
 359    map { gsl_matrix_set($self->{matrix}, 0, $_, $_) } (0..4);
 360    is(gsl_matrix_get_row($vector, $self->{matrix}, 0), 0);
 361    map { is(gsl_vector_get($vector, $_), $_) } (0..4);
 362 }
 363
 364 sub GSL_MATRIX_GET_COL : Tests {
 365    my $self = shift;
 366    my $vector = gsl_vector_alloc(5);
 367    map { gsl_matrix_set($self->{matrix}, $_, 0, $_) } (0..4);
 368    is(gsl_matrix_get_col($vector, $self->{matrix}, 0), 0);
 369    map { is(gsl_vector_get($vector, $_), $_) } (0..4);
 370 }
 371
 372 sub GSL_MATRIX_SET_ROW : Tests {
 373    my $self = shift;
 374    my $vector = gsl_vector_alloc(5);
 375    map { gsl_vector_set($vector, $_, $_**2) } (0..4);
 376    is(gsl_matrix_set_row($self->{matrix}, 1, $vector), 0);
 377
 378    ok_similar( [ map { gsl_matrix_get($self->{matrix}, 1, $_) } (0..4) ],
 379                [ map { $_ ** 2 } (0..4) ],
 380              );
 381 }
 382
 383 sub GSL_MATRIX_SET_COL : Tests {
 384    my $self = shift;
 385    my $vector = gsl_vector_alloc(5);
 386    map { gsl_vector_set($vector, $_, $_**2) } (0..4);
 387    is(gsl_matrix_set_col($self->{matrix}, 1, $vector), 0);
 388
 389    ok_similar( [ map { gsl_matrix_get($self->{matrix}, $_, 1) } (0..4) ],
 390                [ map { $_ ** 2 } (0..4) ],
 391              );
 392 }
 393
 394 sub GSL_MATRIX_FREAD_FWRITE : Tests {
 395    my $self = shift;
 396    for my $line (0..4) {
 397         map { gsl_matrix_set($self->{matrix}, $line, $_, $_**2) } (0..4);
 398    }
 399
 400    my $fh = gsl_fopen("matrix", 'w');
 401    is( gsl_matrix_fwrite($fh, $self->{matrix}), 0);
 402    gsl_fclose($fh);
 403
 404    for my $line (0..4) {
 405         map { gsl_matrix_set($self->{matrix}, $line, $_, $_**3) } (0..4);
 406    }
 407
 408    $fh = gsl_fopen("matrix", 'r');
 409
 410    is(gsl_matrix_fread($fh, $self->{matrix}), 0);
 411    for my $line (0..4) {
 412         ok_similar(
 413                     [ map { gsl_matrix_get($self->{matrix}, $line, $_) } (0..4) ],
 414                     [ map { $_**2 } (0..4) ],
 415                   );
 416    }
 417    gsl_fclose($fh);
 418 }
 419
 420 sub GSL_MATRIX_FPRINTF_FSCANF : Tests {
 421    my $self = shift;
 422
 423    for my $line (0..4) {
 424         map { gsl_matrix_set($self->{matrix}, $line, $_, $_**2) } (0..4);
 425    }
 426
 427    my $fh = gsl_fopen("matrix", 'w');
 428    is( gsl_matrix_fprintf($fh, $self->{matrix}, "%f"), 0);
 429    ok_status(gsl_fclose($fh));
 430
 431    for my $line (0..4) {
 432         map { gsl_matrix_set($self->{matrix}, $line, $_, $_**3) } (0..4);
 433    }
 434
 435    $fh = gsl_fopen("matrix", 'r');
 436    is(gsl_matrix_fscanf($fh, $self->{matrix}), 0);
 437    for my $line (0..4) {
 438         ok_similar(
 439                     [ map { gsl_matrix_get($self->{matrix}, $line, $_) } (0..4) ],
 440                     [ map { $_**2 } (0..4) ],
 441                   );
 442    }
 443    ok_status(gsl_fclose($fh));
 444 }
 445
 446 sub GSL_MATRIX_MINMAX_INDEX : Tests {
 447    my $self = shift;
 448    my $line;
 449    for ($line = 0; $line<4; $line ++) {
 450    map { gsl_matrix_set($self->{matrix}, $line, $_, $_) } (0..4); }
 451    map { gsl_matrix_set($self->{matrix}, 4, $_, $_**2) } (0..4);
 452    my ($imin, $jmin, $imax, $jmax) = gsl_matrix_minmax_index($self->{matrix});
 453    ok_similar( [ $imin, $jmin, $imax, $jmax ], [ 0, 0, 4, 4], 'gsl_matrix_minmax_index' );
 454 }
 455
 456 sub GSL_MATRIX_ADD_DIAGONAL : Tests {
 457    my $self = shift;
 458    map { gsl_matrix_set($self->{matrix}, $_, $_, $_) } (0..4);
 459    gsl_matrix_add_diagonal($self->{matrix}, 4);
 460    ok_similar( [ map { gsl_matrix_get($self->{matrix}, $_, $_)} (0..4) ],
 461                [ 4 .. 8 ],
 462              );
 463 }
 464
 465 sub GSL_MATRIX_NEW : Tests {
 466    my $self = shift;
 467    isa_ok( $self->{obj}, 'Math::GSL::Matrix' );
 468    isa_ok( $self->{obj}->raw, 'Math::GSL::Matrix::gsl_matrix' );
 469    ok( $self->{obj}->rows == 5, '->rows' );
 470    ok( $self->{obj}->cols == 5, '->cols' );
 471 }
 472
 473 sub AS_LIST_SQUARE : Tests {
 474     my $matrix = Math::GSL::Matrix->new(5,5);
 475     map { gsl_matrix_set($matrix->raw, $_, $_, 5 + $_**2) } (0..4);
 476     is_deeply( [
 477                 5, 0, 0, 0, 0,
 478                 0, 6, 0, 0, 0,
 479                 0, 0, 9, 0, 0,
 480                 0, 0, 0,14, 0,
 481                 0, 0, 0, 0, 21
 482                 ],
 483                [ $matrix->as_list],
 484                '$matrix->as_list',
 485     );
 486 }
 487
 488 sub AS_LIST_ROW : Tests {
 489     my $matrix = Math::GSL::Matrix->new(1,5);
 490     map { gsl_matrix_set($matrix->raw, 0 , $_, 5 + $_**2) } (0..4);
 491     is_deeply( [ 5, 6, 9, 14, 21, ],
 492                [ $matrix->as_list],
 493                '$matrix->as_list',
 494     );
 495 }
 496
 497 sub ROW : Tests {
 498     my $matrix = Math::GSL::Matrix->new(5,5);
 499     map { gsl_matrix_set($matrix->raw, $_, $_, 5 + $_**2) } (0..4);
 500     ok_similar( [qw/0 0 9 0 0/] , [$matrix->row(2)->as_list ] );
 501     map { gsl_matrix_set($matrix->raw, 0, $_, $_) } (0..4);
 502     ok_similar( [qw/0 1 2 3 4/] , [$matrix->row(0)->as_list ] );
 503 }
 504
 505 sub COL : Tests {
 506     my $matrix = Math::GSL::Matrix->new(3,3);
 507     map { gsl_matrix_set($matrix->raw, $_, $_, 7 + $_**2) } (0..2);
 508     ok_similar([7,0,0], [$matrix->col(0)->as_list]);
 509 }
 510
 511 sub NEW_SETS_VALUES_TO_ZERO : Tests {
 512     my $matrix = Math::GSL::Matrix->new(5,5);
 513     my $sum;
 514
 515     map { $sum += $_ } $matrix->as_list;
 516     ok( $sum == 0, 'new sets values to zero');
 517 }
 518
 519 sub SET_ROW : Tests {
 520     my $m = Math::GSL::Matrix->new(3,3);
 521     $m->set_row(0, [1,2,3]);
 522     ok_similar([$m->row(0)->as_list], [1,2,3]);
 523 }
 524 sub SET_ROW_CHAINED : Tests {
 525     my $m = Math::GSL::Matrix->new(3,3);
 526     $m->set_row(1, [4,5,6])
 527       ->set_row(2, [9,8,7]);
 528     ok_similar([$m->row(1)->as_list], [4,5,6]);
 529     ok_similar([$m->row(2)->as_list], [9,8,7]);
 530 }
 531
 532 sub SET_COL_CHAINED : Tests {
 533     my $m = Math::GSL::Matrix->new(3,3);
 534     $m->set_col(1, [4,5,6])
 535       ->set_col(2, [9,8,7]);
 536     ok_similar([$m->col(1)->as_list], [4,5,6]);
 537     ok_similar([$m->col(2)->as_list], [9,8,7]);
 538 }
 539
 540 sub GSL_MATRIX_VIEW_ARRAY : Tests {
 541     my $array = [8,4,3,7];
 542     my $matrix_view = gsl_matrix_view_array ($array, 2,2);
 543     ok_similar([map { gsl_matrix_get($matrix_view->{matrix}, 0, $_) } 0..1], [8, 4]);
 544     ok_similar([map { gsl_matrix_get($matrix_view->{matrix}, 1, $_) } 0..1], [3, 7]);
 545 }
 546
 547 sub GSL_MATRIX_VIEW_ARRAY_WITH_TDA : Tests {
 548     my $array = [8,4,3,7,5];
 549     my $matrix_view = gsl_matrix_view_array_with_tda ($array, 2,2, 3);
 550     ok_similar([map { gsl_matrix_get($matrix_view->{matrix}, 0, $_) } 0..1], [8, 4]);
 551     ok_similar([map { gsl_matrix_get($matrix_view->{matrix}, 1, $_) } 0..1], [7, 5]);
 552 }
 553
 554 sub GSL_MATRIX_OO_ADDITION_CONSTANT : Tests {
 555     my $m = Math::GSL::Matrix->new(3,3);
 556     $m->set_col(1, [4,5,6])
 557       ->set_col(2, [9,8,7]);
 558     my $m2 = $m + 4;
 559     ok_similar([$m->col(2)->as_list], [9,8,7]);
 560     ok_similar([$m->col(1)->as_list], [4,5,6]);
 561     ok_similar([$m->col(0)->as_list], [0,0,0]);
 562
 563     ok_similar([$m2->col(1)->as_list], [8,9,10]);
 564     ok_similar([$m2->col(2)->as_list], [13,12,11]);
 565     ok_similar([$m2->col(0)->as_list], [4,4,4]);
 566
 567     my $m3 = 4 + $m;
 568     ok_similar([$m3->col(1)->as_list], [8,9,10]);
 569     ok_similar([$m3->col(2)->as_list], [13,12,11]);
 570     ok_similar([$m3->col(0)->as_list], [4,4,4]);
 571 }
 572
 573 sub GSL_MATRIX_OO_ADDITION_MATRICES : Tests {
 574     my $m = Math::GSL::Matrix->new(3,3);
 575     $m->set_col(1, [4,5,6])
 576       ->set_col(2, [9,8,7])
 577       ->set_col(0, [1,2,3]);
 578     my $m2 = $m + $m;
 579     ok_similar([$m->col(0)->as_list], [1,2,3]);
 580     ok_similar([$m->col(2)->as_list], [9,8,7]);
 581     ok_similar([$m->col(1)->as_list], [4,5,6]);
 582
 583     ok_similar([$m2->col(0)->as_list], [2,4,6]);
 584     ok_similar([$m2->col(1)->as_list], [8,10,12]);
 585     ok_similar([$m2->col(2)->as_list], [18,16,14]);
 586 }
 587
 588 sub GSL_MATRIX_OO_SUBSTRACTION_CONSTANT : Tests {
 589     my $m = Math::GSL::Matrix->new(3,3);
 590     $m->set_col(1, [4,5,6])
 591       ->set_col(2, [9,8,7]);
 592     my $m2 = $m - 4;
 593     ok_similar([$m->col(2)->as_list], [9,8,7]);
 594     ok_similar([$m->col(1)->as_list], [4,5,6]);
 595     ok_similar([$m->col(0)->as_list], [0,0,0]);
 596
 597     ok_similar([$m2->col(1)->as_list], [0,1,2]);
 598     ok_similar([$m2->col(2)->as_list], [5,4,3]);
 599     ok_similar([$m2->col(0)->as_list], [-4,-4,-4]);
 600 }
 601
 602 sub GSL_MATRIX_OO_SUBSTRACTION_MATRICES : Tests {
 603     my $m = Math::GSL::Matrix->new(3,3);
 604     my $m3 = Math::GSL::Matrix->new(3,3);
 605     $m->set_col(1, [4,5,6])
 606       ->set_col(2, [9,8,7])
 607       ->set_col(0, [1,2,3]);
 608     $m3->set_col(1, [1,2,3])
 609        ->set_col(2, [9,8,7])
 610        ->set_col(0, [1,2,3]);
 611     my $m2 = $m - $m3;
 612     ok_similar([$m->col(0)->as_list], [1,2,3]);
 613     ok_similar([$m->col(2)->as_list], [9,8,7]);
 614     ok_similar([$m->col(1)->as_list], [4,5,6]);
 615
 616     ok_similar([$m2->col(0)->as_list], [0,0,0]);
 617     ok_similar([$m2->col(1)->as_list], [3,3,3]);
 618     ok_similar([$m2->col(2)->as_list], [0,0,0]);
 619 }
 620
 621 sub GSL_MATRIX_OO_MULTIPLICATION_CONSTANT : Tests {
 622     my $m = Math::GSL::Matrix->new(3,3);
 623     $m->set_col(1, [4,5,6])
 624       ->set_col(2, [9,8,7]);
 625     my $m2 = $m . 4;
 626     ok_similar([$m->col(2)->as_list], [9,8,7]);
 627     ok_similar([$m->col(1)->as_list], [4,5,6]);
 628     ok_similar([$m->col(0)->as_list], [0,0,0]);
 629
 630     ok_similar([$m2->col(1)->as_list], [16,20,24]);
 631     ok_similar([$m2->col(2)->as_list], [36,32,28]);
 632     ok_similar([$m2->col(0)->as_list], [0,0,0]);
 633
 634     my $m3 = 4 . $m;
 635     ok_similar([$m3->col(1)->as_list], [16,20,24]);
 636     ok_similar([$m3->col(2)->as_list], [36,32,28]);
 637     ok_similar([$m3->col(0)->as_list], [0,0,0]);
 638 }
 639
 640 sub GSL_MATRIX_OO_MULTIPLICATION_MATRICES : Tests {
 641     my $m = Math::GSL::Matrix->new(3,3);
 642     my $m3 = Math::GSL::Matrix->new(3,3);
 643     $m->set_col(1, [4,5,6])
 644       ->set_col(2, [9,8,7])
 645       ->set_col(0, [1,2,3]);
 646     $m3->set_col(1, [1,2,3])
 647        ->set_col(2, [9,8,7])
 648        ->set_col(0, [1,2,3]);
 649     my $m2 = $m . $m3;
 650     ok_similar([$m->col(0)->as_list], [1,2,3]);
 651     ok_similar([$m->col(2)->as_list], [9,8,7]);
 652     ok_similar([$m->col(1)->as_list], [4,5,6]);
 653
 654     ok_similar([$m2->col(0)->as_list], [1,4,9]);
 655     ok_similar([$m2->col(1)->as_list], [4,10,18]);
 656     ok_similar([$m2->col(2)->as_list], [81,64,49]);
 657 }
 658
 659 sub GSL_MATRIX_EIGENVALUES: Tests(6) {
 660     my $matrix = Math::GSL::Matrix->new(2,2)
 661                               ->set_row(0, [0,-1] )
 662                               ->set_row(1, [1, 0] );
 663     my @eigs = $matrix->eigenvalues;
 664     ok_similar( [ Re($eigs[0]), Im($eigs[0]) ], [ 0,  1 ] ); #  i
 665     ok_similar( [ Re($eigs[1]), Im($eigs[1]) ], [ 0, -1 ] ); # -i
 666
 667     my $rect = Math::GSL::Matrix->new(2,4);
 668     dies_ok( sub { $rect->eigenvalues }, 'eigenvalues for square matrices only' );
 669
 670     my $matrix2 = Math::GSL::Matrix->new(2,2)
 671                               ->set_row(0, [1, 0] )
 672                               ->set_row(1, [0, 1] );
 673     my @eigs2 = $matrix2->eigenvalues;
 674     ok_similar( [ @eigs2 ], [ 1, 1 ] );
 675
 676     my $matrix3 = Math::GSL::Matrix->new(2,2);
 677     ok_similar( [ $matrix3->eigenvalues ], [ 0, 0 ], 'zero matrix eigenvalues = 0');
 678
 679     my $matrix4 = Math::GSL::Matrix->new(2,2)
 680                               ->set_row(0, [1, 3] )
 681                               ->set_row(1, [4, 2] );
 682     ok_similar( [ $matrix4->eigenvalues ], [ -2, 5 ] );
 683 }
 684
 685 sub GSL_MATRIX_EIGENPAIR : Tests(11) {
 686     my $matrix = Math::GSL::Matrix->new(2,2)
 687                               ->set_row(0, [0,-1] )
 688                               ->set_row(1, [1, 0] );
 689
 690     my ($eigenvalues, $eigenvectors) = $matrix->eigenpair;
 691     cmp_ok( $#$eigenvalues, '==', $#$eigenvectors, 'same # of values as vectors');
 692
 693     my ($eig1,$eig2) = @$eigenvalues;
 694     isa_ok( $eig1, 'Math::Complex');
 695     isa_ok( $eig2, 'Math::Complex');
 696
 697     ok_similar( [ Re $eig1 ], [ 0 ] );
 698     ok_similar( [ Im $eig1 ], [ 1 ] );
 699
 700     ok_similar( [ Re $eig2 ], [ 0   ] );
 701     ok_similar( [ Im $eig2 ], [ -1  ] );
 702
 703     my ($u,$v)       = @$eigenvectors;
 704
 705     isa_ok( $u, 'Math::GSL::VectorComplex' );
 706     isa_ok( $v, 'Math::GSL::VectorComplex' );
 707
 708     local $TODO = qq{ VectorComplex->as_list is funky };
 709     # we happen to know that these are real eigenvectors
 710     my ($u1,$u2)     = map { Re $_ } $u->as_list;
 711     my ($v1,$v2)     = map { Re $_ } $v->as_list;
 712     my $sqrt2by2     = sqrt(2)/2;
 713
 714     ok_similar( [ $u1, $u2 ], [ $sqrt2by2, - $sqrt2by2 ] );
 715     ok_similar( [ $v1, $v2 ], [ $sqrt2by2,   $sqrt2by2 ] );
 716
 717 }
 718
 719 sub DOT_PRODUCT_OVERLOAD : Tests {
 720     my $A = Math::GSL::Matrix->new(2,2)
 721                              ->set_row(0, [1,3] )
 722                              ->set_row(1, [4, 2] );
 723     my $B = Math::GSL::Matrix->new(2,2)
 724                              ->set_row(0, [2,5] )
 725                              ->set_row(1, [1, 3] );
 726     my $C = $A * $B;
 727         print Dumper [$C];
 728 #    my @got = $C->row(0)->as_list;
 729 #    ok_similar([@got], [22, 13]);
 730 #    @got = $C->row(1)->as_list;
 731 #    ok_similar([@got], [16, 9]);
 732 }
 733 Test::Class->runtests;