htswanalysis/MACS/lib/gsl/gsl-1.11/matrix/test_source.c

   1 /* matrix/test_source.c
   2  *
   3  * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 3 of the License, or (at
   8  * your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  */
  19
  20 void FUNCTION (test, func) (void);
  21 void FUNCTION (test, trap) (void);
  22 void FUNCTION (test, text) (void);
  23 void FUNCTION (test, binary) (void);
  24
  25 #define TEST(expr,desc) gsl_test((expr), NAME(gsl_matrix) desc " M=%d, N=%d", M, N)
  26
  27 void
  28 FUNCTION (test, func) (void)
  29 {
  30   TYPE (gsl_vector) * v;
  31   size_t i, j;
  32   size_t k = 0;
  33
  34   TYPE (gsl_matrix) * m = FUNCTION (gsl_matrix, alloc) (M, N);
  35
  36   gsl_test (m->data == 0, NAME (gsl_matrix) "_alloc returns valid pointer");
  37   gsl_test (m->size1 != M, NAME (gsl_matrix) "_alloc returns valid size1");
  38   gsl_test (m->size2 != N, NAME (gsl_matrix) "_alloc returns valid size2");
  39   gsl_test (m->tda != N, NAME (gsl_matrix) "_alloc returns valid tda");
  40
  41   for (i = 0; i < M; i++)
  42     {
  43       for (j = 0; j < N; j++)
  44         {
  45           k++;
  46           FUNCTION (gsl_matrix, set) (m, i, j, (BASE) k);
  47         }
  48     }
  49
  50   {
  51     status = 0;
  52     k = 0;
  53     for (i = 0; i < M; i++)
  54       {
  55         for (j = 0; j < N; j++)
  56           {
  57             k++;
  58             if (m->data[i * N + j] != (BASE) k)
  59               status = 1;
  60           };
  61       };
  62
  63     gsl_test (status, NAME (gsl_matrix) "_set writes into array");
  64   }
  65
  66   {
  67     status = 0;
  68     k = 0;
  69     for (i = 0; i < M; i++)
  70       {
  71         for (j = 0; j < N; j++)
  72           {
  73             k++;
  74             if (FUNCTION (gsl_matrix, get) (m, i, j) != (BASE) k)
  75               status = 1;
  76           };
  77       };
  78     gsl_test (status, NAME (gsl_matrix) "_get reads from array");
  79   }
  80
  81
  82   FUNCTION (gsl_matrix, free) (m);      /* free whatever is in m */
  83
  84   m = FUNCTION (gsl_matrix, calloc) (M, N);
  85   v = FUNCTION (gsl_vector, calloc) (N);
  86
  87   {
  88     int status = (FUNCTION(gsl_matrix,isnull)(m) != 1);
  89     TEST (status, "_isnull" DESC " on calloc matrix");
  90
  91     status = (FUNCTION(gsl_matrix,ispos)(m) != 0);
  92     TEST (status, "_ispos" DESC " on calloc matrix");
  93
  94     status = (FUNCTION(gsl_matrix,isneg)(m) != 0);
  95     TEST (status, "_isneg" DESC " on calloc matrix");
  96
  97     status = (FUNCTION(gsl_matrix,isnonneg)(m) != 1);
  98     TEST (status, "_isnonneg" DESC " on calloc matrix");
  99   }
 100
 101
 102   k = 0;
 103   for (i = 0; i < M; i++)
 104     {
 105       for (j = 0; j < N; j++)
 106         {
 107           k++;
 108           FUNCTION (gsl_matrix, set) (m, i, j, (BASE) k);
 109         }
 110     }
 111
 112
 113   {
 114     status = 0;
 115     k = 0;
 116     for (i = 0; i < M; i++)
 117       {
 118         FUNCTION (gsl_matrix, get_row) (v, m, i);
 119
 120         for (j = 0; j < N; j++)
 121           {
 122             k++;
 123             if (v->data[j] != (BASE) k)
 124               status = 1;
 125           }
 126       }
 127
 128     gsl_test (status, NAME (gsl_matrix) "_get_row extracts row");
 129   }
 130
 131   {
 132     BASE exp_max = FUNCTION(gsl_matrix, get) (m, 0, 0);
 133     BASE exp_min = FUNCTION(gsl_matrix, get) (m, 0, 0);
 134     size_t exp_imax = 0, exp_jmax = 0, exp_imin = 0, exp_jmin = 0;
 135
 136     for (i = 0; i < M; i++)
 137       {
 138         for (j = 0; j < N; j++)
 139           {
 140             BASE k = FUNCTION(gsl_matrix, get) (m, i, j);
 141             if (k > exp_max) {
 142               exp_max =  FUNCTION(gsl_matrix, get) (m, i, j);
 143               exp_imax = i;
 144               exp_jmax = j;
 145             }
 146             if (k < exp_min) {
 147               exp_min =  FUNCTION(gsl_matrix, get) (m, i, j);
 148               exp_imin = i;
 149               exp_jmin = j;
 150             }
 151           }
 152       }
 153
 154     {
 155       BASE max = FUNCTION(gsl_matrix, max) (m) ;
 156
 157       gsl_test (max != exp_max, NAME(gsl_matrix) "_max returns correct maximum value");
 158     }
 159
 160     {
 161       BASE min = FUNCTION(gsl_matrix, min) (m) ;
 162
 163       gsl_test (min != exp_min, NAME(gsl_matrix) "_min returns correct minimum value");
 164     }
 165
 166     {
 167       BASE min, max;
 168       FUNCTION(gsl_matrix, minmax) (m, &min, &max);
 169
 170       gsl_test (max != exp_max, NAME(gsl_matrix) "_minmax returns correct maximum value");
 171       gsl_test (min != exp_min, NAME(gsl_matrix) "_minmax returns correct minimum value");
 172     }
 173
 174
 175     {
 176       size_t imax, jmax;
 177       FUNCTION(gsl_matrix, max_index) (m, &imax, &jmax) ;
 178
 179       gsl_test (imax != exp_imax, NAME(gsl_matrix) "_max_index returns correct maximum i");
 180       gsl_test (jmax != exp_jmax, NAME(gsl_matrix) "_max_index returns correct maximum j");
 181     }
 182
 183     {
 184       size_t imin, jmin;
 185       FUNCTION(gsl_matrix, min_index) (m, &imin, &jmin) ;
 186
 187       gsl_test (imin != exp_imin, NAME(gsl_matrix) "_min_index returns correct minimum i");
 188       gsl_test (jmin != exp_jmin, NAME(gsl_matrix) "_min_index returns correct minimum j");
 189     }
 190
 191     {
 192       size_t imin, jmin, imax, jmax;
 193
 194       FUNCTION(gsl_matrix, minmax_index) (m,  &imin, &jmin, &imax, &jmax);
 195
 196       gsl_test (imax != exp_imax, NAME(gsl_matrix) "_minmax_index returns correct maximum i");
 197       gsl_test (jmax != exp_jmax, NAME(gsl_matrix) "_minmax_index returns correct maximum j");
 198
 199       gsl_test (imin != exp_imin, NAME(gsl_matrix) "_minmax_index returns correct minimum i");
 200       gsl_test (jmin != exp_jmin, NAME(gsl_matrix) "_minmax_index returns correct minimum j");
 201     }
 202
 203 #if FP
 204     FUNCTION(gsl_matrix,set)(m, 2, 3, GSL_NAN);
 205     exp_min = GSL_NAN; exp_max = GSL_NAN;
 206     exp_imin = 2; exp_jmin = 3;
 207     exp_imax = 2; exp_jmax = 3;
 208
 209     {
 210       BASE max = FUNCTION(gsl_matrix, max) (m) ;
 211
 212       gsl_test_abs (max,exp_max, 0, NAME(gsl_matrix) "_max returns correct maximum value for NaN");
 213     }
 214
 215     {
 216       BASE min = FUNCTION(gsl_matrix, min) (m) ;
 217
 218       gsl_test_abs (min, exp_min, 0, NAME(gsl_matrix) "_min returns correct minimum value for NaN");
 219     }
 220
 221     {
 222       BASE min, max;
 223       FUNCTION(gsl_matrix, minmax) (m, &min, &max);
 224
 225       gsl_test_abs (max, exp_max, 0, NAME(gsl_matrix) "_minmax returns correct maximum value for NaN");
 226       gsl_test_abs (min, exp_min, 0, NAME(gsl_matrix) "_minmax returns correct minimum value for NaN");
 227     }
 228
 229
 230     {
 231       size_t imax, jmax;
 232       FUNCTION(gsl_matrix, max_index) (m, &imax, &jmax) ;
 233
 234       gsl_test (imax != exp_imax, NAME(gsl_matrix) "_max_index returns correct maximum i for NaN");
 235       gsl_test (jmax != exp_jmax, NAME(gsl_matrix) "_max_index returns correct maximum j for NaN");
 236     }
 237
 238     {
 239       size_t imin, jmin;
 240       FUNCTION(gsl_matrix, min_index) (m, &imin, &jmin) ;
 241
 242       gsl_test (imin != exp_imin, NAME(gsl_matrix) "_min_index returns correct minimum i for NaN");
 243       gsl_test (jmin != exp_jmin, NAME(gsl_matrix) "_min_index returns correct minimum j for NaN");
 244     }
 245
 246     {
 247       size_t imin, jmin, imax, jmax;
 248
 249       FUNCTION(gsl_matrix, minmax_index) (m,  &imin, &jmin, &imax, &jmax);
 250
 251       gsl_test (imax != exp_imax, NAME(gsl_matrix) "_minmax_index returns correct maximum i for NaN");
 252       gsl_test (jmax != exp_jmax, NAME(gsl_matrix) "_minmax_index returns correct maximum j for NaN");
 253
 254       gsl_test (imin != exp_imin, NAME(gsl_matrix) "_minmax_index returns correct minimum i for NaN");
 255       gsl_test (jmin != exp_jmin, NAME(gsl_matrix) "_minmax_index returns correct minimum j for NaN");
 256     }
 257 #endif
 258
 259
 260   }
 261
 262
 263   for (i = 0; i < M; i++)
 264     {
 265       for (j = 0; j < N; j++)
 266         {
 267           FUNCTION (gsl_matrix, set) (m, i, j, (ATOMIC) 0);
 268         }
 269     }
 270
 271   {
 272     status = (FUNCTION(gsl_matrix,isnull)(m) != 1);
 273     TEST (status, "_isnull" DESC " on null matrix") ;
 274
 275     status = (FUNCTION(gsl_matrix,ispos)(m) != 0);
 276     TEST (status, "_ispos" DESC " on null matrix") ;
 277
 278     status = (FUNCTION(gsl_matrix,isneg)(m) != 0);
 279     TEST (status, "_isneg" DESC " on null matrix") ;
 280
 281     status = (FUNCTION(gsl_matrix,isnonneg)(m) != 1);
 282     TEST (status, "_isnonneg" DESC " on null matrix") ;
 283   }
 284
 285
 286   k = 0;
 287   for (i = 0; i < M; i++)
 288     {
 289       for (j = 0; j < N; j++)
 290         {
 291           k++;
 292           FUNCTION (gsl_matrix, set) (m, i, j, (ATOMIC) (k % 10));
 293         }
 294     }
 295
 296   {
 297     status = (FUNCTION(gsl_matrix,isnull)(m) != 0);
 298     TEST (status, "_isnull" DESC " on non-negative matrix") ;
 299
 300     status = (FUNCTION(gsl_matrix,ispos)(m) != 0);
 301     TEST (status, "_ispos" DESC " on non-negative matrix") ;
 302
 303     status = (FUNCTION(gsl_matrix,isneg)(m) != 0);
 304     TEST (status, "_isneg" DESC " on non-negative matrix") ;
 305
 306     status = (FUNCTION(gsl_matrix,isnonneg)(m) != 1);
 307     TEST (status, "_isnonneg" DESC " on non-negative matrix") ;
 308   }
 309
 310 #ifndef UNSIGNED
 311   k = 0;
 312   for (i = 0; i < M; i++)
 313     {
 314       for (j = 0; j < N; j++)
 315         {
 316           ATOMIC mij = ((++k) % 10)  - (ATOMIC) 5;
 317           FUNCTION (gsl_matrix, set) (m, i, j, mij);
 318         }
 319     }
 320
 321   {
 322     status = (FUNCTION(gsl_matrix,isnull)(m) != 0);
 323     TEST (status, "_isnull" DESC " on mixed matrix") ;
 324
 325     status = (FUNCTION(gsl_matrix,ispos)(m) != 0);
 326     TEST (status, "_ispos" DESC " on mixed matrix") ;
 327
 328     status = (FUNCTION(gsl_matrix,isneg)(m) != 0);
 329     TEST (status, "_isneg" DESC " on mixed matrix") ;
 330
 331     status = (FUNCTION(gsl_matrix,isnonneg)(m) != 0);
 332     TEST (status, "_isnonneg" DESC " on mixed matrix") ;
 333   }
 334
 335   k = 0;
 336   for (i = 0; i < M; i++)
 337     {
 338       for (j = 0; j < N; j++)
 339         {
 340           k++;
 341           FUNCTION (gsl_matrix, set) (m, i, j, -(ATOMIC) (k % 10));
 342         }
 343     }
 344
 345   {
 346     status = (FUNCTION(gsl_matrix,isnull)(m) != 0);
 347     TEST (status, "_isnull" DESC " on non-positive matrix") ;
 348
 349     status = (FUNCTION(gsl_matrix,ispos)(m) != 0);
 350     TEST (status, "_ispos" DESC " on non-positive matrix") ;
 351
 352     status = (FUNCTION(gsl_matrix,isneg)(m) != 0);
 353     TEST (status, "_isneg" DESC " on non-positive matrix") ;
 354
 355     status = (FUNCTION(gsl_matrix,isnonneg)(m) != 0);
 356     TEST (status, "_isnonneg" DESC " on non-positive matrix") ;
 357   }
 358 #endif
 359
 360   k = 0;
 361   for (i = 0; i < M; i++)
 362     {
 363       for (j = 0; j < N; j++)
 364         {
 365           k++;
 366           FUNCTION (gsl_matrix, set) (m, i, j, (ATOMIC) (k % 10 + 1));
 367         }
 368     }
 369
 370   {
 371     status = (FUNCTION(gsl_matrix,isnull)(m) != 0);
 372     TEST (status, "_isnull" DESC " on positive matrix") ;
 373
 374     status = (FUNCTION(gsl_matrix,ispos)(m) != 1);
 375     TEST (status, "_ispos" DESC " on positive matrix") ;
 376
 377     status = (FUNCTION(gsl_matrix,isneg)(m) != 0);
 378     TEST (status, "_isneg" DESC " on positive matrix") ;
 379
 380     status = (FUNCTION(gsl_matrix,isnonneg)(m) != 1);
 381     TEST (status, "_isnonneg" DESC " on positive matrix") ;
 382   }
 383
 384 #if (!defined(UNSIGNED) && !defined(BASE_CHAR))
 385   k = 0;
 386   for (i = 0; i < M; i++)
 387     {
 388       for (j = 0; j < N; j++)
 389         {
 390           k++;
 391           FUNCTION (gsl_matrix, set) (m, i, j, -(ATOMIC) (k % 10 + 1));
 392         }
 393     }
 394
 395   {
 396     status = (FUNCTION(gsl_matrix,isnull)(m) != 0);
 397     TEST (status, "_isnull" DESC " on negative matrix") ;
 398
 399     status = (FUNCTION(gsl_matrix,ispos)(m) != 0);
 400     TEST (status, "_ispos" DESC " on negative matrix") ;
 401
 402     status = (FUNCTION(gsl_matrix,isneg)(m) != 1);
 403     TEST (status, "_isneg" DESC " on negative matrix") ;
 404
 405     status = (FUNCTION(gsl_matrix,isnonneg)(m) != 0);
 406     TEST (status, "_isnonneg" DESC " on negative matrix") ;
 407   }
 408 #endif
 409
 410   {
 411     TYPE (gsl_matrix) * a = FUNCTION (gsl_matrix, calloc) (M, N);
 412     TYPE (gsl_matrix) * b = FUNCTION (gsl_matrix, calloc) (M, N);
 413
 414     for (i = 0; i < M; i++)
 415       {
 416         for (j = 0; j < N; j++)
 417           {
 418             FUNCTION (gsl_matrix, set) (a, i, j, (BASE)(3 + i +  5 * j));
 419             FUNCTION (gsl_matrix, set) (b, i, j, (BASE)(3 + 2 * i + 4 * j));
 420           }
 421       }
 422
 423     FUNCTION(gsl_matrix, memcpy) (m, a);
 424     FUNCTION(gsl_matrix, add) (m, b);
 425
 426     {
 427       int status = 0;
 428
 429       for (i = 0; i < M; i++)
 430         {
 431           for (j = 0; j < N; j++)
 432             {
 433               BASE r = FUNCTION(gsl_matrix,get) (m,i,j);
 434               BASE x = FUNCTION(gsl_matrix,get) (a,i,j);
 435               BASE y = FUNCTION(gsl_matrix,get) (b,i,j);
 436               BASE z = x + y;
 437               if (r != z)
 438                 status = 1;
 439             }
 440         }
 441       gsl_test (status, NAME (gsl_matrix) "_add matrix addition");
 442     }
 443
 444
 445     FUNCTION(gsl_matrix, memcpy) (m, a);
 446     FUNCTION(gsl_matrix, sub) (m, b);
 447
 448     {
 449       int status = 0;
 450
 451       for (i = 0; i < M; i++)
 452         {
 453           for (j = 0; j < N; j++)
 454             {
 455               BASE r = FUNCTION(gsl_matrix,get) (m,i,j);
 456               BASE x = FUNCTION(gsl_matrix,get) (a,i,j);
 457               BASE y = FUNCTION(gsl_matrix,get) (b,i,j);
 458               BASE z = x - y;
 459               if (r != z)
 460                 status = 1;
 461             }
 462         }
 463       gsl_test (status, NAME (gsl_matrix) "_sub matrix subtraction");
 464     }
 465
 466     FUNCTION(gsl_matrix, memcpy) (m, a);
 467     FUNCTION(gsl_matrix, mul_elements) (m, b);
 468
 469     {
 470       int status = 0;
 471
 472       for (i = 0; i < M; i++)
 473         {
 474           for (j = 0; j < N; j++)
 475             {
 476               BASE r = FUNCTION(gsl_matrix,get) (m,i,j);
 477               BASE x = FUNCTION(gsl_matrix,get) (a,i,j);
 478               BASE y = FUNCTION(gsl_matrix,get) (b,i,j);
 479               BASE z = x * y;
 480               if (r != z)
 481                 status = 1;
 482             }
 483         }
 484       gsl_test (status, NAME (gsl_matrix) "_mul_elements multiplication");
 485     }
 486
 487     FUNCTION(gsl_matrix, memcpy) (m, a);
 488     FUNCTION(gsl_matrix, div_elements) (m, b);
 489
 490     {
 491       int status = 0;
 492
 493       for (i = 0; i < M; i++)
 494         {
 495           for (j = 0; j < N; j++)
 496             {
 497               BASE r = FUNCTION(gsl_matrix,get) (m,i,j);
 498               BASE x = FUNCTION(gsl_matrix,get) (a,i,j);
 499               BASE y = FUNCTION(gsl_matrix,get) (b,i,j);
 500               BASE z = x / y;
 501               if (fabs(r - z) > 2 * GSL_FLT_EPSILON * fabs(z))
 502                 status = 1;
 503             }
 504         }
 505       gsl_test (status, NAME (gsl_matrix) "_div_elements division");
 506     }
 507
 508
 509     FUNCTION(gsl_matrix, free) (a);
 510     FUNCTION(gsl_matrix, free) (b);
 511   }
 512
 513
 514  FUNCTION (gsl_matrix, free) (m);
 515  FUNCTION (gsl_vector, free) (v);
 516 }
 517
 518 #if !(USES_LONGDOUBLE && !HAVE_PRINTF_LONGDOUBLE)
 519 void
 520 FUNCTION (test, text) (void)
 521 {
 522   TYPE (gsl_matrix) * m = FUNCTION (gsl_matrix, alloc) (M, N);
 523
 524   size_t i, j;
 525   int k = 0;
 526
 527   {
 528     FILE *f = fopen ("test.txt", "w");
 529
 530     for (i = 0; i < M; i++)
 531       {
 532         for (j = 0; j < N; j++)
 533           {
 534             k++;
 535             FUNCTION (gsl_matrix, set) (m, i, j, (BASE) k);
 536           }
 537       }
 538
 539     FUNCTION (gsl_matrix, fprintf) (f, m, OUT_FORMAT);
 540     fclose (f);
 541   }
 542
 543   {
 544     FILE *f = fopen ("test.txt", "r");
 545     TYPE (gsl_matrix) * mm = FUNCTION (gsl_matrix, alloc) (M, N);
 546     status = 0;
 547
 548     FUNCTION (gsl_matrix, fscanf) (f, mm);
 549     k = 0;
 550     for (i = 0; i < M; i++)
 551       {
 552         for (j = 0; j < N; j++)
 553           {
 554             k++;
 555             if (mm->data[i * N + j] != (BASE) k)
 556               status = 1;
 557           }
 558       }
 559
 560     gsl_test (status, NAME (gsl_matrix) "_fprintf and fscanf");
 561
 562     fclose (f);
 563     FUNCTION (gsl_matrix, free) (mm);
 564   }
 565
 566   FUNCTION (gsl_matrix, free) (m);
 567 }
 568 #endif
 569
 570 void
 571 FUNCTION (test, binary) (void)
 572 {
 573   TYPE (gsl_matrix) * m = FUNCTION (gsl_matrix, calloc) (M, N);
 574
 575   size_t i, j;
 576   size_t k = 0;
 577
 578   {
 579     FILE *f = fopen ("test.dat", "wb");
 580     k = 0;
 581     for (i = 0; i < M; i++)
 582       {
 583         for (j = 0; j < N; j++)
 584           {
 585             k++;
 586             FUNCTION (gsl_matrix, set) (m, i, j, (BASE) k);
 587           }
 588       }
 589
 590     FUNCTION (gsl_matrix, fwrite) (f, m);
 591     fclose (f);
 592   }
 593
 594   {
 595     FILE *f = fopen ("test.dat", "rb");
 596     TYPE (gsl_matrix) * mm = FUNCTION (gsl_matrix, alloc) (M, N);
 597     status = 0;
 598
 599     FUNCTION (gsl_matrix, fread) (f, mm);
 600     k = 0;
 601     for (i = 0; i < M; i++)
 602       {
 603         for (j = 0; j < N; j++)
 604           {
 605             k++;
 606             if (mm->data[i * N + j] != (BASE) k)
 607               status = 1;
 608           }
 609       }
 610
 611     gsl_test (status, NAME (gsl_matrix) "_write and read");
 612
 613     fclose (f);
 614     FUNCTION (gsl_matrix, free) (mm);
 615   }
 616
 617   FUNCTION (gsl_matrix, free) (m);
 618 }
 619
 620 void
 621 FUNCTION (test, trap) (void)
 622 {
 623   TYPE (gsl_matrix) * m = FUNCTION (gsl_matrix, alloc) (M, N);
 624
 625   size_t i = 0, j = 0;
 626   double x;
 627
 628   status = 0;
 629   FUNCTION (gsl_matrix, set) (m, M + 1, 0, (BASE) 1.2);
 630   gsl_test (!status,
 631             NAME (gsl_matrix) "_set traps 1st index above upper bound");
 632
 633   status = 0;
 634   FUNCTION (gsl_matrix, set) (m, 0, N + 1, (BASE) 1.2);
 635   gsl_test (!status,
 636             NAME (gsl_matrix) "_set traps 2nd index above upper bound");
 637
 638   status = 0;
 639   FUNCTION (gsl_matrix, set) (m, M, 0, (BASE) 1.2);
 640   gsl_test (!status,
 641             NAME (gsl_matrix) "_set traps 1st index at upper bound");
 642
 643   status = 0;
 644   FUNCTION (gsl_matrix, set) (m, 0, N, (BASE) 1.2);
 645   gsl_test (!status,
 646             NAME (gsl_matrix) "_set traps 2nd index at upper bound");
 647
 648   status = 0;
 649   x = FUNCTION (gsl_matrix, get) (m, i - 1, 0);
 650   gsl_test (!status,
 651             NAME (gsl_matrix) "_get traps 1st index below lower bound");
 652   gsl_test (x != 0,
 653      NAME (gsl_matrix) "_get returns zero for 1st index below lower bound");
 654
 655   status = 0;
 656   x = FUNCTION (gsl_matrix, get) (m, 0, j - 1);
 657   gsl_test (!status,
 658             NAME (gsl_matrix) "_get traps 2nd index below lower bound");
 659   gsl_test (x != 0,
 660      NAME (gsl_matrix) "_get returns zero for 2nd index below lower bound");
 661
 662   status = 0;
 663   x = FUNCTION (gsl_matrix, get) (m, M + 1, 0);
 664   gsl_test (!status,
 665             NAME (gsl_matrix) "_get traps 1st index above upper bound");
 666   gsl_test (x != 0,
 667      NAME (gsl_matrix) "_get returns zero for 1st index above upper bound");
 668
 669   status = 0;
 670   x = FUNCTION (gsl_matrix, get) (m, 0, N + 1);
 671   gsl_test (!status,
 672             NAME (gsl_matrix) "_get traps 2nd index above upper bound");
 673   gsl_test (x != 0,
 674      NAME (gsl_matrix) "_get returns zero for 2nd index above upper bound");
 675
 676   status = 0;
 677   x = FUNCTION (gsl_matrix, get) (m, M, 0);
 678   gsl_test (!status,
 679             NAME (gsl_matrix) "_get traps 1st index at upper bound");
 680   gsl_test (x != 0,
 681         NAME (gsl_matrix) "_get returns zero for 1st index at upper bound");
 682
 683   status = 0;
 684   x = FUNCTION (gsl_matrix, get) (m, 0, N);
 685   gsl_test (!status,
 686             NAME (gsl_matrix) "_get traps 2nd index at upper bound");
 687   gsl_test (x != 0,
 688         NAME (gsl_matrix) "_get returns zero for 2nd index at upper bound");
 689
 690   FUNCTION (gsl_matrix, free) (m);
 691 }