lib/utils_alloc.c

   1 /* -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 4 c-style: "K&R" -*- */
   2
   3 /*
   4    libgpiv - library for Particle Image Velocimetry
   5
   6    Copyright (C) 2007, 2008 Gerber van der Graaf
   7
   8    This file is part of libgpiv.
   9    Libgpiv is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2, or (at your option)
  12    any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software Foundation,
  21    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  22
  23
  24
  25 -------------------------------------------------------------------------------
  26 FILENAME:                l_utils.c
  27 LIBRARY:                 libgpiv:
  28 EXTERNAL FUNCTIONS:
  29
  30
  31
  32 LAST MODIFICATION DATE:  $Id: utils_alloc.c,v 1.3 2008-09-25 13:19:53 gerber Exp $
  33  --------------------------------------------------------------------------- */
  34
  35 #include <gpiv.h>
  36
  37 #define GPIV_END 1                 /*  Used by vector */
  38
  39
  40
  41
  42 gfloat **
  43 gpiv_matrix (long nr,
  44              long nc
  45              )
  46 /*-----------------------------------------------------------------------------
  47  * DESCRIPTION:
  48  *      Allocates memory for 2-dimensional matrix of gfloat data
  49  *
  50  *---------------------------------------------------------------------------*/
  51 {
  52     long i;
  53     gfloat **m;
  54
  55
  56     m = (gfloat **) g_malloc0 (nr * sizeof (gfloat *));
  57     m[0] = (gfloat *) g_malloc0 (nr * nc * sizeof (gfloat));
  58     for (i = 1; i < nr; i++) {
  59         m[i] = m[0] + i * nc;
  60     }
  61
  62
  63     return m;
  64 }
  65
  66
  67
  68 void
  69 gpiv_free_matrix (gfloat **m
  70                   )
  71 /*-----------------------------------------------------------------------------
  72  * DESCRIPTION:
  73  *      Frees memory for 2-dimensional array of float data
  74  *
  75  *---------------------------------------------------------------------------*/
  76 {
  77     g_return_if_fail (m[0] != NULL); /* gpiv_error ("m not allocated"); */
  78     g_free (m[0]);
  79     g_free (m);
  80     m = NULL;
  81 }
  82
  83
  84
  85 gfloat **
  86 gpiv_matrix_index (const long nrl,
  87                    const long nrh,
  88                    const long ncl,
  89                    const long nch
  90                    )
  91 /*-----------------------------------------------------------------------------
  92  * DESCRIPTION:
  93  *      Allocates memory for 2-dimensional matrix of float data
  94  *      with subscript range v[nrl..nrh][ncl..nch]
  95  *
  96  * INPUTS:
  97  *      long nrl:       lowest row index number
  98  *      nrh:            highest row index number
  99  *      ncl:            lowest column index number
 100  *      nch             highest column index number
 101  *
 102  * OUTPUTS:
 103  *
 104  * RETURNS:
 105  *      2-dimensional array
 106  *---------------------------------------------------------------------------*/
 107 {
 108     long i, nrows = nrh - nrl + 1, ncolumns = nch - ncl + 1;
 109     gfloat **m;
 110
 111
 112     m = (gfloat **) g_malloc0 ((size_t) ((nrows + GPIV_END) *
 113                                     sizeof (gfloat *)));
 114     if (!m)  gpiv_error ("gpiv_matrix_index: allocation failure");
 115     m += GPIV_END;
 116     m -= nrl;
 117
 118     m[nrl] =(gfloat *) g_malloc0 ((size_t) ((nrows * ncolumns + GPIV_END) *
 119                                        sizeof (gfloat)));
 120     if (!m[nrl]) gpiv_error ("gpiv_matrix_index: allocation failure");
 121     m[nrl] += GPIV_END;
 122     m[nrl] -= ncl;
 123
 124     for (i=nrl+1; i <= nrh; i++) {
 125         m[i] = m[i-1] + ncolumns;
 126     }
 127
 128
 129     return m;
 130 }
 131
 132
 133
 134 void
 135 gpiv_free_matrix_index (gfloat **m,
 136                         const long nrl,
 137                         const long nrh,
 138                         const long ncl,
 139                         const long nch
 140                         )
 141 /*-----------------------------------------------------------------------------
 142  * DESCRIPTION:
 143  *      Frees memory for 2-dimensional array of float data
 144  *      with subscript range v[nrl..nrh][ncl..nch]
 145  *
 146  * INPUTS:
 147  *      m:              matrix
 148  *      nrl:            lowest row index number
 149  *      long nrh:       highest row index number
 150  *      long ncl:       lowest column index number
 151  *      long nch:       highest column index number
 152  *
 153  * OUTPUTS:
 154  *      m:             NULL pointer
 155  *
 156  * RETURNS:
 157  *---------------------------------------------------------------------------*/
 158 {
 159     g_return_if_fail (m[0] != NULL); /* gpiv_error ("m not allocated"); */
 160     g_free (m[nrl]+ncl-GPIV_END);
 161     g_free (m+nrl-GPIV_END);
 162     m = NULL;
 163 }
 164
 165
 166
 167 guchar **
 168 gpiv_ucmatrix (const long nr,
 169                const long nc
 170                )
 171 /*-----------------------------------------------------------------------------
 172  * DESCRIPTION:
 173  *      Allocates memory for 2-dimensional matrix of guchar data
 174  *
 175  * INPUTS:
 176  *      nr:     row index
 177  *      nc:     column index
 178  *
 179  * OUTPUTS:
 180  *
 181  * RETURNS:
 182  *     matrix
 183  *---------------------------------------------------------------------------*/
 184 {
 185     long i;
 186     guchar **m;
 187
 188
 189     m = (guchar **) g_malloc0 (nr * sizeof (guchar*));
 190     m[0] = (guchar *) g_malloc0 (nr * nc * sizeof (guchar));
 191     for (i = 1; i < nr; i++) {
 192         m[i] = m[0] + i * nc;
 193     }
 194
 195
 196     return m;
 197 }
 198
 199
 200
 201 void
 202 gpiv_free_ucmatrix (guchar **m
 203                     )
 204 /*-----------------------------------------------------------------------------
 205  * DESCRIPTION:
 206  *      Frees memory for 2-dimensional array of guchar data
 207  *
 208  * INPUTS:
 209  *      m:              matrix
 210  *
 211  * OUTPUTS:
 212  *
 213  * RETURNS:
 214  *      m:              NULL pointer
 215  *---------------------------------------------------------------------------*/
 216 {
 217     g_return_if_fail (m[0] != NULL); /* gpiv_error ("m not allocated"); */
 218     g_free (m[0]);
 219     g_free (m);
 220     m = NULL;
 221 }
 222
 223
 224
 225 guint8 **
 226 gpiv_matrix_guint8 (const long nr,
 227                     const long nc
 228                     )
 229 /*-----------------------------------------------------------------------------
 230  * DESCRIPTION:
 231  *      allocate a guint8 matrix with subscript range m[0..nr][0..nc]
 232  *
 233  * INPUTS:
 234  *      nr:             number of rows
 235  *      nc:             number of columns
 236  *
 237  * OUTPUTS:
 238  *
 239  * RETURNS:
 240  *      matrix
 241  *---------------------------------------------------------------------------*/
 242 {
 243     long i;
 244     guint8 **m;
 245
 246
 247     m = (guint8 **) g_malloc0 (nr * sizeof (guint8*));
 248     m[0] = (guint8 *) g_malloc0 (nr * nc * sizeof (guint8));
 249     for (i = 1; i < nr; i++) {
 250         m[i] = m[0] + i * nc;
 251     }
 252
 253
 254     return m;
 255 }
 256
 257
 258
 259 void
 260 gpiv_free_matrix_guint8 (guint8 **m
 261                          )
 262 /*-----------------------------------------------------------------------------
 263  * DESCRIPTION:
 264  *      free a guint8 matrix allocated by gpiv_matrix_guint8
 265  *
 266  * INPUTS:
 267  *      m:              matrix
 268  *
 269  * OUTPUTS:
 270  *      m:              NULL pointer
 271  *
 272  * RETURNS:
 273  *---------------------------------------------------------------------------*/
 274 {
 275     g_return_if_fail (m[0] != NULL); /* gpiv_error ("m not allocated"); */
 276     g_free (m[0]);
 277     g_free (m);
 278     m = NULL;
 279 }
 280
 281
 282
 283 guint16 **
 284 gpiv_matrix_guint16 (const long nr,
 285                      const long nc
 286                      )
 287 /*-----------------------------------------------------------------------------
 288  * DESCRIPTION:
 289  *      allocate a guint16 matrix with subscript range m[0..nr][0..nc]
 290  *
 291  * INPUTS:
 292  *      nr:             number of rows
 293  *      nc:             number of columns
 294  *
 295  * OUTPUTS:
 296  *
 297  * RETURNS:
 298  *      matrix
 299  *---------------------------------------------------------------------------*/
 300 {
 301     long i;
 302     guint16 **m;
 303
 304
 305     m = (guint16 **) g_malloc0 (nr * sizeof (guint16*));
 306     m[0] = (guint16 *) g_malloc0 (nr * nc * sizeof (guint16));
 307     for (i = 1; i < nr; i++) {
 308         m[i] = m[0] + i * nc;
 309     }
 310
 311
 312     return m;
 313 }
 314
 315
 316
 317 void
 318 gpiv_free_matrix_guint16 (guint16 **m
 319                           )
 320 /*-----------------------------------------------------------------------------
 321  * DESCRIPTION:
 322  *      free a guint16 matrix allocated by gpiv_matrix_guint16
 323  *
 324  * INPUTS:
 325  *      m:              matrix
 326  *
 327  * OUTPUTS:
 328  *      m:              NULL pointer
 329  *
 330  * RETURNS:
 331  *---------------------------------------------------------------------------*/
 332 {
 333     g_return_if_fail (m[0] != NULL); /* gpiv_error ("m not allocated"); */
 334     g_free (m[0]);
 335     g_free (m);
 336     m = NULL;
 337 }
 338
 339
 340
 341 gint **
 342 gpiv_imatrix_index (const long nrl,
 343                     const long nrh,
 344                     const long ncl,
 345                     const long nch
 346                     )
 347 /*-----------------------------------------------------------------------------
 348  * DESCRIPTION:
 349  *      Allocates memory for 2-dimensional matrix of integer data
 350  *      with subscript range v[nrl..nrh][ncl..nch]
 351  *
 352  * INPUTS:
 353  *      m:              matrix
 354  *      nrl:            lowest row index number
 355  *      nrh:            highest row index number
 356  *      ncl:            lowest column index number
 357  *      nch:            highest column index number
 358  *
 359  * OUTPUTS:
 360  *
 361  * RETURNS:
 362  *     matrix
 363  *---------------------------------------------------------------------------*/
 364 {
 365     long i, nrows = nrh - nrl + 1, ncolumns = nch - ncl + 1;
 366     gint **m;
 367
 368
 369     m = (gint **) g_malloc0 ((size_t) ((nrows + GPIV_END)*
 370                                      sizeof (gint*)));
 371     m += GPIV_END;
 372     m -= nrl;
 373     m[nrl] = (gint *) g_malloc0 ((size_t) ((nrows * ncolumns + GPIV_END)*
 374                                          sizeof (gint)));
 375     m[nrl] += GPIV_END;
 376     m[nrl] -= ncl;
 377
 378     for (i = nrl + 1; i <= nrh; i++) {
 379         m[i] = m[i-1] + ncolumns;
 380     }
 381
 382
 383     return m;
 384 }
 385
 386
 387
 388 void
 389 gpiv_free_imatrix_index (gint **m,
 390                          const long nrl,
 391                          const long nrh,
 392                          const long ncl,
 393                          const long nch
 394                          )
 395 /*-----------------------------------------------------------------------------
 396  * DESCRIPTION:
 397  *      Frees memory for 2-dimensional array of integer data
 398  *      with subscript range v[nrl..nrh][ncl..nch]
 399  *
 400  * INPUTS:
 401  *      m:              matrix
 402  *      nrl:            lowest row index number
 403  *      nrh:            highest row index number
 404  *      ncl:            lowest column index number
 405  *      nch:            highest column index number
 406  *
 407  * OUTPUTS:
 408  *      m:              NULL pointer
 409  *
 410  * RETURNS:
 411  *---------------------------------------------------------------------------*/
 412 {
 413     g_return_if_fail (m[0] != NULL); /* gpiv_error ("m not allocated"); */
 414     g_free (m[nrl]+ncl - GPIV_END);
 415     g_free (m+nrl - GPIV_END);
 416     m = NULL;
 417 }
 418
 419
 420
 421 gint **
 422 gpiv_imatrix (const long nr,
 423               const long nc)
 424
 425 /*-----------------------------------------------------------------------------
 426  * DESCRIPTION:
 427  *      Allocates memory for 2-dimensional matrix of integer data
 428  *      unappreciated, use gpiv_imatrix_index instead
 429  *
 430  * INPUTS:
 431  *      nr:             lowest row index number
 432  *      nc:             lowest column index number
 433  *
 434  * OUTPUTS:
 435  *
 436  * RETURNS:
 437  *     matrix
 438  *---------------------------------------------------------------------------*/
 439 {
 440     long i;
 441     gint **m;
 442
 443
 444     m = (gint **) g_malloc0 (nr * sizeof (gint*));
 445     m[0] = (gint *) g_malloc0 (nr * nc * sizeof (gint));
 446     for (i = 1; i < nr; i++) {
 447         m[i] = m[0] + i * nc;
 448     }
 449
 450
 451     return m;
 452 }
 453
 454
 455
 456 void
 457 gpiv_free_imatrix (gint **m
 458                    )
 459 /*-----------------------------------------------------------------------------
 460  * DESCRIPTION:
 461  *      Frees memory for 2-dimensional array of integer data
 462  *      unappreciated, use gpiv_free_imatrix_index instead
 463  *
 464  * INPUTS:
 465  *      m:              matrix
 466  *
 467  * OUTPUTS:
 468  *      m:              NULL pointer
 469  *
 470  * RETURNS:
 471  *---------------------------------------------------------------------------*/
 472 {
 473     g_return_if_fail (m[0] != NULL); /* gpiv_error ("m not allocated"); */
 474     g_free (m[0]);
 475     g_free (m);
 476     m = NULL;
 477 }
 478
 479
 480
 481 double **
 482 gpiv_double_matrix (const glong nr,
 483                     const glong nc
 484                     )
 485 /*-----------------------------------------------------------------------------
 486  * DESCRIPTION:
 487  *      allocate a contiguous 2-dimensional double matrix
 488  *      of nr x nc
 489  *
 490  * INPUTS:
 491  *      nr:             number of rows
 492  *      nc:             number of columns
 493  *
 494  * OUTPUTS:
 495  *
 496  * RETURNS:
 497  *     matrix
 498  *---------------------------------------------------------------------------*/
 499 {
 500     double **m;
 501     gint i;
 502
 503
 504     m = (double **) g_malloc0 (nr * sizeof (double *));
 505     m[0] = (double *) g_malloc0 (nr * nc * sizeof (double));
 506     for (i = 1; i < nr; i++) {
 507         m[i] = m[0] + i * nc;
 508     }
 509
 510
 511     return m;
 512 }
 513
 514
 515
 516 void
 517 gpiv_free_double_matrix (double **m
 518                          )
 519 /*-----------------------------------------------------------------------------
 520  * DESCRIPTION:
 521  *      free a double matrix allocated by gpiv_double_matrix()
 522  *
 523  * INPUTS:
 524  *      m:              matrix
 525  *
 526  * OUTPUTS:
 527  *      m:              NULL pointer
 528  *
 529  * RETURNS:
 530  *---------------------------------------------------------------------------*/
 531 {
 532     g_return_if_fail (m[0] != NULL); /* gpiv_error ("m not allocated"); */
 533     g_free (m[0]);
 534     g_free (m);
 535     m = NULL;
 536 }
 537
 538
 539 #ifndef USE_FFTW3
 540 fftw_real **
 541 gpiv_fftw_real_matrix (glong nr,
 542                        glong nc
 543                        )
 544 /*-----------------------------------------------------------------------------
 545  * DESCRIPTION:
 546  *      allocate a contiguous 2-dimensional fftw_real matrix
 547  *      of nr x nc
 548  *
 549  * INPUTS:
 550  *      nr:             number of rows
 551  *      nc:             number of columns
 552  *
 553  * OUTPUTS:
 554  *
 555  * RETURNS:
 556  *     matrix
 557  *---------------------------------------------------------------------------*/
 558 {
 559     fftw_real **m;
 560     gint i;
 561
 562
 563     m = (fftw_real **) g_malloc0 (nr * sizeof (fftw_real *));
 564     m[0] = (fftw_real *) g_malloc0 (nr * nc * sizeof (fftw_real));
 565     for (i = 1; i < nr; i++) {
 566         m[i] = m[0] + i * nc;
 567     }
 568
 569
 570     return m;
 571 }
 572
 573
 574
 575 void
 576 gpiv_free_fftw_real_matrix (fftw_real **m
 577                             )
 578 /*-----------------------------------------------------------------------------
 579  * DESCRIPTION:
 580  *      free a gdouble matrix allocated by gpiv_fftw_real_matrix()
 581  *
 582  * INPUTS:
 583  *      m:              matrix
 584  *
 585  * OUTPUTS:
 586  *      m:              NULL pointer
 587  *
 588  * RETURNS:
 589  *---------------------------------------------------------------------------*/
 590 {
 591     g_return_if_fail (m[0] != NULL); /* gpiv_error ("m not allocated"); */
 592     g_free (m[0]);
 593     g_free (m);
 594     m = NULL;
 595 }
 596 #endif /* USE_FFTW3 */
 597
 598
 599
 600 fftw_complex **
 601 gpiv_fftw_complex_matrix (const long nr,
 602                           const long nc
 603                           )
 604 /*-----------------------------------------------------------------------------
 605  * DESCRIPTION:
 606  *      allocate a contiguous 2-dimensional fftw_complex matrix
 607  *      of nr x nc
 608  *
 609  * INPUTS:
 610  *      nr:             number of rows
 611  *      nc:             number of columns
 612  *
 613  * OUTPUTS:
 614  *
 615  * RETURNS:
 616  *     matrix
 617  *---------------------------------------------------------------------------*/
 618 {
 619     fftw_complex **m;
 620     gint i;
 621
 622
 623     /*
 624      * allocate pointers to rows
 625      */
 626     m = (fftw_complex **) fftw_malloc (nr * sizeof (fftw_complex *));
 627     m[0] = (fftw_complex *) fftw_malloc (nr * nc * sizeof (fftw_complex));
 628     for (i = 1; i < nr; i++) {
 629         m[i] = m[0] + i * nc;
 630     }
 631
 632
 633     return m;
 634 }
 635
 636
 637
 638 void
 639 gpiv_free_fftw_complex_matrix (fftw_complex **m
 640                                )
 641 /*-----------------------------------------------------------------------------
 642  * DESCRIPTION:
 643  *      free a fftw_complex matrix allocated by gpiv_fftw_complex_matrix()
 644  *
 645  * INPUTS:
 646  *      m:              matrix
 647  *
 648  * OUTPUTS:
 649  *      m:              NULL pointer
 650  *
 651  * RETURNS:
 652  *---------------------------------------------------------------------------*/
 653 {
 654     g_return_if_fail (m[0] != NULL); /* gpiv_error ("m not allocated"); */
 655     fftw_free (m[0]);
 656     fftw_free (m);
 657     m = NULL;
 658 }
 659
 660
 661
 662 float *
 663 gpiv_vector (const long nl
 664              )
 665 /*-----------------------------------------------------------------------------
 666  * DESCRIPTION:
 667  *      Allocates memory for a 1-dimensional vector of float data
 668  *
 669  * INPUTS:
 670  *      nl:             vector length
 671  *
 672  * OUTPUTS:
 673  *
 674  * RETURNS:
 675  *      vector
 676  *---------------------------------------------------------------------------*/
 677 {
 678     float *v;
 679
 680
 681     v = (float *)g_malloc0 ((size_t) (nl * sizeof (float)));
 682 /*     v = (float *)g_malloc0 (gsize * nl * sizeof (float))); */
 683
 684
 685     return v;
 686 }
 687
 688
 689
 690 void
 691 gpiv_free_vector (float *v
 692                   )
 693 /*-----------------------------------------------------------------------------
 694  * DESCRIPTION:
 695  *      frees memory for a 1-dimensional vector of float data
 696  *
 697  * INPUTS:
 698  *      vector:             vector of 1-dimensional float data
 699  *
 700  * OUTPUTS:
 701  *      vector:              NULL pointer
 702  *
 703  * RETURNS:
 704  *---------------------------------------------------------------------------*/
 705 {
 706     g_return_if_fail (v != NULL); /* gpiv_error ("v not allocated"); */
 707     g_free (v);
 708     v = NULL;
 709 }
 710
 711
 712
 713 float *
 714 gpiv_vector_index (const long nl,
 715                    const long nh
 716                    )
 717 /*-----------------------------------------------------------------------------
 718  * DESCRIPTION:
 719  *      Allocates memory for a 1-dimensional vector of float data
 720  *      with subscript range v[nl..nh]
 721  *
 722  * INPUTS:
 723  *      nl:            lowest index number
 724  *      nh:            highest index number
 725  *
 726  * OUTPUTS:
 727  *
 728  * RETURNS:
 729  *      vector
 730  *---------------------------------------------------------------------------*/
 731 {
 732     float *v;
 733
 734     v = (float *)g_malloc0 ((size_t) ((nh + 1 - nl + GPIV_END)
 735                                       * sizeof (float)));
 736
 737
 738     return v - nl;
 739 }
 740
 741
 742
 743 void
 744 gpiv_free_vector_index (float *v,
 745                         const long nl,
 746                         const long nh
 747                         )
 748 /*-----------------------------------------------------------------------------
 749  * DESCRIPTION:
 750  *      frees memory for a 1-dimensional vector of float data
 751  *      with subscript range v[nrl..nrh][ncl..nch]
 752  *
 753  * INPUTS:
 754  *      vector:        vector of 1-dimensional float data
 755  *      nl:            lowest index number
 756  *      nh:            highest index number
 757  *
 758  * OUTPUTS:
 759  *      vector:              NULL pointer
 760  *
 761  * RETURNS:
 762  *---------------------------------------------------------------------------*/
 763 {
 764     g_return_if_fail (v != NULL); /* gpiv_error ("v not allocated"); */
 765     g_free (v + nl);
 766     v = NULL;
 767 }
 768
 769
 770
 771 gdouble *
 772 gpiv_dvector (const glong nl
 773               )
 774 /*-----------------------------------------------------------------------------
 775  * DESCRIPTION:
 776  *      Allocates memory for a 1-dimensional vector of double data
 777  *
 778  * INPUTS:
 779  *      nl:             vector length
 780  *
 781  * OUTPUTS:
 782  *
 783  * RETURNS:
 784  *      vector
 785  *---------------------------------------------------------------------------*/
 786 {
 787     gdouble *v;
 788
 789
 790     v = (gdouble *)g_malloc0 ((size_t) (nl * sizeof (gdouble)));
 791
 792
 793     return v;
 794 }
 795
 796
 797
 798 void
 799 gpiv_free_dvector (gdouble *v
 800                    )
 801 /*-----------------------------------------------------------------------------
 802  * DESCRIPTION:
 803  *      frees memory for a 1-dimensional vector of double data
 804  *
 805  * INPUTS:
 806  *      vector:             vector of 1-dimensional float data
 807  *
 808  * OUTPUTS:
 809  *      vector:              NULL pointer
 810  *
 811  * RETURNS:
 812  *---------------------------------------------------------------------------*/
 813 {
 814     g_return_if_fail (v != NULL); /* gpiv_error ("v not allocated"); */
 815     g_free (v);
 816     v = NULL;
 817 }
 818
 819
 820
 821 gdouble *
 822 gpiv_dvector_index (const long nl,
 823                     const long nh
 824                     )
 825 /*-----------------------------------------------------------------------------
 826  * DESCRIPTION:
 827  *      Allocates memory for a 1-dimensional vector of double data
 828  *      with subscript range v[nl..nh]
 829  *
 830  * INPUTS:
 831  *      nl:            lowest index number
 832  *      nh:            highest index number
 833  *
 834  * OUTPUTS:
 835  *
 836  * RETURNS:
 837  *      vector
 838  *---------------------------------------------------------------------------*/
 839 {
 840     gdouble *v;
 841
 842
 843     v = (gdouble *)g_malloc0 ((size_t) ((nh + 1 -nl + GPIV_END) *
 844                                       sizeof (gdouble)));
 845
 846
 847     return v - nl;
 848 }
 849
 850
 851
 852 void
 853 gpiv_free_dvector_index (gdouble *v,
 854                          const long nl,
 855                          const long nh
 856                          )
 857 /*-----------------------------------------------------------------------------
 858  * DESCRIPTION:
 859  *      frees memory for a 1-dimensional vector of double data
 860  *      with subscript range v[nrl..nrh][ncl..nch]
 861  *
 862  * INPUTS:
 863  *      vector:        vector of 1-dimensional float data
 864  *      nl:            lowest index number
 865  *      nh:            highest index number
 866  *
 867  * OUTPUTS:
 868  *      vector:              NULL pointer
 869  *
 870  * RETURNS:
 871  *---------------------------------------------------------------------------*/
 872 {
 873     g_return_if_fail (v != NULL); /* gpiv_error ("v not allocated"); */
 874     g_free (v + nl);
 875     v = NULL;
 876 }
 877
 878
 879
 880 long *
 881 gpiv_nulvector (const long nl
 882                 )
 883 /*-----------------------------------------------------------------------------
 884  * DESCRIPTION:
 885  *      Allocates memory for a 1-dimensional vector of long data
 886  *
 887  * INPUTS:
 888  *      nl:             vector length
 889  *
 890  * OUTPUTS:
 891  *
 892  * RETURNS:
 893  *      vector
 894  *---------------------------------------------------------------------------*/
 895 {
 896     long *v;
 897
 898
 899     v = (long *)g_malloc0 ((size_t) (nl * sizeof (long)));
 900
 901
 902     return v;
 903 }
 904
 905
 906
 907 void
 908 gpiv_free_nulvector (long *v
 909                      )
 910 /*-----------------------------------------------------------------------------
 911  * DESCRIPTION:
 912  *      frees memory for a 1-dimensional vector of long data
 913  *
 914  * INPUTS:
 915  *      vector:             vector of 1-dimensional float data
 916  *
 917  * OUTPUTS:
 918  *      vector:              NULL pointer
 919  *
 920  * RETURNS:
 921  *---------------------------------------------------------------------------*/
 922 {
 923     g_return_if_fail (v != NULL); /* gpiv_error ("v not allocated"); */
 924     g_free (v);
 925     v = NULL;
 926 }
 927
 928
 929
 930 long *
 931 gpiv_nulvector_index (const long nl,
 932                       const long nh
 933                       )
 934 /*-----------------------------------------------------------------------------
 935  * DESCRIPTION:
 936  *      Allocates memory for a 1-dimensional vector of long data
 937  *      with subscript range v[nl..nh]
 938  *
 939  * INPUTS:
 940  *      nl:            lowest index number
 941  *      nh:            highest index number
 942  *
 943  * OUTPUTS:
 944  *
 945  * RETURNS:
 946  *      vector
 947  *---------------------------------------------------------------------------*/
 948 {
 949     long *v;
 950
 951
 952     v = (long *)g_malloc0 ((size_t) ((nh + 1 - nl + GPIV_END) *
 953                                     sizeof (long)));
 954
 955
 956     return v - nl;
 957 }
 958
 959
 960
 961 void
 962 gpiv_free_nulvector_index (long *v,
 963                            const long nl,
 964                            const long nh)
 965 /*-----------------------------------------------------------------------------
 966  * DESCRIPTION:
 967  *      frees memory for a 1-dimensional vector of long data
 968  *      with subscript range v[nrl..nrh][ncl..nch]
 969  *
 970  * INPUTS:
 971  *      vector:        vector of 1-dimensional float data
 972  *      nl:            lowest index number
 973  *      nh:            highest index number
 974  *
 975  * OUTPUTS:
 976  *      vector:              NULL pointer
 977  *
 978  * RETURNS:
 979  *---------------------------------------------------------------------------*/
 980 {
 981     g_return_if_fail (v != NULL); /* gpiv_error ("v not allocated"); */
 982     g_free (v + nl);
 983     v = NULL;
 984 }
 985
 986
 987
 988 unsigned long *
 989 gpiv_ulvector (const long nl
 990                )
 991 /*-----------------------------------------------------------------------------
 992  * DESCRIPTION:
 993  *      Allocates memory for a 1-dimensional vector of unsigned long data
 994  *
 995  * INPUTS:
 996  *      nl:             vector length
 997  *
 998  * OUTPUTS:
 999  *
1000  * RETURNS:
1001  *      vector
1002  *---------------------------------------------------------------------------*/
1003 {
1004     unsigned long *v;
1005
1006
1007     v = (unsigned long *)g_malloc0 ((size_t) (nl * sizeof (long)));
1008     if (!v); gpiv_error ("gpiv_ulvector: allocation failure");
1009
1010
1011     return v;
1012 }
1013
1014
1015
1016 void
1017 gpiv_free_ulvector (unsigned long *v
1018                     )
1019 /*-----------------------------------------------------------------------------
1020  * DESCRIPTION:
1021  *      frees memory for a 1-dimensional vector of unsigned long data
1022  *
1023  * INPUTS:
1024  *      vector:             vector of 1-dimensional float data
1025  *
1026  * OUTPUTS:
1027  *      vector:              NULL pointer
1028  *
1029  * RETURNS:
1030  *---------------------------------------------------------------------------*/
1031 {
1032     g_return_if_fail (v != NULL); /* gpiv_error ("v not allocated"); */
1033     g_free (v);
1034     v = NULL;
1035 }
1036
1037
1038
1039 unsigned long *
1040 gpiv_ulvector_index (const long nl,
1041                      const long nh
1042                      )
1043 /*-----------------------------------------------------------------------------
1044  * DESCRIPTION:
1045  *      Allocates memory for a 1-dimensional vector of unsigned long data
1046  *      with subscript range v[nl..nh]
1047  *
1048  * INPUTS:
1049  *      nl:            lowest index number
1050  *      nh:            highest index number
1051  *
1052  * OUTPUTS:
1053  *
1054  * RETURNS:
1055  *      vector
1056  *---------------------------------------------------------------------------*/
1057 {
1058     unsigned long *v;
1059
1060
1061     v = (unsigned long *)g_malloc0 ((size_t) ((nh + 1 - nl + GPIV_END) *
1062                                              sizeof (long)));
1063     if (!v); gpiv_error ("gpiv_ulvector_index: allocation failure");
1064
1065
1066     return v - nl;
1067 }
1068
1069
1070
1071 void
1072 gpiv_free_ulvector_index (unsigned long *v,
1073                           const long nl,
1074                           const long nh
1075                           )
1076 /*-----------------------------------------------------------------------------
1077  * DESCRIPTION:
1078  *      frees memory for a 1-dimensional vector of unsigned long data
1079  *      with subscript range v[nrl..nrh][ncl..nch]
1080  *
1081  * INPUTS:
1082  *      vector:        vector of 1-dimensional float data
1083  *      nl:            lowest index number
1084  *      nh:            highest index number
1085  *
1086  * OUTPUTS:
1087  *      vector:              NULL pointer
1088  *
1089  * RETURNS:
1090  *---------------------------------------------------------------------------*/
1091 {
1092     g_return_if_fail (v != NULL); /* gpiv_error ("v not allocated"); */
1093     g_free (v + nl);
1094     v = NULL;
1095 }
1096
1097
1098
1099 gint *
1100 gpiv_ivector (const long nl
1101               )
1102 /*-----------------------------------------------------------------------------
1103  * DESCRIPTION:
1104  *      Allocates memory for a 1-dimensional vector of integer data
1105  *
1106  * INPUTS:
1107  *      nl:             vector length
1108  *
1109  * OUTPUTS:
1110  *
1111  * RETURNS:
1112  *      vector
1113  *---------------------------------------------------------------------------*/
1114 {
1115     gint *v;
1116
1117
1118     v = (gint *) g_malloc0 ((size_t) (nl * sizeof (gint)));
1119     if (!v)  gpiv_error ("gpiv_ivector: allocation failure");
1120
1121
1122     return v;
1123 }
1124
1125
1126
1127 void
1128 gpiv_free_ivector (gint *v
1129                    )
1130 /*-----------------------------------------------------------------------------
1131  * DESCRIPTION:
1132  *      frees memory for a 1-dimensional vector of integer data
1133  *
1134  * INPUTS:
1135  *      vector:             vector of 1-dimensional float data
1136  *
1137  * OUTPUTS:
1138  *      vector:              NULL pointer
1139  *
1140  * RETURNS:
1141  *---------------------------------------------------------------------------*/
1142 {
1143     g_return_if_fail (v != NULL); /* gpiv_error ("v not allocated"); */
1144     g_free (v);
1145     v = NULL;
1146 }
1147
1148
1149
1150 gint *
1151 gpiv_ivector_index (const long nl,
1152                     const long nh
1153                     )
1154 /*-----------------------------------------------------------------------------
1155  * DESCRIPTION:
1156  *      Allocates memory for a 1-dimensional vector of integer data
1157  *      with subscript range v[nl..nh]
1158  *
1159  * INPUTS:
1160  *      nl:            lowest index number
1161  *      nh:            highest index number
1162  *
1163  * OUTPUTS:
1164  *
1165  * RETURNS:
1166  *      vector
1167  *---------------------------------------------------------------------------*/
1168 {
1169     gint *v;
1170
1171
1172     v = (gint *)g_malloc0 ((size_t) ((nh + 1 - nl + GPIV_END)*sizeof (gint)));
1173     if (!v) gpiv_error ("gpiv_ivector_index: allocation failure");
1174
1175
1176     return v - nl;
1177 }
1178
1179
1180
1181 void
1182 gpiv_free_ivector_index (gint *v,
1183                          const long nl,
1184                          const long nh
1185                          )
1186 /*-----------------------------------------------------------------------------
1187  * DESCRIPTION:
1188  *      frees memory for a 1-dimensional vector of integer data
1189  *      with subscript range v[nrl..nrh][ncl..nch]
1190  *
1191  * INPUTS:
1192  *      vector:        vector of 1-dimensional float data
1193  *      nl:            lowest index number
1194  *      nh:            highest index number
1195  *
1196  * OUTPUTS:
1197  *      vector:              NULL pointer
1198  *
1199  * RETURNS:
1200  *---------------------------------------------------------------------------*/
1201 {
1202     g_return_if_fail (v != NULL); /* gpiv_error ("v not allocated"); */
1203     g_free (v + nl);
1204     v = NULL;
1205 }
1206
1207
1208
1209 gboolean *
1210 gpiv_gbolvector (const glong nl
1211                  )
1212 /*-----------------------------------------------------------------------------
1213  * DESCRIPTION:
1214  *      Allocates memory for a 1-dimensional vector of gboolean data
1215  *
1216  * INPUTS:
1217  *      nl:             vector length
1218  *
1219  * OUTPUTS:
1220  *
1221  * RETURNS:
1222  *      vector
1223  *---------------------------------------------------------------------------*/
1224 {
1225     gboolean *v;
1226
1227
1228     v = (gboolean *)g_malloc0 ((size_t) (nl * sizeof (gboolean)));
1229
1230
1231     return v;
1232 }
1233
1234
1235
1236 void
1237 gpiv_free_gbolvector (gboolean *v
1238                       )
1239 /*-----------------------------------------------------------------------------
1240  * DESCRIPTION:
1241  *      frees memory for a 1-dimensional vector of gboolean data
1242  *
1243  * INPUTS:
1244  *      vector:             vector of 1-dimensional boolean data
1245  *
1246  * OUTPUTS:
1247  *      vector:              NULL pointer
1248  *
1249  * RETURNS:
1250  *---------------------------------------------------------------------------*/
1251 {
1252     g_return_if_fail (v != NULL); /* gpiv_error ("v not allocated"); */
1253     g_free (v);
1254     v = NULL;
1255 }
1256
1257
1258
1259 #undef GPIV_END