IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 502


Ignore:
Timestamp:
Apr 22, 2004, 11:15:01 AM (22 years ago)
Author:
harman
Message:

Created static functions. Replaced p_xxx allocation functions with psXX
alloation functions

Location:
trunk/psLib/src
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/collections/psArray.c

    r495 r502  
    33 *  @brief Contains support for array types
    44 *
    5  *  The type of basic one dimensional arrays are defined here include: int, float, double, complex float, and
    6  *  void *.
     5 *  This file defines basic types of one dimensional arrays which include: int, float, double, complex float, and
     6 *  void **.
    77 *
    88 *  @author Ross Harman, MHPCC
    99 *   
    10  *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2004-04-21 21:05:39 $
     10 *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2004-04-22 21:15:01 $
    1212 *
    1313 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    4848/*****************************************************************************/
    4949
     50static void* p_psArrayAlloc(psType *arrType, psElemType elemType, int nalloc, int elemSize)
     51{
     52    void *arr = NULL;
     53
     54    arrType->dimen = PS_DIMEN_VECTOR;
     55    arrType->type = elemType;
     56
     57    if(nalloc != 0) {
     58        arr = psAlloc(nalloc*sizeof(elemSize));
     59    }
     60
     61    return arr;
     62}
     63
    5064static psVoidPtrArray *p_psVoidPtrArrayRealloc(psVoidPtrArray *restrict psArr, int nalloc)
    5165{
    52     if(psArr == NULL) {
    53         return psVoidPtrArrayAlloc(nalloc);
    54     }
    55     if(nalloc <= psArr->nalloc) {
    56         if (psArr->n < nalloc) {
    57             psArr->n = nalloc;
    58         }
    59     } else {
    60         psArr->arr = p_psRealloc(psArr->arr, nalloc*sizeof(void*), __FILE__, __LINE__);
    61         psArr->nalloc = nalloc;
    62     }
     66    if(nalloc < psArr->n) {                                         // For decrease in psArray size
     67        psArr->n = nalloc;
     68        psArr->nalloc = nalloc;
     69        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(void*));   // For increase in psArray size
     70    } else if(nalloc > psArr->nalloc) {
     71        psArr->nalloc = nalloc;
     72        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(void*));
     73    } else if(psArr == NULL) {                                      // For creating new psArray with realloc
     74        psArr = psVoidPtrArrayAlloc(nalloc);
     75    }
     76
    6377    return psArr;
    6478}
    … …  
    6983        return;
    7084    }
    71     p_psFree(psArr->arr, __FILE__, __LINE__);
    72     p_psFree(psArr, __FILE__, __LINE__);
     85    psFree(psArr->arr);
     86    psFree(psArr);
    7387}
    7488
    … …  
    7993psIntArray* psIntArrayAlloc(int nalloc)
    8094{
    81     psIntArray *psArr = (psIntArray*)p_psAlloc(sizeof(psIntArray), __FILE__, __LINE__);
    82     psArr->type.dimen = PS_DIMEN_VECTOR;
    83     psArr->type.type = PS_TYPE_INT;
    84     psArr->nalloc = nalloc;
    85     psArr->n = 0;
    86 
    87     if(nalloc == 0) {
    88         psArr->arr = NULL;
    89     } else {
    90         psArr->arr = p_psAlloc(nalloc*sizeof(int), __FILE__, __LINE__);
    91     }
     95    psIntArray *psArr = NULL;
     96    psArr = (psIntArray*)psAlloc(sizeof(psIntArray));
     97    psArr->nalloc = nalloc;
     98    psArr->n = 0;
     99    psArr->arr = (int*)p_psArrayAlloc(&psArr->type, PS_TYPE_INT, nalloc, sizeof(int));
    92100
    93101    return psArr;
    … …  
    96104psIntArray *psIntArrayRealloc(psIntArray *psArr, int nalloc)
    97105{
    98     if(psArr == NULL) {
    99         return psIntArrayAlloc(nalloc);
    100     }
    101     if(nalloc <= psArr->nalloc) {
    102         if (psArr->n < nalloc) {
    103             psArr->n = nalloc;
    104         }
    105     } else {
    106         psArr->arr = p_psRealloc(psArr->arr, nalloc*sizeof(int), __FILE__, __LINE__);
    107         psArr->nalloc = nalloc;
    108     }
     106    if(nalloc < psArr->n) {                                         // For decrease in psArray size
     107        psArr->n = nalloc;
     108        psArr->nalloc = nalloc;
     109        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(int));     // For increase in psArray size
     110    } else if(nalloc > psArr->nalloc) {
     111        psArr->nalloc = nalloc;
     112        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(int));
     113    } else if(psArr == NULL) {                                      // For creating new psArray with realloc
     114        psArr = psIntArrayAlloc(nalloc);
     115    }
     116
    109117    return psArr;
    110118}
    … …  
    115123        return;
    116124    }
    117     p_psFree(psArr->arr, __FILE__, __LINE__);
    118     p_psFree(psArr, __FILE__, __LINE__);
     125
     126    psFree(psArr->arr);
     127    psFree(psArr);
    119128}
    120129
    121130psFloatArray* psFloatArrayAlloc(int nalloc)
    122131{
    123     psFloatArray *psArr = (psFloatArray*)p_psAlloc(sizeof(psFloatArray), __FILE__, __LINE__);
    124     psArr->type.dimen = PS_DIMEN_VECTOR;
    125     psArr->type.type = PS_TYPE_FLOAT;
    126     psArr->nalloc = nalloc;
    127     psArr->n = 0;
    128 
    129     if(nalloc == 0) {
    130         psArr->arr = NULL;
    131     } else {
    132         psArr->arr = p_psAlloc(nalloc*sizeof(float), __FILE__, __LINE__);
    133     }
     132    psFloatArray *psArr = NULL;
     133    psArr = (psFloatArray*)psAlloc(sizeof(psFloatArray));
     134    psArr->nalloc = nalloc;
     135    psArr->n = 0;
     136    psArr->arr = (float*)p_psArrayAlloc(&psArr->type, PS_TYPE_FLOAT, nalloc, sizeof(float));
    134137
    135138    return psArr;
    … …  
    138141psFloatArray *psFloatArrayRealloc(psFloatArray *psArr, int nalloc)
    139142{
    140     if(psArr == NULL) {
    141         return psFloatArrayAlloc(nalloc);
    142     }
    143     if(nalloc <= psArr->nalloc) {
    144         if (psArr->n < nalloc) {
    145             psArr->n = nalloc;
    146         }
    147     } else {
    148         psArr->arr = p_psRealloc(psArr->arr, nalloc*sizeof(float), __FILE__, __LINE__);
    149         psArr->nalloc = nalloc;
    150     }
     143    if(nalloc < psArr->n) {                                         // For decrease in psArray size
     144        psArr->n = nalloc;
     145        psArr->nalloc = nalloc;
     146        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(float));   // For increase in psArray size
     147    } else if(nalloc > psArr->nalloc) {
     148        psArr->nalloc = nalloc;
     149        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(float));
     150    } else if(psArr == NULL) {                                      // For creating new psArray with realloc
     151        psArr = psFloatArrayAlloc(nalloc);
     152    }
     153
    151154    return psArr;
    152155}
    … …  
    157160        return;
    158161    }
    159     p_psFree(psArr->arr, __FILE__, __LINE__);
    160     p_psFree(psArr, __FILE__, __LINE__);
     162    psFree(psArr->arr);
     163    psFree(psArr);
    161164}
    162165
    163166psDoubleArray* psDoubleArrayAlloc(int nalloc)
    164167{
    165     psDoubleArray *psArr = (psDoubleArray*)p_psAlloc(sizeof(psDoubleArray), __FILE__, __LINE__);
    166     psArr->type.dimen = PS_DIMEN_VECTOR;
    167     psArr->type.type = PS_TYPE_DOUBLE;
    168     psArr->nalloc = nalloc;
    169     psArr->n = 0;
    170 
    171     if(nalloc == 0) {
    172         psArr->arr = NULL;
    173     } else {
    174         psArr->arr = p_psAlloc(nalloc*sizeof(double), __FILE__, __LINE__);
    175     }
     168    psDoubleArray *psArr = NULL;
     169    psArr = (psDoubleArray*)psAlloc(sizeof(psDoubleArray));
     170    psArr->nalloc = nalloc;
     171    psArr->n = 0;
     172    psArr->arr = (double*)p_psArrayAlloc(&psArr->type, PS_TYPE_DOUBLE, nalloc, sizeof(double));
    176173
    177174    return psArr;
    … …  
    180177psDoubleArray *psDoubleArrayRealloc(psDoubleArray *psArr, int nalloc)
    181178{
    182     if(psArr == NULL) {
    183         return psDoubleArrayAlloc(nalloc);
    184     }
    185     if(nalloc <= psArr->nalloc) {
    186         if (psArr->n < nalloc) {
    187             psArr->n = nalloc;
    188         }
    189     } else {
    190         psArr->arr = p_psRealloc(psArr->arr, nalloc*sizeof(double), __FILE__, __LINE__);
    191         psArr->nalloc = nalloc;
    192     }
     179    if(nalloc < psArr->n) {                                         // For decrease in psArray size
     180        psArr->n = nalloc;
     181        psArr->nalloc = nalloc;
     182        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(double));  // For increase in psArray size
     183    } else if(nalloc > psArr->nalloc) {
     184        psArr->nalloc = nalloc;
     185        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(double));
     186    } else if(psArr == NULL) {                                      // For creating new psArray with realloc
     187        psArr = psDoubleArrayAlloc(nalloc);
     188    }
     189
    193190    return psArr;
    194191}
    … …  
    199196        return;
    200197    }
    201     p_psFree(psArr->arr, __FILE__, __LINE__);
    202     p_psFree(psArr, __FILE__, __LINE__);
     198    psFree(psArr->arr);
     199    psFree(psArr);
    203200}
    204201
    205202psComplexArray* psComplexArrayAlloc(int nalloc)
    206203{
    207     psComplexArray *psArr = (psComplexArray*)p_psAlloc(sizeof(psComplexArray), __FILE__, __LINE__);
    208     psArr->type.dimen = PS_DIMEN_VECTOR;
    209     psArr->type.type = PS_TYPE_COMPLEX;
    210     psArr->nalloc = nalloc;
    211     psArr->n = 0;
    212 
    213     if(nalloc == 0) {
    214         psArr->arr = NULL;
    215     } else {
    216         psArr->arr = p_psAlloc(nalloc*sizeof(complex float), __FILE__, __LINE__);
    217     }
     204    psComplexArray *psArr = NULL;
     205    psArr = (psComplexArray*)psAlloc(sizeof(psComplexArray));
     206    psArr->nalloc = nalloc;
     207    psArr->n = 0;
     208    psArr->arr = (complex float*)p_psArrayAlloc(&psArr->type, PS_TYPE_COMPLEX, nalloc, sizeof(complex float));
    218209
    219210    return psArr;
    … …  
    222213psComplexArray *psComplexArrayRealloc(psComplexArray *psArr, int nalloc)
    223214{
    224     if(psArr == NULL) {
    225         return psComplexArrayAlloc(nalloc);
    226     }
    227     if(nalloc <= psArr->nalloc) {
    228         if (psArr->n < nalloc) {
    229             psArr->n = nalloc;
    230         }
    231     } else {
    232         psArr->arr = p_psRealloc(psArr->arr, nalloc*sizeof(complex float), __FILE__, __LINE__);
    233         psArr->nalloc = nalloc;
    234     }
     215    if(nalloc < psArr->n) {                                                 // For decrease in psArray size
     216        psArr->n = nalloc;
     217        psArr->nalloc = nalloc;
     218        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(complex float));   // For increase in psArray size
     219    } else if(nalloc > psArr->nalloc) {
     220        psArr->nalloc = nalloc;
     221        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(complex float));
     222    } else if(psArr == NULL) {                                              // For creating new psArray with realloc
     223        psArr = psComplexArrayAlloc(nalloc);
     224    }
     225
    235226    return psArr;
    236227}
    … …  
    241232        return;
    242233    }
    243     p_psFree(psArr->arr, __FILE__, __LINE__);
    244     p_psFree(psArr, __FILE__, __LINE__);
     234    psFree(psArr->arr);
     235    psFree(psArr);
    245236}
    246237
    247238psVoidPtrArray* psVoidPtrArrayAlloc(int nalloc)
    248239{
    249     psVoidPtrArray *psArr = (psVoidPtrArray*)p_psAlloc(sizeof(psVoidPtrArray), __FILE__, __LINE__);
    250     psArr->type.dimen = PS_DIMEN_VECTOR;
    251     psArr->type.type = PS_TYPE_OTHER;
    252     psArr->nalloc = nalloc;
    253     psArr->n = 0;
    254 
    255     if(nalloc == 0) {
    256         psArr->arr = NULL;
    257     } else {
    258         psArr->arr = p_psAlloc(nalloc*sizeof(void*), __FILE__, __LINE__);
    259     }
     240    psVoidPtrArray *psArr = NULL;
     241    psArr = (psVoidPtrArray*)psAlloc(sizeof(psVoidPtrArray));
     242    psArr->nalloc = nalloc;
     243    psArr->n = 0;
     244    psArr->arr = (void*)p_psArrayAlloc(&psArr->type, PS_TYPE_OTHER, nalloc, sizeof(void*));
    260245
    261246    return psArr;

  • trunk/psLib/src/collections/psArray.h

    r495 r502  
    33 *  @brief Contains support for basic array types
    44 *
    5  *  The types of basic one dimensional arrays defined include: int, float, double, complex float, and
    6  *  void *.
     5 *  This file defines basic types of one dimensional arrays which include: int, float, double, complex float, and
     6 *  void **.
    77 *
    88 *  @author Ross Harman, MHPCC
    99 *   
    10  *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2004-04-21 21:05:39 $
     10 *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2004-04-22 21:15:01 $
    1212 *
    1313 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii

  • trunk/psLib/src/types/psArray.c

    r495 r502  
    33 *  @brief Contains support for array types
    44 *
    5  *  The type of basic one dimensional arrays are defined here include: int, float, double, complex float, and
    6  *  void *.
     5 *  This file defines basic types of one dimensional arrays which include: int, float, double, complex float, and
     6 *  void **.
    77 *
    88 *  @author Ross Harman, MHPCC
    99 *   
    10  *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2004-04-21 21:05:39 $
     10 *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2004-04-22 21:15:01 $
    1212 *
    1313 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    4848/*****************************************************************************/
    4949
     50static void* p_psArrayAlloc(psType *arrType, psElemType elemType, int nalloc, int elemSize)
     51{
     52    void *arr = NULL;
     53
     54    arrType->dimen = PS_DIMEN_VECTOR;
     55    arrType->type = elemType;
     56
     57    if(nalloc != 0) {
     58        arr = psAlloc(nalloc*sizeof(elemSize));
     59    }
     60
     61    return arr;
     62}
     63
    5064static psVoidPtrArray *p_psVoidPtrArrayRealloc(psVoidPtrArray *restrict psArr, int nalloc)
    5165{
    52     if(psArr == NULL) {
    53         return psVoidPtrArrayAlloc(nalloc);
    54     }
    55     if(nalloc <= psArr->nalloc) {
    56         if (psArr->n < nalloc) {
    57             psArr->n = nalloc;
    58         }
    59     } else {
    60         psArr->arr = p_psRealloc(psArr->arr, nalloc*sizeof(void*), __FILE__, __LINE__);
    61         psArr->nalloc = nalloc;
    62     }
     66    if(nalloc < psArr->n) {                                         // For decrease in psArray size
     67        psArr->n = nalloc;
     68        psArr->nalloc = nalloc;
     69        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(void*));   // For increase in psArray size
     70    } else if(nalloc > psArr->nalloc) {
     71        psArr->nalloc = nalloc;
     72        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(void*));
     73    } else if(psArr == NULL) {                                      // For creating new psArray with realloc
     74        psArr = psVoidPtrArrayAlloc(nalloc);
     75    }
     76
    6377    return psArr;
    6478}
    … …  
    6983        return;
    7084    }
    71     p_psFree(psArr->arr, __FILE__, __LINE__);
    72     p_psFree(psArr, __FILE__, __LINE__);
     85    psFree(psArr->arr);
     86    psFree(psArr);
    7387}
    7488
    … …  
    7993psIntArray* psIntArrayAlloc(int nalloc)
    8094{
    81     psIntArray *psArr = (psIntArray*)p_psAlloc(sizeof(psIntArray), __FILE__, __LINE__);
    82     psArr->type.dimen = PS_DIMEN_VECTOR;
    83     psArr->type.type = PS_TYPE_INT;
    84     psArr->nalloc = nalloc;
    85     psArr->n = 0;
    86 
    87     if(nalloc == 0) {
    88         psArr->arr = NULL;
    89     } else {
    90         psArr->arr = p_psAlloc(nalloc*sizeof(int), __FILE__, __LINE__);
    91     }
     95    psIntArray *psArr = NULL;
     96    psArr = (psIntArray*)psAlloc(sizeof(psIntArray));
     97    psArr->nalloc = nalloc;
     98    psArr->n = 0;
     99    psArr->arr = (int*)p_psArrayAlloc(&psArr->type, PS_TYPE_INT, nalloc, sizeof(int));
    92100
    93101    return psArr;
    … …  
    96104psIntArray *psIntArrayRealloc(psIntArray *psArr, int nalloc)
    97105{
    98     if(psArr == NULL) {
    99         return psIntArrayAlloc(nalloc);
    100     }
    101     if(nalloc <= psArr->nalloc) {
    102         if (psArr->n < nalloc) {
    103             psArr->n = nalloc;
    104         }
    105     } else {
    106         psArr->arr = p_psRealloc(psArr->arr, nalloc*sizeof(int), __FILE__, __LINE__);
    107         psArr->nalloc = nalloc;
    108     }
     106    if(nalloc < psArr->n) {                                         // For decrease in psArray size
     107        psArr->n = nalloc;
     108        psArr->nalloc = nalloc;
     109        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(int));     // For increase in psArray size
     110    } else if(nalloc > psArr->nalloc) {
     111        psArr->nalloc = nalloc;
     112        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(int));
     113    } else if(psArr == NULL) {                                      // For creating new psArray with realloc
     114        psArr = psIntArrayAlloc(nalloc);
     115    }
     116
    109117    return psArr;
    110118}
    … …  
    115123        return;
    116124    }
    117     p_psFree(psArr->arr, __FILE__, __LINE__);
    118     p_psFree(psArr, __FILE__, __LINE__);
     125
     126    psFree(psArr->arr);
     127    psFree(psArr);
    119128}
    120129
    121130psFloatArray* psFloatArrayAlloc(int nalloc)
    122131{
    123     psFloatArray *psArr = (psFloatArray*)p_psAlloc(sizeof(psFloatArray), __FILE__, __LINE__);
    124     psArr->type.dimen = PS_DIMEN_VECTOR;
    125     psArr->type.type = PS_TYPE_FLOAT;
    126     psArr->nalloc = nalloc;
    127     psArr->n = 0;
    128 
    129     if(nalloc == 0) {
    130         psArr->arr = NULL;
    131     } else {
    132         psArr->arr = p_psAlloc(nalloc*sizeof(float), __FILE__, __LINE__);
    133     }
     132    psFloatArray *psArr = NULL;
     133    psArr = (psFloatArray*)psAlloc(sizeof(psFloatArray));
     134    psArr->nalloc = nalloc;
     135    psArr->n = 0;
     136    psArr->arr = (float*)p_psArrayAlloc(&psArr->type, PS_TYPE_FLOAT, nalloc, sizeof(float));
    134137
    135138    return psArr;
    … …  
    138141psFloatArray *psFloatArrayRealloc(psFloatArray *psArr, int nalloc)
    139142{
    140     if(psArr == NULL) {
    141         return psFloatArrayAlloc(nalloc);
    142     }
    143     if(nalloc <= psArr->nalloc) {
    144         if (psArr->n < nalloc) {
    145             psArr->n = nalloc;
    146         }
    147     } else {
    148         psArr->arr = p_psRealloc(psArr->arr, nalloc*sizeof(float), __FILE__, __LINE__);
    149         psArr->nalloc = nalloc;
    150     }
     143    if(nalloc < psArr->n) {                                         // For decrease in psArray size
     144        psArr->n = nalloc;
     145        psArr->nalloc = nalloc;
     146        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(float));   // For increase in psArray size
     147    } else if(nalloc > psArr->nalloc) {
     148        psArr->nalloc = nalloc;
     149        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(float));
     150    } else if(psArr == NULL) {                                      // For creating new psArray with realloc
     151        psArr = psFloatArrayAlloc(nalloc);
     152    }
     153
    151154    return psArr;
    152155}
    … …  
    157160        return;
    158161    }
    159     p_psFree(psArr->arr, __FILE__, __LINE__);
    160     p_psFree(psArr, __FILE__, __LINE__);
     162    psFree(psArr->arr);
     163    psFree(psArr);
    161164}
    162165
    163166psDoubleArray* psDoubleArrayAlloc(int nalloc)
    164167{
    165     psDoubleArray *psArr = (psDoubleArray*)p_psAlloc(sizeof(psDoubleArray), __FILE__, __LINE__);
    166     psArr->type.dimen = PS_DIMEN_VECTOR;
    167     psArr->type.type = PS_TYPE_DOUBLE;
    168     psArr->nalloc = nalloc;
    169     psArr->n = 0;
    170 
    171     if(nalloc == 0) {
    172         psArr->arr = NULL;
    173     } else {
    174         psArr->arr = p_psAlloc(nalloc*sizeof(double), __FILE__, __LINE__);
    175     }
     168    psDoubleArray *psArr = NULL;
     169    psArr = (psDoubleArray*)psAlloc(sizeof(psDoubleArray));
     170    psArr->nalloc = nalloc;
     171    psArr->n = 0;
     172    psArr->arr = (double*)p_psArrayAlloc(&psArr->type, PS_TYPE_DOUBLE, nalloc, sizeof(double));
    176173
    177174    return psArr;
    … …  
    180177psDoubleArray *psDoubleArrayRealloc(psDoubleArray *psArr, int nalloc)
    181178{
    182     if(psArr == NULL) {
    183         return psDoubleArrayAlloc(nalloc);
    184     }
    185     if(nalloc <= psArr->nalloc) {
    186         if (psArr->n < nalloc) {
    187             psArr->n = nalloc;
    188         }
    189     } else {
    190         psArr->arr = p_psRealloc(psArr->arr, nalloc*sizeof(double), __FILE__, __LINE__);
    191         psArr->nalloc = nalloc;
    192     }
     179    if(nalloc < psArr->n) {                                         // For decrease in psArray size
     180        psArr->n = nalloc;
     181        psArr->nalloc = nalloc;
     182        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(double));  // For increase in psArray size
     183    } else if(nalloc > psArr->nalloc) {
     184        psArr->nalloc = nalloc;
     185        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(double));
     186    } else if(psArr == NULL) {                                      // For creating new psArray with realloc
     187        psArr = psDoubleArrayAlloc(nalloc);
     188    }
     189
    193190    return psArr;
    194191}
    … …  
    199196        return;
    200197    }
    201     p_psFree(psArr->arr, __FILE__, __LINE__);
    202     p_psFree(psArr, __FILE__, __LINE__);
     198    psFree(psArr->arr);
     199    psFree(psArr);
    203200}
    204201
    205202psComplexArray* psComplexArrayAlloc(int nalloc)
    206203{
    207     psComplexArray *psArr = (psComplexArray*)p_psAlloc(sizeof(psComplexArray), __FILE__, __LINE__);
    208     psArr->type.dimen = PS_DIMEN_VECTOR;
    209     psArr->type.type = PS_TYPE_COMPLEX;
    210     psArr->nalloc = nalloc;
    211     psArr->n = 0;
    212 
    213     if(nalloc == 0) {
    214         psArr->arr = NULL;
    215     } else {
    216         psArr->arr = p_psAlloc(nalloc*sizeof(complex float), __FILE__, __LINE__);
    217     }
     204    psComplexArray *psArr = NULL;
     205    psArr = (psComplexArray*)psAlloc(sizeof(psComplexArray));
     206    psArr->nalloc = nalloc;
     207    psArr->n = 0;
     208    psArr->arr = (complex float*)p_psArrayAlloc(&psArr->type, PS_TYPE_COMPLEX, nalloc, sizeof(complex float));
    218209
    219210    return psArr;
    … …  
    222213psComplexArray *psComplexArrayRealloc(psComplexArray *psArr, int nalloc)
    223214{
    224     if(psArr == NULL) {
    225         return psComplexArrayAlloc(nalloc);
    226     }
    227     if(nalloc <= psArr->nalloc) {
    228         if (psArr->n < nalloc) {
    229             psArr->n = nalloc;
    230         }
    231     } else {
    232         psArr->arr = p_psRealloc(psArr->arr, nalloc*sizeof(complex float), __FILE__, __LINE__);
    233         psArr->nalloc = nalloc;
    234     }
     215    if(nalloc < psArr->n) {                                                 // For decrease in psArray size
     216        psArr->n = nalloc;
     217        psArr->nalloc = nalloc;
     218        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(complex float));   // For increase in psArray size
     219    } else if(nalloc > psArr->nalloc) {
     220        psArr->nalloc = nalloc;
     221        psArr->arr = psRealloc(psArr->arr, nalloc*sizeof(complex float));
     222    } else if(psArr == NULL) {                                              // For creating new psArray with realloc
     223        psArr = psComplexArrayAlloc(nalloc);
     224    }
     225
    235226    return psArr;
    236227}
    … …  
    241232        return;
    242233    }
    243     p_psFree(psArr->arr, __FILE__, __LINE__);
    244     p_psFree(psArr, __FILE__, __LINE__);
     234    psFree(psArr->arr);
     235    psFree(psArr);
    245236}
    246237
    247238psVoidPtrArray* psVoidPtrArrayAlloc(int nalloc)
    248239{
    249     psVoidPtrArray *psArr = (psVoidPtrArray*)p_psAlloc(sizeof(psVoidPtrArray), __FILE__, __LINE__);
    250     psArr->type.dimen = PS_DIMEN_VECTOR;
    251     psArr->type.type = PS_TYPE_OTHER;
    252     psArr->nalloc = nalloc;
    253     psArr->n = 0;
    254 
    255     if(nalloc == 0) {
    256         psArr->arr = NULL;
    257     } else {
    258         psArr->arr = p_psAlloc(nalloc*sizeof(void*), __FILE__, __LINE__);
    259     }
     240    psVoidPtrArray *psArr = NULL;
     241    psArr = (psVoidPtrArray*)psAlloc(sizeof(psVoidPtrArray));
     242    psArr->nalloc = nalloc;
     243    psArr->n = 0;
     244    psArr->arr = (void*)p_psArrayAlloc(&psArr->type, PS_TYPE_OTHER, nalloc, sizeof(void*));
    260245
    261246    return psArr;

  • trunk/psLib/src/types/psArray.h

    r495 r502  
    33 *  @brief Contains support for basic array types
    44 *
    5  *  The types of basic one dimensional arrays defined include: int, float, double, complex float, and
    6  *  void *.
     5 *  This file defines basic types of one dimensional arrays which include: int, float, double, complex float, and
     6 *  void **.
    77 *
    88 *  @author Ross Harman, MHPCC
    99 *   
    10  *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2004-04-21 21:05:39 $
     10 *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2004-04-22 21:15:01 $
    1212 *
    1313 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
Note: See TracChangeset for help on using the changeset viewer.