IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 4029


Ignore:
Timestamp:
May 25, 2005, 10:26:55 AM (21 years ago)
Author:
gusciora
Message:

I renamed many of the PS_CHECK macros to PS_ASSERT...

Location:
trunk/psLib/src
Files:
27 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/astro/psCoord.c

    r3991 r4029  
    1010*  @author GLG, MHPCC
    1111*
    12 *  @version $Revision: 1.69 $ $Name: not supported by cvs2svn $
    13 *  @date $Date: 2005-05-20 00:15:50 $
     12*  @version $Revision: 1.70 $ $Name: not supported by cvs2svn $
     13*  @date $Date: 2005-05-25 20:26:55 $
    1414*
    1515*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    9494psPlaneTransform *p_psPlaneTransformLinearInvert(psPlaneTransform *transform)
    9595{
    96     PS_PTR_CHECK_NULL(transform, 0);
    97     PS_PTR_CHECK_NULL(transform->x, 0);
    98     PS_PTR_CHECK_NULL(transform->y, 0);
     96    PS_ASSERT_PTR_NON_NULL(transform, 0);
     97    PS_ASSERT_PTR_NON_NULL(transform->x, 0);
     98    PS_ASSERT_PTR_NON_NULL(transform->y, 0);
    9999
    100100    psF64 A = 0.0;
    … …  
    160160psS32 p_psIsProjectionLinear(psPlaneTransform *transform)
    161161{
    162     PS_PTR_CHECK_NULL(transform, 0);
    163     PS_PTR_CHECK_NULL(transform->x, 0);
    164     PS_PTR_CHECK_NULL(transform->y, 0);
     162    PS_ASSERT_PTR_NON_NULL(transform, 0);
     163    PS_ASSERT_PTR_NON_NULL(transform->x, 0);
     164    PS_ASSERT_PTR_NON_NULL(transform->y, 0);
    165165
    166166    for (psS32 i=0;i<(transform->x->nX);i++) {
    … …  
    223223psPlaneTransform* psPlaneTransformAlloc(psS32 n1, psS32 n2)
    224224{
    225     PS_INT_CHECK_NON_NEGATIVE(n1, NULL);
    226     PS_INT_CHECK_NON_NEGATIVE(n2, NULL);
     225    PS_ASSERT_INT_NONNEGATIVE(n1, NULL);
     226    PS_ASSERT_INT_NONNEGATIVE(n2, NULL);
    227227
    228228    psPlaneTransform *pt = psAlloc(sizeof(psPlaneTransform));
    … …  
    238238                               const psPlane* coords)
    239239{
    240     PS_PTR_CHECK_NULL(transform, NULL);
    241     PS_PTR_CHECK_NULL(transform->x, NULL);
    242     PS_PTR_CHECK_NULL(transform->y, NULL);
    243     PS_PTR_CHECK_NULL(coords, NULL);
     240    PS_ASSERT_PTR_NON_NULL(transform, NULL);
     241    PS_ASSERT_PTR_NON_NULL(transform->x, NULL);
     242    PS_ASSERT_PTR_NON_NULL(transform->y, NULL);
     243    PS_ASSERT_PTR_NON_NULL(coords, NULL);
    244244
    245245    if (out == NULL) {
    … …  
    267267psPlaneDistort* psPlaneDistortAlloc(psS32 n1, psS32 n2, psS32 n3, psS32 n4)
    268268{
    269     PS_INT_CHECK_NON_NEGATIVE(n1, NULL);
    270     PS_INT_CHECK_NON_NEGATIVE(n2, NULL);
    271     PS_INT_CHECK_NON_NEGATIVE(n3, NULL);
    272     PS_INT_CHECK_NON_NEGATIVE(n4, NULL);
     269    PS_ASSERT_INT_NONNEGATIVE(n1, NULL);
     270    PS_ASSERT_INT_NONNEGATIVE(n2, NULL);
     271    PS_ASSERT_INT_NONNEGATIVE(n3, NULL);
     272    PS_ASSERT_INT_NONNEGATIVE(n4, NULL);
    273273
    274274    psPlaneDistort *pt = psAlloc(sizeof(psPlaneDistort));
    … …  
    290290                             float magnitude)
    291291{
    292     PS_PTR_CHECK_NULL(transform, NULL);
    293     PS_PTR_CHECK_NULL(transform->x, NULL);
    294     PS_PTR_CHECK_NULL(transform->y, NULL);
    295     PS_PTR_CHECK_NULL(coords, NULL);
     292    PS_ASSERT_PTR_NON_NULL(transform, NULL);
     293    PS_ASSERT_PTR_NON_NULL(transform->x, NULL);
     294    PS_ASSERT_PTR_NON_NULL(transform->y, NULL);
     295    PS_ASSERT_PTR_NON_NULL(coords, NULL);
    296296
    297297    if (out == NULL) {
    … …  
    364364                                 const psSphere* coord)
    365365{
    366     PS_PTR_CHECK_NULL(transform, NULL);
    367     PS_PTR_CHECK_NULL(coord, NULL);
     366    PS_ASSERT_PTR_NON_NULL(transform, NULL);
     367    PS_ASSERT_PTR_NON_NULL(coord, NULL);
    368368
    369369    if (out == NULL) {
    … …  
    394394
    395395    // Check for null parameter
    396     PS_PTR_CHECK_NULL(time, NULL);
     396    PS_ASSERT_PTR_NON_NULL(time, NULL);
    397397
    398398    // Convert psTime to MJD
    … …  
    427427
    428428    // Check for null parameter
    429     PS_PTR_CHECK_NULL(time, NULL);
     429    PS_ASSERT_PTR_NON_NULL(time, NULL);
    430430
    431431    // Convert psTime to MJD
    … …  
    498498                   const psProjection* projection)
    499499{
    500     PS_PTR_CHECK_NULL(coord, NULL);
    501     PS_PTR_CHECK_NULL(projection, NULL);
     500    PS_ASSERT_PTR_NON_NULL(coord, NULL);
     501    PS_ASSERT_PTR_NON_NULL(projection, NULL);
    502502
    503503    psF64   theta = 0.0;
    … …  
    550550                      const psProjection* projection)
    551551{
    552     PS_PTR_CHECK_NULL(coord, NULL);
    553     PS_PTR_CHECK_NULL(projection, NULL);
     552    PS_ASSERT_PTR_NON_NULL(coord, NULL);
     553    PS_ASSERT_PTR_NON_NULL(projection, NULL);
    554554
    555555    psF64  theta = 0.0;
    … …  
    622622                            psSphereOffsetUnit unit)
    623623{
    624     PS_PTR_CHECK_NULL(position1, NULL);
    625     PS_PTR_CHECK_NULL(position2, NULL);
     624    PS_ASSERT_PTR_NON_NULL(position1, NULL);
     625    PS_ASSERT_PTR_NON_NULL(position2, NULL);
    626626
    627627    // Check positions near 90 degree and issue warnings if necessary
    … …  
    721721                            psSphereOffsetUnit unit)
    722722{
    723     PS_PTR_CHECK_NULL(position, NULL);
    724     PS_PTR_CHECK_NULL(offset, NULL);
     723    PS_ASSERT_PTR_NON_NULL(position, NULL);
     724    PS_ASSERT_PTR_NON_NULL(offset, NULL);
    725725
    726726    psSphere* tmp;
    … …  
    811811{
    812812    // Check input for NULL pointers
    813     PS_PTR_CHECK_NULL(coords, NULL);
    814     PS_PTR_CHECK_NULL(fromTime, NULL);
    815     PS_PTR_CHECK_NULL(toTime, NULL);
     813    PS_ASSERT_PTR_NON_NULL(coords, NULL);
     814    PS_ASSERT_PTR_NON_NULL(fromTime, NULL);
     815    PS_ASSERT_PTR_NON_NULL(toTime, NULL);
    816816
    817817    // Calculate Julian centuries
    … …  
    904904    // XXX: This does not yet use region and nSamples:  need to modify -rdd
    905905
    906     PS_PTR_CHECK_NULL(trans1, NULL);
    907     PS_PTR_CHECK_NULL(trans2, NULL);
     906    PS_ASSERT_PTR_NON_NULL(trans1, NULL);
     907    PS_ASSERT_PTR_NON_NULL(trans2, NULL);
    908908    //TRACE: printf("psPlaneTransformCombine(%d, %d, %d, %d: %d, %d, %d, %d)\n", trans1->x->nX, trans1->x->nY, trans1->y->nX, trans1->y->nY, trans2->x->nX, trans2->x->nY, trans2->y->nX, trans2->y->nY);
    909909    //
    … …  
    10471047                         float sigmaClip)
    10481048{
    1049     PS_PTR_CHECK_NULL(trans, NULL);
    1050     PS_PTR_CHECK_NULL(source, NULL);
    1051     PS_PTR_CHECK_NULL(dest, NULL);
     1049    PS_ASSERT_PTR_NON_NULL(trans, NULL);
     1050    PS_ASSERT_PTR_NON_NULL(source, NULL);
     1051    PS_ASSERT_PTR_NON_NULL(dest, NULL);
    10521052
    10531053    psS32 numCoords = PS_MIN(source->n, dest->n);
    … …  
    11591159        int nSamples)
    11601160{
    1161     PS_PTR_CHECK_NULL(in, NULL);
     1161    PS_ASSERT_PTR_NON_NULL(in, NULL);
    11621162    //
    11631163    // If the transform is linear, then invert it exactly and return.

  • trunk/psLib/src/astro/psTime.c

    r3884 r4029  
    1010 *  @author Ross Harman, MHPCC
    1111 *
    12  *  @version $Revision: 1.60 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2005-05-11 22:02:15 $
     12 *  @version $Revision: 1.61 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2005-05-25 20:26:55 $
    1414 *
    1515 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    178178        }
    179179        table = (psLookupTable*)tableMetadataItem->data.V;
    180         PS_PTR_CHECK_NULL(table,0.0);
     180        PS_ASSERT_PTR_NON_NULL(table,0.0);
    181181
    182182        // Attempt to interpolate table
    … …  
    403403
    404404    // Error checks
    405     PS_PTR_CHECK_NULL(time,NULL);
    406     PS_INT_CHECK_RANGE(time->nsec,0,1e9-1,NULL);
     405    PS_ASSERT_PTR_NON_NULL(time,NULL);
     406    PS_ASSERT_INT_WITHIN_RANGE(time->nsec,0,1e9-1,NULL);
    407407
    408408    if (time->type == type) { // time already right type.  That was easy!
    … …  
    448448
    449449    // Error checks
    450     PS_PTR_CHECK_NULL(time,NAN);
    451     PS_INT_CHECK_RANGE(time->nsec,0,1e9-1,NAN);
     450    PS_ASSERT_PTR_NON_NULL(time,NAN);
     451    PS_ASSERT_INT_WITHIN_RANGE(time->nsec,0,1e9-1,NAN);
    452452
    453453    // Calculate TAI or UTC time based on type of time user passes
    … …  
    519519
    520520    // Error checks
    521     PS_PTR_CHECK_NULL(time,NAN);
    522     PS_INT_CHECK_RANGE(time->nsec,0,1e9-1,NAN);
     521    PS_ASSERT_PTR_NON_NULL(time,NAN);
     522    PS_ASSERT_INT_WITHIN_RANGE(time->nsec,0,1e9-1,NAN);
    523523
    524524    if(time->type != PS_TIME_TAI) {
    … …  
    560560        }
    561561        dut = (psVector*)tableMetadataItem->data.V;
    562         PS_PTR_CHECK_NULL(dut,0.0);
     562        PS_ASSERT_PTR_NON_NULL(dut,0.0);
    563563
    564564        t = 2000.0 + (mjd - 51544.03)/365.2422;
    … …  
    592592
    593593    // Error checks
    594     PS_PTR_CHECK_NULL(time,NULL);
    595     PS_INT_CHECK_RANGE(time->nsec,0,1e9-1,NULL);
     594    PS_ASSERT_PTR_NON_NULL(time,NULL);
     595    PS_ASSERT_INT_WITHIN_RANGE(time->nsec,0,1e9-1,NULL);
    596596
    597597    if(time->type != PS_TIME_TAI)
    … …  
    658658        }
    659659        xp = (psVector*)tableMetadataItem->data.V;
    660         PS_PTR_CHECK_NULL(xp,NULL);
     660        PS_ASSERT_PTR_NON_NULL(xp,NULL);
    661661
    662662        // Get yp
    … …  
    667667        }
    668668        yp = (psVector*)tableMetadataItem->data.V;
    669         PS_PTR_CHECK_NULL(yp,NULL);
     669        PS_ASSERT_PTR_NON_NULL(yp,NULL);
    670670
    671671        // Calculate "a" and "c" constants
    … …  
    715715
    716716    // Error checks
    717     PS_PTR_CHECK_NULL(time,NAN);
    718     PS_INT_CHECK_RANGE(time->nsec,0,1e9-1,NAN);
     717    PS_ASSERT_PTR_NON_NULL(time,NAN);
     718    PS_ASSERT_INT_WITHIN_RANGE(time->nsec,0,1e9-1,NAN);
    719719
    720720    // Check time metadata
    … …  
    733733    }
    734734    table = (psLookupTable*)tableMetadataItem->data.V;
    735     PS_PTR_CHECK_NULL(table,0);
     735    PS_ASSERT_PTR_NON_NULL(table,0);
    736736
    737737    // Determine Julian and modified Julian dates used in table lookup and time delta calculation
    … …  
    767767
    768768    // Error checks
    769     PS_PTR_CHECK_NULL(time1,0);
    770     PS_PTR_CHECK_NULL(time2,0);
    771     PS_INT_CHECK_RANGE(time1->nsec,0,1e9-1,0);
    772     PS_INT_CHECK_RANGE(time2->nsec,0,1e9-1,0);
     769    PS_ASSERT_PTR_NON_NULL(time1,0);
     770    PS_ASSERT_PTR_NON_NULL(time2,0);
     771    PS_ASSERT_INT_WITHIN_RANGE(time1->nsec,0,1e9-1,0);
     772    PS_ASSERT_INT_WITHIN_RANGE(time2->nsec,0,1e9-1,0);
    773773    diff = abs((psS64)psTimeGetTAIDelta((psTime*)time1)-(psS64)psTimeGetTAIDelta((psTime*)time2));
    774774
    … …  
    781781
    782782    // Error checks
    783     PS_PTR_CHECK_NULL(time,NAN);
    784     PS_INT_CHECK_RANGE(time->nsec,0,1e9-1,NAN);
     783    PS_ASSERT_PTR_NON_NULL(time,NAN);
     784    PS_ASSERT_INT_WITHIN_RANGE(time->nsec,0,1e9-1,NAN);
    785785
    786786    // Julian date conversion
    … …  
    800800
    801801    // Error checks
    802     PS_PTR_CHECK_NULL(time,NAN);
    803     PS_INT_CHECK_RANGE(time->nsec,0,1e9-1,NAN);
     802    PS_ASSERT_PTR_NON_NULL(time,NAN);
     803    PS_ASSERT_INT_WITHIN_RANGE(time->nsec,0,1e9-1,NAN);
    804804
    805805    // Modified Julian date conversion
    … …  
    823823
    824824    // Error checks
    825     PS_PTR_CHECK_NULL(time,NULL);
    826     PS_INT_CHECK_RANGE(time->nsec,0,1e9-1,NULL);
     825    PS_ASSERT_PTR_NON_NULL(time,NULL);
     826    PS_ASSERT_INT_WITHIN_RANGE(time->nsec,0,1e9-1,NULL);
    827827
    828828    tempString = psAlloc(MAX_TIME_STRING_LENGTH);
    … …  
    856856
    857857    // Error checks
    858     PS_PTR_CHECK_NULL(time,timevalTime);
    859     PS_INT_CHECK_RANGE(time->nsec,0,1e9-1,timevalTime);
     858    PS_ASSERT_PTR_NON_NULL(time,timevalTime);
     859    PS_ASSERT_INT_WITHIN_RANGE(time->nsec,0,1e9-1,timevalTime);
    860860
    861861    timevalTime.tv_sec = time->sec;
    … …  
    879879
    880880    // Error checks
    881     PS_PTR_CHECK_NULL(time,NULL);
    882     PS_INT_CHECK_RANGE(time->nsec,0,1e9-1,NULL);
     881    PS_ASSERT_PTR_NON_NULL(time,NULL);
     882    PS_ASSERT_INT_WITHIN_RANGE(time->nsec,0,1e9-1,NULL);
    883883
    884884    seconds = time->sec%60;
    … …  
    949949
    950950    // Error check
    951     PS_INT_CHECK_RANGE(outTime->nsec,0,1e9-1,outTime);
     951    PS_ASSERT_INT_WITHIN_RANGE(outTime->nsec,0,1e9-1,outTime);
    952952
    953953    return outTime;
    … …  
    975975
    976976    // Error check
    977     PS_INT_CHECK_RANGE(outTime->nsec,0,1e9-1,outTime);
     977    PS_ASSERT_INT_WITHIN_RANGE(outTime->nsec,0,1e9-1,outTime);
    978978
    979979    return outTime;
    … …  
    993993    }
    994994
    995     PS_INT_CHECK_NON_NEGATIVE(tmTime.tm_year, outTime);
    996     PS_INT_CHECK_RANGE(tmTime.tm_mon,1,12,outTime);
    997     PS_INT_CHECK_RANGE(tmTime.tm_mday,1,31,outTime);
    998     PS_INT_CHECK_RANGE(tmTime.tm_hour,0,23,outTime);
    999     PS_INT_CHECK_RANGE(tmTime.tm_min,0,59,outTime);
    1000     PS_INT_CHECK_RANGE(tmTime.tm_sec,0,59,outTime);
    1001     PS_INT_CHECK_RANGE(millisecond,0,999,outTime);
     995    PS_ASSERT_INT_NONNEGATIVE(tmTime.tm_year, outTime);
     996    PS_ASSERT_INT_WITHIN_RANGE(tmTime.tm_mon,1,12,outTime);
     997    PS_ASSERT_INT_WITHIN_RANGE(tmTime.tm_mday,1,31,outTime);
     998    PS_ASSERT_INT_WITHIN_RANGE(tmTime.tm_hour,0,23,outTime);
     999    PS_ASSERT_INT_WITHIN_RANGE(tmTime.tm_min,0,59,outTime);
     1000    PS_ASSERT_INT_WITHIN_RANGE(tmTime.tm_sec,0,59,outTime);
     1001    PS_ASSERT_INT_WITHIN_RANGE(millisecond,0,999,outTime);
    10021002
    10031003    tmTime.tm_year -= 1900;
    … …  
    10181018
    10191019    // Error check
    1020     PS_PTR_CHECK_NULL(time,NULL);
     1020    PS_ASSERT_PTR_NON_NULL(time,NULL);
    10211021
    10221022    // Allocate psTime struct
    … …  
    10281028
    10291029    // Error check
    1030     PS_INT_CHECK_RANGE(outTime->nsec,0,1e9-1,outTime);
     1030    PS_ASSERT_INT_WITHIN_RANGE(outTime->nsec,0,1e9-1,outTime);
    10311031
    10321032    return outTime;
    … …  
    10461046
    10471047    // Error check
    1048     PS_PTR_CHECK_NULL(time,NULL);
     1048    PS_ASSERT_PTR_NON_NULL(time,NULL);
    10491049
    10501050    // Allocate psTime struct
    … …  
    10871087
    10881088    // Error check
    1089     PS_INT_CHECK_RANGE(outTime->nsec,0,1e9-1,outTime);
     1089    PS_ASSERT_INT_WITHIN_RANGE(outTime->nsec,0,1e9-1,outTime);
    10901090
    10911091    return outTime;
    … …  
    11001100
    11011101    // Error checks
    1102     PS_PTR_CHECK_NULL(time,NULL);
    1103     PS_INT_CHECK_RANGE(time->nsec,0,1e9-1,NULL);
     1102    PS_ASSERT_PTR_NON_NULL(time,NULL);
     1103    PS_ASSERT_INT_WITHIN_RANGE(time->nsec,0,1e9-1,NULL);
    11041104
    11051105    // Convert time to TAI if necessary, but without changing input arguments
    … …  
    11201120
    11211121    // Error check
    1122     PS_INT_CHECK_RANGE(outTime->nsec,0,1e9-1,outTime);
     1122    PS_ASSERT_INT_WITHIN_RANGE(outTime->nsec,0,1e9-1,outTime);
    11231123
    11241124    // Convert result to same time type as input
    … …  
    11421142
    11431143    // Error checks
    1144     PS_PTR_CHECK_NULL(time1,0.0);
    1145     PS_INT_CHECK_RANGE(time1->nsec,0,1e9-1,0.0);
    1146     PS_PTR_CHECK_NULL(time2,0.0);
    1147     PS_INT_CHECK_RANGE(time2->nsec,0,1e9-1,0.0);
     1144    PS_ASSERT_PTR_NON_NULL(time1,0.0);
     1145    PS_ASSERT_INT_WITHIN_RANGE(time1->nsec,0,1e9-1,0.0);
     1146    PS_ASSERT_PTR_NON_NULL(time2,0.0);
     1147    PS_ASSERT_INT_WITHIN_RANGE(time2->nsec,0,1e9-1,0.0);
    11481148
    11491149    // Convert time to TAI if necessary, but without changing input arguments

  • trunk/psLib/src/astronomy/psAstrometry.c

    r3708 r4029  
    88 *  @author GLG, MHPCC
    99 *
    10  *  @version $Revision: 1.65 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2005-04-19 00:17:05 $
     10 *  @version $Revision: 1.66 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2005-05-25 20:26:55 $
    1212 *
    1313 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    4141                                   psImage* tmpImage)
    4242{
    43     PS_IMAGE_CHECK_NULL(tmpImage, 0);
     43    PS_ASSERT_IMAGE_NON_NULL(tmpImage, 0);
    4444
    4545    if ((x < 0.0) || (x > (double)tmpImage->numCols) ||
    … …  
    154154    psS32 j;
    155155
    156     PS_IMAGE_CHECK_NULL(x, NULL);
    157     PS_IMAGE_CHECK_NULL(y, NULL);
    158     PS_IMAGE_CHECK_TYPE(x, PS_TYPE_F64, NULL);
    159     PS_IMAGE_CHECK_TYPE(y, PS_TYPE_F64, NULL);
     156    PS_ASSERT_IMAGE_NON_NULL(x, NULL);
     157    PS_ASSERT_IMAGE_NON_NULL(y, NULL);
     158    PS_ASSERT_IMAGE_TYPE(x, PS_TYPE_F64, NULL);
     159    PS_ASSERT_IMAGE_TYPE(y, PS_TYPE_F64, NULL);
    160160
    161161    tmp = (psFixedPattern *) psAlloc(sizeof(psFixedPattern));
    … …  
    211211                            const psObservatory* observatory)
    212212{
    213     PS_PTR_CHECK_NULL(observatory, NULL);
     213    PS_ASSERT_PTR_NON_NULL(observatory, NULL);
    214214
    215215    psExposure* exp = psAlloc(sizeof(psExposure));
    … …  
    271271                  const psExposure* exp)
    272272{
    273     PS_INT_CHECK_NON_NEGATIVE(nChips, NULL);
     273    PS_ASSERT_INT_NONNEGATIVE(nChips, NULL);
    274274
    275275    psFPA* newFPA = psAlloc(sizeof(psFPA));
    … …  
    315315                    psFPA *parentFPA)
    316316{
    317     PS_INT_CHECK_NON_NEGATIVE(nCells, NULL);
     317    PS_ASSERT_INT_NONNEGATIVE(nCells, NULL);
    318318
    319319    psChip* chip = psAlloc(sizeof(psChip));
    … …  
    350350                    psChip* parentChip)
    351351{
    352     PS_INT_CHECK_NON_NEGATIVE(nReadouts, NULL);
     352    PS_ASSERT_INT_NONNEGATIVE(nReadouts, NULL);
    353353
    354354    psCell* cell = psAlloc(sizeof(psCell));
    … …  
    406406psGrommit* psGrommitAlloc(const psExposure* exp)
    407407{
    408     PS_PTR_CHECK_NULL(exp, NULL);
     408    PS_ASSERT_PTR_NON_NULL(exp, NULL);
    409409
    410410    double date = psTimeToMJD(exp->time);
    … …  
    436436                    const psFPA* FPA)
    437437{
    438     PS_PTR_CHECK_NULL(fpaCoord, NULL);
    439     PS_PTR_CHECK_NULL(FPA, NULL);
     438    PS_ASSERT_PTR_NON_NULL(fpaCoord, NULL);
     439    PS_ASSERT_PTR_NON_NULL(FPA, NULL);
    440440
    441441    psChip* tmpChip = NULL;
    … …  
    461461                    const psFPA* FPA)
    462462{
    463     PS_PTR_CHECK_NULL(fpaCoord, NULL);
    464     PS_PTR_CHECK_NULL(FPA, NULL);
    465     PS_PTR_CHECK_NULL(FPA->chips, NULL);
     463    PS_ASSERT_PTR_NON_NULL(fpaCoord, NULL);
     464    PS_ASSERT_PTR_NON_NULL(FPA, NULL);
     465    PS_ASSERT_PTR_NON_NULL(FPA->chips, NULL);
    466466
    467467    psArray* chips = FPA->chips;
    … …  
    476476    for (psS32 i = 0; i < nChips; i++) {
    477477        psChip* tmpChip = chips->data[i];
    478         PS_PTR_CHECK_NULL(tmpChip, NULL);
    479         PS_PTR_CHECK_NULL(tmpChip->fromFPA, NULL);
     478        PS_ASSERT_PTR_NON_NULL(tmpChip, NULL);
     479        PS_ASSERT_PTR_NON_NULL(tmpChip->fromFPA, NULL);
    480480
    481481        psPlaneTransformApply(&chipCoord, tmpChip->fromFPA, fpaCoord);
    … …  
    494494                     const psChip* chip)
    495495{
    496     PS_PTR_CHECK_NULL(chipCoord, NULL);
    497     PS_PTR_CHECK_NULL(chip, NULL);
     496    PS_ASSERT_PTR_NON_NULL(chipCoord, NULL);
     497    PS_ASSERT_PTR_NON_NULL(chip, NULL);
    498498
    499499    psPlane cellCoord;
    … …  
    511511    for (psS32 i = 0; i < cells->n; i++) {
    512512        psCell* tmpCell = (psCell* ) cells->data[i];
    513         PS_PTR_CHECK_NULL(tmpCell, NULL);
    514         PS_PTR_CHECK_NULL(tmpCell->fromChip, NULL);
     513        PS_ASSERT_PTR_NON_NULL(tmpCell, NULL);
     514        PS_ASSERT_PTR_NON_NULL(tmpCell->fromChip, NULL);
    515515        psArray* readouts = tmpCell->readouts;
    516516
    … …  
    518518            for (psS32 j = 0; j < readouts->n; j++) {
    519519                psReadout* tmpReadout = readouts->data[j];
    520                 PS_READOUT_CHECK_NULL(tmpReadout, NULL);
     520                PS_ASSERT_READOUT_NON_NULL(tmpReadout, NULL);
    521521
    522522                psPlaneTransformApply(&cellCoord,
    … …  
    540540                           const psCell* cell)
    541541{
    542     PS_PTR_CHECK_NULL(inCoord, NULL);
    543     PS_PTR_CHECK_NULL(cell, NULL);
     542    PS_ASSERT_PTR_NON_NULL(inCoord, NULL);
     543    PS_ASSERT_PTR_NON_NULL(cell, NULL);
    544544
    545545    return (psPlaneTransformApply(outCoord, cell->toChip, inCoord));
    … …  
    550550                          const psChip* chip)
    551551{
    552     PS_PTR_CHECK_NULL(inCoord, NULL);
    553     PS_PTR_CHECK_NULL(chip, NULL);
     552    PS_ASSERT_PTR_NON_NULL(inCoord, NULL);
     553    PS_ASSERT_PTR_NON_NULL(chip, NULL);
    554554
    555555    return (psPlaneTransformApply(outCoord, chip->toFPA, inCoord));
    … …  
    562562                        const psFPA* fpa)
    563563{
    564     PS_PTR_CHECK_NULL(inCoord, NULL);
    565     PS_PTR_CHECK_NULL(fpa, NULL);
     564    PS_ASSERT_PTR_NON_NULL(inCoord, NULL);
     565    PS_ASSERT_PTR_NON_NULL(fpa, NULL);
    566566
    567567    return(psPlaneDistortApply(outCoord, fpa->toTangentPlane, inCoord,
    … …  
    576576                         const psGrommit* grommit)
    577577{
    578     PS_PTR_CHECK_NULL(tpCoord, NULL);
    579     PS_PTR_CHECK_NULL(grommit, NULL);
     578    PS_ASSERT_PTR_NON_NULL(tpCoord, NULL);
     579    PS_ASSERT_PTR_NON_NULL(grommit, NULL);
    580580
    581581    double AOB = 0.0;
    … …  
    596596                          const psCell* cell)
    597597{
    598     PS_PTR_CHECK_NULL(cellCoord, NULL);
    599     PS_PTR_CHECK_NULL(cell, NULL);
     598    PS_ASSERT_PTR_NON_NULL(cellCoord, NULL);
     599    PS_ASSERT_PTR_NON_NULL(cell, NULL);
    600600
    601601    return (psPlaneTransformApply(fpaCoord, cell->toFPA, cellCoord));
    … …  
    608608                           const psCell* cell)
    609609{
    610     PS_PTR_CHECK_NULL(cellCoord, NULL);
    611     PS_PTR_CHECK_NULL(cell, NULL);
    612     PS_PTR_CHECK_NULL(cell->toFPA, NULL);
    613     PS_PTR_CHECK_NULL(cell->parent, NULL);
    614     PS_PTR_CHECK_NULL(cell->parent->parent, NULL);
    615     PS_PTR_CHECK_NULL(cell->parent->parent->toTangentPlane, NULL);
    616     PS_PTR_CHECK_NULL(cell->parent->parent->exposure, NULL);
     610    PS_ASSERT_PTR_NON_NULL(cellCoord, NULL);
     611    PS_ASSERT_PTR_NON_NULL(cell, NULL);
     612    PS_ASSERT_PTR_NON_NULL(cell->toFPA, NULL);
     613    PS_ASSERT_PTR_NON_NULL(cell->parent, NULL);
     614    PS_ASSERT_PTR_NON_NULL(cell->parent->parent, NULL);
     615    PS_ASSERT_PTR_NON_NULL(cell->parent->parent->toTangentPlane, NULL);
     616    PS_ASSERT_PTR_NON_NULL(cell->parent->parent->exposure, NULL);
    617617
    618618    psPlane* fpaCoord = NULL;
    … …  
    645645                                const psCell* cell)
    646646{
    647     PS_PTR_CHECK_NULL(cellCoord, NULL);
    648     PS_PTR_CHECK_NULL(cell, NULL);
    649     PS_PTR_CHECK_NULL(cell->toSky, NULL);
    650     PS_PTR_CHECK_NULL(cell->parent, NULL);
    651     PS_PTR_CHECK_NULL(cell->parent->parent, NULL);
    652     PS_PTR_CHECK_NULL(cell->parent->parent->projection, NULL);
     647    PS_ASSERT_PTR_NON_NULL(cellCoord, NULL);
     648    PS_ASSERT_PTR_NON_NULL(cell, NULL);
     649    PS_ASSERT_PTR_NON_NULL(cell->toSky, NULL);
     650    PS_ASSERT_PTR_NON_NULL(cell->parent, NULL);
     651    PS_ASSERT_PTR_NON_NULL(cell->parent->parent, NULL);
     652    PS_ASSERT_PTR_NON_NULL(cell->parent->parent->projection, NULL);
    653653    if (cell->toSky) {
    654654        // XXX: Should we use toTP or toSky?
    … …  
    690690                        const psGrommit* grommit)
    691691{
    692     PS_PTR_CHECK_NULL(in, NULL);
    693     PS_PTR_CHECK_NULL(grommit, NULL);
     692    PS_ASSERT_PTR_NON_NULL(in, NULL);
     693    PS_ASSERT_PTR_NON_NULL(grommit, NULL);
    694694
    695695    char* type = "RA";
    … …  
    711711                        const psFPA* fpa)
    712712{
    713     PS_PTR_CHECK_NULL(tpCoord, NULL);
    714     PS_PTR_CHECK_NULL(fpa, NULL);
    715     PS_PTR_CHECK_NULL(fpa->fromTangentPlane, NULL);
     713    PS_ASSERT_PTR_NON_NULL(tpCoord, NULL);
     714    PS_ASSERT_PTR_NON_NULL(fpa, NULL);
     715    PS_ASSERT_PTR_NON_NULL(fpa->fromTangentPlane, NULL);
    716716
    717717    return (psPlaneDistortApply(fpaCoord, fpa->fromTangentPlane,
    … …  
    723723                          const psChip* chip)
    724724{
    725     PS_PTR_CHECK_NULL(fpaCoord, NULL);
    726     PS_PTR_CHECK_NULL(chip, NULL);
    727     PS_PTR_CHECK_NULL(chip->fromFPA, NULL);
     725    PS_ASSERT_PTR_NON_NULL(fpaCoord, NULL);
     726    PS_ASSERT_PTR_NON_NULL(chip, NULL);
     727    PS_ASSERT_PTR_NON_NULL(chip->fromFPA, NULL);
    728728
    729729    chipCoord = psPlaneTransformApply(chipCoord, chip->fromFPA, fpaCoord);
    … …  
    735735                           const psCell* cell)
    736736{
    737     PS_PTR_CHECK_NULL(chipCoord, NULL);
    738     PS_PTR_CHECK_NULL(cell, NULL);
    739     PS_PTR_CHECK_NULL(cell->fromChip, NULL);
     737    PS_ASSERT_PTR_NON_NULL(chipCoord, NULL);
     738    PS_ASSERT_PTR_NON_NULL(cell, NULL);
     739    PS_ASSERT_PTR_NON_NULL(cell->fromChip, NULL);
    740740
    741741    cellCoord = psPlaneTransformApply(cellCoord, cell->fromChip, chipCoord);
    … …  
    749749                          const psCell* cell)
    750750{
    751     PS_PTR_CHECK_NULL(skyCoord, NULL);
    752     PS_PTR_CHECK_NULL(cell, NULL);
    753     PS_PTR_CHECK_NULL(cell->parent, NULL);
    754     PS_PTR_CHECK_NULL(cell->parent->parent, NULL);
    755     PS_PTR_CHECK_NULL(cell->parent->parent->grommit, NULL);
     751    PS_ASSERT_PTR_NON_NULL(skyCoord, NULL);
     752    PS_ASSERT_PTR_NON_NULL(cell, NULL);
     753    PS_ASSERT_PTR_NON_NULL(cell->parent, NULL);
     754    PS_ASSERT_PTR_NON_NULL(cell->parent->parent, NULL);
     755    PS_ASSERT_PTR_NON_NULL(cell->parent->parent->grommit, NULL);
    756756
    757757    psChip *parChip = cell->parent;
    … …  
    783783                               const psCell* cell)
    784784{
    785     PS_PTR_CHECK_NULL(skyCoord, NULL);
    786     PS_PTR_CHECK_NULL(cell, NULL);
    787     PS_PTR_CHECK_NULL(cell->parent, NULL);
    788     PS_PTR_CHECK_NULL(cell->parent->parent, NULL);
    789     PS_PTR_CHECK_NULL(cell->parent->parent->projection, NULL);
    790     PS_PTR_CHECK_NULL(cell->toTP, NULL);
     785    PS_ASSERT_PTR_NON_NULL(skyCoord, NULL);
     786    PS_ASSERT_PTR_NON_NULL(cell, NULL);
     787    PS_ASSERT_PTR_NON_NULL(cell->parent, NULL);
     788    PS_ASSERT_PTR_NON_NULL(cell->parent->parent, NULL);
     789    PS_ASSERT_PTR_NON_NULL(cell->parent->parent->projection, NULL);
     790    PS_ASSERT_PTR_NON_NULL(cell->toTP, NULL);
    791791    if (cell->toSky) {
    792792        // XXX: Should we use toTP or toSky?

  • trunk/psLib/src/astronomy/psCoord.c

    r3991 r4029  
    1010*  @author GLG, MHPCC
    1111*
    12 *  @version $Revision: 1.69 $ $Name: not supported by cvs2svn $
    13 *  @date $Date: 2005-05-20 00:15:50 $
     12*  @version $Revision: 1.70 $ $Name: not supported by cvs2svn $
     13*  @date $Date: 2005-05-25 20:26:55 $
    1414*
    1515*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    9494psPlaneTransform *p_psPlaneTransformLinearInvert(psPlaneTransform *transform)
    9595{
    96     PS_PTR_CHECK_NULL(transform, 0);
    97     PS_PTR_CHECK_NULL(transform->x, 0);
    98     PS_PTR_CHECK_NULL(transform->y, 0);
     96    PS_ASSERT_PTR_NON_NULL(transform, 0);
     97    PS_ASSERT_PTR_NON_NULL(transform->x, 0);
     98    PS_ASSERT_PTR_NON_NULL(transform->y, 0);
    9999
    100100    psF64 A = 0.0;
    … …  
    160160psS32 p_psIsProjectionLinear(psPlaneTransform *transform)
    161161{
    162     PS_PTR_CHECK_NULL(transform, 0);
    163     PS_PTR_CHECK_NULL(transform->x, 0);
    164     PS_PTR_CHECK_NULL(transform->y, 0);
     162    PS_ASSERT_PTR_NON_NULL(transform, 0);
     163    PS_ASSERT_PTR_NON_NULL(transform->x, 0);
     164    PS_ASSERT_PTR_NON_NULL(transform->y, 0);
    165165
    166166    for (psS32 i=0;i<(transform->x->nX);i++) {
    … …  
    223223psPlaneTransform* psPlaneTransformAlloc(psS32 n1, psS32 n2)
    224224{
    225     PS_INT_CHECK_NON_NEGATIVE(n1, NULL);
    226     PS_INT_CHECK_NON_NEGATIVE(n2, NULL);
     225    PS_ASSERT_INT_NONNEGATIVE(n1, NULL);
     226    PS_ASSERT_INT_NONNEGATIVE(n2, NULL);
    227227
    228228    psPlaneTransform *pt = psAlloc(sizeof(psPlaneTransform));
    … …  
    238238                               const psPlane* coords)
    239239{
    240     PS_PTR_CHECK_NULL(transform, NULL);
    241     PS_PTR_CHECK_NULL(transform->x, NULL);
    242     PS_PTR_CHECK_NULL(transform->y, NULL);
    243     PS_PTR_CHECK_NULL(coords, NULL);
     240    PS_ASSERT_PTR_NON_NULL(transform, NULL);
     241    PS_ASSERT_PTR_NON_NULL(transform->x, NULL);
     242    PS_ASSERT_PTR_NON_NULL(transform->y, NULL);
     243    PS_ASSERT_PTR_NON_NULL(coords, NULL);
    244244
    245245    if (out == NULL) {
    … …  
    267267psPlaneDistort* psPlaneDistortAlloc(psS32 n1, psS32 n2, psS32 n3, psS32 n4)
    268268{
    269     PS_INT_CHECK_NON_NEGATIVE(n1, NULL);
    270     PS_INT_CHECK_NON_NEGATIVE(n2, NULL);
    271     PS_INT_CHECK_NON_NEGATIVE(n3, NULL);
    272     PS_INT_CHECK_NON_NEGATIVE(n4, NULL);
     269    PS_ASSERT_INT_NONNEGATIVE(n1, NULL);
     270    PS_ASSERT_INT_NONNEGATIVE(n2, NULL);
     271    PS_ASSERT_INT_NONNEGATIVE(n3, NULL);
     272    PS_ASSERT_INT_NONNEGATIVE(n4, NULL);
    273273
    274274    psPlaneDistort *pt = psAlloc(sizeof(psPlaneDistort));
    … …  
    290290                             float magnitude)
    291291{
    292     PS_PTR_CHECK_NULL(transform, NULL);
    293     PS_PTR_CHECK_NULL(transform->x, NULL);
    294     PS_PTR_CHECK_NULL(transform->y, NULL);
    295     PS_PTR_CHECK_NULL(coords, NULL);
     292    PS_ASSERT_PTR_NON_NULL(transform, NULL);
     293    PS_ASSERT_PTR_NON_NULL(transform->x, NULL);
     294    PS_ASSERT_PTR_NON_NULL(transform->y, NULL);
     295    PS_ASSERT_PTR_NON_NULL(coords, NULL);
    296296
    297297    if (out == NULL) {
    … …  
    364364                                 const psSphere* coord)
    365365{
    366     PS_PTR_CHECK_NULL(transform, NULL);
    367     PS_PTR_CHECK_NULL(coord, NULL);
     366    PS_ASSERT_PTR_NON_NULL(transform, NULL);
     367    PS_ASSERT_PTR_NON_NULL(coord, NULL);
    368368
    369369    if (out == NULL) {
    … …  
    394394
    395395    // Check for null parameter
    396     PS_PTR_CHECK_NULL(time, NULL);
     396    PS_ASSERT_PTR_NON_NULL(time, NULL);
    397397
    398398    // Convert psTime to MJD
    … …  
    427427
    428428    // Check for null parameter
    429     PS_PTR_CHECK_NULL(time, NULL);
     429    PS_ASSERT_PTR_NON_NULL(time, NULL);
    430430
    431431    // Convert psTime to MJD
    … …  
    498498                   const psProjection* projection)
    499499{
    500     PS_PTR_CHECK_NULL(coord, NULL);
    501     PS_PTR_CHECK_NULL(projection, NULL);
     500    PS_ASSERT_PTR_NON_NULL(coord, NULL);
     501    PS_ASSERT_PTR_NON_NULL(projection, NULL);
    502502
    503503    psF64   theta = 0.0;
    … …  
    550550                      const psProjection* projection)
    551551{
    552     PS_PTR_CHECK_NULL(coord, NULL);
    553     PS_PTR_CHECK_NULL(projection, NULL);
     552    PS_ASSERT_PTR_NON_NULL(coord, NULL);
     553    PS_ASSERT_PTR_NON_NULL(projection, NULL);
    554554
    555555    psF64  theta = 0.0;
    … …  
    622622                            psSphereOffsetUnit unit)
    623623{
    624     PS_PTR_CHECK_NULL(position1, NULL);
    625     PS_PTR_CHECK_NULL(position2, NULL);
     624    PS_ASSERT_PTR_NON_NULL(position1, NULL);
     625    PS_ASSERT_PTR_NON_NULL(position2, NULL);
    626626
    627627    // Check positions near 90 degree and issue warnings if necessary
    … …  
    721721                            psSphereOffsetUnit unit)
    722722{
    723     PS_PTR_CHECK_NULL(position, NULL);
    724     PS_PTR_CHECK_NULL(offset, NULL);
     723    PS_ASSERT_PTR_NON_NULL(position, NULL);
     724    PS_ASSERT_PTR_NON_NULL(offset, NULL);
    725725
    726726    psSphere* tmp;
    … …  
    811811{
    812812    // Check input for NULL pointers
    813     PS_PTR_CHECK_NULL(coords, NULL);
    814     PS_PTR_CHECK_NULL(fromTime, NULL);
    815     PS_PTR_CHECK_NULL(toTime, NULL);
     813    PS_ASSERT_PTR_NON_NULL(coords, NULL);
     814    PS_ASSERT_PTR_NON_NULL(fromTime, NULL);
     815    PS_ASSERT_PTR_NON_NULL(toTime, NULL);
    816816
    817817    // Calculate Julian centuries
    … …  
    904904    // XXX: This does not yet use region and nSamples:  need to modify -rdd
    905905
    906     PS_PTR_CHECK_NULL(trans1, NULL);
    907     PS_PTR_CHECK_NULL(trans2, NULL);
     906    PS_ASSERT_PTR_NON_NULL(trans1, NULL);
     907    PS_ASSERT_PTR_NON_NULL(trans2, NULL);
    908908    //TRACE: printf("psPlaneTransformCombine(%d, %d, %d, %d: %d, %d, %d, %d)\n", trans1->x->nX, trans1->x->nY, trans1->y->nX, trans1->y->nY, trans2->x->nX, trans2->x->nY, trans2->y->nX, trans2->y->nY);
    909909    //
    … …  
    10471047                         float sigmaClip)
    10481048{
    1049     PS_PTR_CHECK_NULL(trans, NULL);
    1050     PS_PTR_CHECK_NULL(source, NULL);
    1051     PS_PTR_CHECK_NULL(dest, NULL);
     1049    PS_ASSERT_PTR_NON_NULL(trans, NULL);
     1050    PS_ASSERT_PTR_NON_NULL(source, NULL);
     1051    PS_ASSERT_PTR_NON_NULL(dest, NULL);
    10521052
    10531053    psS32 numCoords = PS_MIN(source->n, dest->n);
    … …  
    11591159        int nSamples)
    11601160{
    1161     PS_PTR_CHECK_NULL(in, NULL);
     1161    PS_ASSERT_PTR_NON_NULL(in, NULL);
    11621162    //
    11631163    // If the transform is linear, then invert it exactly and return.

  • trunk/psLib/src/astronomy/psTime.c

    r3884 r4029  
    1010 *  @author Ross Harman, MHPCC
    1111 *
    12  *  @version $Revision: 1.60 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2005-05-11 22:02:15 $
     12 *  @version $Revision: 1.61 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2005-05-25 20:26:55 $
    1414 *
    1515 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    178178        }
    179179        table = (psLookupTable*)tableMetadataItem->data.V;
    180         PS_PTR_CHECK_NULL(table,0.0);
     180        PS_ASSERT_PTR_NON_NULL(table,0.0);
    181181
    182182        // Attempt to interpolate table
    … …  
    403403
    404404    // Error checks
    405     PS_PTR_CHECK_NULL(time,NULL);
    406     PS_INT_CHECK_RANGE(time->nsec,0,1e9-1,NULL);
     405    PS_ASSERT_PTR_NON_NULL(time,NULL);
     406    PS_ASSERT_INT_WITHIN_RANGE(time->nsec,0,1e9-1,NULL);
    407407
    408408    if (time->type == type) { // time already right type.  That was easy!
    … …  
    448448
    449449    // Error checks
    450     PS_PTR_CHECK_NULL(time,NAN);
    451     PS_INT_CHECK_RANGE(time->nsec,0,1e9-1,NAN);
     450    PS_ASSERT_PTR_NON_NULL(time,NAN);
     451    PS_ASSERT_INT_WITHIN_RANGE(time->nsec,0,1e9-1,NAN);
    452452
    453453    // Calculate TAI or UTC time based on type of time user passes
    … …  
    519519
    520520    // Error checks
    521     PS_PTR_CHECK_NULL(time,NAN);
    522     PS_INT_CHECK_RANGE(time->nsec,0,1e9-1,NAN);
     521    PS_ASSERT_PTR_NON_NULL(time,NAN);
     522    PS_ASSERT_INT_WITHIN_RANGE(time->nsec,0,1e9-1,NAN);
    523523
    524524    if(time->type != PS_TIME_TAI) {
    … …  
    560560        }
    561561        dut = (psVector*)tableMetadataItem->data.V;
    562         PS_PTR_CHECK_NULL(dut,0.0);
     562        PS_ASSERT_PTR_NON_NULL(dut,0.0);
    563563
    564564        t = 2000.0 + (mjd - 51544.03)/365.2422;
    … …  
    592592
    593593    // Error checks
    594     PS_PTR_CHECK_NULL(time,NULL);
    595     PS_INT_CHECK_RANGE(time->nsec,0,1e9-1,NULL);
     594    PS_ASSERT_PTR_NON_NULL(time,NULL);
     595    PS_ASSERT_INT_WITHIN_RANGE(time->nsec,0,1e9-1,NULL);
    596596
    597597    if(time->type != PS_TIME_TAI)
    … …  
    658658        }
    659659        xp = (psVector*)tableMetadataItem->data.V;
    660         PS_PTR_CHECK_NULL(xp,NULL);
     660        PS_ASSERT_PTR_NON_NULL(xp,NULL);
    661661
    662662        // Get yp
    … …  
    667667        }
    668668        yp = (psVector*)tableMetadataItem->data.V;
    669         PS_PTR_CHECK_NULL(yp,NULL);
     669        PS_ASSERT_PTR_NON_NULL(yp,NULL);
    670670
    671671        // Calculate "a" and "c" constants
    … …  
    715715
    716716    // Error checks
    717     PS_PTR_CHECK_NULL(time,NAN);
    718     PS_INT_CHECK_RANGE(time->nsec,0,1e9-1,NAN);
     717    PS_ASSERT_PTR_NON_NULL(time,NAN);
     718    PS_ASSERT_INT_WITHIN_RANGE(time->nsec,0,1e9-1,NAN);
    719719
    720720    // Check time metadata
    … …  
    733733    }
    734734    table = (psLookupTable*)tableMetadataItem->data.V;
    735     PS_PTR_CHECK_NULL(table,0);
     735    PS_ASSERT_PTR_NON_NULL(table,0);
    736736
    737737    // Determine Julian and modified Julian dates used in table lookup and time delta calculation
    … …  
    767767
    768768    // Error checks
    769     PS_PTR_CHECK_NULL(time1,0);
    770     PS_PTR_CHECK_NULL(time2,0);
    771     PS_INT_CHECK_RANGE(time1->nsec,0,1e9-1,0);
    772     PS_INT_CHECK_RANGE(time2->nsec,0,1e9-1,0);
     769    PS_ASSERT_PTR_NON_NULL(time1,0);
     770    PS_ASSERT_PTR_NON_NULL(time2,0);
     771    PS_ASSERT_INT_WITHIN_RANGE(time1->nsec,0,1e9-1,0);
     772    PS_ASSERT_INT_WITHIN_RANGE(time2->nsec,0,1e9-1,0);
    773773    diff = abs((psS64)psTimeGetTAIDelta((psTime*)time1)-(psS64)psTimeGetTAIDelta((psTime*)time2));
    774774
    … …  
    781781
    782782    // Error checks
    783     PS_PTR_CHECK_NULL(time,NAN);
    784     PS_INT_CHECK_RANGE(time->nsec,0,1e9-1,NAN);
     783    PS_ASSERT_PTR_NON_NULL(time,NAN);
     784    PS_ASSERT_INT_WITHIN_RANGE(time->nsec,0,1e9-1,NAN);
    785785
    786786    // Julian date conversion
    … …  
    800800
    801801    // Error checks
    802     PS_PTR_CHECK_NULL(time,NAN);
    803     PS_INT_CHECK_RANGE(time->nsec,0,1e9-1,NAN);
     802    PS_ASSERT_PTR_NON_NULL(time,NAN);
     803    PS_ASSERT_INT_WITHIN_RANGE(time->nsec,0,1e9-1,NAN);
    804804
    805805    // Modified Julian date conversion
    … …  
    823823
    824824    // Error checks
    825     PS_PTR_CHECK_NULL(time,NULL);
    826     PS_INT_CHECK_RANGE(time->nsec,0,1e9-1,NULL);
     825    PS_ASSERT_PTR_NON_NULL(time,NULL);
     826    PS_ASSERT_INT_WITHIN_RANGE(time->nsec,0,1e9-1,NULL);
    827827
    828828    tempString = psAlloc(MAX_TIME_STRING_LENGTH);
    … …  
    856856
    857857    // Error checks
    858     PS_PTR_CHECK_NULL(time,timevalTime);
    859     PS_INT_CHECK_RANGE(time->nsec,0,1e9-1,timevalTime);
     858    PS_ASSERT_PTR_NON_NULL(time,timevalTime);
     859    PS_ASSERT_INT_WITHIN_RANGE(time->nsec,0,1e9-1,timevalTime);
    860860
    861861    timevalTime.tv_sec = time->sec;
    … …  
    879879
    880880    // Error checks
    881     PS_PTR_CHECK_NULL(time,NULL);
    882     PS_INT_CHECK_RANGE(time->nsec,0,1e9-1,NULL);
     881    PS_ASSERT_PTR_NON_NULL(time,NULL);
     882    PS_ASSERT_INT_WITHIN_RANGE(time->nsec,0,1e9-1,NULL);
    883883
    884884    seconds = time->sec%60;
    … …  
    949949
    950950    // Error check
    951     PS_INT_CHECK_RANGE(outTime->nsec,0,1e9-1,outTime);
     951    PS_ASSERT_INT_WITHIN_RANGE(outTime->nsec,0,1e9-1,outTime);
    952952
    953953    return outTime;
    … …  
    975975
    976976    // Error check
    977     PS_INT_CHECK_RANGE(outTime->nsec,0,1e9-1,outTime);
     977    PS_ASSERT_INT_WITHIN_RANGE(outTime->nsec,0,1e9-1,outTime);
    978978
    979979    return outTime;
    … …  
    993993    }
    994994
    995     PS_INT_CHECK_NON_NEGATIVE(tmTime.tm_year, outTime);
    996     PS_INT_CHECK_RANGE(tmTime.tm_mon,1,12,outTime);
    997     PS_INT_CHECK_RANGE(tmTime.tm_mday,1,31,outTime);
    998     PS_INT_CHECK_RANGE(tmTime.tm_hour,0,23,outTime);
    999     PS_INT_CHECK_RANGE(tmTime.tm_min,0,59,outTime);
    1000     PS_INT_CHECK_RANGE(tmTime.tm_sec,0,59,outTime);
    1001     PS_INT_CHECK_RANGE(millisecond,0,999,outTime);
     995    PS_ASSERT_INT_NONNEGATIVE(tmTime.tm_year, outTime);
     996    PS_ASSERT_INT_WITHIN_RANGE(tmTime.tm_mon,1,12,outTime);
     997    PS_ASSERT_INT_WITHIN_RANGE(tmTime.tm_mday,1,31,outTime);
     998    PS_ASSERT_INT_WITHIN_RANGE(tmTime.tm_hour,0,23,outTime);
     999    PS_ASSERT_INT_WITHIN_RANGE(tmTime.tm_min,0,59,outTime);
     1000    PS_ASSERT_INT_WITHIN_RANGE(tmTime.tm_sec,0,59,outTime);
     1001    PS_ASSERT_INT_WITHIN_RANGE(millisecond,0,999,outTime);
    10021002
    10031003    tmTime.tm_year -= 1900;
    … …  
    10181018
    10191019    // Error check
    1020     PS_PTR_CHECK_NULL(time,NULL);
     1020    PS_ASSERT_PTR_NON_NULL(time,NULL);
    10211021
    10221022    // Allocate psTime struct
    … …  
    10281028
    10291029    // Error check
    1030     PS_INT_CHECK_RANGE(outTime->nsec,0,1e9-1,outTime);
     1030    PS_ASSERT_INT_WITHIN_RANGE(outTime->nsec,0,1e9-1,outTime);
    10311031
    10321032    return outTime;
    … …  
    10461046
    10471047    // Error check
    1048     PS_PTR_CHECK_NULL(time,NULL);
     1048    PS_ASSERT_PTR_NON_NULL(time,NULL);
    10491049
    10501050    // Allocate psTime struct
    … …  
    10871087
    10881088    // Error check
    1089     PS_INT_CHECK_RANGE(outTime->nsec,0,1e9-1,outTime);
     1089    PS_ASSERT_INT_WITHIN_RANGE(outTime->nsec,0,1e9-1,outTime);
    10901090
    10911091    return outTime;
    … …  
    11001100
    11011101    // Error checks
    1102     PS_PTR_CHECK_NULL(time,NULL);
    1103     PS_INT_CHECK_RANGE(time->nsec,0,1e9-1,NULL);
     1102    PS_ASSERT_PTR_NON_NULL(time,NULL);
     1103    PS_ASSERT_INT_WITHIN_RANGE(time->nsec,0,1e9-1,NULL);
    11041104
    11051105    // Convert time to TAI if necessary, but without changing input arguments
    … …  
    11201120
    11211121    // Error check
    1122     PS_INT_CHECK_RANGE(outTime->nsec,0,1e9-1,outTime);
     1122    PS_ASSERT_INT_WITHIN_RANGE(outTime->nsec,0,1e9-1,outTime);
    11231123
    11241124    // Convert result to same time type as input
    … …  
    11421142
    11431143    // Error checks
    1144     PS_PTR_CHECK_NULL(time1,0.0);
    1145     PS_INT_CHECK_RANGE(time1->nsec,0,1e9-1,0.0);
    1146     PS_PTR_CHECK_NULL(time2,0.0);
    1147     PS_INT_CHECK_RANGE(time2->nsec,0,1e9-1,0.0);
     1144    PS_ASSERT_PTR_NON_NULL(time1,0.0);
     1145    PS_ASSERT_INT_WITHIN_RANGE(time1->nsec,0,1e9-1,0.0);
     1146    PS_ASSERT_PTR_NON_NULL(time2,0.0);
     1147    PS_ASSERT_INT_WITHIN_RANGE(time2->nsec,0,1e9-1,0.0);
    11481148
    11491149    // Convert time to TAI if necessary, but without changing input arguments

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

    r3945 r4029  
    1212*  @author Ross Harman, MHPCC
    1313*
    14 *  @version $Revision: 1.62 $ $Name: not supported by cvs2svn $
    15 *  @date $Date: 2005-05-16 19:43:53 $
     14*  @version $Revision: 1.63 $ $Name: not supported by cvs2svn $
     15*  @date $Date: 2005-05-25 20:26:55 $
    1616*
    1717*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    179179
    180180
    181     PS_PTR_CHECK_NULL(name,NULL);
     181    PS_ASSERT_PTR_NON_NULL(name,NULL);
    182182
    183183    // Allocate metadata item
    … …  
    275275    psMetadataItem *existingEntry = NULL;
    276276
    277     PS_PTR_CHECK_NULL(md,NULL);
    278     PS_PTR_CHECK_NULL(md->table,NULL);
    279     PS_PTR_CHECK_NULL(md->list,NULL);
    280     PS_PTR_CHECK_NULL(metadataItem,NULL);
    281     PS_PTR_CHECK_NULL(metadataItem->name,NULL);
     277    PS_ASSERT_PTR_NON_NULL(md,NULL);
     278    PS_ASSERT_PTR_NON_NULL(md->table,NULL);
     279    PS_ASSERT_PTR_NON_NULL(md->list,NULL);
     280    PS_ASSERT_PTR_NON_NULL(metadataItem,NULL);
     281    PS_ASSERT_PTR_NON_NULL(metadataItem->name,NULL);
    282282
    283283    mdTable = md->table;
    … …  
    410410psBool psMetadataRemove(psMetadata *md, psS32 where, const char *key)
    411411{
    412     PS_PTR_CHECK_NULL(md,NULL);
    413 
    414     PS_PTR_CHECK_NULL(md->list,NULL);
     412    PS_ASSERT_PTR_NON_NULL(md,NULL);
     413
     414    PS_ASSERT_PTR_NON_NULL(md->list,NULL);
    415415    psList* mdList = md->list;
    416416
    417     PS_PTR_CHECK_NULL(md->table,NULL);
     417    PS_ASSERT_PTR_NON_NULL(md->table,NULL);
    418418    psHash* mdTable = md->table;
    419419
    … …  
    482482
    483483
    484     PS_PTR_CHECK_NULL(md,NULL);
    485     PS_PTR_CHECK_NULL(md->table,NULL);
    486     PS_PTR_CHECK_NULL(key,NULL);
     484    PS_ASSERT_PTR_NON_NULL(md,NULL);
     485    PS_ASSERT_PTR_NON_NULL(md->table,NULL);
     486    PS_ASSERT_PTR_NON_NULL(key,NULL);
    487487
    488488    mdTable = md->table;
    … …  
    583583    psMetadataItem* entry = NULL;
    584584
    585     PS_PTR_CHECK_NULL(md,NULL);
    586     PS_PTR_CHECK_NULL(md->list,NULL);
     585    PS_ASSERT_PTR_NON_NULL(md,NULL);
     586    PS_ASSERT_PTR_NON_NULL(md->list,NULL);
    587587
    588588    entry = (psMetadataItem*) psListGet(md->list, where);
    … …  
    599599        const char* regex)
    600600{
    601     PS_PTR_CHECK_NULL(md,NULL);
    602     PS_PTR_CHECK_NULL(md->list,NULL);
     601    PS_ASSERT_PTR_NON_NULL(md,NULL);
     602    PS_ASSERT_PTR_NON_NULL(md->list,NULL);
    603603
    604604    psMetadataIterator* newIter = psAlloc(sizeof(psMetadataIterator));
    … …  
    637637    psMetadataItem* cursor;
    638638
    639     PS_PTR_CHECK_NULL(iterator,NULL);
     639    PS_ASSERT_PTR_NON_NULL(iterator,NULL);
    640640
    641641    psListIterator* iter = iterator->iter;
    642     PS_PTR_CHECK_NULL(iterator->iter,NULL);
     642    PS_ASSERT_PTR_NON_NULL(iterator->iter,NULL);
    643643
    644644    regex_t* preg = iterator->preg;
    … …  
    686686    psMetadataItem* oldValue;
    687687
    688     PS_PTR_CHECK_NULL(iterator,NULL);
     688    PS_ASSERT_PTR_NON_NULL(iterator,NULL);
    689689
    690690    psListIterator* iter = iterator->iter;
    691     PS_PTR_CHECK_NULL(iterator->iter,NULL);
     691    PS_ASSERT_PTR_NON_NULL(iterator->iter,NULL);
    692692
    693693    regex_t* preg = iterator->preg;
    … …  
    714714    psMetadataItem* oldValue;
    715715
    716     PS_PTR_CHECK_NULL(iterator,NULL);
     716    PS_ASSERT_PTR_NON_NULL(iterator,NULL);
    717717
    718718    psListIterator* iter = iterator->iter;
    719     PS_PTR_CHECK_NULL(iterator->iter,NULL);
     719    PS_ASSERT_PTR_NON_NULL(iterator->iter,NULL);
    720720
    721721    regex_t* preg = iterator->preg;

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

    r3980 r4029  
    1010*  @author Eric Van Alst, MHPCC
    1111*
    12 *  @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
    13 *  @date $Date: 2005-05-19 20:48:28 $
     12*  @version $Revision: 1.28 $ $Name: not supported by cvs2svn $
     13*  @date $Date: 2005-05-25 20:26:55 $
    1414*
    1515*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    368368    psBool success = true;
    369369
    370     PS_PTR_CHECK_NULL(fd, success);
    371     PS_PTR_CHECK_NULL(format, success);
    372     PS_PTR_CHECK_NULL(metadataItem, success);
     370    PS_ASSERT_PTR_NON_NULL(fd, success);
     371    PS_ASSERT_PTR_NON_NULL(format, success);
     372    PS_ASSERT_PTR_NON_NULL(metadataItem, success);
    373373
    374374    type = metadataItem->type;
    … …  
    469469    fitsfile *fd = NULL;
    470470
    471     PS_PTR_CHECK_NULL(fileName,NULL);
     471    PS_ASSERT_PTR_NON_NULL(fileName,NULL);
    472472
    473473    fits_open_file(&fd, fileName, READONLY, &status);
    … …  
    10861086
    10871087    // Check for NULL file name
    1088     PS_PTR_CHECK_NULL(fileName,NULL);
     1088    PS_ASSERT_PTR_NON_NULL(fileName,NULL);
    10891089
    10901090    // Check for NULL nFail
    1091     PS_PTR_CHECK_NULL(nFail,NULL);
     1091    PS_ASSERT_PTR_NON_NULL(nFail,NULL);
    10921092
    10931093    // Attempt to open specified file
    … …  
    11561156    // Get and check initial data pointers
    11571157    ctxt = (xmlParserCtxtPtr)ctx;
    1158     PS_PTR_CHECK_NULL_GENERAL(ctxt, return);
     1158    PS_ASSERT_GENERAL_PTR_NON_NULL(ctxt, return);
    11591159    md = (psMetadata*)ctxt->sax->_private;
    1160     PS_PTR_CHECK_NULL_GENERAL(md, return);
     1160    PS_ASSERT_GENERAL_PTR_NON_NULL(md, return);
    11611161    input = (xmlParserInputPtr)ctxt->input;
    1162     PS_PTR_CHECK_NULL_GENERAL(input, return);
     1162    PS_ASSERT_GENERAL_PTR_NON_NULL(input, return);
    11631163
    11641164    // Copy XML strings to psStrings to avoid libxml2/psLib memory corruption problems
    … …  
    11731173        psHashAdd(htAtts, "tagName", psTagName);
    11741174    } else {
    1175         PS_PTR_CHECK_NULL_GENERAL(psTagName, return);
     1175        PS_ASSERT_GENERAL_PTR_NON_NULL(psTagName, return);
    11761176        psFree(htAtts);
    11771177        psFree(psTagName);
    … …  
    11931193                psFree(psAttValue);
    11941194            } else {
    1195                 PS_PTR_CHECK_NULL_GENERAL(psAttValue, return);
     1195                PS_ASSERT_GENERAL_PTR_NON_NULL(psAttValue, return);
    11961196                psFree(htAtts);
    11971197                psFree(psTagName);
    … …  
    12371237    // Get and check initial data pointers
    12381238    ctxt = (xmlParserCtxtPtr)ctx;
    1239     PS_PTR_CHECK_NULL_GENERAL(ctxt, return);
     1239    PS_ASSERT_GENERAL_PTR_NON_NULL(ctxt, return);
    12401240    md = (psMetadata*)ctxt->sax->_private;
    1241     PS_PTR_CHECK_NULL_GENERAL(md, return);
     1241    PS_ASSERT_GENERAL_PTR_NON_NULL(md, return);
    12421242    input = (xmlParserInputPtr)ctxt->input;
    1243     PS_PTR_CHECK_NULL_GENERAL(input, return);
     1243    PS_ASSERT_GENERAL_PTR_NON_NULL(input, return);
    12441244    metadataItem = psMetadataLookup(md, "htAtts");
    1245     PS_PTR_CHECK_NULL_GENERAL(metadataItem, return);
    1246     PS_PTR_CHECK_NULL_GENERAL(metadataItem->data.list, return);
     1245    PS_ASSERT_GENERAL_PTR_NON_NULL(metadataItem, return);
     1246    PS_ASSERT_GENERAL_PTR_NON_NULL(metadataItem->data.list, return);
    12471247    metadataItem = (psMetadataItem*)psListGet(metadataItem->data.list,PS_LIST_TAIL);
    12481248    htAtts = (psHash*)metadataItem->data.list;
    1249     PS_PTR_CHECK_NULL_GENERAL(htAtts, return);
     1249    PS_ASSERT_GENERAL_PTR_NON_NULL(htAtts, return);
    12501250    fileName = (char*)input->filename;
    1251     PS_PTR_CHECK_NULL_GENERAL(fileName, return);
     1251    PS_ASSERT_GENERAL_PTR_NON_NULL(fileName, return);
    12521252    lineNumber = input->line;
    12531253
    … …  
    13861386    // Get and check initial data pointers
    13871387    ctxt = (xmlParserCtxtPtr)ctx;
    1388     PS_PTR_CHECK_NULL_GENERAL(ctxt, return);
     1388    PS_ASSERT_GENERAL_PTR_NON_NULL(ctxt, return);
    13891389    md = (psMetadata*)ctxt->sax->_private;
    1390     PS_PTR_CHECK_NULL_GENERAL(md, return);
     1390    PS_ASSERT_GENERAL_PTR_NON_NULL(md, return);
    13911391    input = (xmlParserInputPtr)ctxt->input;
    1392     PS_PTR_CHECK_NULL_GENERAL(input, return);
     1392    PS_ASSERT_GENERAL_PTR_NON_NULL(input, return);
    13931393    tables = psMetadataLookup(md, "htAtts");
    1394     PS_PTR_CHECK_NULL_GENERAL(tables, return);
    1395     PS_PTR_CHECK_NULL_GENERAL(tables->data.list, return);
     1394    PS_ASSERT_GENERAL_PTR_NON_NULL(tables, return);
     1395    PS_ASSERT_GENERAL_PTR_NON_NULL(tables->data.list, return);
    13961396    table = (psMetadataItem*)psListGet(tables->data.list,PS_LIST_TAIL);
    13971397    htAtts = (psHash*)table->data.list;
    1398     PS_PTR_CHECK_NULL_GENERAL(htAtts, return);
     1398    PS_ASSERT_GENERAL_PTR_NON_NULL(htAtts, return);
    13991399    fileName = (char*)input->filename;
    1400     PS_PTR_CHECK_NULL_GENERAL(fileName, return);
     1400    PS_ASSERT_GENERAL_PTR_NON_NULL(fileName, return);
    14011401    lineNumber = input->line;
    14021402
    … …  
    14271427
    14281428    strValue = psHashLookup(htAtts, "value");
    1429     PS_PTR_CHECK_NULL_GENERAL(strValue, return);
     1429    PS_ASSERT_GENERAL_PTR_NON_NULL(strValue, return);
    14301430
    14311431
    … …  
    14821482    // Get and check initial data pointers
    14831483    ctxt = (xmlParserCtxtPtr)ctx;
    1484     PS_PTR_CHECK_NULL_GENERAL(ctxt, return);
     1484    PS_ASSERT_GENERAL_PTR_NON_NULL(ctxt, return);
    14851485    md = (psMetadata*)ctxt->sax->_private;
    1486     PS_PTR_CHECK_NULL_GENERAL(md, return);
     1486    PS_ASSERT_GENERAL_PTR_NON_NULL(md, return);
    14871487    input = (xmlParserInputPtr)ctxt->input;
    1488     PS_PTR_CHECK_NULL_GENERAL(input, return);
     1488    PS_ASSERT_GENERAL_PTR_NON_NULL(input, return);
    14891489    tables = psMetadataLookup(md, "htAtts");
    1490     PS_PTR_CHECK_NULL_GENERAL(tables, return);
    1491     PS_PTR_CHECK_NULL_GENERAL(tables->data.list, return);
     1490    PS_ASSERT_GENERAL_PTR_NON_NULL(tables, return);
     1491    PS_ASSERT_GENERAL_PTR_NON_NULL(tables->data.list, return);
    14921492    table = (psMetadataItem*)psListGet(tables->data.list,PS_LIST_TAIL);
    14931493    htAtts = (psHash*)table->data.list;
    1494     PS_PTR_CHECK_NULL_GENERAL(htAtts, return);
     1494    PS_ASSERT_GENERAL_PTR_NON_NULL(htAtts, return);
    14951495
    14961496    // Copy XML strings to psStrings to avoid libxml2/psLib memory corruption problems
    … …  
    14991499    // Compare start and end tag names
    15001500    psStartTagName = psHashLookup(htAtts, "tagName");
    1501     PS_PTR_CHECK_NULL_GENERAL(psStartTagName, return);
     1501    PS_ASSERT_GENERAL_PTR_NON_NULL(psStartTagName, return);
    15021502    if(strcmp(psEndTagName, psStartTagName)) {
    15031503        psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_TAG_MISMATCH, psStartTagName, psEndTagName);
    … …  
    15271527
    15281528    // Error checks
    1529     PS_PTR_CHECK_NULL(fileName, NULL);
     1529    PS_ASSERT_PTR_NON_NULL(fileName, NULL);
    15301530
    15311531    // Allocate metadata if necessary

  • trunk/psLib/src/dataManip/psBinaryOp.c

    r3182 r4029  
    3030 *  @author Robert DeSonia, MHPCC
    3131 *
    32  *  @version $Revision: 1.1 $ $Name: not supported by cvs2svn $
    33  *  @date $Date: 2005-02-10 02:36:41 $
     32 *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
     33 *  @date $Date: 2005-05-25 20:26:55 $
    3434 *
    3535 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    439439                            }
    440440
    441     PS_PTR_CHECK_NULL_GENERAL(input1, psBinaryOp_EXIT);
    442     PS_PTR_CHECK_NULL_GENERAL(input2, psBinaryOp_EXIT);
    443     PS_PTR_CHECK_NULL_GENERAL(op, psBinaryOp_EXIT);
    444 
    445     PS_PTR_CHECK_TYPE_EQUAL_GENERAL(input1,input2, psBinaryOp_EXIT);
    446 
    447     PS_PTR_CHECK_DIMEN_GENERAL_NOT(input1, PS_DIMEN_OTHER, psBinaryOp_EXIT);
    448     PS_PTR_CHECK_DIMEN_GENERAL_NOT(input2, PS_DIMEN_OTHER, psBinaryOp_EXIT);
     441    PS_ASSERT_GENERAL_PTR_NON_NULL(input1, psBinaryOp_EXIT);
     442    PS_ASSERT_GENERAL_PTR_NON_NULL(input2, psBinaryOp_EXIT);
     443    PS_ASSERT_GENERAL_PTR_NON_NULL(op, psBinaryOp_EXIT);
     444
     445    PS_ASSERT_PTRS_TYPE_EQUAL_GENERAL(input1,input2, psBinaryOp_EXIT);
     446
     447    PS_ASSERT_PTR_DIMEN_GENERAL_NOT(input1, PS_DIMEN_OTHER, psBinaryOp_EXIT);
     448    PS_ASSERT_PTR_DIMEN_GENERAL_NOT(input2, PS_DIMEN_OTHER, psBinaryOp_EXIT);
    449449
    450450    psType* psType1 = (psType*)in1;

  • trunk/psLib/src/dataManip/psConstants.h

    r4028 r4029  
    66 *  @author GLG, MHPCC
    77 *
    8  *  @version $Revision: 1.68 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2005-05-25 19:25:29 $
     8 *  @version $Revision: 1.69 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2005-05-25 20:26:55 $
    1010 *
    1111 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    5959*****************************************************************************/
    6060
    61 #define PS_INT_CHECK_EQUALS(NAME1, NAME2, RVAL) \
     61#define PS_ASSERT_INT_UNEQUAL(NAME1, NAME2, RVAL) \
    6262if (NAME1 == NAME2) { \
    6363    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    … …  
    6767}
    6868
    69 #define PS_INT_CHECK_NON_EQUALS(NAME1, NAME2, RVAL) \
     69#define PS_ASSERT_INT_EQUAL(NAME1, NAME2, RVAL) \
    7070if (NAME1 != NAME2) { \
    7171    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    … …  
    7676
    7777// Return an error if the arg is less than zero.
    78 #define PS_INT_CHECK_NEGATIVE(NAME, RVAL) \
     78#define PS_ASSERT_INT_NONNEGATIVE(NAME, RVAL) \
    7979if (NAME < 0) { \
    8080    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    … …  
    8686// XXX: This naming scheme is opposite most other macros.  This should be
    8787// corrected as soon as a fresh checkin/out can be performed.
    88 #define PS_INT_CHECK_NON_NEGATIVE(NAME, RVAL) \
     88#define PS_ASSERT_INT_NONNEGATIVE(NAME, RVAL) \
    8989if (NAME < 0) { \
    9090    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    … …  
    9696// XXX: This naming scheme is opposite most other macros.  This should be
    9797// corrected as soon as a fresh checkin/out can be performed.
    98 #define PS_INT_CHECK_POSITIVE(NAME, RVAL) \
     98#define PS_ASSERT_INT_POSITIVE(NAME, RVAL) \
    9999if (NAME < 1) { \
    100100    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    … …  
    104104
    105105// Return an error if the arg is not equal to zero.
    106 #define PS_INT_CHECK_NON_ZERO(NAME, RVAL) \
     106#define PS_ASSERT_INT_ZERO(NAME, RVAL) \
    107107if (NAME != 0) { \
    108108    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    … …  
    112112
    113113// Return an error if the arg is equal to zero.
    114 #define PS_INT_CHECK_ZERO(NAME, RVAL) \
     114#define PS_ASSERT_INT_NONZERO(NAME, RVAL) \
    115115if (NAME == 0) { \
    116116    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    … …  
    120120
    121121// Return an error if the arg is lies outside the supplied range.
    122 #define PS_INT_CHECK_RANGE(NAME, LOWER, UPPER, RVAL) \
     122#define PS_ASSERT_INT_WITHIN_RANGE(NAME, LOWER, UPPER, RVAL) \
    123123if ((int)NAME < LOWER || (int)NAME > UPPER) { \
    124124    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    … …  
    148148// Generate an error if the two floats are equal.
    149149// XXX: Inconsistent naming.
    150 #define PS_FLOAT_CHECK_NON_EQUAL(NAME1, NAME2, RVAL) \
     150#define PS_ASSERT_FLOAT_NON_EQUAL(NAME1, NAME2, RVAL) \
    151151if (fabs(NAME2 - NAME1) < FLT_EPSILON) { \
    152152    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    … …  
    157157
    158158// Return an error if the arg is lies outside the supplied range.
    159 #define PS_FLOAT_CHECK_RANGE(NAME, LOWER, UPPER, RVAL) \
     159#define PS_ASSERT_FLOAT_WITHIN_RANGE(NAME, LOWER, UPPER, RVAL) \
    160160if ((NAME) < (LOWER) || (NAME) > (UPPER)) { \
    161161    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    … …  
    169169the wrong type.
    170170*****************************************************************************/
    171 #define PS_PTR_CHECK_NULL(NAME, RVAL) PS_PTR_CHECK_NULL_GENERAL(NAME, return RVAL)
    172 #define PS_PTR_CHECK_NULL_GENERAL(NAME, CLEANUP) \
     171#define PS_ASSERT_PTR_NON_NULL(NAME, RVAL) PS_ASSERT_GENERAL_PTR_NON_NULL(NAME, return RVAL)
     172#define PS_ASSERT_GENERAL_PTR_NON_NULL(NAME, CLEANUP) \
    173173if (NAME == NULL) { \
    174174    psError(PS_ERR_BAD_PARAMETER_NULL, true, \
    … …  
    178178}
    179179
    180 #define PS_PTR_CHECK_TYPE(NAME, TYPE, RVAL) \
     180#define PS_ASSERT_PTR_TYPE(NAME, TYPE, RVAL) \
    181181if (NAME->type.type != TYPE) { \
    182182    psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
    … …  
    186186}
    187187
    188 #define PS_PTR_CHECK_DIMEN(NAME, DIMEN, RVAL) PS_PTR_CHECK_DIMEN_GENERAL(NAME, DIMEN, return RVAL)
    189 #define PS_PTR_CHECK_DIMEN_GENERAL(NAME, DIMEN, CLEANUP) \
     188#define PS_ASSERT_PTR_DIMEN(NAME, DIMEN, RVAL) PS_ASSERT_GENERAL_PTR_DIMEN(NAME, DIMEN, return RVAL)
     189#define PS_ASSERT_GENERAL_PTR_DIMEN(NAME, DIMEN, CLEANUP) \
    190190if (NAME->type.dimen != DIMEN) { \
    191191    psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
    … …  
    195195}
    196196
    197 #define PS_PTR_CHECK_DIMEN_GENERAL_NOT(NAME, DIMEN, CLEANUP) \
     197#define PS_ASSERT_PTR_DIMEN_GENERAL_NOT(NAME, DIMEN, CLEANUP) \
    198198if (NAME->type.dimen == DIMEN) { \
    199199    psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
    … …  
    204204
    205205
    206 #define PS_PTR_CHECK_SIZE_EQUAL(PTR1, PTR2, RVAL) \
     206#define PS_ASSERT_PTRS_SIZE_EQUAL(PTR1, PTR2, RVAL) \
    207207if (PTR1->n != PTR2->n) { \
    208208    psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
    … …  
    212212}
    213213
    214 #define PS_PTR_CHECK_TYPE_EQUAL(PTR1, PTR2, RVAL) PS_PTR_CHECK_TYPE_EQUAL_GENERAL(PTR1, PTR2, return RVAL)
    215 
    216 #define PS_PTR_CHECK_TYPE_EQUAL_GENERAL(PTR1, PTR2, CLEANUP) \
     214#define PS_ASSERT_PTR_TYPE_EQUAL(PTR1, PTR2, RVAL) PS_ASSERT_PTRS_TYPE_EQUAL_GENERAL(PTR1, PTR2, return RVAL)
     215#define PS_ASSERT_PTRS_TYPE_EQUAL_GENERAL(PTR1, PTR2, CLEANUP) \
    217216if (PTR1->type.type != PTR2->type.type) { \
    218217    psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
    … …  
    226225    PS_VECTOR macros:
    227226 *****************************************************************************/
    228 #define PS_VECTOR_CHECK_NULL(NAME, RVAL) PS_VECTOR_CHECK_NULL_GENERAL(NAME, return RVAL)
    229 #define PS_VECTOR_CHECK_NULL_GENERAL(NAME, CLEANUP) \
     227#define PS_ASSERT_VECTOR_NON_NULL(NAME, RVAL) PS_ASSERT_GENERAL_VECTOR_NON_NULL(NAME, return RVAL)
     228#define PS_ASSERT_GENERAL_VECTOR_NON_NULL(NAME, CLEANUP) \
    230229if (NAME == NULL || NAME->data.U8 == NULL) { \
    231230    psError(PS_ERR_BAD_PARAMETER_NULL, true, \
    … …  
    235234} \
    236235
    237 #define PS_VECTOR_CHECK_EMPTY(NAME, RVAL) PS_VECTOR_CHECK_EMPTY_GENERAL(NAME, return RVAL)
    238 #define PS_VECTOR_CHECK_EMPTY_GENERAL(NAME, CLEANUP) \
     236#define PS_ASSERT_VECTOR_NON_EMPTY(NAME, RVAL) PS_ASSERT_GENERAL_VECTOR_NON_EMPTY(NAME, return RVAL)
     237#define PS_ASSERT_GENERAL_VECTOR_NON_EMPTY(NAME, CLEANUP) \
    239238if (NAME->n < 1) { \
    240239    psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
    … …  
    244243} \
    245244
    246 #define PS_VECTOR_CHECK_TYPE_F32_OR_F64(NAME, RVAL) \
     245#define PS_ASSERT_VECTOR_TYPE_F32_OR_F64(NAME, RVAL) \
    247246if ((NAME->type.type != PS_TYPE_F32) && (NAME->type.type != PS_TYPE_F64)) { \
    248247    psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
    … …  
    252251} \
    253252
    254 #define PS_VECTOR_CHECK_TYPE_S16_S32_F32(NAME, RVAL) \
     253#define PS_ASSERT_VECTOR_TYPE_S16_S32_F32(NAME, RVAL) \
    255254if ((NAME->type.type != PS_TYPE_S16) && (NAME->type.type != PS_TYPE_S32) && (NAME->type.type != PS_TYPE_F32)) { \
    256255    psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
    … …  
    260259} \
    261260
    262 #define PS_VECTOR_CHECK_TYPE(NAME, TYPE, RVAL) \
     261#define PS_ASSERT_VECTOR_TYPE(NAME, TYPE, RVAL) \
    263262if (NAME->type.type != TYPE) { \
    264263    psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
    … …  
    268267}
    269268
    270 #define PS_VECTOR_CHECK_SIZE_EQUAL(VEC1, VEC2, RVAL) \
     269#define PS_ASSERT_VECTORS_SIZE_EQUAL(VEC1, VEC2, RVAL) \
    271270if (VEC1->n != VEC2->n) { \
    272271    psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
    … …  
    276275}
    277276
    278 #define PS_VECTOR_CHECK_TYPE_EQUAL(VEC1, VEC2, RVAL) \
     277#define PS_ASSERT_VECTOR_TYPE_EQUAL(VEC1, VEC2, RVAL) \
    279278if (VEC1->type.type != VEC2->type.type) { \
    280279    psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
    … …  
    428427    PS_POLY macros:
    429428*****************************************************************************/
    430 #define PS_POLY_CHECK_NULL(NAME, RVAL) \
     429#define PS_ASSERT_POLY_NON_NULL(NAME, RVAL) \
    431430if (NAME == NULL || NAME->coeff == NULL) { \
    432431    psError(PS_ERR_BAD_PARAMETER_NULL, true, \
    … …  
    436435} \
    437436
    438 #define PS_POLY_CHECK_TYPE(NAME, TYPE, RVAL) \
     437#define PS_ASSERT_POLY_TYPE(NAME, TYPE, RVAL) \
    439438if (NAME->type != TYPE) { \
    440439    psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
    … …  
    508507    PS_IMAGE macros:
    509508*****************************************************************************/
    510 #define PS_IMAGE_CHECK_NULL(NAME, RVAL) PS_IMAGE_CHECK_NULL_GENERAL(NAME, return RVAL)
    511 #define PS_IMAGE_CHECK_NULL_GENERAL(NAME, CLEANUP) \
     509#define PS_ASSERT_IMAGE_NON_NULL(NAME, RVAL) PS_ASSERT_GENERAL_IMAGE_NON_NULL(NAME, return RVAL)
     510#define PS_ASSERT_GENERAL_IMAGE_NON_NULL(NAME, CLEANUP) \
    512511if (NAME == NULL || NAME->data.V == NULL) { \
    513512    psError(PS_ERR_BAD_PARAMETER_NULL, true, \
    … …  
    517516}
    518517
    519 #define PS_IMAGE_CHECK_EMPTY(NAME, RVAL) PS_IMAGE_CHECK_EMPTY_GENERAL(NAME, return RVAL)
    520 #define PS_IMAGE_CHECK_EMPTY_GENERAL(NAME, CLEANUP) \
     518#define PS_ASSERT_IMAGE_NON_EMPTY(NAME, RVAL) PS_ASSERT_GENERAL_IMAGE_NON_EMPTY(NAME, return RVAL)
     519#define PS_ASSERT_GENERAL_IMAGE_NON_EMPTY(NAME, CLEANUP) \
    521520if (NAME->numCols < 1 || NAME->numRows < 1) { \
    522521    psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
    … …  
    526525}
    527526
    528 #define PS_IMAGE_CHECK_TYPE(NAME, TYPE, RVAL) \
     527#define PS_ASSERT_IMAGE_TYPE(NAME, TYPE, RVAL) \
    529528if (NAME->type.type != TYPE) { \
    530529    psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
    … …  
    534533}
    535534
    536 #define PS_IMAGE_CHECK_SIZE_EQUAL(NAME1, NAME2, RVAL) \
     535#define PS_ASSERT_IMAGES_SIZE_EQUAL(NAME1, NAME2, RVAL) \
    537536if ((NAME1->numCols != NAME2->numCols) || \
    538537        (NAME1->numRows != NAME2->numRows)) { \
    … …  
    543542}
    544543
    545 #define PS_IMAGE_CHECK_SIZE(NAME1, NUM_COLS, NUM_ROWS, RVAL) \
     544#define PS_ASSERT_IMAGE_SIZE(NAME1, NUM_COLS, NUM_ROWS, RVAL) \
    546545if ((NAME1->numCols != NUM_COLS) || \
    547546        (NAME1->numRows != NUM_ROWS)) { \
    … …  
    634633    PS_READOUT macros:
    635634*****************************************************************************/
    636 #define PS_READOUT_CHECK_NULL(NAME, RVAL) \
     635#define PS_ASSERT_READOUT_NON_NULL(NAME, RVAL) \
    637636if (NAME == NULL || NAME->image == NULL) { \
    638637    psError(PS_ERR_BAD_PARAMETER_NULL, true, \
    … …  
    642641}
    643642
    644 #define PS_READOUT_CHECK_EMPTY(NAME, RVAL) \
     643#define PS_ASSERT_READOUT_NON_EMPTY(NAME, RVAL) \
    645644if (NAME->image->numCols < 1 || NAME->image->numRows < 1) { \
    646645    psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
    … …  
    649648}
    650649
    651 #define PS_READOUT_CHECK_TYPE(NAME, TYPE, RVAL) \
     650#define PS_ASSERT_READOUT_TYPE(NAME, TYPE, RVAL) \
    652651if (NAME->image->type.type != TYPE) { \
    653652    psError(PS_ERR_BAD_PARAMETER_TYPE, true, \

  • trunk/psLib/src/dataManip/psFunctions.c

    r3990 r4029  
    77 *  polynomials.  It also contains a Gaussian functions.
    88 *
    9  *  @version $Revision: 1.103 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2005-05-19 23:57:37 $
     9 *  @version $Revision: 1.104 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2005-05-25 20:26:55 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    246246static psPolynomial1D **createChebyshevPolys(psS32 maxChebyPoly)
    247247{
    248     PS_INT_CHECK_NON_NEGATIVE(maxChebyPoly, NULL);
     248    PS_ASSERT_INT_NONNEGATIVE(maxChebyPoly, NULL);
    249249
    250250    psPolynomial1D **chebPolys = NULL;
    … …  
    314314static psF32 chebPolynomial1DEval(psF32 x, const psPolynomial1D* myPoly)
    315315{
    316     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
     316    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
    317317    // XXX: Create a macro for this in psConstants.h
    318318    if (myPoly->n < 1) {
    … …  
    398398                                 const psPolynomial2D* myPoly)
    399399{
    400     PS_POLY_CHECK_NULL(myPoly, NAN);
     400    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    401401
    402402    psS32 loop_x = 0;
    … …  
    422422static psF32 chebPolynomial2DEval(psF32 x, psF32 y, const psPolynomial2D* myPoly)
    423423{
    424     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
    425     PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
    426     PS_POLY_CHECK_NULL(myPoly, NAN);
     424    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     425    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
     426    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    427427
    428428    psS32 loop_x = 0;
    … …  
    487487static psF32 chebPolynomial3DEval(psF32 x, psF32 y, psF32 z, const psPolynomial3D* myPoly)
    488488{
    489     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
    490     PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
    491     PS_FLOAT_CHECK_RANGE(z, -1.0, 1.0, 0.0);
     489    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     490    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
     491    PS_ASSERT_FLOAT_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
    492492    psS32 loop_x = 0;
    493493    psS32 loop_y = 0;
    … …  
    565565static psF32 chebPolynomial4DEval(psF32 w, psF32 x, psF32 y, psF32 z, const psPolynomial4D* myPoly)
    566566{
    567     PS_FLOAT_CHECK_RANGE(w, -1.0, 1.0, 0.0);
    568     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
    569     PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
    570     PS_FLOAT_CHECK_RANGE(z, -1.0, 1.0, 0.0);
     567    PS_ASSERT_FLOAT_WITHIN_RANGE(w, -1.0, 1.0, 0.0);
     568    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     569    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
     570    PS_ASSERT_FLOAT_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
    571571    psS32 loop_w = 0;
    572572    psS32 loop_x = 0;
    … …  
    638638static psF64 dChebPolynomial1DEval(psF64 x, const psDPolynomial1D* myPoly)
    639639{
    640     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
     640    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
    641641    psVector *d;
    642642    psS32 n;
    … …  
    697697static psF64 dChebPolynomial2DEval(psF64 x, psF64 y, const psDPolynomial2D* myPoly)
    698698{
    699     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
    700     PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
     699    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     700    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
    701701    psS32 loop_x = 0;
    702702    psS32 loop_y = 0;
    … …  
    761761static psF64 dChebPolynomial3DEval(psF64 x, psF64 y, psF64 z, const psDPolynomial3D* myPoly)
    762762{
    763     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
    764     PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
    765     PS_FLOAT_CHECK_RANGE(z, -1.0, 1.0, 0.0);
     763    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     764    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
     765    PS_ASSERT_FLOAT_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
    766766    psS32 loop_x = 0;
    767767    psS32 loop_y = 0;
    … …  
    839839static psF64 dChebPolynomial4DEval(psF64 w, psF64 x, psF64 y, psF64 z, const psDPolynomial4D* myPoly)
    840840{
    841     PS_FLOAT_CHECK_RANGE(w, -1.0, 1.0, 0.0);
    842     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
    843     PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
    844     PS_FLOAT_CHECK_RANGE(z, -1.0, 1.0, 0.0);
     841    PS_ASSERT_FLOAT_WITHIN_RANGE(w, -1.0, 1.0, 0.0);
     842    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     843    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
     844    PS_ASSERT_FLOAT_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
    845845    psS32 loop_w = 0;
    846846    psS32 loop_x = 0;
    … …  
    973973                              psF32 x)
    974974{
    975     PS_PTR_CHECK_NULL(domain, NAN)
    976     PS_PTR_CHECK_NULL(range, NAN)
     975    PS_ASSERT_PTR_NON_NULL(domain, NAN)
     976    PS_ASSERT_PTR_NON_NULL(range, NAN)
    977977    // XXX: Check valid values for n, order, and x?
    978978
    … …  
    10441044psVector* p_psGaussianDev(psF32 mean, psF32 sigma, psS32 Npts)
    10451045{
    1046     PS_INT_CHECK_NON_NEGATIVE(Npts, NULL);
     1046    PS_ASSERT_INT_NONNEGATIVE(Npts, NULL);
    10471047
    10481048    psVector* gauss = NULL;
    … …  
    10721072                                    psPolynomialType type)
    10731073{
    1074     PS_INT_CHECK_POSITIVE(n, NULL);
     1074    PS_ASSERT_INT_POSITIVE(n, NULL);
    10751075
    10761076    psS32 i = 0;
    … …  
    10971097                                    psPolynomialType type)
    10981098{
    1099     PS_INT_CHECK_POSITIVE(nX, NULL);
    1100     PS_INT_CHECK_POSITIVE(nY, NULL);
     1099    PS_ASSERT_INT_POSITIVE(nX, NULL);
     1100    PS_ASSERT_INT_POSITIVE(nY, NULL);
    11011101
    11021102    psS32 x = 0;
    … …  
    11331133                                    psPolynomialType type)
    11341134{
    1135     PS_INT_CHECK_POSITIVE(nX, NULL);
    1136     PS_INT_CHECK_POSITIVE(nY, NULL);
    1137     PS_INT_CHECK_POSITIVE(nZ, NULL);
     1135    PS_ASSERT_INT_POSITIVE(nX, NULL);
     1136    PS_ASSERT_INT_POSITIVE(nY, NULL);
     1137    PS_ASSERT_INT_POSITIVE(nZ, NULL);
    11381138
    11391139    psS32 x = 0;
    … …  
    11791179                                    psPolynomialType type)
    11801180{
    1181     PS_INT_CHECK_POSITIVE(nW, NULL);
    1182     PS_INT_CHECK_POSITIVE(nX, NULL);
    1183     PS_INT_CHECK_POSITIVE(nY, NULL);
    1184     PS_INT_CHECK_POSITIVE(nZ, NULL);
     1181    PS_ASSERT_INT_POSITIVE(nW, NULL);
     1182    PS_ASSERT_INT_POSITIVE(nX, NULL);
     1183    PS_ASSERT_INT_POSITIVE(nY, NULL);
     1184    PS_ASSERT_INT_POSITIVE(nZ, NULL);
    11851185
    11861186    psS32 w = 0;
    … …  
    12341234psF32 psPolynomial1DEval(const psPolynomial1D* myPoly, psF32 x)
    12351235{
    1236     PS_POLY_CHECK_NULL(myPoly, NAN);
     1236    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    12371237
    12381238    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    12511251                                   const psVector *x)
    12521252{
    1253     PS_POLY_CHECK_NULL(myPoly, NULL);
    1254     PS_VECTOR_CHECK_NULL(x, NULL);
    1255     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F32, NULL);
     1253    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1254    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1255    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
    12561256
    12571257    psVector *tmp;
    … …  
    12671267psF32 psPolynomial2DEval(const psPolynomial2D* myPoly, psF32 x, psF32 y)
    12681268{
    1269     PS_POLY_CHECK_NULL(myPoly, NAN);
     1269    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    12701270
    12711271    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    12861286
    12871287{
    1288     PS_POLY_CHECK_NULL(myPoly, NULL);
    1289     PS_VECTOR_CHECK_NULL(x, NULL);
    1290     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F32, NULL);
    1291     PS_VECTOR_CHECK_NULL(y, NULL);
    1292     PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F32, NULL);
     1288    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1289    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1290    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
     1291    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     1292    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F32, NULL);
    12931293
    12941294    psVector *tmp;
    … …  
    13141314psF32 psPolynomial3DEval(const psPolynomial3D* myPoly, psF32 x, psF32 y, psF32 z)
    13151315{
    1316     PS_POLY_CHECK_NULL(myPoly, NAN);
     1316    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    13171317
    13181318    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    13341334
    13351335{
    1336     PS_POLY_CHECK_NULL(myPoly, NULL);
    1337     PS_VECTOR_CHECK_NULL(x, NULL);
    1338     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F32, NULL);
    1339     PS_VECTOR_CHECK_NULL(y, NULL);
    1340     PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F32, NULL);
    1341     PS_VECTOR_CHECK_NULL(z, NULL);
    1342     PS_VECTOR_CHECK_TYPE(z, PS_TYPE_F32, NULL);
     1336    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1337    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1338    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
     1339    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     1340    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F32, NULL);
     1341    PS_ASSERT_VECTOR_NON_NULL(z, NULL);
     1342    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F32, NULL);
    13431343
    13441344    psVector *tmp;
    … …  
    13701370psF32 psPolynomial4DEval(const psPolynomial4D* myPoly, psF32 w, psF32 x, psF32 y, psF32 z)
    13711371{
    1372     PS_POLY_CHECK_NULL(myPoly, NAN);
     1372    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    13731373
    13741374    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    13901390                                   const psVector *z)
    13911391{
    1392     PS_POLY_CHECK_NULL(myPoly, NULL);
    1393     PS_VECTOR_CHECK_NULL(w, NULL);
    1394     PS_VECTOR_CHECK_TYPE(w, PS_TYPE_F32, NULL);
    1395     PS_VECTOR_CHECK_NULL(x, NULL);
    1396     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F32, NULL);
    1397     PS_VECTOR_CHECK_NULL(y, NULL);
    1398     PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F32, NULL);
    1399     PS_VECTOR_CHECK_NULL(z, NULL);
    1400     PS_VECTOR_CHECK_TYPE(z, PS_TYPE_F32, NULL);
     1392    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1393    PS_ASSERT_VECTOR_NON_NULL(w, NULL);
     1394    PS_ASSERT_VECTOR_TYPE(w, PS_TYPE_F32, NULL);
     1395    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1396    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
     1397    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     1398    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F32, NULL);
     1399    PS_ASSERT_VECTOR_NON_NULL(z, NULL);
     1400    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F32, NULL);
    14011401
    14021402    psVector *tmp;
    … …  
    14341434                                      psPolynomialType type)
    14351435{
    1436     PS_INT_CHECK_POSITIVE(n, NULL);
     1436    PS_ASSERT_INT_POSITIVE(n, NULL);
    14371437
    14381438    psS32 i = 0;
    … …  
    14591459                                      psPolynomialType type)
    14601460{
    1461     PS_INT_CHECK_POSITIVE(nX, NULL);
    1462     PS_INT_CHECK_POSITIVE(nY, NULL);
     1461    PS_ASSERT_INT_POSITIVE(nX, NULL);
     1462    PS_ASSERT_INT_POSITIVE(nY, NULL);
    14631463
    14641464    psS32 x = 0;
    … …  
    14951495                                      psPolynomialType type)
    14961496{
    1497     PS_INT_CHECK_POSITIVE(nX, NULL);
    1498     PS_INT_CHECK_POSITIVE(nY, NULL);
    1499     PS_INT_CHECK_POSITIVE(nZ, NULL);
     1497    PS_ASSERT_INT_POSITIVE(nX, NULL);
     1498    PS_ASSERT_INT_POSITIVE(nY, NULL);
     1499    PS_ASSERT_INT_POSITIVE(nZ, NULL);
    15001500
    15011501    psS32 x = 0;
    … …  
    15411541                                      psPolynomialType type)
    15421542{
    1543     PS_INT_CHECK_POSITIVE(nW, NULL);
    1544     PS_INT_CHECK_POSITIVE(nX, NULL);
    1545     PS_INT_CHECK_POSITIVE(nY, NULL);
    1546     PS_INT_CHECK_POSITIVE(nZ, NULL);
     1543    PS_ASSERT_INT_POSITIVE(nW, NULL);
     1544    PS_ASSERT_INT_POSITIVE(nX, NULL);
     1545    PS_ASSERT_INT_POSITIVE(nY, NULL);
     1546    PS_ASSERT_INT_POSITIVE(nZ, NULL);
    15471547
    15481548    psS32 w = 0;
    … …  
    15971597psF64 psDPolynomial1DEval(const psDPolynomial1D* myPoly, psF64 x)
    15981598{
    1599     PS_POLY_CHECK_NULL(myPoly, NAN);
     1599    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    16001600
    16011601    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    16151615
    16161616{
    1617     PS_POLY_CHECK_NULL(myPoly, NULL);
    1618     PS_VECTOR_CHECK_NULL(x, NULL);
    1619     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F64, NULL);
     1617    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1618    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1619    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
    16201620
    16211621    psVector *tmp;
    … …  
    16351635                          psF64 y)
    16361636{
    1637     PS_POLY_CHECK_NULL(myPoly, NAN);
     1637    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    16381638
    16391639    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    16531653                                    const psVector *y)
    16541654{
    1655     PS_POLY_CHECK_NULL(myPoly, NULL);
    1656     PS_VECTOR_CHECK_NULL(x, NULL);
    1657     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F64, NULL);
    1658     PS_VECTOR_CHECK_NULL(y, NULL);
    1659     PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F64, NULL);
     1655    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1656    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1657    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
     1658    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     1659    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F64, NULL);
    16601660
    16611661    psVector *tmp;
    … …  
    16851685                          psF64 z)
    16861686{
    1687     PS_POLY_CHECK_NULL(myPoly, NAN);
     1687    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    16881688
    16891689    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    17051705
    17061706{
    1707     PS_POLY_CHECK_NULL(myPoly, NULL);
    1708     PS_VECTOR_CHECK_NULL(x, NULL);
    1709     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F64, NULL);
    1710     PS_VECTOR_CHECK_NULL(y, NULL);
    1711     PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F64, NULL);
    1712     PS_VECTOR_CHECK_NULL(z, NULL);
    1713     PS_VECTOR_CHECK_TYPE(z, PS_TYPE_F64, NULL);
     1707    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1708    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1709    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
     1710    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     1711    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F64, NULL);
     1712    PS_ASSERT_VECTOR_NON_NULL(z, NULL);
     1713    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F64, NULL);
    17141714
    17151715    psVector *tmp;
    … …  
    17451745                          psF64 z)
    17461746{
    1747     PS_POLY_CHECK_NULL(myPoly, NAN);
     1747    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    17481748
    17491749    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    17651765                                    const psVector *z)
    17661766{
    1767     PS_POLY_CHECK_NULL(myPoly, NULL);
    1768     PS_VECTOR_CHECK_NULL(w, NULL);
    1769     PS_VECTOR_CHECK_TYPE(w, PS_TYPE_F64, NULL);
    1770     PS_VECTOR_CHECK_NULL(x, NULL);
    1771     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F64, NULL);
    1772     PS_VECTOR_CHECK_NULL(y, NULL);
    1773     PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F64, NULL);
    1774     PS_VECTOR_CHECK_NULL(z, NULL);
    1775     PS_VECTOR_CHECK_TYPE(z, PS_TYPE_F64, NULL);
     1767    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1768    PS_ASSERT_VECTOR_NON_NULL(w, NULL);
     1769    PS_ASSERT_VECTOR_TYPE(w, PS_TYPE_F64, NULL);
     1770    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1771    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
     1772    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     1773    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F64, NULL);
     1774    PS_ASSERT_VECTOR_NON_NULL(z, NULL);
     1775    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F64, NULL);
    17761776
    17771777    psVector *tmp;
    … …  
    18281828                            psF32 max)
    18291829{
    1830     PS_INT_CHECK_NON_NEGATIVE(numSplines, NULL);
    1831     PS_INT_CHECK_NON_NEGATIVE(order, NULL);
    1832     PS_FLOAT_CHECK_NON_EQUAL(max, min, NULL);
     1830    PS_ASSERT_INT_NONNEGATIVE(numSplines, NULL);
     1831    PS_ASSERT_INT_NONNEGATIVE(order, NULL);
     1832    PS_ASSERT_FLOAT_NON_EQUAL(max, min, NULL);
    18331833
    18341834    psSpline1D *tmp = NULL;
    … …  
    18701870                                   psS32 order)
    18711871{
    1872     PS_VECTOR_CHECK_NULL(bounds, NULL);
    1873     PS_VECTOR_CHECK_EMPTY(bounds, NULL);
    1874     PS_INT_CHECK_NON_NEGATIVE(order, NULL);
     1872    PS_ASSERT_VECTOR_NON_NULL(bounds, NULL);
     1873    PS_ASSERT_VECTOR_NON_EMPTY(bounds, NULL);
     1874    PS_ASSERT_INT_NONNEGATIVE(order, NULL);
    18751875
    18761876    psSpline1D *tmp = NULL;
    … …  
    19831983                          psScalar *x)
    19841984{
    1985     PS_VECTOR_CHECK_NULL(bins, -4);
    1986     PS_VECTOR_CHECK_EMPTY(bins, -4);
    1987     PS_PTR_CHECK_NULL(x, -6);
    1988     PS_PTR_CHECK_TYPE_EQUAL(x, bins, -3);
     1985    PS_ASSERT_VECTOR_NON_NULL(bins, -4);
     1986    PS_ASSERT_VECTOR_NON_EMPTY(bins, -4);
     1987    PS_ASSERT_PTR_NON_NULL(x, -6);
     1988    PS_ASSERT_PTR_TYPE_EQUAL(x, bins, -3);
    19891989    char* strType;
    19901990
    … …  
    20492049                                psScalar *x)
    20502050{
    2051     PS_VECTOR_CHECK_NULL(domain, NULL);
    2052     PS_VECTOR_CHECK_NULL(range, NULL);
    2053     PS_PTR_CHECK_NULL(x, NULL);
    2054     PS_INT_CHECK_NON_NEGATIVE(order, NULL);
    2055     PS_VECTOR_CHECK_SIZE_EQUAL(domain, range, NULL);
    2056     PS_PTR_CHECK_TYPE_EQUAL(domain, range, NULL);
    2057     PS_PTR_CHECK_TYPE_EQUAL(domain, x, NULL);
     2051    PS_ASSERT_VECTOR_NON_NULL(domain, NULL);
     2052    PS_ASSERT_VECTOR_NON_NULL(range, NULL);
     2053    PS_ASSERT_PTR_NON_NULL(x, NULL);
     2054    PS_ASSERT_INT_NONNEGATIVE(order, NULL);
     2055    PS_ASSERT_VECTORS_SIZE_EQUAL(domain, range, NULL);
     2056    PS_ASSERT_PTR_TYPE_EQUAL(domain, range, NULL);
     2057    PS_ASSERT_PTR_TYPE_EQUAL(domain, x, NULL);
    20582058
    20592059    psVector *range32 = NULL;
    … …  
    21312131)
    21322132{
    2133     PS_PTR_CHECK_NULL(spline, NAN);
    2134     PS_INT_CHECK_NON_NEGATIVE(spline->n, NAN);
    2135     PS_VECTOR_CHECK_TYPE(spline->knots, PS_TYPE_F32, NAN);
     2133    PS_ASSERT_PTR_NON_NULL(spline, NAN);
     2134    PS_ASSERT_INT_NONNEGATIVE(spline->n, NAN);
     2135    PS_ASSERT_VECTOR_TYPE(spline->knots, PS_TYPE_F32, NAN);
    21362136
    21372137    psS32 binNum;
    … …  
    21672167)
    21682168{
    2169     PS_PTR_CHECK_NULL(spline, NULL);
    2170     PS_VECTOR_CHECK_NULL(x, NULL);
    2171     PS_VECTOR_CHECK_TYPE_F32_OR_F64(x, NULL);
    2172     PS_VECTOR_CHECK_TYPE(spline->knots, PS_TYPE_F32, NULL);
     2169    PS_ASSERT_PTR_NON_NULL(spline, NULL);
     2170    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     2171    PS_ASSERT_VECTOR_TYPE_F32_OR_F64(x, NULL);
     2172    PS_ASSERT_VECTOR_TYPE(spline->knots, PS_TYPE_F32, NULL);
    21732173
    21742174    psS32 i;

  • trunk/psLib/src/dataManip/psMatrix.c

    r3880 r4029  
    2121 *  @author Robert DeSonia, MHPCC
    2222 *
    23  *  @version $Revision: 1.28 $ $Name: not supported by cvs2svn $
    24  *  @date $Date: 2005-05-11 02:29:39 $
     23 *  @version $Revision: 1.29 $ $Name: not supported by cvs2svn $
     24 *  @date $Date: 2005-05-25 20:26:55 $
    2525 *
    2626 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    188188
    189189    // Error checks
    190     PS_IMAGE_CHECK_NULL_GENERAL(inImage, psMatrixLUD_EXIT);
     190    PS_ASSERT_GENERAL_IMAGE_NON_NULL(inImage, psMatrixLUD_EXIT);
    191191    PS_CHECK_POINTERS(inImage, outImage, psMatrixLUD_EXIT);
    192192    PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, psMatrixLUD_EXIT);
    193     PS_PTR_CHECK_NULL_GENERAL(outPerm, psMatrixLUD_EXIT);
     193    PS_ASSERT_GENERAL_PTR_NON_NULL(outPerm, psMatrixLUD_EXIT);
    194194
    195195    outImage = psImageRecycle(outImage, inImage->numCols, inImage->numRows, inImage->type.type);
    … …  
    247247
    248248    // Error checks
    249     PS_IMAGE_CHECK_NULL_GENERAL(inImage, LUSOLVE_CLEANUP);
     249    PS_ASSERT_GENERAL_IMAGE_NON_NULL(inImage, LUSOLVE_CLEANUP);
    250250    PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, LUSOLVE_CLEANUP);
    251     PS_IMAGE_CHECK_EMPTY_GENERAL(inImage, LUSOLVE_CLEANUP);
    252     PS_VECTOR_CHECK_NULL_GENERAL(inVector, LUSOLVE_CLEANUP);
     251    PS_ASSERT_GENERAL_IMAGE_NON_EMPTY(inImage, LUSOLVE_CLEANUP);
     252    PS_ASSERT_GENERAL_VECTOR_NON_NULL(inVector, LUSOLVE_CLEANUP);
    253253    PS_CHECK_DIMEN_AND_TYPE(inVector, PS_DIMEN_VECTOR, LUSOLVE_CLEANUP);
    254     PS_VECTOR_CHECK_NULL_GENERAL(inPerm, LUSOLVE_CLEANUP);
     254    PS_ASSERT_GENERAL_VECTOR_NON_NULL(inPerm, LUSOLVE_CLEANUP);
    255255
    256256    outVector = psVectorRecycle(outVector, inImage->numRows, inImage->type.type);
    … …  
    300300    #define INVERT_CLEANUP { psFree(outImage); return NULL; }
    301301    // Error checks
    302     PS_PTR_CHECK_NULL_GENERAL(det, INVERT_CLEANUP);
    303     PS_IMAGE_CHECK_NULL_GENERAL(inImage, INVERT_CLEANUP);
     302    PS_ASSERT_GENERAL_PTR_NON_NULL(det, INVERT_CLEANUP);
     303    PS_ASSERT_GENERAL_IMAGE_NON_NULL(inImage, INVERT_CLEANUP);
    304304    PS_CHECK_POINTERS(inImage, outImage, INVERT_CLEANUP);
    305305    PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, INVERT_CLEANUP);
    306     PS_IMAGE_CHECK_EMPTY_GENERAL(inImage, INVERT_CLEANUP);
     306    PS_ASSERT_GENERAL_IMAGE_NON_EMPTY(inImage, INVERT_CLEANUP);
    307307
    308308    outImage = psImageRecycle(outImage, inImage->numCols, inImage->numRows, inImage->type.type);
    … …  
    348348    #define DETERMINANT_EXIT { return NULL; }
    349349    // Error checks
    350     PS_IMAGE_CHECK_NULL_GENERAL(inImage, DETERMINANT_EXIT);
     350    PS_ASSERT_GENERAL_IMAGE_NON_NULL(inImage, DETERMINANT_EXIT);
    351351    PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, DETERMINANT_EXIT);
    352     PS_IMAGE_CHECK_EMPTY_GENERAL(inImage, DETERMINANT_EXIT);
     352    PS_ASSERT_GENERAL_IMAGE_NON_EMPTY(inImage, DETERMINANT_EXIT);
    353353    PS_CHECK_SQUARE(inImage, DETERMINANT_EXIT);
    354354
    … …  
    383383
    384384    // Error checks
    385     PS_IMAGE_CHECK_NULL_GENERAL(inImage1, MULTIPLY_CLEANUP);
    386     PS_IMAGE_CHECK_NULL_GENERAL(inImage2, MULTIPLY_CLEANUP);
    387     PS_IMAGE_CHECK_EMPTY_GENERAL(inImage1, MULTIPLY_CLEANUP);
    388     PS_IMAGE_CHECK_EMPTY_GENERAL(inImage2, MULTIPLY_CLEANUP);
     385    PS_ASSERT_GENERAL_IMAGE_NON_NULL(inImage1, MULTIPLY_CLEANUP);
     386    PS_ASSERT_GENERAL_IMAGE_NON_NULL(inImage2, MULTIPLY_CLEANUP);
     387    PS_ASSERT_GENERAL_IMAGE_NON_EMPTY(inImage1, MULTIPLY_CLEANUP);
     388    PS_ASSERT_GENERAL_IMAGE_NON_EMPTY(inImage2, MULTIPLY_CLEANUP);
    389389    PS_CHECK_DIMEN_AND_TYPE(inImage1, PS_DIMEN_IMAGE, MULTIPLY_CLEANUP);
    390390    PS_CHECK_DIMEN_AND_TYPE(inImage2, PS_DIMEN_IMAGE, MULTIPLY_CLEANUP);
    … …  
    435435    #define TRANSPOSE_CLEANUP { psFree(outImage); return NULL; }
    436436    // Error checks
    437     PS_IMAGE_CHECK_NULL_GENERAL(inImage, TRANSPOSE_CLEANUP);
     437    PS_ASSERT_GENERAL_IMAGE_NON_NULL(inImage, TRANSPOSE_CLEANUP);
    438438    PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, TRANSPOSE_CLEANUP);
    439     PS_IMAGE_CHECK_EMPTY_GENERAL(inImage, TRANSPOSE_CLEANUP);
     439    PS_ASSERT_GENERAL_IMAGE_NON_EMPTY(inImage, TRANSPOSE_CLEANUP);
    440440    PS_CHECK_POINTERS(inImage, outImage, TRANSPOSE_CLEANUP);
    441441
    … …  
    481481    #define EIGENVECTORS_CLEANUP { psFree(outImage); return NULL; }
    482482    // Error checks
    483     PS_IMAGE_CHECK_NULL_GENERAL(inImage, EIGENVECTORS_CLEANUP);
     483    PS_ASSERT_GENERAL_IMAGE_NON_NULL(inImage, EIGENVECTORS_CLEANUP);
    484484    PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, EIGENVECTORS_CLEANUP);
    485     PS_IMAGE_CHECK_EMPTY_GENERAL(inImage, EIGENVECTORS_CLEANUP);
     485    PS_ASSERT_GENERAL_IMAGE_NON_EMPTY(inImage, EIGENVECTORS_CLEANUP);
    486486    PS_CHECK_POINTERS(inImage, outImage, EIGENVECTORS_CLEANUP);
    487487
    … …  
    526526
    527527    // Error checks
    528     PS_IMAGE_CHECK_NULL_GENERAL(inImage, psMatrixToVector_EXIT);
     528    PS_ASSERT_GENERAL_IMAGE_NON_NULL(inImage, psMatrixToVector_EXIT);
    529529    PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, psMatrixToVector_EXIT);
    530     PS_IMAGE_CHECK_EMPTY_GENERAL(inImage, psMatrixToVector_EXIT);
     530    PS_ASSERT_GENERAL_IMAGE_NON_EMPTY(inImage, psMatrixToVector_EXIT);
    531531
    532532    if (inImage->numRows == 1) {
    … …  
    589589    #define VECTORTOMATRIX_CLEANUP {psFree(outImage); return NULL; }
    590590    // Error checks
    591     PS_VECTOR_CHECK_NULL_GENERAL(inVector, VECTORTOMATRIX_CLEANUP);
     591    PS_ASSERT_GENERAL_VECTOR_NON_NULL(inVector, VECTORTOMATRIX_CLEANUP);
    592592
    593593    if (inVector->type.dimen == PS_DIMEN_VECTOR) {
    594594        PS_CHECK_DIMEN_AND_TYPE(inVector, PS_DIMEN_VECTOR, VECTORTOMATRIX_CLEANUP);
    595         PS_VECTOR_CHECK_EMPTY_GENERAL(inVector, VECTORTOMATRIX_CLEANUP);
     595        PS_ASSERT_GENERAL_VECTOR_NON_EMPTY(inVector, VECTORTOMATRIX_CLEANUP);
    596596
    597597        outImage = psImageRecycle(outImage, 1, inVector->n, inVector->type.type);
    … …  
    614614    } else if (inVector->type.dimen == PS_DIMEN_TRANSV) {
    615615        PS_CHECK_DIMEN_AND_TYPE(inVector, PS_DIMEN_TRANSV, VECTORTOMATRIX_CLEANUP);
    616         PS_VECTOR_CHECK_EMPTY_GENERAL(inVector, VECTORTOMATRIX_CLEANUP);
     616        PS_ASSERT_GENERAL_VECTOR_NON_EMPTY(inVector, VECTORTOMATRIX_CLEANUP);
    617617        outImage = psImageRecycle(outImage, inVector->n, 1, inVector->type.type);
    618618        // More checks for PS_DIMEN_TRANSV
    … …  
    632632    }
    633633
    634     PS_IMAGE_CHECK_NULL_GENERAL(outImage, VECTORTOMATRIX_CLEANUP);
     634    PS_ASSERT_GENERAL_IMAGE_NON_NULL(outImage, VECTORTOMATRIX_CLEANUP);
    635635    PS_CHECK_DIMEN_AND_TYPE(outImage, PS_DIMEN_IMAGE, VECTORTOMATRIX_CLEANUP);
    636636

  • trunk/psLib/src/dataManip/psMinimize.c

    r3990 r4029  
    99 *  @author GLG, MHPCC
    1010 *
    11  *  @version $Revision: 1.119 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2005-05-19 23:57:37 $
     11 *  @version $Revision: 1.120 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2005-05-25 20:26:55 $
    1313 *
    1414 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    174174                         psF32 X)
    175175{
    176     PS_PTR_CHECK_NULL(spline, NAN);
    177     PS_INT_CHECK_NON_NEGATIVE(spline->n, NAN);
    178     PS_VECTOR_CHECK_NULL(spline->domains, NAN);
    179     PS_PTR_CHECK_NULL(spline->p_psDeriv2, NAN);
    180     PS_VECTOR_CHECK_NULL(x, NAN);
    181     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F32, NAN);
    182     PS_VECTOR_CHECK_NULL(y, NAN);
    183     PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F32, NAN);
    184     PS_VECTOR_CHECK_TYPE(spline->knots, PS_TYPE_F32, NULL);
     176    PS_ASSERT_PTR_NON_NULL(spline, NAN);
     177    PS_ASSERT_INT_NONNEGATIVE(spline->n, NAN);
     178    PS_ASSERT_VECTOR_NON_NULL(spline->domains, NAN);
     179    PS_ASSERT_PTR_NON_NULL(spline->p_psDeriv2, NAN);
     180    PS_ASSERT_VECTOR_NON_NULL(x, NAN);
     181    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NAN);
     182    PS_ASSERT_VECTOR_NON_NULL(y, NAN);
     183    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F32, NAN);
     184    PS_ASSERT_VECTOR_TYPE(spline->knots, PS_TYPE_F32, NULL);
    185185 
    186186    psS32 n;
    … …  
    258258                                const psVector* yErr)     ///< Errors in coordinates, or NULL
    259259{
    260     PS_VECTOR_CHECK_NULL(y, NULL);
    261     PS_VECTOR_CHECK_TYPE_F32_OR_F64(y, NULL);
     260    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     261    PS_ASSERT_VECTOR_TYPE_F32_OR_F64(y, NULL);
    262262    if (mySpline != NULL) {
    263         PS_VECTOR_CHECK_TYPE(mySpline->knots, PS_TYPE_F32, NULL);
     263        PS_ASSERT_VECTOR_TYPE(mySpline->knots, PS_TYPE_F32, NULL);
    264264    }
    265265
    … …  
    285285        yErr32 = yErr32Static;
    286286    } else {
    287         PS_VECTOR_CHECK_TYPE_F32_OR_F64(yErr, NULL);
     287        PS_ASSERT_VECTOR_TYPE_F32_OR_F64(yErr, NULL);
    288288        PS_VECTOR_CONVERT_F64_TO_F32_STATIC(yErr, yErr32, yErr32Static);
    289289    }
    … …  
    294294        x32 = x32Static;
    295295    } else {
    296         PS_VECTOR_CHECK_TYPE_F32_OR_F64(x, NULL);
     296        PS_ASSERT_VECTOR_TYPE_F32_OR_F64(x, NULL);
    297297        PS_VECTOR_CONVERT_F64_TO_F32_STATIC(x, x32, x32Static);
    298298    }
    299     PS_VECTOR_CHECK_SIZE_EQUAL(x32, y32, NULL);
    300     PS_VECTOR_CHECK_SIZE_EQUAL(yErr32, y32, NULL);
     299    PS_ASSERT_VECTORS_SIZE_EQUAL(x32, y32, NULL);
     300    PS_ASSERT_VECTORS_SIZE_EQUAL(yErr32, y32, NULL);
    301301
    302302    /*
    … …  
    310310        mySpline = psSpline1DAllocGeneric(x32, 3);
    311311    }
    312     PS_PTR_CHECK_NULL(mySpline, NULL);
    313     PS_INT_CHECK_NON_NEGATIVE(mySpline->n, NULL);
     312    PS_ASSERT_PTR_NON_NULL(mySpline, NULL);
     313    PS_ASSERT_INT_NONNEGATIVE(mySpline->n, NULL);
    314314
    315315    if (y32->n != (1 + mySpline->n)) {
    … …  
    440440                                  const psArray *coords)
    441441{
    442     PS_PTR_CHECK_NULL(coords, NULL);
    443     PS_PTR_CHECK_NULL(params, NULL);
     442    PS_ASSERT_PTR_NON_NULL(coords, NULL);
     443    PS_ASSERT_PTR_NON_NULL(params, NULL);
    444444
    445445    psTrace(".psLib.dataManip.psMinimize", 4,
    … …  
    457457        deriv = psImageAlloc(params->n, coords->n, PS_TYPE_F32);
    458458    } else {
    459         PS_IMAGE_CHECK_SIZE(deriv, params->n, coords->n, NULL);
    460         PS_IMAGE_CHECK_TYPE(deriv, PS_TYPE_F32, NULL);
     459        PS_ASSERT_IMAGE_SIZE(deriv, params->n, coords->n, NULL);
     460        PS_ASSERT_IMAGE_TYPE(deriv, PS_TYPE_F32, NULL);
    461461    }
    462462
    … …  
    513513                                  const psArray *coords)
    514514{
    515     PS_PTR_CHECK_NULL(coords, NULL);
    516     PS_PTR_CHECK_NULL(params, NULL);
     515    PS_ASSERT_PTR_NON_NULL(coords, NULL);
     516    PS_ASSERT_PTR_NON_NULL(params, NULL);
    517517
    518518    psF64 normalization = params->data.F32[0];
    … …  
    527527        deriv = psImageAlloc(params->n, coords->n, PS_TYPE_F32);
    528528    } else {
    529         PS_IMAGE_CHECK_SIZE(deriv, 6, coords->n, NULL);
    530         PS_IMAGE_CHECK_TYPE(deriv, PS_TYPE_F32, NULL);
     529        PS_ASSERT_IMAGE_SIZE(deriv, 6, coords->n, NULL);
     530        PS_ASSERT_IMAGE_TYPE(deriv, PS_TYPE_F32, NULL);
    531531    }
    532532
    … …  
    572572                        psMinimizeLMChi2Func func)
    573573{
    574     PS_PTR_CHECK_NULL(min, NULL);
    575     PS_VECTOR_CHECK_NULL(params, NULL);
    576     PS_VECTOR_CHECK_EMPTY(params, NULL);
    577     PS_PTR_CHECK_NULL(x, NULL);
    578     PS_VECTOR_CHECK_NULL(y, NULL);
    579     PS_VECTOR_CHECK_EMPTY(y, NULL);
    580     PS_VECTOR_CHECK_SIZE_EQUAL(x, y, NULL);
    581     PS_PTR_CHECK_NULL(func, NULL);
     574    PS_ASSERT_PTR_NON_NULL(min, NULL);
     575    PS_ASSERT_VECTOR_NON_NULL(params, NULL);
     576    PS_ASSERT_VECTOR_NON_EMPTY(params, NULL);
     577    PS_ASSERT_PTR_NON_NULL(x, NULL);
     578    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     579    PS_ASSERT_VECTOR_NON_EMPTY(y, NULL);
     580    PS_ASSERT_VECTORS_SIZE_EQUAL(x, y, NULL);
     581    PS_ASSERT_PTR_NON_NULL(func, NULL);
    582582
    583583    // this function has test and current values for several things
    … …  
    923923                           psMinimizeLMChi2Func func)
    924924{
    925     PS_PTR_CHECK_NULL(min, NULL);
    926     PS_VECTOR_CHECK_NULL(params, NULL);
    927     PS_VECTOR_CHECK_EMPTY(params, NULL);
    928     PS_PTR_CHECK_NULL(x, NULL);
    929     PS_VECTOR_CHECK_NULL(y, NULL);
    930     PS_VECTOR_CHECK_EMPTY(y, NULL);
    931     PS_VECTOR_CHECK_SIZE_EQUAL(x, y, NULL);
    932     PS_PTR_CHECK_NULL(func, NULL);
     925    PS_ASSERT_PTR_NON_NULL(min, NULL);
     926    PS_ASSERT_VECTOR_NON_NULL(params, NULL);
     927    PS_ASSERT_VECTOR_NON_EMPTY(params, NULL);
     928    PS_ASSERT_PTR_NON_NULL(x, NULL);
     929    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     930    PS_ASSERT_VECTOR_NON_EMPTY(y, NULL);
     931    PS_ASSERT_VECTORS_SIZE_EQUAL(x, y, NULL);
     932    PS_ASSERT_PTR_NON_NULL(func, NULL);
    933933
    934934    if (paramMask != NULL) {
    935         PS_VECTOR_CHECK_SIZE_EQUAL(params, paramMask, NULL);
     935        PS_ASSERT_VECTORS_SIZE_EQUAL(params, paramMask, NULL);
    936936    }
    937937    if (yErr != NULL) {
    938         PS_VECTOR_CHECK_SIZE_EQUAL(y, yErr, NULL);
     938        PS_ASSERT_VECTORS_SIZE_EQUAL(y, yErr, NULL);
    939939    }
    940940    if (covar != NULL) {
    941         PS_IMAGE_CHECK_SIZE(covar, params->n, params->n, NULL);
     941        PS_ASSERT_IMAGE_SIZE(covar, params->n, params->n, NULL);
    942942    }
    943943
    … …  
    13631363                                        const psVector* yErr)
    13641364{
    1365     PS_POLY_CHECK_NULL(myPoly, NULL);
    1366     PS_INT_CHECK_NON_NEGATIVE(myPoly->n, NULL);
    1367     PS_VECTOR_CHECK_NULL(y, NULL);
    1368     PS_VECTOR_CHECK_EMPTY(y, NULL);
    1369     PS_VECTOR_CHECK_TYPE_F32_OR_F64(y, NULL);
     1365    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1366    PS_ASSERT_INT_NONNEGATIVE(myPoly->n, NULL);
     1367    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     1368    PS_ASSERT_VECTOR_NON_EMPTY(y, NULL);
     1369    PS_ASSERT_VECTOR_TYPE_F32_OR_F64(y, NULL);
    13701370
    13711371    psS32 i;
    … …  
    13831383        yErr64 = yErr64Static;
    13841384    } else {
    1385         PS_VECTOR_CHECK_TYPE_F32_OR_F64(yErr, NULL);
     1385        PS_ASSERT_VECTOR_TYPE_F32_OR_F64(yErr, NULL);
    13861386        PS_VECTOR_CONVERT_F32_TO_F64_STATIC(yErr, yErr64, yErr64Static);
    13871387    }
    … …  
    13951395        x64 = x64Static;
    13961396    } else {
    1397         PS_VECTOR_CHECK_TYPE_F32_OR_F64(x, NULL);
     1397        PS_ASSERT_VECTOR_TYPE_F32_OR_F64(x, NULL);
    13981398        PS_VECTOR_CONVERT_F32_TO_F64_STATIC(x, x64, x64Static);
    13991399        if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    … …  
    14011401        }
    14021402    }
    1403     PS_VECTOR_CHECK_SIZE_EQUAL(x64, y64, NULL);
    1404     PS_VECTOR_CHECK_SIZE_EQUAL(yErr64, y64, NULL);
     1403    PS_ASSERT_VECTORS_SIZE_EQUAL(x64, y64, NULL);
     1404    PS_ASSERT_VECTORS_SIZE_EQUAL(yErr64, y64, NULL);
    14051405
    14061406    // Call the appropriate vector fitting routine.
    … …  
    14301430                                    psF32 tol)
    14311431{
    1432     PS_INT_CHECK_NON_NEGATIVE(maxIter, NULL);
     1432    PS_ASSERT_INT_NONNEGATIVE(maxIter, NULL);
    14331433
    14341434    psMinimization *min = psAlloc(sizeof(psMinimization));
    … …  
    17651765                  psMinimizePowellFunc func)
    17661766{
    1767     PS_PTR_CHECK_NULL(min, NAN);
    1768     PS_VECTOR_CHECK_NULL(params, NAN);
    1769     PS_VECTOR_CHECK_EMPTY(params, NAN);
    1770     PS_VECTOR_CHECK_TYPE(params, PS_TYPE_F32, NAN);
    1771     PS_VECTOR_CHECK_NULL(line, NAN);
    1772     PS_VECTOR_CHECK_EMPTY(line, NAN);
    1773     PS_VECTOR_CHECK_TYPE(line, PS_TYPE_F32, NAN);
    1774     PS_VECTOR_CHECK_NULL(paramMask, NAN);
    1775     PS_VECTOR_CHECK_EMPTY(paramMask, NAN);
    1776     PS_VECTOR_CHECK_TYPE(paramMask, PS_TYPE_U8, NAN);
    1777     PS_PTR_CHECK_NULL(coords, NAN);
    1778     PS_PTR_CHECK_NULL(func, NAN);
     1767    PS_ASSERT_PTR_NON_NULL(min, NAN);
     1768    PS_ASSERT_VECTOR_NON_NULL(params, NAN);
     1769    PS_ASSERT_VECTOR_NON_EMPTY(params, NAN);
     1770    PS_ASSERT_VECTOR_TYPE(params, PS_TYPE_F32, NAN);
     1771    PS_ASSERT_VECTOR_NON_NULL(line, NAN);
     1772    PS_ASSERT_VECTOR_NON_EMPTY(line, NAN);
     1773    PS_ASSERT_VECTOR_TYPE(line, PS_TYPE_F32, NAN);
     1774    PS_ASSERT_VECTOR_NON_NULL(paramMask, NAN);
     1775    PS_ASSERT_VECTOR_NON_EMPTY(paramMask, NAN);
     1776    PS_ASSERT_VECTOR_TYPE(paramMask, PS_TYPE_U8, NAN);
     1777    PS_ASSERT_PTR_NON_NULL(coords, NAN);
     1778    PS_ASSERT_PTR_NON_NULL(func, NAN);
    17791779    psVector *bracket;
    17801780    psF32 a = 0.0;
    … …  
    19191919                        psMinimizePowellFunc func)
    19201920{
    1921     PS_PTR_CHECK_NULL(min, NULL);
    1922     PS_VECTOR_CHECK_NULL(params, NULL);
    1923     PS_VECTOR_CHECK_EMPTY(params, NULL);
    1924     PS_VECTOR_CHECK_TYPE(params, PS_TYPE_F32, NULL);
    1925     PS_PTR_CHECK_NULL(coords, NULL);
    1926     PS_PTR_CHECK_NULL(func, NULL);
     1921    PS_ASSERT_PTR_NON_NULL(min, NULL);
     1922    PS_ASSERT_VECTOR_NON_NULL(params, NULL);
     1923    PS_ASSERT_VECTOR_NON_EMPTY(params, NULL);
     1924    PS_ASSERT_VECTOR_TYPE(params, PS_TYPE_F32, NULL);
     1925    PS_ASSERT_PTR_NON_NULL(coords, NULL);
     1926    PS_ASSERT_PTR_NON_NULL(func, NULL);
    19271927    psS32 numDims = params->n;
    19281928    PS_VECTOR_GEN_STATIC_RECYCLED(pQP, numDims, PS_TYPE_F32);
    … …  
    19571957        myParamMask = (psVector *) paramMask;
    19581958    }
    1959     PS_VECTOR_CHECK_SIZE_EQUAL(params, myParamMask, NULL);
     1959    PS_ASSERT_VECTORS_SIZE_EQUAL(params, myParamMask, NULL);
    19601960
    19611961    // 1: Set v[i] to be the unit vectors for each dimension in params
    … …  
    21192119                                      const psArray *coords)
    21202120{
    2121     PS_PTR_CHECK_NULL(coords, NULL);
    2122     PS_PTR_CHECK_NULL(params, NULL);
     2121    PS_ASSERT_PTR_NON_NULL(coords, NULL);
     2122    PS_ASSERT_PTR_NON_NULL(params, NULL);
    21232123
    21242124    psF32 x;
    … …  
    21502150    psTrace(".psLib.dataManip.myPowellChi2Func", 4,
    21512151            "---- myPowellChi2Func() begin ----\n");
    2152     PS_VECTOR_CHECK_NULL(params, NAN);
    2153     PS_VECTOR_CHECK_EMPTY(params, NAN);
    2154     PS_VECTOR_CHECK_NULL(myValue, NAN);
    2155     PS_VECTOR_CHECK_EMPTY(myValue, NAN);
    2156     PS_PTR_CHECK_NULL(coords, NAN);
     2152    PS_ASSERT_VECTOR_NON_NULL(params, NAN);
     2153    PS_ASSERT_VECTOR_NON_EMPTY(params, NAN);
     2154    PS_ASSERT_VECTOR_NON_NULL(myValue, NAN);
     2155    PS_ASSERT_VECTOR_NON_EMPTY(myValue, NAN);
     2156    PS_ASSERT_PTR_NON_NULL(coords, NAN);
    21572157
    21582158    psF32 chi2 = 0.0;

  • trunk/psLib/src/dataManip/psStats.c

    r4028 r4029  
    99 *  @author GLG, MHPCC
    1010 *
    11  *  @version $Revision: 1.128 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2005-05-25 19:25:29 $
     11 *  @version $Revision: 1.129 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2005-05-25 20:26:55 $
    1313 *
    1414 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    424424                             psStats* stats)
    425425{
    426     PS_VECTOR_CHECK_NULL(myVector, -1);
    427     PS_PTR_CHECK_NULL(stats, -1);
     426    PS_ASSERT_VECTOR_NON_NULL(myVector, -1);
     427    PS_ASSERT_PTR_NON_NULL(stats, -1);
    428428    psS32 i = 0;                // Loop index variable
    429429
    … …  
    472472                        psStats* stats)
    473473{
    474     PS_VECTOR_CHECK_NULL(myVector, -1);
    475     PS_PTR_CHECK_NULL(stats, -1);
     474    PS_ASSERT_VECTOR_NON_NULL(myVector, -1);
     475    PS_ASSERT_PTR_NON_NULL(stats, -1);
    476476    psS32 i = 0;                // Loop index variable
    477477    psS32 numData = 0;          // The number of data points
    … …  
    619619                                       psF32 sigma)
    620620{
    621     PS_PTR_CHECK_NULL(robustHistogram, NULL);
    622     PS_PTR_CHECK_NULL(robustHistogram->bounds, NULL);
     621    PS_ASSERT_PTR_NON_NULL(robustHistogram, NULL);
     622    PS_ASSERT_PTR_NON_NULL(robustHistogram->bounds, NULL);
    623623
    624624    psS32 i = 0;                  // Loop index variable
    … …  
    10291029
    10301030    // Ensure that stats->clipIter is within the proper range.
    1031     PS_INT_CHECK_RANGE(stats->clipIter,
    1032                        PS_CLIPPED_NUM_ITER_LB,
    1033                        PS_CLIPPED_NUM_ITER_UB, -1);
     1031    PS_ASSERT_INT_WITHIN_RANGE(stats->clipIter,
     1032                               PS_CLIPPED_NUM_ITER_LB,
     1033                               PS_CLIPPED_NUM_ITER_UB, -1);
    10341034
    10351035    // Ensure that stats->clipSigma is within the proper range.
    1036     PS_INT_CHECK_RANGE(stats->clipSigma,
    1037                        PS_CLIPPED_SIGMA_LB,
    1038                        PS_CLIPPED_SIGMA_UB, -1);
     1036    PS_ASSERT_INT_WITHIN_RANGE(stats->clipSigma,
     1037                               PS_CLIPPED_SIGMA_LB,
     1038                               PS_CLIPPED_SIGMA_UB, -1);
    10391039
    10401040    // Allocate a psStats structure for calculating the mean, median, and
    … …  
    12631263                       psF32 getThisValue)
    12641264{
    1265     PS_POLY_CHECK_NULL(myPoly, NAN);
     1265    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    12661266    PS_FLOAT_COMPARE(rangeLow, rangeHigh, NAN);
    12671267    // We ensure that the requested f(y) value, which is getThisValue, is
    … …  
    13321332                                        psF32 yVal)
    13331333{
    1334     PS_VECTOR_CHECK_NULL(xVec, NAN);
    1335     PS_VECTOR_CHECK_NULL(yVec, NAN);
    1336     PS_VECTOR_CHECK_TYPE(xVec, PS_TYPE_F32, NAN);
    1337     PS_VECTOR_CHECK_TYPE(yVec, PS_TYPE_F32, NAN);
    1338     //    PS_VECTOR_CHECK_SIZE_EQUAL(xVec, yVec, NAN);
    1339     PS_INT_CHECK_RANGE(binNum, 0, (xVec->n - 1), NAN);
    1340     PS_INT_CHECK_RANGE(binNum, 0, (yVec->n - 1), NAN);
     1334    PS_ASSERT_VECTOR_NON_NULL(xVec, NAN);
     1335    PS_ASSERT_VECTOR_NON_NULL(yVec, NAN);
     1336    PS_ASSERT_VECTOR_TYPE(xVec, PS_TYPE_F32, NAN);
     1337    PS_ASSERT_VECTOR_TYPE(yVec, PS_TYPE_F32, NAN);
     1338    //    PS_ASSERT_VECTORS_SIZE_EQUAL(xVec, yVec, NAN);
     1339    PS_ASSERT_INT_WITHIN_RANGE(binNum, 0, (xVec->n - 1), NAN);
     1340    PS_ASSERT_INT_WITHIN_RANGE(binNum, 0, (yVec->n - 1), NAN);
    13411341
    13421342    //    PS_VECTOR_DECLARE_ALLOC_STATIC(x, 3, PS_TYPE_F64);
    … …  
    18271827psHistogram* psHistogramAlloc(psF32 lower, psF32 upper, psS32 n)
    18281828{
    1829     PS_INT_CHECK_POSITIVE(n, NULL);
     1829    PS_ASSERT_INT_POSITIVE(n, NULL);
    18301830    PS_FLOAT_COMPARE(lower, upper, NULL);
    18311831
    … …  
    18751875psHistogram* psHistogramAllocGeneric(const psVector* bounds)
    18761876{
    1877     PS_VECTOR_CHECK_NULL(bounds, NULL);
    1878     PS_VECTOR_CHECK_TYPE(bounds, PS_TYPE_F32, NULL);
     1877    PS_ASSERT_VECTOR_NON_NULL(bounds, NULL);
     1878    PS_ASSERT_VECTOR_TYPE(bounds, PS_TYPE_F32, NULL);
    18791879    PS_INT_COMPARE(2, bounds->n, NULL);
    18801880
    … …  
    19301930                          psF32 error)
    19311931{
    1932     PS_PTR_CHECK_NULL(out, -1);
    1933     PS_PTR_CHECK_NULL(out->bounds, -1);
    1934     PS_PTR_CHECK_NULL(out->nums, -1);
    1935     PS_INT_CHECK_RANGE(binNum, 0, ((out->nums->n)-1), -2);
     1932    PS_ASSERT_PTR_NON_NULL(out, -1);
     1933    PS_ASSERT_PTR_NON_NULL(out->bounds, -1);
     1934    PS_ASSERT_PTR_NON_NULL(out->nums, -1);
     1935    PS_ASSERT_INT_WITHIN_RANGE(binNum, 0, ((out->nums->n)-1), -2);
    19361936    PS_FLOAT_COMPARE(0.0, error, -3);
    1937     PS_FLOAT_CHECK_RANGE(data, out->bounds->data.F32[0], out->bounds->data.F32[(out->bounds->n)-1], -4);
     1937    PS_ASSERT_FLOAT_WITHIN_RANGE(data, out->bounds->data.F32[0], out->bounds->data.F32[(out->bounds->n)-1], -4);
    19381938
    19391939    psF32 boxcarWidth = 2.35 * error;
    … …  
    20192019                               psU32 maskVal)
    20202020{
    2021     PS_PTR_CHECK_NULL(out, NULL);
    2022     PS_VECTOR_CHECK_NULL(out->bounds, NULL);
    2023     PS_VECTOR_CHECK_TYPE(out->bounds, PS_TYPE_F32, NULL);
    2024     PS_INT_CHECK_NON_NEGATIVE(out->bounds->n, NULL);
    2025     PS_VECTOR_CHECK_NULL(out->nums, NULL);
    2026     PS_VECTOR_CHECK_TYPE(out->nums, PS_TYPE_F32, NULL);
    2027     PS_INT_CHECK_NON_NEGATIVE(out->nums->n, NULL);
    2028     PS_VECTOR_CHECK_NULL(in, out);
     2021    PS_ASSERT_PTR_NON_NULL(out, NULL);
     2022    PS_ASSERT_VECTOR_NON_NULL(out->bounds, NULL);
     2023    PS_ASSERT_VECTOR_TYPE(out->bounds, PS_TYPE_F32, NULL);
     2024    PS_ASSERT_INT_NONNEGATIVE(out->bounds->n, NULL);
     2025    PS_ASSERT_VECTOR_NON_NULL(out->nums, NULL);
     2026    PS_ASSERT_VECTOR_TYPE(out->nums, PS_TYPE_F32, NULL);
     2027    PS_ASSERT_INT_NONNEGATIVE(out->nums->n, NULL);
     2028    PS_ASSERT_VECTOR_NON_NULL(in, out);
    20292029    if (mask != NULL) {
    2030         PS_VECTOR_CHECK_SIZE_EQUAL(in, mask, NULL);
    2031         PS_VECTOR_CHECK_TYPE(mask, PS_TYPE_U8, NULL);
     2030        PS_ASSERT_VECTORS_SIZE_EQUAL(in, mask, NULL);
     2031        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, NULL);
    20322032    }
    20332033    if (errors != NULL) {
    2034         PS_VECTOR_CHECK_SIZE_EQUAL(in, errors, NULL);
    2035         PS_VECTOR_CHECK_TYPE(errors, in->type.type, NULL);
     2034        PS_ASSERT_VECTORS_SIZE_EQUAL(in, errors, NULL);
     2035        PS_ASSERT_VECTOR_TYPE(errors, in->type.type, NULL);
    20362036    }
    20372037
    … …  
    22162216                       psU32 maskVal)
    22172217{
    2218     PS_PTR_CHECK_NULL(stats, NULL);
    2219     PS_VECTOR_CHECK_NULL(in, stats);
     2218    PS_ASSERT_PTR_NON_NULL(stats, NULL);
     2219    PS_ASSERT_VECTOR_NON_NULL(in, stats);
    22202220    if (mask != NULL) {
    2221         PS_VECTOR_CHECK_SIZE_EQUAL(mask, in, stats);
    2222         PS_VECTOR_CHECK_TYPE(mask, PS_TYPE_U8, stats);
     2221        PS_ASSERT_VECTORS_SIZE_EQUAL(mask, in, stats);
     2222        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, stats);
    22232223    }
    22242224    if (errors != NULL) {
    2225         PS_VECTOR_CHECK_SIZE_EQUAL(errors, in, stats);
    2226         PS_VECTOR_CHECK_TYPE(errors, in->type.type, stats);
     2225        PS_ASSERT_VECTORS_SIZE_EQUAL(errors, in, stats);
     2226        PS_ASSERT_VECTOR_TYPE(errors, in->type.type, stats);
    22272227    }
    22282228

  • trunk/psLib/src/dataManip/psUnaryOp.c

    r3887 r4029  
    3030 *  @author Robert DeSonia, MHPCC
    3131 *
    32  *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
    33  *  @date $Date: 2005-05-12 00:54:49 $
     32 *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
     33 *  @date $Date: 2005-05-25 20:26:55 $
    3434 *
    3535 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    315315    psType* psTypeIn = (psType* ) in;
    316316
    317     PS_PTR_CHECK_NULL_GENERAL(in, psUnaryOp_EXIT);
    318     PS_PTR_CHECK_NULL_GENERAL(op, psUnaryOp_EXIT);
     317    PS_ASSERT_GENERAL_PTR_NON_NULL(in, psUnaryOp_EXIT);
     318    PS_ASSERT_GENERAL_PTR_NON_NULL(op, psUnaryOp_EXIT);
    319319
    320320    psDimen dimIn = psTypeIn->dimen;

  • trunk/psLib/src/image/psImageStats.c

    r3884 r4029  
    99 *  @author GLG, MHPCC
    1010 *
    11  *  @version $Revision: 1.73 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2005-05-11 22:02:16 $
     11 *  @version $Revision: 1.74 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2005-05-25 20:26:55 $
    1313 *
    1414 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    5252    psVector *junkMask = NULL;
    5353
    54     PS_PTR_CHECK_NULL(stats, NULL);
    55     PS_INT_CHECK_ZERO(stats->options, NULL);
    56     PS_IMAGE_CHECK_NULL(in, NULL)
     54    PS_ASSERT_PTR_NON_NULL(stats, NULL);
     55    PS_ASSERT_INT_NONZERO(stats->options, NULL);
     56    PS_ASSERT_IMAGE_NON_NULL(in, NULL)
    5757    if (mask != NULL) {
    58         PS_IMAGE_CHECK_TYPE(mask, PS_TYPE_U8, NULL);
    59         PS_IMAGE_CHECK_SIZE_EQUAL(in, mask, NULL);
     58        PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_U8, NULL);
     59        PS_ASSERT_IMAGES_SIZE_EQUAL(in, mask, NULL);
    6060    }
    6161
    … …  
    124124                              psU32 maskVal)
    125125{
    126     PS_PTR_CHECK_NULL(out, NULL);
    127     PS_PTR_CHECK_NULL(in, NULL);
     126    PS_ASSERT_PTR_NON_NULL(out, NULL);
     127    PS_ASSERT_PTR_NON_NULL(in, NULL);
    128128    if (mask != NULL) {
    129         PS_IMAGE_CHECK_TYPE(mask, PS_TYPE_U8, NULL);
    130         PS_IMAGE_CHECK_SIZE_EQUAL(in, mask, NULL);
     129        PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_U8, NULL);
     130        PS_ASSERT_IMAGES_SIZE_EQUAL(in, mask, NULL);
    131131    }
    132132    psVector* junkData = NULL;
    … …  
    200200double* calcScaleFactors(psS32 n)
    201201{
    202     PS_INT_CHECK_NON_NEGATIVE(n, NULL);
     202    PS_ASSERT_INT_NONNEGATIVE(n, NULL);
    203203    psS32 i = 0;
    204204    double tmp = 0.0;
    … …  
    217217psPolynomial1D **p_psCreateChebyshevPolys(psS32 maxChebyPoly)
    218218{
    219     PS_INT_CHECK_POSITIVE(maxChebyPoly, NULL);
     219    PS_ASSERT_INT_POSITIVE(maxChebyPoly, NULL);
    220220    psPolynomial1D **chebPolys = NULL;
    221221    psS32 i = 0;
    … …  
    265265                                     const psImage* input)
    266266{
    267     PS_IMAGE_CHECK_NULL(input, NULL);
    268     PS_IMAGE_CHECK_EMPTY(input, NULL);
     267    PS_ASSERT_IMAGE_NON_NULL(input, NULL);
     268    PS_ASSERT_IMAGE_NON_EMPTY(input, NULL);
    269269    if ((input->type.type != PS_TYPE_S8) &&
    270270            (input->type.type != PS_TYPE_U16) &&
    … …  
    273273        psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Unallowable image type.\n");
    274274    }
    275     PS_POLY_CHECK_NULL(coeffs, NULL);
    276     PS_POLY_CHECK_TYPE(coeffs, PS_POLYNOMIAL_CHEB, NULL);
     275    PS_ASSERT_POLY_NON_NULL(coeffs, NULL);
     276    PS_ASSERT_POLY_TYPE(coeffs, PS_POLYNOMIAL_CHEB, NULL);
    277277    psS32 x = 0;
    278278    psS32 y = 0;
    … …  
    388388        const psImage* input)
    389389{
    390     PS_IMAGE_CHECK_NULL(input, NULL);
    391     PS_IMAGE_CHECK_EMPTY(input, NULL);
     390    PS_ASSERT_IMAGE_NON_NULL(input, NULL);
     391    PS_ASSERT_IMAGE_NON_EMPTY(input, NULL);
    392392    if ((input->type.type != PS_TYPE_S8) &&
    393393            (input->type.type != PS_TYPE_U16) &&
    … …  
    396396        psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Unallowable image type.\n");
    397397    }
    398     PS_POLY_CHECK_NULL(coeffs, NULL);
    399     PS_POLY_CHECK_TYPE(coeffs, PS_POLYNOMIAL_CHEB, NULL);
     398    PS_ASSERT_POLY_NON_NULL(coeffs, NULL);
     399    PS_ASSERT_POLY_TYPE(coeffs, PS_POLYNOMIAL_CHEB, NULL);
    400400    psS32 x = 0;
    401401    psS32 y = 0;
    … …  
    519519                                     const psPolynomial2D* coeffs)
    520520{
    521     PS_POLY_CHECK_TYPE(coeffs, PS_POLYNOMIAL_CHEB, NULL);
     521    PS_ASSERT_POLY_TYPE(coeffs, PS_POLYNOMIAL_CHEB, NULL);
    522522
    523523    psS32 x = 0;
    … …  
    586586                                    const psPolynomial2D* coeffs)
    587587{
    588     PS_POLY_CHECK_TYPE(coeffs, PS_POLYNOMIAL_ORD, NULL);
     588    PS_ASSERT_POLY_TYPE(coeffs, PS_POLYNOMIAL_ORD, NULL);
    589589
    590590    for (int row = 0; row < input->numRows ; row++) {
    … …  
    613613                               const psPolynomial2D* coeffs)
    614614{
    615     PS_IMAGE_CHECK_NULL(input, NULL);
    616     PS_IMAGE_CHECK_EMPTY(input, NULL);
     615    PS_ASSERT_IMAGE_NON_NULL(input, NULL);
     616    PS_ASSERT_IMAGE_NON_EMPTY(input, NULL);
    617617    if ((input->type.type != PS_TYPE_S8) &&
    618618            (input->type.type != PS_TYPE_U16) &&
    … …  
    622622                "Unallowable image type.\n");
    623623    }
    624     PS_POLY_CHECK_NULL(coeffs, NULL);
     624    PS_ASSERT_POLY_NON_NULL(coeffs, NULL);
    625625
    626626    if (coeffs->type == PS_POLYNOMIAL_ORD) {

  • trunk/psLib/src/imageops/psImageStats.c

    r3884 r4029  
    99 *  @author GLG, MHPCC
    1010 *
    11  *  @version $Revision: 1.73 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2005-05-11 22:02:16 $
     11 *  @version $Revision: 1.74 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2005-05-25 20:26:55 $
    1313 *
    1414 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    5252    psVector *junkMask = NULL;
    5353
    54     PS_PTR_CHECK_NULL(stats, NULL);
    55     PS_INT_CHECK_ZERO(stats->options, NULL);
    56     PS_IMAGE_CHECK_NULL(in, NULL)
     54    PS_ASSERT_PTR_NON_NULL(stats, NULL);
     55    PS_ASSERT_INT_NONZERO(stats->options, NULL);
     56    PS_ASSERT_IMAGE_NON_NULL(in, NULL)
    5757    if (mask != NULL) {
    58         PS_IMAGE_CHECK_TYPE(mask, PS_TYPE_U8, NULL);
    59         PS_IMAGE_CHECK_SIZE_EQUAL(in, mask, NULL);
     58        PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_U8, NULL);
     59        PS_ASSERT_IMAGES_SIZE_EQUAL(in, mask, NULL);
    6060    }
    6161
    … …  
    124124                              psU32 maskVal)
    125125{
    126     PS_PTR_CHECK_NULL(out, NULL);
    127     PS_PTR_CHECK_NULL(in, NULL);
     126    PS_ASSERT_PTR_NON_NULL(out, NULL);
     127    PS_ASSERT_PTR_NON_NULL(in, NULL);
    128128    if (mask != NULL) {
    129         PS_IMAGE_CHECK_TYPE(mask, PS_TYPE_U8, NULL);
    130         PS_IMAGE_CHECK_SIZE_EQUAL(in, mask, NULL);
     129        PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_U8, NULL);
     130        PS_ASSERT_IMAGES_SIZE_EQUAL(in, mask, NULL);
    131131    }
    132132    psVector* junkData = NULL;
    … …  
    200200double* calcScaleFactors(psS32 n)
    201201{
    202     PS_INT_CHECK_NON_NEGATIVE(n, NULL);
     202    PS_ASSERT_INT_NONNEGATIVE(n, NULL);
    203203    psS32 i = 0;
    204204    double tmp = 0.0;
    … …  
    217217psPolynomial1D **p_psCreateChebyshevPolys(psS32 maxChebyPoly)
    218218{
    219     PS_INT_CHECK_POSITIVE(maxChebyPoly, NULL);
     219    PS_ASSERT_INT_POSITIVE(maxChebyPoly, NULL);
    220220    psPolynomial1D **chebPolys = NULL;
    221221    psS32 i = 0;
    … …  
    265265                                     const psImage* input)
    266266{
    267     PS_IMAGE_CHECK_NULL(input, NULL);
    268     PS_IMAGE_CHECK_EMPTY(input, NULL);
     267    PS_ASSERT_IMAGE_NON_NULL(input, NULL);
     268    PS_ASSERT_IMAGE_NON_EMPTY(input, NULL);
    269269    if ((input->type.type != PS_TYPE_S8) &&
    270270            (input->type.type != PS_TYPE_U16) &&
    … …  
    273273        psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Unallowable image type.\n");
    274274    }
    275     PS_POLY_CHECK_NULL(coeffs, NULL);
    276     PS_POLY_CHECK_TYPE(coeffs, PS_POLYNOMIAL_CHEB, NULL);
     275    PS_ASSERT_POLY_NON_NULL(coeffs, NULL);
     276    PS_ASSERT_POLY_TYPE(coeffs, PS_POLYNOMIAL_CHEB, NULL);
    277277    psS32 x = 0;
    278278    psS32 y = 0;
    … …  
    388388        const psImage* input)
    389389{
    390     PS_IMAGE_CHECK_NULL(input, NULL);
    391     PS_IMAGE_CHECK_EMPTY(input, NULL);
     390    PS_ASSERT_IMAGE_NON_NULL(input, NULL);
     391    PS_ASSERT_IMAGE_NON_EMPTY(input, NULL);
    392392    if ((input->type.type != PS_TYPE_S8) &&
    393393            (input->type.type != PS_TYPE_U16) &&
    … …  
    396396        psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Unallowable image type.\n");
    397397    }
    398     PS_POLY_CHECK_NULL(coeffs, NULL);
    399     PS_POLY_CHECK_TYPE(coeffs, PS_POLYNOMIAL_CHEB, NULL);
     398    PS_ASSERT_POLY_NON_NULL(coeffs, NULL);
     399    PS_ASSERT_POLY_TYPE(coeffs, PS_POLYNOMIAL_CHEB, NULL);
    400400    psS32 x = 0;
    401401    psS32 y = 0;
    … …  
    519519                                     const psPolynomial2D* coeffs)
    520520{
    521     PS_POLY_CHECK_TYPE(coeffs, PS_POLYNOMIAL_CHEB, NULL);
     521    PS_ASSERT_POLY_TYPE(coeffs, PS_POLYNOMIAL_CHEB, NULL);
    522522
    523523    psS32 x = 0;
    … …  
    586586                                    const psPolynomial2D* coeffs)
    587587{
    588     PS_POLY_CHECK_TYPE(coeffs, PS_POLYNOMIAL_ORD, NULL);
     588    PS_ASSERT_POLY_TYPE(coeffs, PS_POLYNOMIAL_ORD, NULL);
    589589
    590590    for (int row = 0; row < input->numRows ; row++) {
    … …  
    613613                               const psPolynomial2D* coeffs)
    614614{
    615     PS_IMAGE_CHECK_NULL(input, NULL);
    616     PS_IMAGE_CHECK_EMPTY(input, NULL);
     615    PS_ASSERT_IMAGE_NON_NULL(input, NULL);
     616    PS_ASSERT_IMAGE_NON_EMPTY(input, NULL);
    617617    if ((input->type.type != PS_TYPE_S8) &&
    618618            (input->type.type != PS_TYPE_U16) &&
    … …  
    622622                "Unallowable image type.\n");
    623623    }
    624     PS_POLY_CHECK_NULL(coeffs, NULL);
     624    PS_ASSERT_POLY_NON_NULL(coeffs, NULL);
    625625
    626626    if (coeffs->type == PS_POLYNOMIAL_ORD) {

  • trunk/psLib/src/math/psBinaryOp.c

    r3182 r4029  
    3030 *  @author Robert DeSonia, MHPCC
    3131 *
    32  *  @version $Revision: 1.1 $ $Name: not supported by cvs2svn $
    33  *  @date $Date: 2005-02-10 02:36:41 $
     32 *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
     33 *  @date $Date: 2005-05-25 20:26:55 $
    3434 *
    3535 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    439439                            }
    440440
    441     PS_PTR_CHECK_NULL_GENERAL(input1, psBinaryOp_EXIT);
    442     PS_PTR_CHECK_NULL_GENERAL(input2, psBinaryOp_EXIT);
    443     PS_PTR_CHECK_NULL_GENERAL(op, psBinaryOp_EXIT);
    444 
    445     PS_PTR_CHECK_TYPE_EQUAL_GENERAL(input1,input2, psBinaryOp_EXIT);
    446 
    447     PS_PTR_CHECK_DIMEN_GENERAL_NOT(input1, PS_DIMEN_OTHER, psBinaryOp_EXIT);
    448     PS_PTR_CHECK_DIMEN_GENERAL_NOT(input2, PS_DIMEN_OTHER, psBinaryOp_EXIT);
     441    PS_ASSERT_GENERAL_PTR_NON_NULL(input1, psBinaryOp_EXIT);
     442    PS_ASSERT_GENERAL_PTR_NON_NULL(input2, psBinaryOp_EXIT);
     443    PS_ASSERT_GENERAL_PTR_NON_NULL(op, psBinaryOp_EXIT);
     444
     445    PS_ASSERT_PTRS_TYPE_EQUAL_GENERAL(input1,input2, psBinaryOp_EXIT);
     446
     447    PS_ASSERT_PTR_DIMEN_GENERAL_NOT(input1, PS_DIMEN_OTHER, psBinaryOp_EXIT);
     448    PS_ASSERT_PTR_DIMEN_GENERAL_NOT(input2, PS_DIMEN_OTHER, psBinaryOp_EXIT);
    449449
    450450    psType* psType1 = (psType*)in1;

  • trunk/psLib/src/math/psConstants.h

    r4028 r4029  
    66 *  @author GLG, MHPCC
    77 *
    8  *  @version $Revision: 1.68 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2005-05-25 19:25:29 $
     8 *  @version $Revision: 1.69 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2005-05-25 20:26:55 $
    1010 *
    1111 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    5959*****************************************************************************/
    6060
    61 #define PS_INT_CHECK_EQUALS(NAME1, NAME2, RVAL) \
     61#define PS_ASSERT_INT_UNEQUAL(NAME1, NAME2, RVAL) \
    6262if (NAME1 == NAME2) { \
    6363    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    … …  
    6767}
    6868
    69 #define PS_INT_CHECK_NON_EQUALS(NAME1, NAME2, RVAL) \
     69#define PS_ASSERT_INT_EQUAL(NAME1, NAME2, RVAL) \
    7070if (NAME1 != NAME2) { \
    7171    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    … …  
    7676
    7777// Return an error if the arg is less than zero.
    78 #define PS_INT_CHECK_NEGATIVE(NAME, RVAL) \
     78#define PS_ASSERT_INT_NONNEGATIVE(NAME, RVAL) \
    7979if (NAME < 0) { \
    8080    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    … …  
    8686// XXX: This naming scheme is opposite most other macros.  This should be
    8787// corrected as soon as a fresh checkin/out can be performed.
    88 #define PS_INT_CHECK_NON_NEGATIVE(NAME, RVAL) \
     88#define PS_ASSERT_INT_NONNEGATIVE(NAME, RVAL) \
    8989if (NAME < 0) { \
    9090    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    … …  
    9696// XXX: This naming scheme is opposite most other macros.  This should be
    9797// corrected as soon as a fresh checkin/out can be performed.
    98 #define PS_INT_CHECK_POSITIVE(NAME, RVAL) \
     98#define PS_ASSERT_INT_POSITIVE(NAME, RVAL) \
    9999if (NAME < 1) { \
    100100    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    … …  
    104104
    105105// Return an error if the arg is not equal to zero.
    106 #define PS_INT_CHECK_NON_ZERO(NAME, RVAL) \
     106#define PS_ASSERT_INT_ZERO(NAME, RVAL) \
    107107if (NAME != 0) { \
    108108    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    … …  
    112112
    113113// Return an error if the arg is equal to zero.
    114 #define PS_INT_CHECK_ZERO(NAME, RVAL) \
     114#define PS_ASSERT_INT_NONZERO(NAME, RVAL) \
    115115if (NAME == 0) { \
    116116    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    … …  
    120120
    121121// Return an error if the arg is lies outside the supplied range.
    122 #define PS_INT_CHECK_RANGE(NAME, LOWER, UPPER, RVAL) \
     122#define PS_ASSERT_INT_WITHIN_RANGE(NAME, LOWER, UPPER, RVAL) \
    123123if ((int)NAME < LOWER || (int)NAME > UPPER) { \
    124124    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    … …  
    148148// Generate an error if the two floats are equal.
    149149// XXX: Inconsistent naming.
    150 #define PS_FLOAT_CHECK_NON_EQUAL(NAME1, NAME2, RVAL) \
     150#define PS_ASSERT_FLOAT_NON_EQUAL(NAME1, NAME2, RVAL) \
    151151if (fabs(NAME2 - NAME1) < FLT_EPSILON) { \
    152152    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    … …  
    157157
    158158// Return an error if the arg is lies outside the supplied range.
    159 #define PS_FLOAT_CHECK_RANGE(NAME, LOWER, UPPER, RVAL) \
     159#define PS_ASSERT_FLOAT_WITHIN_RANGE(NAME, LOWER, UPPER, RVAL) \
    160160if ((NAME) < (LOWER) || (NAME) > (UPPER)) { \
    161161    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    … …  
    169169the wrong type.
    170170*****************************************************************************/
    171 #define PS_PTR_CHECK_NULL(NAME, RVAL) PS_PTR_CHECK_NULL_GENERAL(NAME, return RVAL)
    172 #define PS_PTR_CHECK_NULL_GENERAL(NAME, CLEANUP) \
     171#define PS_ASSERT_PTR_NON_NULL(NAME, RVAL) PS_ASSERT_GENERAL_PTR_NON_NULL(NAME, return RVAL)
     172#define PS_ASSERT_GENERAL_PTR_NON_NULL(NAME, CLEANUP) \
    173173if (NAME == NULL) { \
    174174    psError(PS_ERR_BAD_PARAMETER_NULL, true, \
    … …  
    178178}
    179179
    180 #define PS_PTR_CHECK_TYPE(NAME, TYPE, RVAL) \
     180#define PS_ASSERT_PTR_TYPE(NAME, TYPE, RVAL) \
    181181if (NAME->type.type != TYPE) { \
    182182    psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
    … …  
    186186}
    187187
    188 #define PS_PTR_CHECK_DIMEN(NAME, DIMEN, RVAL) PS_PTR_CHECK_DIMEN_GENERAL(NAME, DIMEN, return RVAL)
    189 #define PS_PTR_CHECK_DIMEN_GENERAL(NAME, DIMEN, CLEANUP) \
     188#define PS_ASSERT_PTR_DIMEN(NAME, DIMEN, RVAL) PS_ASSERT_GENERAL_PTR_DIMEN(NAME, DIMEN, return RVAL)
     189#define PS_ASSERT_GENERAL_PTR_DIMEN(NAME, DIMEN, CLEANUP) \
    190190if (NAME->type.dimen != DIMEN) { \
    191191    psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
    … …  
    195195}
    196196
    197 #define PS_PTR_CHECK_DIMEN_GENERAL_NOT(NAME, DIMEN, CLEANUP) \
     197#define PS_ASSERT_PTR_DIMEN_GENERAL_NOT(NAME, DIMEN, CLEANUP) \
    198198if (NAME->type.dimen == DIMEN) { \
    199199    psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
    … …  
    204204
    205205
    206 #define PS_PTR_CHECK_SIZE_EQUAL(PTR1, PTR2, RVAL) \
     206#define PS_ASSERT_PTRS_SIZE_EQUAL(PTR1, PTR2, RVAL) \
    207207if (PTR1->n != PTR2->n) { \
    208208    psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
    … …  
    212212}
    213213
    214 #define PS_PTR_CHECK_TYPE_EQUAL(PTR1, PTR2, RVAL) PS_PTR_CHECK_TYPE_EQUAL_GENERAL(PTR1, PTR2, return RVAL)
    215 
    216 #define PS_PTR_CHECK_TYPE_EQUAL_GENERAL(PTR1, PTR2, CLEANUP) \
     214#define PS_ASSERT_PTR_TYPE_EQUAL(PTR1, PTR2, RVAL) PS_ASSERT_PTRS_TYPE_EQUAL_GENERAL(PTR1, PTR2, return RVAL)
     215#define PS_ASSERT_PTRS_TYPE_EQUAL_GENERAL(PTR1, PTR2, CLEANUP) \
    217216if (PTR1->type.type != PTR2->type.type) { \
    218217    psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
    … …  
    226225    PS_VECTOR macros:
    227226 *****************************************************************************/
    228 #define PS_VECTOR_CHECK_NULL(NAME, RVAL) PS_VECTOR_CHECK_NULL_GENERAL(NAME, return RVAL)
    229 #define PS_VECTOR_CHECK_NULL_GENERAL(NAME, CLEANUP) \
     227#define PS_ASSERT_VECTOR_NON_NULL(NAME, RVAL) PS_ASSERT_GENERAL_VECTOR_NON_NULL(NAME, return RVAL)
     228#define PS_ASSERT_GENERAL_VECTOR_NON_NULL(NAME, CLEANUP) \
    230229if (NAME == NULL || NAME->data.U8 == NULL) { \
    231230    psError(PS_ERR_BAD_PARAMETER_NULL, true, \
    … …  
    235234} \
    236235
    237 #define PS_VECTOR_CHECK_EMPTY(NAME, RVAL) PS_VECTOR_CHECK_EMPTY_GENERAL(NAME, return RVAL)
    238 #define PS_VECTOR_CHECK_EMPTY_GENERAL(NAME, CLEANUP) \
     236#define PS_ASSERT_VECTOR_NON_EMPTY(NAME, RVAL) PS_ASSERT_GENERAL_VECTOR_NON_EMPTY(NAME, return RVAL)
     237#define PS_ASSERT_GENERAL_VECTOR_NON_EMPTY(NAME, CLEANUP) \
    239238if (NAME->n < 1) { \
    240239    psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
    … …  
    244243} \
    245244
    246 #define PS_VECTOR_CHECK_TYPE_F32_OR_F64(NAME, RVAL) \
     245#define PS_ASSERT_VECTOR_TYPE_F32_OR_F64(NAME, RVAL) \
    247246if ((NAME->type.type != PS_TYPE_F32) && (NAME->type.type != PS_TYPE_F64)) { \
    248247    psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
    … …  
    252251} \
    253252
    254 #define PS_VECTOR_CHECK_TYPE_S16_S32_F32(NAME, RVAL) \
     253#define PS_ASSERT_VECTOR_TYPE_S16_S32_F32(NAME, RVAL) \
    255254if ((NAME->type.type != PS_TYPE_S16) && (NAME->type.type != PS_TYPE_S32) && (NAME->type.type != PS_TYPE_F32)) { \
    256255    psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
    … …  
    260259} \
    261260
    262 #define PS_VECTOR_CHECK_TYPE(NAME, TYPE, RVAL) \
     261#define PS_ASSERT_VECTOR_TYPE(NAME, TYPE, RVAL) \
    263262if (NAME->type.type != TYPE) { \
    264263    psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
    … …  
    268267}
    269268
    270 #define PS_VECTOR_CHECK_SIZE_EQUAL(VEC1, VEC2, RVAL) \
     269#define PS_ASSERT_VECTORS_SIZE_EQUAL(VEC1, VEC2, RVAL) \
    271270if (VEC1->n != VEC2->n) { \
    272271    psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
    … …  
    276275}
    277276
    278 #define PS_VECTOR_CHECK_TYPE_EQUAL(VEC1, VEC2, RVAL) \
     277#define PS_ASSERT_VECTOR_TYPE_EQUAL(VEC1, VEC2, RVAL) \
    279278if (VEC1->type.type != VEC2->type.type) { \
    280279    psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
    … …  
    428427    PS_POLY macros:
    429428*****************************************************************************/
    430 #define PS_POLY_CHECK_NULL(NAME, RVAL) \
     429#define PS_ASSERT_POLY_NON_NULL(NAME, RVAL) \
    431430if (NAME == NULL || NAME->coeff == NULL) { \
    432431    psError(PS_ERR_BAD_PARAMETER_NULL, true, \
    … …  
    436435} \
    437436
    438 #define PS_POLY_CHECK_TYPE(NAME, TYPE, RVAL) \
     437#define PS_ASSERT_POLY_TYPE(NAME, TYPE, RVAL) \
    439438if (NAME->type != TYPE) { \
    440439    psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
    … …  
    508507    PS_IMAGE macros:
    509508*****************************************************************************/
    510 #define PS_IMAGE_CHECK_NULL(NAME, RVAL) PS_IMAGE_CHECK_NULL_GENERAL(NAME, return RVAL)
    511 #define PS_IMAGE_CHECK_NULL_GENERAL(NAME, CLEANUP) \
     509#define PS_ASSERT_IMAGE_NON_NULL(NAME, RVAL) PS_ASSERT_GENERAL_IMAGE_NON_NULL(NAME, return RVAL)
     510#define PS_ASSERT_GENERAL_IMAGE_NON_NULL(NAME, CLEANUP) \
    512511if (NAME == NULL || NAME->data.V == NULL) { \
    513512    psError(PS_ERR_BAD_PARAMETER_NULL, true, \
    … …  
    517516}
    518517
    519 #define PS_IMAGE_CHECK_EMPTY(NAME, RVAL) PS_IMAGE_CHECK_EMPTY_GENERAL(NAME, return RVAL)
    520 #define PS_IMAGE_CHECK_EMPTY_GENERAL(NAME, CLEANUP) \
     518#define PS_ASSERT_IMAGE_NON_EMPTY(NAME, RVAL) PS_ASSERT_GENERAL_IMAGE_NON_EMPTY(NAME, return RVAL)
     519#define PS_ASSERT_GENERAL_IMAGE_NON_EMPTY(NAME, CLEANUP) \
    521520if (NAME->numCols < 1 || NAME->numRows < 1) { \
    522521    psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
    … …  
    526525}
    527526
    528 #define PS_IMAGE_CHECK_TYPE(NAME, TYPE, RVAL) \
     527#define PS_ASSERT_IMAGE_TYPE(NAME, TYPE, RVAL) \
    529528if (NAME->type.type != TYPE) { \
    530529    psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
    … …  
    534533}
    535534
    536 #define PS_IMAGE_CHECK_SIZE_EQUAL(NAME1, NAME2, RVAL) \
     535#define PS_ASSERT_IMAGES_SIZE_EQUAL(NAME1, NAME2, RVAL) \
    537536if ((NAME1->numCols != NAME2->numCols) || \
    538537        (NAME1->numRows != NAME2->numRows)) { \
    … …  
    543542}
    544543
    545 #define PS_IMAGE_CHECK_SIZE(NAME1, NUM_COLS, NUM_ROWS, RVAL) \
     544#define PS_ASSERT_IMAGE_SIZE(NAME1, NUM_COLS, NUM_ROWS, RVAL) \
    546545if ((NAME1->numCols != NUM_COLS) || \
    547546        (NAME1->numRows != NUM_ROWS)) { \
    … …  
    634633    PS_READOUT macros:
    635634*****************************************************************************/
    636 #define PS_READOUT_CHECK_NULL(NAME, RVAL) \
     635#define PS_ASSERT_READOUT_NON_NULL(NAME, RVAL) \
    637636if (NAME == NULL || NAME->image == NULL) { \
    638637    psError(PS_ERR_BAD_PARAMETER_NULL, true, \
    … …  
    642641}
    643642
    644 #define PS_READOUT_CHECK_EMPTY(NAME, RVAL) \
     643#define PS_ASSERT_READOUT_NON_EMPTY(NAME, RVAL) \
    645644if (NAME->image->numCols < 1 || NAME->image->numRows < 1) { \
    646645    psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
    … …  
    649648}
    650649
    651 #define PS_READOUT_CHECK_TYPE(NAME, TYPE, RVAL) \
     650#define PS_ASSERT_READOUT_TYPE(NAME, TYPE, RVAL) \
    652651if (NAME->image->type.type != TYPE) { \
    653652    psError(PS_ERR_BAD_PARAMETER_TYPE, true, \

  • trunk/psLib/src/math/psMatrix.c

    r3880 r4029  
    2121 *  @author Robert DeSonia, MHPCC
    2222 *
    23  *  @version $Revision: 1.28 $ $Name: not supported by cvs2svn $
    24  *  @date $Date: 2005-05-11 02:29:39 $
     23 *  @version $Revision: 1.29 $ $Name: not supported by cvs2svn $
     24 *  @date $Date: 2005-05-25 20:26:55 $
    2525 *
    2626 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    188188
    189189    // Error checks
    190     PS_IMAGE_CHECK_NULL_GENERAL(inImage, psMatrixLUD_EXIT);
     190    PS_ASSERT_GENERAL_IMAGE_NON_NULL(inImage, psMatrixLUD_EXIT);
    191191    PS_CHECK_POINTERS(inImage, outImage, psMatrixLUD_EXIT);
    192192    PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, psMatrixLUD_EXIT);
    193     PS_PTR_CHECK_NULL_GENERAL(outPerm, psMatrixLUD_EXIT);
     193    PS_ASSERT_GENERAL_PTR_NON_NULL(outPerm, psMatrixLUD_EXIT);
    194194
    195195    outImage = psImageRecycle(outImage, inImage->numCols, inImage->numRows, inImage->type.type);
    … …  
    247247
    248248    // Error checks
    249     PS_IMAGE_CHECK_NULL_GENERAL(inImage, LUSOLVE_CLEANUP);
     249    PS_ASSERT_GENERAL_IMAGE_NON_NULL(inImage, LUSOLVE_CLEANUP);
    250250    PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, LUSOLVE_CLEANUP);
    251     PS_IMAGE_CHECK_EMPTY_GENERAL(inImage, LUSOLVE_CLEANUP);
    252     PS_VECTOR_CHECK_NULL_GENERAL(inVector, LUSOLVE_CLEANUP);
     251    PS_ASSERT_GENERAL_IMAGE_NON_EMPTY(inImage, LUSOLVE_CLEANUP);
     252    PS_ASSERT_GENERAL_VECTOR_NON_NULL(inVector, LUSOLVE_CLEANUP);
    253253    PS_CHECK_DIMEN_AND_TYPE(inVector, PS_DIMEN_VECTOR, LUSOLVE_CLEANUP);
    254     PS_VECTOR_CHECK_NULL_GENERAL(inPerm, LUSOLVE_CLEANUP);
     254    PS_ASSERT_GENERAL_VECTOR_NON_NULL(inPerm, LUSOLVE_CLEANUP);
    255255
    256256    outVector = psVectorRecycle(outVector, inImage->numRows, inImage->type.type);
    … …  
    300300    #define INVERT_CLEANUP { psFree(outImage); return NULL; }
    301301    // Error checks
    302     PS_PTR_CHECK_NULL_GENERAL(det, INVERT_CLEANUP);
    303     PS_IMAGE_CHECK_NULL_GENERAL(inImage, INVERT_CLEANUP);
     302    PS_ASSERT_GENERAL_PTR_NON_NULL(det, INVERT_CLEANUP);
     303    PS_ASSERT_GENERAL_IMAGE_NON_NULL(inImage, INVERT_CLEANUP);
    304304    PS_CHECK_POINTERS(inImage, outImage, INVERT_CLEANUP);
    305305    PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, INVERT_CLEANUP);
    306     PS_IMAGE_CHECK_EMPTY_GENERAL(inImage, INVERT_CLEANUP);
     306    PS_ASSERT_GENERAL_IMAGE_NON_EMPTY(inImage, INVERT_CLEANUP);
    307307
    308308    outImage = psImageRecycle(outImage, inImage->numCols, inImage->numRows, inImage->type.type);
    … …  
    348348    #define DETERMINANT_EXIT { return NULL; }
    349349    // Error checks
    350     PS_IMAGE_CHECK_NULL_GENERAL(inImage, DETERMINANT_EXIT);
     350    PS_ASSERT_GENERAL_IMAGE_NON_NULL(inImage, DETERMINANT_EXIT);
    351351    PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, DETERMINANT_EXIT);
    352     PS_IMAGE_CHECK_EMPTY_GENERAL(inImage, DETERMINANT_EXIT);
     352    PS_ASSERT_GENERAL_IMAGE_NON_EMPTY(inImage, DETERMINANT_EXIT);
    353353    PS_CHECK_SQUARE(inImage, DETERMINANT_EXIT);
    354354
    … …  
    383383
    384384    // Error checks
    385     PS_IMAGE_CHECK_NULL_GENERAL(inImage1, MULTIPLY_CLEANUP);
    386     PS_IMAGE_CHECK_NULL_GENERAL(inImage2, MULTIPLY_CLEANUP);
    387     PS_IMAGE_CHECK_EMPTY_GENERAL(inImage1, MULTIPLY_CLEANUP);
    388     PS_IMAGE_CHECK_EMPTY_GENERAL(inImage2, MULTIPLY_CLEANUP);
     385    PS_ASSERT_GENERAL_IMAGE_NON_NULL(inImage1, MULTIPLY_CLEANUP);
     386    PS_ASSERT_GENERAL_IMAGE_NON_NULL(inImage2, MULTIPLY_CLEANUP);
     387    PS_ASSERT_GENERAL_IMAGE_NON_EMPTY(inImage1, MULTIPLY_CLEANUP);
     388    PS_ASSERT_GENERAL_IMAGE_NON_EMPTY(inImage2, MULTIPLY_CLEANUP);
    389389    PS_CHECK_DIMEN_AND_TYPE(inImage1, PS_DIMEN_IMAGE, MULTIPLY_CLEANUP);
    390390    PS_CHECK_DIMEN_AND_TYPE(inImage2, PS_DIMEN_IMAGE, MULTIPLY_CLEANUP);
    … …  
    435435    #define TRANSPOSE_CLEANUP { psFree(outImage); return NULL; }
    436436    // Error checks
    437     PS_IMAGE_CHECK_NULL_GENERAL(inImage, TRANSPOSE_CLEANUP);
     437    PS_ASSERT_GENERAL_IMAGE_NON_NULL(inImage, TRANSPOSE_CLEANUP);
    438438    PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, TRANSPOSE_CLEANUP);
    439     PS_IMAGE_CHECK_EMPTY_GENERAL(inImage, TRANSPOSE_CLEANUP);
     439    PS_ASSERT_GENERAL_IMAGE_NON_EMPTY(inImage, TRANSPOSE_CLEANUP);
    440440    PS_CHECK_POINTERS(inImage, outImage, TRANSPOSE_CLEANUP);
    441441
    … …  
    481481    #define EIGENVECTORS_CLEANUP { psFree(outImage); return NULL; }
    482482    // Error checks
    483     PS_IMAGE_CHECK_NULL_GENERAL(inImage, EIGENVECTORS_CLEANUP);
     483    PS_ASSERT_GENERAL_IMAGE_NON_NULL(inImage, EIGENVECTORS_CLEANUP);
    484484    PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, EIGENVECTORS_CLEANUP);
    485     PS_IMAGE_CHECK_EMPTY_GENERAL(inImage, EIGENVECTORS_CLEANUP);
     485    PS_ASSERT_GENERAL_IMAGE_NON_EMPTY(inImage, EIGENVECTORS_CLEANUP);
    486486    PS_CHECK_POINTERS(inImage, outImage, EIGENVECTORS_CLEANUP);
    487487
    … …  
    526526
    527527    // Error checks
    528     PS_IMAGE_CHECK_NULL_GENERAL(inImage, psMatrixToVector_EXIT);
     528    PS_ASSERT_GENERAL_IMAGE_NON_NULL(inImage, psMatrixToVector_EXIT);
    529529    PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, psMatrixToVector_EXIT);
    530     PS_IMAGE_CHECK_EMPTY_GENERAL(inImage, psMatrixToVector_EXIT);
     530    PS_ASSERT_GENERAL_IMAGE_NON_EMPTY(inImage, psMatrixToVector_EXIT);
    531531
    532532    if (inImage->numRows == 1) {
    … …  
    589589    #define VECTORTOMATRIX_CLEANUP {psFree(outImage); return NULL; }
    590590    // Error checks
    591     PS_VECTOR_CHECK_NULL_GENERAL(inVector, VECTORTOMATRIX_CLEANUP);
     591    PS_ASSERT_GENERAL_VECTOR_NON_NULL(inVector, VECTORTOMATRIX_CLEANUP);
    592592
    593593    if (inVector->type.dimen == PS_DIMEN_VECTOR) {
    594594        PS_CHECK_DIMEN_AND_TYPE(inVector, PS_DIMEN_VECTOR, VECTORTOMATRIX_CLEANUP);
    595         PS_VECTOR_CHECK_EMPTY_GENERAL(inVector, VECTORTOMATRIX_CLEANUP);
     595        PS_ASSERT_GENERAL_VECTOR_NON_EMPTY(inVector, VECTORTOMATRIX_CLEANUP);
    596596
    597597        outImage = psImageRecycle(outImage, 1, inVector->n, inVector->type.type);
    … …  
    614614    } else if (inVector->type.dimen == PS_DIMEN_TRANSV) {
    615615        PS_CHECK_DIMEN_AND_TYPE(inVector, PS_DIMEN_TRANSV, VECTORTOMATRIX_CLEANUP);
    616         PS_VECTOR_CHECK_EMPTY_GENERAL(inVector, VECTORTOMATRIX_CLEANUP);
     616        PS_ASSERT_GENERAL_VECTOR_NON_EMPTY(inVector, VECTORTOMATRIX_CLEANUP);
    617617        outImage = psImageRecycle(outImage, inVector->n, 1, inVector->type.type);
    618618        // More checks for PS_DIMEN_TRANSV
    … …  
    632632    }
    633633
    634     PS_IMAGE_CHECK_NULL_GENERAL(outImage, VECTORTOMATRIX_CLEANUP);
     634    PS_ASSERT_GENERAL_IMAGE_NON_NULL(outImage, VECTORTOMATRIX_CLEANUP);
    635635    PS_CHECK_DIMEN_AND_TYPE(outImage, PS_DIMEN_IMAGE, VECTORTOMATRIX_CLEANUP);
    636636

  • trunk/psLib/src/math/psMinimize.c

    r3990 r4029  
    99 *  @author GLG, MHPCC
    1010 *
    11  *  @version $Revision: 1.119 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2005-05-19 23:57:37 $
     11 *  @version $Revision: 1.120 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2005-05-25 20:26:55 $
    1313 *
    1414 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    174174                         psF32 X)
    175175{
    176     PS_PTR_CHECK_NULL(spline, NAN);
    177     PS_INT_CHECK_NON_NEGATIVE(spline->n, NAN);
    178     PS_VECTOR_CHECK_NULL(spline->domains, NAN);
    179     PS_PTR_CHECK_NULL(spline->p_psDeriv2, NAN);
    180     PS_VECTOR_CHECK_NULL(x, NAN);
    181     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F32, NAN);
    182     PS_VECTOR_CHECK_NULL(y, NAN);
    183     PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F32, NAN);
    184     PS_VECTOR_CHECK_TYPE(spline->knots, PS_TYPE_F32, NULL);
     176    PS_ASSERT_PTR_NON_NULL(spline, NAN);
     177    PS_ASSERT_INT_NONNEGATIVE(spline->n, NAN);
     178    PS_ASSERT_VECTOR_NON_NULL(spline->domains, NAN);
     179    PS_ASSERT_PTR_NON_NULL(spline->p_psDeriv2, NAN);
     180    PS_ASSERT_VECTOR_NON_NULL(x, NAN);
     181    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NAN);
     182    PS_ASSERT_VECTOR_NON_NULL(y, NAN);
     183    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F32, NAN);
     184    PS_ASSERT_VECTOR_TYPE(spline->knots, PS_TYPE_F32, NULL);
    185185 
    186186    psS32 n;
    … …  
    258258                                const psVector* yErr)     ///< Errors in coordinates, or NULL
    259259{
    260     PS_VECTOR_CHECK_NULL(y, NULL);
    261     PS_VECTOR_CHECK_TYPE_F32_OR_F64(y, NULL);
     260    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     261    PS_ASSERT_VECTOR_TYPE_F32_OR_F64(y, NULL);
    262262    if (mySpline != NULL) {
    263         PS_VECTOR_CHECK_TYPE(mySpline->knots, PS_TYPE_F32, NULL);
     263        PS_ASSERT_VECTOR_TYPE(mySpline->knots, PS_TYPE_F32, NULL);
    264264    }
    265265
    … …  
    285285        yErr32 = yErr32Static;
    286286    } else {
    287         PS_VECTOR_CHECK_TYPE_F32_OR_F64(yErr, NULL);
     287        PS_ASSERT_VECTOR_TYPE_F32_OR_F64(yErr, NULL);
    288288        PS_VECTOR_CONVERT_F64_TO_F32_STATIC(yErr, yErr32, yErr32Static);
    289289    }
    … …  
    294294        x32 = x32Static;
    295295    } else {
    296         PS_VECTOR_CHECK_TYPE_F32_OR_F64(x, NULL);
     296        PS_ASSERT_VECTOR_TYPE_F32_OR_F64(x, NULL);
    297297        PS_VECTOR_CONVERT_F64_TO_F32_STATIC(x, x32, x32Static);
    298298    }
    299     PS_VECTOR_CHECK_SIZE_EQUAL(x32, y32, NULL);
    300     PS_VECTOR_CHECK_SIZE_EQUAL(yErr32, y32, NULL);
     299    PS_ASSERT_VECTORS_SIZE_EQUAL(x32, y32, NULL);
     300    PS_ASSERT_VECTORS_SIZE_EQUAL(yErr32, y32, NULL);
    301301
    302302    /*
    … …  
    310310        mySpline = psSpline1DAllocGeneric(x32, 3);
    311311    }
    312     PS_PTR_CHECK_NULL(mySpline, NULL);
    313     PS_INT_CHECK_NON_NEGATIVE(mySpline->n, NULL);
     312    PS_ASSERT_PTR_NON_NULL(mySpline, NULL);
     313    PS_ASSERT_INT_NONNEGATIVE(mySpline->n, NULL);
    314314
    315315    if (y32->n != (1 + mySpline->n)) {
    … …  
    440440                                  const psArray *coords)
    441441{
    442     PS_PTR_CHECK_NULL(coords, NULL);
    443     PS_PTR_CHECK_NULL(params, NULL);
     442    PS_ASSERT_PTR_NON_NULL(coords, NULL);
     443    PS_ASSERT_PTR_NON_NULL(params, NULL);
    444444
    445445    psTrace(".psLib.dataManip.psMinimize", 4,
    … …  
    457457        deriv = psImageAlloc(params->n, coords->n, PS_TYPE_F32);
    458458    } else {
    459         PS_IMAGE_CHECK_SIZE(deriv, params->n, coords->n, NULL);
    460         PS_IMAGE_CHECK_TYPE(deriv, PS_TYPE_F32, NULL);
     459        PS_ASSERT_IMAGE_SIZE(deriv, params->n, coords->n, NULL);
     460        PS_ASSERT_IMAGE_TYPE(deriv, PS_TYPE_F32, NULL);
    461461    }
    462462
    … …  
    513513                                  const psArray *coords)
    514514{
    515     PS_PTR_CHECK_NULL(coords, NULL);
    516     PS_PTR_CHECK_NULL(params, NULL);
     515    PS_ASSERT_PTR_NON_NULL(coords, NULL);
     516    PS_ASSERT_PTR_NON_NULL(params, NULL);
    517517
    518518    psF64 normalization = params->data.F32[0];
    … …  
    527527        deriv = psImageAlloc(params->n, coords->n, PS_TYPE_F32);
    528528    } else {
    529         PS_IMAGE_CHECK_SIZE(deriv, 6, coords->n, NULL);
    530         PS_IMAGE_CHECK_TYPE(deriv, PS_TYPE_F32, NULL);
     529        PS_ASSERT_IMAGE_SIZE(deriv, 6, coords->n, NULL);
     530        PS_ASSERT_IMAGE_TYPE(deriv, PS_TYPE_F32, NULL);
    531531    }
    532532
    … …  
    572572                        psMinimizeLMChi2Func func)
    573573{
    574     PS_PTR_CHECK_NULL(min, NULL);
    575     PS_VECTOR_CHECK_NULL(params, NULL);
    576     PS_VECTOR_CHECK_EMPTY(params, NULL);
    577     PS_PTR_CHECK_NULL(x, NULL);
    578     PS_VECTOR_CHECK_NULL(y, NULL);
    579     PS_VECTOR_CHECK_EMPTY(y, NULL);
    580     PS_VECTOR_CHECK_SIZE_EQUAL(x, y, NULL);
    581     PS_PTR_CHECK_NULL(func, NULL);
     574    PS_ASSERT_PTR_NON_NULL(min, NULL);
     575    PS_ASSERT_VECTOR_NON_NULL(params, NULL);
     576    PS_ASSERT_VECTOR_NON_EMPTY(params, NULL);
     577    PS_ASSERT_PTR_NON_NULL(x, NULL);
     578    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     579    PS_ASSERT_VECTOR_NON_EMPTY(y, NULL);
     580    PS_ASSERT_VECTORS_SIZE_EQUAL(x, y, NULL);
     581    PS_ASSERT_PTR_NON_NULL(func, NULL);
    582582
    583583    // this function has test and current values for several things
    … …  
    923923                           psMinimizeLMChi2Func func)
    924924{
    925     PS_PTR_CHECK_NULL(min, NULL);
    926     PS_VECTOR_CHECK_NULL(params, NULL);
    927     PS_VECTOR_CHECK_EMPTY(params, NULL);
    928     PS_PTR_CHECK_NULL(x, NULL);
    929     PS_VECTOR_CHECK_NULL(y, NULL);
    930     PS_VECTOR_CHECK_EMPTY(y, NULL);
    931     PS_VECTOR_CHECK_SIZE_EQUAL(x, y, NULL);
    932     PS_PTR_CHECK_NULL(func, NULL);
     925    PS_ASSERT_PTR_NON_NULL(min, NULL);
     926    PS_ASSERT_VECTOR_NON_NULL(params, NULL);
     927    PS_ASSERT_VECTOR_NON_EMPTY(params, NULL);
     928    PS_ASSERT_PTR_NON_NULL(x, NULL);
     929    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     930    PS_ASSERT_VECTOR_NON_EMPTY(y, NULL);
     931    PS_ASSERT_VECTORS_SIZE_EQUAL(x, y, NULL);
     932    PS_ASSERT_PTR_NON_NULL(func, NULL);
    933933
    934934    if (paramMask != NULL) {
    935         PS_VECTOR_CHECK_SIZE_EQUAL(params, paramMask, NULL);
     935        PS_ASSERT_VECTORS_SIZE_EQUAL(params, paramMask, NULL);
    936936    }
    937937    if (yErr != NULL) {
    938         PS_VECTOR_CHECK_SIZE_EQUAL(y, yErr, NULL);
     938        PS_ASSERT_VECTORS_SIZE_EQUAL(y, yErr, NULL);
    939939    }
    940940    if (covar != NULL) {
    941         PS_IMAGE_CHECK_SIZE(covar, params->n, params->n, NULL);
     941        PS_ASSERT_IMAGE_SIZE(covar, params->n, params->n, NULL);
    942942    }
    943943
    … …  
    13631363                                        const psVector* yErr)
    13641364{
    1365     PS_POLY_CHECK_NULL(myPoly, NULL);
    1366     PS_INT_CHECK_NON_NEGATIVE(myPoly->n, NULL);
    1367     PS_VECTOR_CHECK_NULL(y, NULL);
    1368     PS_VECTOR_CHECK_EMPTY(y, NULL);
    1369     PS_VECTOR_CHECK_TYPE_F32_OR_F64(y, NULL);
     1365    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1366    PS_ASSERT_INT_NONNEGATIVE(myPoly->n, NULL);
     1367    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     1368    PS_ASSERT_VECTOR_NON_EMPTY(y, NULL);
     1369    PS_ASSERT_VECTOR_TYPE_F32_OR_F64(y, NULL);
    13701370
    13711371    psS32 i;
    … …  
    13831383        yErr64 = yErr64Static;
    13841384    } else {
    1385         PS_VECTOR_CHECK_TYPE_F32_OR_F64(yErr, NULL);
     1385        PS_ASSERT_VECTOR_TYPE_F32_OR_F64(yErr, NULL);
    13861386        PS_VECTOR_CONVERT_F32_TO_F64_STATIC(yErr, yErr64, yErr64Static);
    13871387    }
    … …  
    13951395        x64 = x64Static;
    13961396    } else {
    1397         PS_VECTOR_CHECK_TYPE_F32_OR_F64(x, NULL);
     1397        PS_ASSERT_VECTOR_TYPE_F32_OR_F64(x, NULL);
    13981398        PS_VECTOR_CONVERT_F32_TO_F64_STATIC(x, x64, x64Static);
    13991399        if (myPoly->type == PS_POLYNOMIAL_CHEB) {
    … …  
    14011401        }
    14021402    }
    1403     PS_VECTOR_CHECK_SIZE_EQUAL(x64, y64, NULL);
    1404     PS_VECTOR_CHECK_SIZE_EQUAL(yErr64, y64, NULL);
     1403    PS_ASSERT_VECTORS_SIZE_EQUAL(x64, y64, NULL);
     1404    PS_ASSERT_VECTORS_SIZE_EQUAL(yErr64, y64, NULL);
    14051405
    14061406    // Call the appropriate vector fitting routine.
    … …  
    14301430                                    psF32 tol)
    14311431{
    1432     PS_INT_CHECK_NON_NEGATIVE(maxIter, NULL);
     1432    PS_ASSERT_INT_NONNEGATIVE(maxIter, NULL);
    14331433
    14341434    psMinimization *min = psAlloc(sizeof(psMinimization));
    … …  
    17651765                  psMinimizePowellFunc func)
    17661766{
    1767     PS_PTR_CHECK_NULL(min, NAN);
    1768     PS_VECTOR_CHECK_NULL(params, NAN);
    1769     PS_VECTOR_CHECK_EMPTY(params, NAN);
    1770     PS_VECTOR_CHECK_TYPE(params, PS_TYPE_F32, NAN);
    1771     PS_VECTOR_CHECK_NULL(line, NAN);
    1772     PS_VECTOR_CHECK_EMPTY(line, NAN);
    1773     PS_VECTOR_CHECK_TYPE(line, PS_TYPE_F32, NAN);
    1774     PS_VECTOR_CHECK_NULL(paramMask, NAN);
    1775     PS_VECTOR_CHECK_EMPTY(paramMask, NAN);
    1776     PS_VECTOR_CHECK_TYPE(paramMask, PS_TYPE_U8, NAN);
    1777     PS_PTR_CHECK_NULL(coords, NAN);
    1778     PS_PTR_CHECK_NULL(func, NAN);
     1767    PS_ASSERT_PTR_NON_NULL(min, NAN);
     1768    PS_ASSERT_VECTOR_NON_NULL(params, NAN);
     1769    PS_ASSERT_VECTOR_NON_EMPTY(params, NAN);
     1770    PS_ASSERT_VECTOR_TYPE(params, PS_TYPE_F32, NAN);
     1771    PS_ASSERT_VECTOR_NON_NULL(line, NAN);
     1772    PS_ASSERT_VECTOR_NON_EMPTY(line, NAN);
     1773    PS_ASSERT_VECTOR_TYPE(line, PS_TYPE_F32, NAN);
     1774    PS_ASSERT_VECTOR_NON_NULL(paramMask, NAN);
     1775    PS_ASSERT_VECTOR_NON_EMPTY(paramMask, NAN);
     1776    PS_ASSERT_VECTOR_TYPE(paramMask, PS_TYPE_U8, NAN);
     1777    PS_ASSERT_PTR_NON_NULL(coords, NAN);
     1778    PS_ASSERT_PTR_NON_NULL(func, NAN);
    17791779    psVector *bracket;
    17801780    psF32 a = 0.0;
    … …  
    19191919                        psMinimizePowellFunc func)
    19201920{
    1921     PS_PTR_CHECK_NULL(min, NULL);
    1922     PS_VECTOR_CHECK_NULL(params, NULL);
    1923     PS_VECTOR_CHECK_EMPTY(params, NULL);
    1924     PS_VECTOR_CHECK_TYPE(params, PS_TYPE_F32, NULL);
    1925     PS_PTR_CHECK_NULL(coords, NULL);
    1926     PS_PTR_CHECK_NULL(func, NULL);
     1921    PS_ASSERT_PTR_NON_NULL(min, NULL);
     1922    PS_ASSERT_VECTOR_NON_NULL(params, NULL);
     1923    PS_ASSERT_VECTOR_NON_EMPTY(params, NULL);
     1924    PS_ASSERT_VECTOR_TYPE(params, PS_TYPE_F32, NULL);
     1925    PS_ASSERT_PTR_NON_NULL(coords, NULL);
     1926    PS_ASSERT_PTR_NON_NULL(func, NULL);
    19271927    psS32 numDims = params->n;
    19281928    PS_VECTOR_GEN_STATIC_RECYCLED(pQP, numDims, PS_TYPE_F32);
    … …  
    19571957        myParamMask = (psVector *) paramMask;
    19581958    }
    1959     PS_VECTOR_CHECK_SIZE_EQUAL(params, myParamMask, NULL);
     1959    PS_ASSERT_VECTORS_SIZE_EQUAL(params, myParamMask, NULL);
    19601960
    19611961    // 1: Set v[i] to be the unit vectors for each dimension in params
    … …  
    21192119                                      const psArray *coords)
    21202120{
    2121     PS_PTR_CHECK_NULL(coords, NULL);
    2122     PS_PTR_CHECK_NULL(params, NULL);
     2121    PS_ASSERT_PTR_NON_NULL(coords, NULL);
     2122    PS_ASSERT_PTR_NON_NULL(params, NULL);
    21232123
    21242124    psF32 x;
    … …  
    21502150    psTrace(".psLib.dataManip.myPowellChi2Func", 4,
    21512151            "---- myPowellChi2Func() begin ----\n");
    2152     PS_VECTOR_CHECK_NULL(params, NAN);
    2153     PS_VECTOR_CHECK_EMPTY(params, NAN);
    2154     PS_VECTOR_CHECK_NULL(myValue, NAN);
    2155     PS_VECTOR_CHECK_EMPTY(myValue, NAN);
    2156     PS_PTR_CHECK_NULL(coords, NAN);
     2152    PS_ASSERT_VECTOR_NON_NULL(params, NAN);
     2153    PS_ASSERT_VECTOR_NON_EMPTY(params, NAN);
     2154    PS_ASSERT_VECTOR_NON_NULL(myValue, NAN);
     2155    PS_ASSERT_VECTOR_NON_EMPTY(myValue, NAN);
     2156    PS_ASSERT_PTR_NON_NULL(coords, NAN);
    21572157
    21582158    psF32 chi2 = 0.0;

  • trunk/psLib/src/math/psPolynomial.c

    r3990 r4029  
    77 *  polynomials.  It also contains a Gaussian functions.
    88 *
    9  *  @version $Revision: 1.103 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2005-05-19 23:57:37 $
     9 *  @version $Revision: 1.104 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2005-05-25 20:26:55 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    246246static psPolynomial1D **createChebyshevPolys(psS32 maxChebyPoly)
    247247{
    248     PS_INT_CHECK_NON_NEGATIVE(maxChebyPoly, NULL);
     248    PS_ASSERT_INT_NONNEGATIVE(maxChebyPoly, NULL);
    249249
    250250    psPolynomial1D **chebPolys = NULL;
    … …  
    314314static psF32 chebPolynomial1DEval(psF32 x, const psPolynomial1D* myPoly)
    315315{
    316     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
     316    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
    317317    // XXX: Create a macro for this in psConstants.h
    318318    if (myPoly->n < 1) {
    … …  
    398398                                 const psPolynomial2D* myPoly)
    399399{
    400     PS_POLY_CHECK_NULL(myPoly, NAN);
     400    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    401401
    402402    psS32 loop_x = 0;
    … …  
    422422static psF32 chebPolynomial2DEval(psF32 x, psF32 y, const psPolynomial2D* myPoly)
    423423{
    424     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
    425     PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
    426     PS_POLY_CHECK_NULL(myPoly, NAN);
     424    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     425    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
     426    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    427427
    428428    psS32 loop_x = 0;
    … …  
    487487static psF32 chebPolynomial3DEval(psF32 x, psF32 y, psF32 z, const psPolynomial3D* myPoly)
    488488{
    489     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
    490     PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
    491     PS_FLOAT_CHECK_RANGE(z, -1.0, 1.0, 0.0);
     489    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     490    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
     491    PS_ASSERT_FLOAT_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
    492492    psS32 loop_x = 0;
    493493    psS32 loop_y = 0;
    … …  
    565565static psF32 chebPolynomial4DEval(psF32 w, psF32 x, psF32 y, psF32 z, const psPolynomial4D* myPoly)
    566566{
    567     PS_FLOAT_CHECK_RANGE(w, -1.0, 1.0, 0.0);
    568     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
    569     PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
    570     PS_FLOAT_CHECK_RANGE(z, -1.0, 1.0, 0.0);
     567    PS_ASSERT_FLOAT_WITHIN_RANGE(w, -1.0, 1.0, 0.0);
     568    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     569    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
     570    PS_ASSERT_FLOAT_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
    571571    psS32 loop_w = 0;
    572572    psS32 loop_x = 0;
    … …  
    638638static psF64 dChebPolynomial1DEval(psF64 x, const psDPolynomial1D* myPoly)
    639639{
    640     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
     640    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
    641641    psVector *d;
    642642    psS32 n;
    … …  
    697697static psF64 dChebPolynomial2DEval(psF64 x, psF64 y, const psDPolynomial2D* myPoly)
    698698{
    699     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
    700     PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
     699    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     700    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
    701701    psS32 loop_x = 0;
    702702    psS32 loop_y = 0;
    … …  
    761761static psF64 dChebPolynomial3DEval(psF64 x, psF64 y, psF64 z, const psDPolynomial3D* myPoly)
    762762{
    763     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
    764     PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
    765     PS_FLOAT_CHECK_RANGE(z, -1.0, 1.0, 0.0);
     763    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     764    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
     765    PS_ASSERT_FLOAT_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
    766766    psS32 loop_x = 0;
    767767    psS32 loop_y = 0;
    … …  
    839839static psF64 dChebPolynomial4DEval(psF64 w, psF64 x, psF64 y, psF64 z, const psDPolynomial4D* myPoly)
    840840{
    841     PS_FLOAT_CHECK_RANGE(w, -1.0, 1.0, 0.0);
    842     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
    843     PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
    844     PS_FLOAT_CHECK_RANGE(z, -1.0, 1.0, 0.0);
     841    PS_ASSERT_FLOAT_WITHIN_RANGE(w, -1.0, 1.0, 0.0);
     842    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     843    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
     844    PS_ASSERT_FLOAT_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
    845845    psS32 loop_w = 0;
    846846    psS32 loop_x = 0;
    … …  
    973973                              psF32 x)
    974974{
    975     PS_PTR_CHECK_NULL(domain, NAN)
    976     PS_PTR_CHECK_NULL(range, NAN)
     975    PS_ASSERT_PTR_NON_NULL(domain, NAN)
     976    PS_ASSERT_PTR_NON_NULL(range, NAN)
    977977    // XXX: Check valid values for n, order, and x?
    978978
    … …  
    10441044psVector* p_psGaussianDev(psF32 mean, psF32 sigma, psS32 Npts)
    10451045{
    1046     PS_INT_CHECK_NON_NEGATIVE(Npts, NULL);
     1046    PS_ASSERT_INT_NONNEGATIVE(Npts, NULL);
    10471047
    10481048    psVector* gauss = NULL;
    … …  
    10721072                                    psPolynomialType type)
    10731073{
    1074     PS_INT_CHECK_POSITIVE(n, NULL);
     1074    PS_ASSERT_INT_POSITIVE(n, NULL);
    10751075
    10761076    psS32 i = 0;
    … …  
    10971097                                    psPolynomialType type)
    10981098{
    1099     PS_INT_CHECK_POSITIVE(nX, NULL);
    1100     PS_INT_CHECK_POSITIVE(nY, NULL);
     1099    PS_ASSERT_INT_POSITIVE(nX, NULL);
     1100    PS_ASSERT_INT_POSITIVE(nY, NULL);
    11011101
    11021102    psS32 x = 0;
    … …  
    11331133                                    psPolynomialType type)
    11341134{
    1135     PS_INT_CHECK_POSITIVE(nX, NULL);
    1136     PS_INT_CHECK_POSITIVE(nY, NULL);
    1137     PS_INT_CHECK_POSITIVE(nZ, NULL);
     1135    PS_ASSERT_INT_POSITIVE(nX, NULL);
     1136    PS_ASSERT_INT_POSITIVE(nY, NULL);
     1137    PS_ASSERT_INT_POSITIVE(nZ, NULL);
    11381138
    11391139    psS32 x = 0;
    … …  
    11791179                                    psPolynomialType type)
    11801180{
    1181     PS_INT_CHECK_POSITIVE(nW, NULL);
    1182     PS_INT_CHECK_POSITIVE(nX, NULL);
    1183     PS_INT_CHECK_POSITIVE(nY, NULL);
    1184     PS_INT_CHECK_POSITIVE(nZ, NULL);
     1181    PS_ASSERT_INT_POSITIVE(nW, NULL);
     1182    PS_ASSERT_INT_POSITIVE(nX, NULL);
     1183    PS_ASSERT_INT_POSITIVE(nY, NULL);
     1184    PS_ASSERT_INT_POSITIVE(nZ, NULL);
    11851185
    11861186    psS32 w = 0;
    … …  
    12341234psF32 psPolynomial1DEval(const psPolynomial1D* myPoly, psF32 x)
    12351235{
    1236     PS_POLY_CHECK_NULL(myPoly, NAN);
     1236    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    12371237
    12381238    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    12511251                                   const psVector *x)
    12521252{
    1253     PS_POLY_CHECK_NULL(myPoly, NULL);
    1254     PS_VECTOR_CHECK_NULL(x, NULL);
    1255     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F32, NULL);
     1253    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1254    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1255    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
    12561256
    12571257    psVector *tmp;
    … …  
    12671267psF32 psPolynomial2DEval(const psPolynomial2D* myPoly, psF32 x, psF32 y)
    12681268{
    1269     PS_POLY_CHECK_NULL(myPoly, NAN);
     1269    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    12701270
    12711271    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    12861286
    12871287{
    1288     PS_POLY_CHECK_NULL(myPoly, NULL);
    1289     PS_VECTOR_CHECK_NULL(x, NULL);
    1290     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F32, NULL);
    1291     PS_VECTOR_CHECK_NULL(y, NULL);
    1292     PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F32, NULL);
     1288    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1289    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1290    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
     1291    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     1292    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F32, NULL);
    12931293
    12941294    psVector *tmp;
    … …  
    13141314psF32 psPolynomial3DEval(const psPolynomial3D* myPoly, psF32 x, psF32 y, psF32 z)
    13151315{
    1316     PS_POLY_CHECK_NULL(myPoly, NAN);
     1316    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    13171317
    13181318    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    13341334
    13351335{
    1336     PS_POLY_CHECK_NULL(myPoly, NULL);
    1337     PS_VECTOR_CHECK_NULL(x, NULL);
    1338     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F32, NULL);
    1339     PS_VECTOR_CHECK_NULL(y, NULL);
    1340     PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F32, NULL);
    1341     PS_VECTOR_CHECK_NULL(z, NULL);
    1342     PS_VECTOR_CHECK_TYPE(z, PS_TYPE_F32, NULL);
     1336    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1337    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1338    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
     1339    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     1340    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F32, NULL);
     1341    PS_ASSERT_VECTOR_NON_NULL(z, NULL);
     1342    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F32, NULL);
    13431343
    13441344    psVector *tmp;
    … …  
    13701370psF32 psPolynomial4DEval(const psPolynomial4D* myPoly, psF32 w, psF32 x, psF32 y, psF32 z)
    13711371{
    1372     PS_POLY_CHECK_NULL(myPoly, NAN);
     1372    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    13731373
    13741374    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    13901390                                   const psVector *z)
    13911391{
    1392     PS_POLY_CHECK_NULL(myPoly, NULL);
    1393     PS_VECTOR_CHECK_NULL(w, NULL);
    1394     PS_VECTOR_CHECK_TYPE(w, PS_TYPE_F32, NULL);
    1395     PS_VECTOR_CHECK_NULL(x, NULL);
    1396     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F32, NULL);
    1397     PS_VECTOR_CHECK_NULL(y, NULL);
    1398     PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F32, NULL);
    1399     PS_VECTOR_CHECK_NULL(z, NULL);
    1400     PS_VECTOR_CHECK_TYPE(z, PS_TYPE_F32, NULL);
     1392    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1393    PS_ASSERT_VECTOR_NON_NULL(w, NULL);
     1394    PS_ASSERT_VECTOR_TYPE(w, PS_TYPE_F32, NULL);
     1395    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1396    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
     1397    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     1398    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F32, NULL);
     1399    PS_ASSERT_VECTOR_NON_NULL(z, NULL);
     1400    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F32, NULL);
    14011401
    14021402    psVector *tmp;
    … …  
    14341434                                      psPolynomialType type)
    14351435{
    1436     PS_INT_CHECK_POSITIVE(n, NULL);
     1436    PS_ASSERT_INT_POSITIVE(n, NULL);
    14371437
    14381438    psS32 i = 0;
    … …  
    14591459                                      psPolynomialType type)
    14601460{
    1461     PS_INT_CHECK_POSITIVE(nX, NULL);
    1462     PS_INT_CHECK_POSITIVE(nY, NULL);
     1461    PS_ASSERT_INT_POSITIVE(nX, NULL);
     1462    PS_ASSERT_INT_POSITIVE(nY, NULL);
    14631463
    14641464    psS32 x = 0;
    … …  
    14951495                                      psPolynomialType type)
    14961496{
    1497     PS_INT_CHECK_POSITIVE(nX, NULL);
    1498     PS_INT_CHECK_POSITIVE(nY, NULL);
    1499     PS_INT_CHECK_POSITIVE(nZ, NULL);
     1497    PS_ASSERT_INT_POSITIVE(nX, NULL);
     1498    PS_ASSERT_INT_POSITIVE(nY, NULL);
     1499    PS_ASSERT_INT_POSITIVE(nZ, NULL);
    15001500
    15011501    psS32 x = 0;
    … …  
    15411541                                      psPolynomialType type)
    15421542{
    1543     PS_INT_CHECK_POSITIVE(nW, NULL);
    1544     PS_INT_CHECK_POSITIVE(nX, NULL);
    1545     PS_INT_CHECK_POSITIVE(nY, NULL);
    1546     PS_INT_CHECK_POSITIVE(nZ, NULL);
     1543    PS_ASSERT_INT_POSITIVE(nW, NULL);
     1544    PS_ASSERT_INT_POSITIVE(nX, NULL);
     1545    PS_ASSERT_INT_POSITIVE(nY, NULL);
     1546    PS_ASSERT_INT_POSITIVE(nZ, NULL);
    15471547
    15481548    psS32 w = 0;
    … …  
    15971597psF64 psDPolynomial1DEval(const psDPolynomial1D* myPoly, psF64 x)
    15981598{
    1599     PS_POLY_CHECK_NULL(myPoly, NAN);
     1599    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    16001600
    16011601    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    16151615
    16161616{
    1617     PS_POLY_CHECK_NULL(myPoly, NULL);
    1618     PS_VECTOR_CHECK_NULL(x, NULL);
    1619     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F64, NULL);
     1617    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1618    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1619    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
    16201620
    16211621    psVector *tmp;
    … …  
    16351635                          psF64 y)
    16361636{
    1637     PS_POLY_CHECK_NULL(myPoly, NAN);
     1637    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    16381638
    16391639    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    16531653                                    const psVector *y)
    16541654{
    1655     PS_POLY_CHECK_NULL(myPoly, NULL);
    1656     PS_VECTOR_CHECK_NULL(x, NULL);
    1657     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F64, NULL);
    1658     PS_VECTOR_CHECK_NULL(y, NULL);
    1659     PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F64, NULL);
     1655    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1656    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1657    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
     1658    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     1659    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F64, NULL);
    16601660
    16611661    psVector *tmp;
    … …  
    16851685                          psF64 z)
    16861686{
    1687     PS_POLY_CHECK_NULL(myPoly, NAN);
     1687    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    16881688
    16891689    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    17051705
    17061706{
    1707     PS_POLY_CHECK_NULL(myPoly, NULL);
    1708     PS_VECTOR_CHECK_NULL(x, NULL);
    1709     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F64, NULL);
    1710     PS_VECTOR_CHECK_NULL(y, NULL);
    1711     PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F64, NULL);
    1712     PS_VECTOR_CHECK_NULL(z, NULL);
    1713     PS_VECTOR_CHECK_TYPE(z, PS_TYPE_F64, NULL);
     1707    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1708    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1709    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
     1710    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     1711    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F64, NULL);
     1712    PS_ASSERT_VECTOR_NON_NULL(z, NULL);
     1713    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F64, NULL);
    17141714
    17151715    psVector *tmp;
    … …  
    17451745                          psF64 z)
    17461746{
    1747     PS_POLY_CHECK_NULL(myPoly, NAN);
     1747    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    17481748
    17491749    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    17651765                                    const psVector *z)
    17661766{
    1767     PS_POLY_CHECK_NULL(myPoly, NULL);
    1768     PS_VECTOR_CHECK_NULL(w, NULL);
    1769     PS_VECTOR_CHECK_TYPE(w, PS_TYPE_F64, NULL);
    1770     PS_VECTOR_CHECK_NULL(x, NULL);
    1771     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F64, NULL);
    1772     PS_VECTOR_CHECK_NULL(y, NULL);
    1773     PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F64, NULL);
    1774     PS_VECTOR_CHECK_NULL(z, NULL);
    1775     PS_VECTOR_CHECK_TYPE(z, PS_TYPE_F64, NULL);
     1767    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1768    PS_ASSERT_VECTOR_NON_NULL(w, NULL);
     1769    PS_ASSERT_VECTOR_TYPE(w, PS_TYPE_F64, NULL);
     1770    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1771    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
     1772    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     1773    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F64, NULL);
     1774    PS_ASSERT_VECTOR_NON_NULL(z, NULL);
     1775    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F64, NULL);
    17761776
    17771777    psVector *tmp;
    … …  
    18281828                            psF32 max)
    18291829{
    1830     PS_INT_CHECK_NON_NEGATIVE(numSplines, NULL);
    1831     PS_INT_CHECK_NON_NEGATIVE(order, NULL);
    1832     PS_FLOAT_CHECK_NON_EQUAL(max, min, NULL);
     1830    PS_ASSERT_INT_NONNEGATIVE(numSplines, NULL);
     1831    PS_ASSERT_INT_NONNEGATIVE(order, NULL);
     1832    PS_ASSERT_FLOAT_NON_EQUAL(max, min, NULL);
    18331833
    18341834    psSpline1D *tmp = NULL;
    … …  
    18701870                                   psS32 order)
    18711871{
    1872     PS_VECTOR_CHECK_NULL(bounds, NULL);
    1873     PS_VECTOR_CHECK_EMPTY(bounds, NULL);
    1874     PS_INT_CHECK_NON_NEGATIVE(order, NULL);
     1872    PS_ASSERT_VECTOR_NON_NULL(bounds, NULL);
     1873    PS_ASSERT_VECTOR_NON_EMPTY(bounds, NULL);
     1874    PS_ASSERT_INT_NONNEGATIVE(order, NULL);
    18751875
    18761876    psSpline1D *tmp = NULL;
    … …  
    19831983                          psScalar *x)
    19841984{
    1985     PS_VECTOR_CHECK_NULL(bins, -4);
    1986     PS_VECTOR_CHECK_EMPTY(bins, -4);
    1987     PS_PTR_CHECK_NULL(x, -6);
    1988     PS_PTR_CHECK_TYPE_EQUAL(x, bins, -3);
     1985    PS_ASSERT_VECTOR_NON_NULL(bins, -4);
     1986    PS_ASSERT_VECTOR_NON_EMPTY(bins, -4);
     1987    PS_ASSERT_PTR_NON_NULL(x, -6);
     1988    PS_ASSERT_PTR_TYPE_EQUAL(x, bins, -3);
    19891989    char* strType;
    19901990
    … …  
    20492049                                psScalar *x)
    20502050{
    2051     PS_VECTOR_CHECK_NULL(domain, NULL);
    2052     PS_VECTOR_CHECK_NULL(range, NULL);
    2053     PS_PTR_CHECK_NULL(x, NULL);
    2054     PS_INT_CHECK_NON_NEGATIVE(order, NULL);
    2055     PS_VECTOR_CHECK_SIZE_EQUAL(domain, range, NULL);
    2056     PS_PTR_CHECK_TYPE_EQUAL(domain, range, NULL);
    2057     PS_PTR_CHECK_TYPE_EQUAL(domain, x, NULL);
     2051    PS_ASSERT_VECTOR_NON_NULL(domain, NULL);
     2052    PS_ASSERT_VECTOR_NON_NULL(range, NULL);
     2053    PS_ASSERT_PTR_NON_NULL(x, NULL);
     2054    PS_ASSERT_INT_NONNEGATIVE(order, NULL);
     2055    PS_ASSERT_VECTORS_SIZE_EQUAL(domain, range, NULL);
     2056    PS_ASSERT_PTR_TYPE_EQUAL(domain, range, NULL);
     2057    PS_ASSERT_PTR_TYPE_EQUAL(domain, x, NULL);
    20582058
    20592059    psVector *range32 = NULL;
    … …  
    21312131)
    21322132{
    2133     PS_PTR_CHECK_NULL(spline, NAN);
    2134     PS_INT_CHECK_NON_NEGATIVE(spline->n, NAN);
    2135     PS_VECTOR_CHECK_TYPE(spline->knots, PS_TYPE_F32, NAN);
     2133    PS_ASSERT_PTR_NON_NULL(spline, NAN);
     2134    PS_ASSERT_INT_NONNEGATIVE(spline->n, NAN);
     2135    PS_ASSERT_VECTOR_TYPE(spline->knots, PS_TYPE_F32, NAN);
    21362136
    21372137    psS32 binNum;
    … …  
    21672167)
    21682168{
    2169     PS_PTR_CHECK_NULL(spline, NULL);
    2170     PS_VECTOR_CHECK_NULL(x, NULL);
    2171     PS_VECTOR_CHECK_TYPE_F32_OR_F64(x, NULL);
    2172     PS_VECTOR_CHECK_TYPE(spline->knots, PS_TYPE_F32, NULL);
     2169    PS_ASSERT_PTR_NON_NULL(spline, NULL);
     2170    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     2171    PS_ASSERT_VECTOR_TYPE_F32_OR_F64(x, NULL);
     2172    PS_ASSERT_VECTOR_TYPE(spline->knots, PS_TYPE_F32, NULL);
    21732173
    21742174    psS32 i;

  • trunk/psLib/src/math/psSpline.c

    r3990 r4029  
    77 *  polynomials.  It also contains a Gaussian functions.
    88 *
    9  *  @version $Revision: 1.103 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2005-05-19 23:57:37 $
     9 *  @version $Revision: 1.104 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2005-05-25 20:26:55 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    246246static psPolynomial1D **createChebyshevPolys(psS32 maxChebyPoly)
    247247{
    248     PS_INT_CHECK_NON_NEGATIVE(maxChebyPoly, NULL);
     248    PS_ASSERT_INT_NONNEGATIVE(maxChebyPoly, NULL);
    249249
    250250    psPolynomial1D **chebPolys = NULL;
    … …  
    314314static psF32 chebPolynomial1DEval(psF32 x, const psPolynomial1D* myPoly)
    315315{
    316     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
     316    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
    317317    // XXX: Create a macro for this in psConstants.h
    318318    if (myPoly->n < 1) {
    … …  
    398398                                 const psPolynomial2D* myPoly)
    399399{
    400     PS_POLY_CHECK_NULL(myPoly, NAN);
     400    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    401401
    402402    psS32 loop_x = 0;
    … …  
    422422static psF32 chebPolynomial2DEval(psF32 x, psF32 y, const psPolynomial2D* myPoly)
    423423{
    424     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
    425     PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
    426     PS_POLY_CHECK_NULL(myPoly, NAN);
     424    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     425    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
     426    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    427427
    428428    psS32 loop_x = 0;
    … …  
    487487static psF32 chebPolynomial3DEval(psF32 x, psF32 y, psF32 z, const psPolynomial3D* myPoly)
    488488{
    489     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
    490     PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
    491     PS_FLOAT_CHECK_RANGE(z, -1.0, 1.0, 0.0);
     489    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     490    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
     491    PS_ASSERT_FLOAT_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
    492492    psS32 loop_x = 0;
    493493    psS32 loop_y = 0;
    … …  
    565565static psF32 chebPolynomial4DEval(psF32 w, psF32 x, psF32 y, psF32 z, const psPolynomial4D* myPoly)
    566566{
    567     PS_FLOAT_CHECK_RANGE(w, -1.0, 1.0, 0.0);
    568     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
    569     PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
    570     PS_FLOAT_CHECK_RANGE(z, -1.0, 1.0, 0.0);
     567    PS_ASSERT_FLOAT_WITHIN_RANGE(w, -1.0, 1.0, 0.0);
     568    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     569    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
     570    PS_ASSERT_FLOAT_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
    571571    psS32 loop_w = 0;
    572572    psS32 loop_x = 0;
    … …  
    638638static psF64 dChebPolynomial1DEval(psF64 x, const psDPolynomial1D* myPoly)
    639639{
    640     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
     640    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
    641641    psVector *d;
    642642    psS32 n;
    … …  
    697697static psF64 dChebPolynomial2DEval(psF64 x, psF64 y, const psDPolynomial2D* myPoly)
    698698{
    699     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
    700     PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
     699    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     700    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
    701701    psS32 loop_x = 0;
    702702    psS32 loop_y = 0;
    … …  
    761761static psF64 dChebPolynomial3DEval(psF64 x, psF64 y, psF64 z, const psDPolynomial3D* myPoly)
    762762{
    763     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
    764     PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
    765     PS_FLOAT_CHECK_RANGE(z, -1.0, 1.0, 0.0);
     763    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     764    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
     765    PS_ASSERT_FLOAT_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
    766766    psS32 loop_x = 0;
    767767    psS32 loop_y = 0;
    … …  
    839839static psF64 dChebPolynomial4DEval(psF64 w, psF64 x, psF64 y, psF64 z, const psDPolynomial4D* myPoly)
    840840{
    841     PS_FLOAT_CHECK_RANGE(w, -1.0, 1.0, 0.0);
    842     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
    843     PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
    844     PS_FLOAT_CHECK_RANGE(z, -1.0, 1.0, 0.0);
     841    PS_ASSERT_FLOAT_WITHIN_RANGE(w, -1.0, 1.0, 0.0);
     842    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     843    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
     844    PS_ASSERT_FLOAT_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
    845845    psS32 loop_w = 0;
    846846    psS32 loop_x = 0;
    … …  
    973973                              psF32 x)
    974974{
    975     PS_PTR_CHECK_NULL(domain, NAN)
    976     PS_PTR_CHECK_NULL(range, NAN)
     975    PS_ASSERT_PTR_NON_NULL(domain, NAN)
     976    PS_ASSERT_PTR_NON_NULL(range, NAN)
    977977    // XXX: Check valid values for n, order, and x?
    978978
    … …  
    10441044psVector* p_psGaussianDev(psF32 mean, psF32 sigma, psS32 Npts)
    10451045{
    1046     PS_INT_CHECK_NON_NEGATIVE(Npts, NULL);
     1046    PS_ASSERT_INT_NONNEGATIVE(Npts, NULL);
    10471047
    10481048    psVector* gauss = NULL;
    … …  
    10721072                                    psPolynomialType type)
    10731073{
    1074     PS_INT_CHECK_POSITIVE(n, NULL);
     1074    PS_ASSERT_INT_POSITIVE(n, NULL);
    10751075
    10761076    psS32 i = 0;
    … …  
    10971097                                    psPolynomialType type)
    10981098{
    1099     PS_INT_CHECK_POSITIVE(nX, NULL);
    1100     PS_INT_CHECK_POSITIVE(nY, NULL);
     1099    PS_ASSERT_INT_POSITIVE(nX, NULL);
     1100    PS_ASSERT_INT_POSITIVE(nY, NULL);
    11011101
    11021102    psS32 x = 0;
    … …  
    11331133                                    psPolynomialType type)
    11341134{
    1135     PS_INT_CHECK_POSITIVE(nX, NULL);
    1136     PS_INT_CHECK_POSITIVE(nY, NULL);
    1137     PS_INT_CHECK_POSITIVE(nZ, NULL);
     1135    PS_ASSERT_INT_POSITIVE(nX, NULL);
     1136    PS_ASSERT_INT_POSITIVE(nY, NULL);
     1137    PS_ASSERT_INT_POSITIVE(nZ, NULL);
    11381138
    11391139    psS32 x = 0;
    … …  
    11791179                                    psPolynomialType type)
    11801180{
    1181     PS_INT_CHECK_POSITIVE(nW, NULL);
    1182     PS_INT_CHECK_POSITIVE(nX, NULL);
    1183     PS_INT_CHECK_POSITIVE(nY, NULL);
    1184     PS_INT_CHECK_POSITIVE(nZ, NULL);
     1181    PS_ASSERT_INT_POSITIVE(nW, NULL);
     1182    PS_ASSERT_INT_POSITIVE(nX, NULL);
     1183    PS_ASSERT_INT_POSITIVE(nY, NULL);
     1184    PS_ASSERT_INT_POSITIVE(nZ, NULL);
    11851185
    11861186    psS32 w = 0;
    … …  
    12341234psF32 psPolynomial1DEval(const psPolynomial1D* myPoly, psF32 x)
    12351235{
    1236     PS_POLY_CHECK_NULL(myPoly, NAN);
     1236    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    12371237
    12381238    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    12511251                                   const psVector *x)
    12521252{
    1253     PS_POLY_CHECK_NULL(myPoly, NULL);
    1254     PS_VECTOR_CHECK_NULL(x, NULL);
    1255     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F32, NULL);
     1253    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1254    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1255    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
    12561256
    12571257    psVector *tmp;
    … …  
    12671267psF32 psPolynomial2DEval(const psPolynomial2D* myPoly, psF32 x, psF32 y)
    12681268{
    1269     PS_POLY_CHECK_NULL(myPoly, NAN);
     1269    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    12701270
    12711271    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    12861286
    12871287{
    1288     PS_POLY_CHECK_NULL(myPoly, NULL);
    1289     PS_VECTOR_CHECK_NULL(x, NULL);
    1290     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F32, NULL);
    1291     PS_VECTOR_CHECK_NULL(y, NULL);
    1292     PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F32, NULL);
     1288    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1289    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1290    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
     1291    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     1292    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F32, NULL);
    12931293
    12941294    psVector *tmp;
    … …  
    13141314psF32 psPolynomial3DEval(const psPolynomial3D* myPoly, psF32 x, psF32 y, psF32 z)
    13151315{
    1316     PS_POLY_CHECK_NULL(myPoly, NAN);
     1316    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    13171317
    13181318    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    13341334
    13351335{
    1336     PS_POLY_CHECK_NULL(myPoly, NULL);
    1337     PS_VECTOR_CHECK_NULL(x, NULL);
    1338     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F32, NULL);
    1339     PS_VECTOR_CHECK_NULL(y, NULL);
    1340     PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F32, NULL);
    1341     PS_VECTOR_CHECK_NULL(z, NULL);
    1342     PS_VECTOR_CHECK_TYPE(z, PS_TYPE_F32, NULL);
     1336    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1337    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1338    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
     1339    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     1340    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F32, NULL);
     1341    PS_ASSERT_VECTOR_NON_NULL(z, NULL);
     1342    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F32, NULL);
    13431343
    13441344    psVector *tmp;
    … …  
    13701370psF32 psPolynomial4DEval(const psPolynomial4D* myPoly, psF32 w, psF32 x, psF32 y, psF32 z)
    13711371{
    1372     PS_POLY_CHECK_NULL(myPoly, NAN);
     1372    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    13731373
    13741374    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    13901390                                   const psVector *z)
    13911391{
    1392     PS_POLY_CHECK_NULL(myPoly, NULL);
    1393     PS_VECTOR_CHECK_NULL(w, NULL);
    1394     PS_VECTOR_CHECK_TYPE(w, PS_TYPE_F32, NULL);
    1395     PS_VECTOR_CHECK_NULL(x, NULL);
    1396     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F32, NULL);
    1397     PS_VECTOR_CHECK_NULL(y, NULL);
    1398     PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F32, NULL);
    1399     PS_VECTOR_CHECK_NULL(z, NULL);
    1400     PS_VECTOR_CHECK_TYPE(z, PS_TYPE_F32, NULL);
     1392    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1393    PS_ASSERT_VECTOR_NON_NULL(w, NULL);
     1394    PS_ASSERT_VECTOR_TYPE(w, PS_TYPE_F32, NULL);
     1395    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1396    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
     1397    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     1398    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F32, NULL);
     1399    PS_ASSERT_VECTOR_NON_NULL(z, NULL);
     1400    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F32, NULL);
    14011401
    14021402    psVector *tmp;
    … …  
    14341434                                      psPolynomialType type)
    14351435{
    1436     PS_INT_CHECK_POSITIVE(n, NULL);
     1436    PS_ASSERT_INT_POSITIVE(n, NULL);
    14371437
    14381438    psS32 i = 0;
    … …  
    14591459                                      psPolynomialType type)
    14601460{
    1461     PS_INT_CHECK_POSITIVE(nX, NULL);
    1462     PS_INT_CHECK_POSITIVE(nY, NULL);
     1461    PS_ASSERT_INT_POSITIVE(nX, NULL);
     1462    PS_ASSERT_INT_POSITIVE(nY, NULL);
    14631463
    14641464    psS32 x = 0;
    … …  
    14951495                                      psPolynomialType type)
    14961496{
    1497     PS_INT_CHECK_POSITIVE(nX, NULL);
    1498     PS_INT_CHECK_POSITIVE(nY, NULL);
    1499     PS_INT_CHECK_POSITIVE(nZ, NULL);
     1497    PS_ASSERT_INT_POSITIVE(nX, NULL);
     1498    PS_ASSERT_INT_POSITIVE(nY, NULL);
     1499    PS_ASSERT_INT_POSITIVE(nZ, NULL);
    15001500
    15011501    psS32 x = 0;
    … …  
    15411541                                      psPolynomialType type)
    15421542{
    1543     PS_INT_CHECK_POSITIVE(nW, NULL);
    1544     PS_INT_CHECK_POSITIVE(nX, NULL);
    1545     PS_INT_CHECK_POSITIVE(nY, NULL);
    1546     PS_INT_CHECK_POSITIVE(nZ, NULL);
     1543    PS_ASSERT_INT_POSITIVE(nW, NULL);
     1544    PS_ASSERT_INT_POSITIVE(nX, NULL);
     1545    PS_ASSERT_INT_POSITIVE(nY, NULL);
     1546    PS_ASSERT_INT_POSITIVE(nZ, NULL);
    15471547
    15481548    psS32 w = 0;
    … …  
    15971597psF64 psDPolynomial1DEval(const psDPolynomial1D* myPoly, psF64 x)
    15981598{
    1599     PS_POLY_CHECK_NULL(myPoly, NAN);
     1599    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    16001600
    16011601    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    16151615
    16161616{
    1617     PS_POLY_CHECK_NULL(myPoly, NULL);
    1618     PS_VECTOR_CHECK_NULL(x, NULL);
    1619     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F64, NULL);
     1617    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1618    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1619    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
    16201620
    16211621    psVector *tmp;
    … …  
    16351635                          psF64 y)
    16361636{
    1637     PS_POLY_CHECK_NULL(myPoly, NAN);
     1637    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    16381638
    16391639    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    16531653                                    const psVector *y)
    16541654{
    1655     PS_POLY_CHECK_NULL(myPoly, NULL);
    1656     PS_VECTOR_CHECK_NULL(x, NULL);
    1657     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F64, NULL);
    1658     PS_VECTOR_CHECK_NULL(y, NULL);
    1659     PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F64, NULL);
     1655    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1656    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1657    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
     1658    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     1659    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F64, NULL);
    16601660
    16611661    psVector *tmp;
    … …  
    16851685                          psF64 z)
    16861686{
    1687     PS_POLY_CHECK_NULL(myPoly, NAN);
     1687    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    16881688
    16891689    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    17051705
    17061706{
    1707     PS_POLY_CHECK_NULL(myPoly, NULL);
    1708     PS_VECTOR_CHECK_NULL(x, NULL);
    1709     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F64, NULL);
    1710     PS_VECTOR_CHECK_NULL(y, NULL);
    1711     PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F64, NULL);
    1712     PS_VECTOR_CHECK_NULL(z, NULL);
    1713     PS_VECTOR_CHECK_TYPE(z, PS_TYPE_F64, NULL);
     1707    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1708    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1709    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
     1710    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     1711    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F64, NULL);
     1712    PS_ASSERT_VECTOR_NON_NULL(z, NULL);
     1713    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F64, NULL);
    17141714
    17151715    psVector *tmp;
    … …  
    17451745                          psF64 z)
    17461746{
    1747     PS_POLY_CHECK_NULL(myPoly, NAN);
     1747    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    17481748
    17491749    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    17651765                                    const psVector *z)
    17661766{
    1767     PS_POLY_CHECK_NULL(myPoly, NULL);
    1768     PS_VECTOR_CHECK_NULL(w, NULL);
    1769     PS_VECTOR_CHECK_TYPE(w, PS_TYPE_F64, NULL);
    1770     PS_VECTOR_CHECK_NULL(x, NULL);
    1771     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F64, NULL);
    1772     PS_VECTOR_CHECK_NULL(y, NULL);
    1773     PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F64, NULL);
    1774     PS_VECTOR_CHECK_NULL(z, NULL);
    1775     PS_VECTOR_CHECK_TYPE(z, PS_TYPE_F64, NULL);
     1767    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1768    PS_ASSERT_VECTOR_NON_NULL(w, NULL);
     1769    PS_ASSERT_VECTOR_TYPE(w, PS_TYPE_F64, NULL);
     1770    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1771    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
     1772    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     1773    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F64, NULL);
     1774    PS_ASSERT_VECTOR_NON_NULL(z, NULL);
     1775    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F64, NULL);
    17761776
    17771777    psVector *tmp;
    … …  
    18281828                            psF32 max)
    18291829{
    1830     PS_INT_CHECK_NON_NEGATIVE(numSplines, NULL);
    1831     PS_INT_CHECK_NON_NEGATIVE(order, NULL);
    1832     PS_FLOAT_CHECK_NON_EQUAL(max, min, NULL);
     1830    PS_ASSERT_INT_NONNEGATIVE(numSplines, NULL);
     1831    PS_ASSERT_INT_NONNEGATIVE(order, NULL);
     1832    PS_ASSERT_FLOAT_NON_EQUAL(max, min, NULL);
    18331833
    18341834    psSpline1D *tmp = NULL;
    … …  
    18701870                                   psS32 order)
    18711871{
    1872     PS_VECTOR_CHECK_NULL(bounds, NULL);
    1873     PS_VECTOR_CHECK_EMPTY(bounds, NULL);
    1874     PS_INT_CHECK_NON_NEGATIVE(order, NULL);
     1872    PS_ASSERT_VECTOR_NON_NULL(bounds, NULL);
     1873    PS_ASSERT_VECTOR_NON_EMPTY(bounds, NULL);
     1874    PS_ASSERT_INT_NONNEGATIVE(order, NULL);
    18751875
    18761876    psSpline1D *tmp = NULL;
    … …  
    19831983                          psScalar *x)
    19841984{
    1985     PS_VECTOR_CHECK_NULL(bins, -4);
    1986     PS_VECTOR_CHECK_EMPTY(bins, -4);
    1987     PS_PTR_CHECK_NULL(x, -6);
    1988     PS_PTR_CHECK_TYPE_EQUAL(x, bins, -3);
     1985    PS_ASSERT_VECTOR_NON_NULL(bins, -4);
     1986    PS_ASSERT_VECTOR_NON_EMPTY(bins, -4);
     1987    PS_ASSERT_PTR_NON_NULL(x, -6);
     1988    PS_ASSERT_PTR_TYPE_EQUAL(x, bins, -3);
    19891989    char* strType;
    19901990
    … …  
    20492049                                psScalar *x)
    20502050{
    2051     PS_VECTOR_CHECK_NULL(domain, NULL);
    2052     PS_VECTOR_CHECK_NULL(range, NULL);
    2053     PS_PTR_CHECK_NULL(x, NULL);
    2054     PS_INT_CHECK_NON_NEGATIVE(order, NULL);
    2055     PS_VECTOR_CHECK_SIZE_EQUAL(domain, range, NULL);
    2056     PS_PTR_CHECK_TYPE_EQUAL(domain, range, NULL);
    2057     PS_PTR_CHECK_TYPE_EQUAL(domain, x, NULL);
     2051    PS_ASSERT_VECTOR_NON_NULL(domain, NULL);
     2052    PS_ASSERT_VECTOR_NON_NULL(range, NULL);
     2053    PS_ASSERT_PTR_NON_NULL(x, NULL);
     2054    PS_ASSERT_INT_NONNEGATIVE(order, NULL);
     2055    PS_ASSERT_VECTORS_SIZE_EQUAL(domain, range, NULL);
     2056    PS_ASSERT_PTR_TYPE_EQUAL(domain, range, NULL);
     2057    PS_ASSERT_PTR_TYPE_EQUAL(domain, x, NULL);
    20582058
    20592059    psVector *range32 = NULL;
    … …  
    21312131)
    21322132{
    2133     PS_PTR_CHECK_NULL(spline, NAN);
    2134     PS_INT_CHECK_NON_NEGATIVE(spline->n, NAN);
    2135     PS_VECTOR_CHECK_TYPE(spline->knots, PS_TYPE_F32, NAN);
     2133    PS_ASSERT_PTR_NON_NULL(spline, NAN);
     2134    PS_ASSERT_INT_NONNEGATIVE(spline->n, NAN);
     2135    PS_ASSERT_VECTOR_TYPE(spline->knots, PS_TYPE_F32, NAN);
    21362136
    21372137    psS32 binNum;
    … …  
    21672167)
    21682168{
    2169     PS_PTR_CHECK_NULL(spline, NULL);
    2170     PS_VECTOR_CHECK_NULL(x, NULL);
    2171     PS_VECTOR_CHECK_TYPE_F32_OR_F64(x, NULL);
    2172     PS_VECTOR_CHECK_TYPE(spline->knots, PS_TYPE_F32, NULL);
     2169    PS_ASSERT_PTR_NON_NULL(spline, NULL);
     2170    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     2171    PS_ASSERT_VECTOR_TYPE_F32_OR_F64(x, NULL);
     2172    PS_ASSERT_VECTOR_TYPE(spline->knots, PS_TYPE_F32, NULL);
    21732173
    21742174    psS32 i;

  • trunk/psLib/src/math/psStats.c

    r4028 r4029  
    99 *  @author GLG, MHPCC
    1010 *
    11  *  @version $Revision: 1.128 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2005-05-25 19:25:29 $
     11 *  @version $Revision: 1.129 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2005-05-25 20:26:55 $
    1313 *
    1414 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    424424                             psStats* stats)
    425425{
    426     PS_VECTOR_CHECK_NULL(myVector, -1);
    427     PS_PTR_CHECK_NULL(stats, -1);
     426    PS_ASSERT_VECTOR_NON_NULL(myVector, -1);
     427    PS_ASSERT_PTR_NON_NULL(stats, -1);
    428428    psS32 i = 0;                // Loop index variable
    429429
    … …  
    472472                        psStats* stats)
    473473{
    474     PS_VECTOR_CHECK_NULL(myVector, -1);
    475     PS_PTR_CHECK_NULL(stats, -1);
     474    PS_ASSERT_VECTOR_NON_NULL(myVector, -1);
     475    PS_ASSERT_PTR_NON_NULL(stats, -1);
    476476    psS32 i = 0;                // Loop index variable
    477477    psS32 numData = 0;          // The number of data points
    … …  
    619619                                       psF32 sigma)
    620620{
    621     PS_PTR_CHECK_NULL(robustHistogram, NULL);
    622     PS_PTR_CHECK_NULL(robustHistogram->bounds, NULL);
     621    PS_ASSERT_PTR_NON_NULL(robustHistogram, NULL);
     622    PS_ASSERT_PTR_NON_NULL(robustHistogram->bounds, NULL);
    623623
    624624    psS32 i = 0;                  // Loop index variable
    … …  
    10291029
    10301030    // Ensure that stats->clipIter is within the proper range.
    1031     PS_INT_CHECK_RANGE(stats->clipIter,
    1032                        PS_CLIPPED_NUM_ITER_LB,
    1033                        PS_CLIPPED_NUM_ITER_UB, -1);
     1031    PS_ASSERT_INT_WITHIN_RANGE(stats->clipIter,
     1032                               PS_CLIPPED_NUM_ITER_LB,
     1033                               PS_CLIPPED_NUM_ITER_UB, -1);
    10341034
    10351035    // Ensure that stats->clipSigma is within the proper range.
    1036     PS_INT_CHECK_RANGE(stats->clipSigma,
    1037                        PS_CLIPPED_SIGMA_LB,
    1038                        PS_CLIPPED_SIGMA_UB, -1);
     1036    PS_ASSERT_INT_WITHIN_RANGE(stats->clipSigma,
     1037                               PS_CLIPPED_SIGMA_LB,
     1038                               PS_CLIPPED_SIGMA_UB, -1);
    10391039
    10401040    // Allocate a psStats structure for calculating the mean, median, and
    … …  
    12631263                       psF32 getThisValue)
    12641264{
    1265     PS_POLY_CHECK_NULL(myPoly, NAN);
     1265    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    12661266    PS_FLOAT_COMPARE(rangeLow, rangeHigh, NAN);
    12671267    // We ensure that the requested f(y) value, which is getThisValue, is
    … …  
    13321332                                        psF32 yVal)
    13331333{
    1334     PS_VECTOR_CHECK_NULL(xVec, NAN);
    1335     PS_VECTOR_CHECK_NULL(yVec, NAN);
    1336     PS_VECTOR_CHECK_TYPE(xVec, PS_TYPE_F32, NAN);
    1337     PS_VECTOR_CHECK_TYPE(yVec, PS_TYPE_F32, NAN);
    1338     //    PS_VECTOR_CHECK_SIZE_EQUAL(xVec, yVec, NAN);
    1339     PS_INT_CHECK_RANGE(binNum, 0, (xVec->n - 1), NAN);
    1340     PS_INT_CHECK_RANGE(binNum, 0, (yVec->n - 1), NAN);
     1334    PS_ASSERT_VECTOR_NON_NULL(xVec, NAN);
     1335    PS_ASSERT_VECTOR_NON_NULL(yVec, NAN);
     1336    PS_ASSERT_VECTOR_TYPE(xVec, PS_TYPE_F32, NAN);
     1337    PS_ASSERT_VECTOR_TYPE(yVec, PS_TYPE_F32, NAN);
     1338    //    PS_ASSERT_VECTORS_SIZE_EQUAL(xVec, yVec, NAN);
     1339    PS_ASSERT_INT_WITHIN_RANGE(binNum, 0, (xVec->n - 1), NAN);
     1340    PS_ASSERT_INT_WITHIN_RANGE(binNum, 0, (yVec->n - 1), NAN);
    13411341
    13421342    //    PS_VECTOR_DECLARE_ALLOC_STATIC(x, 3, PS_TYPE_F64);
    … …  
    18271827psHistogram* psHistogramAlloc(psF32 lower, psF32 upper, psS32 n)
    18281828{
    1829     PS_INT_CHECK_POSITIVE(n, NULL);
     1829    PS_ASSERT_INT_POSITIVE(n, NULL);
    18301830    PS_FLOAT_COMPARE(lower, upper, NULL);
    18311831
    … …  
    18751875psHistogram* psHistogramAllocGeneric(const psVector* bounds)
    18761876{
    1877     PS_VECTOR_CHECK_NULL(bounds, NULL);
    1878     PS_VECTOR_CHECK_TYPE(bounds, PS_TYPE_F32, NULL);
     1877    PS_ASSERT_VECTOR_NON_NULL(bounds, NULL);
     1878    PS_ASSERT_VECTOR_TYPE(bounds, PS_TYPE_F32, NULL);
    18791879    PS_INT_COMPARE(2, bounds->n, NULL);
    18801880
    … …  
    19301930                          psF32 error)
    19311931{
    1932     PS_PTR_CHECK_NULL(out, -1);
    1933     PS_PTR_CHECK_NULL(out->bounds, -1);
    1934     PS_PTR_CHECK_NULL(out->nums, -1);
    1935     PS_INT_CHECK_RANGE(binNum, 0, ((out->nums->n)-1), -2);
     1932    PS_ASSERT_PTR_NON_NULL(out, -1);
     1933    PS_ASSERT_PTR_NON_NULL(out->bounds, -1);
     1934    PS_ASSERT_PTR_NON_NULL(out->nums, -1);
     1935    PS_ASSERT_INT_WITHIN_RANGE(binNum, 0, ((out->nums->n)-1), -2);
    19361936    PS_FLOAT_COMPARE(0.0, error, -3);
    1937     PS_FLOAT_CHECK_RANGE(data, out->bounds->data.F32[0], out->bounds->data.F32[(out->bounds->n)-1], -4);
     1937    PS_ASSERT_FLOAT_WITHIN_RANGE(data, out->bounds->data.F32[0], out->bounds->data.F32[(out->bounds->n)-1], -4);
    19381938
    19391939    psF32 boxcarWidth = 2.35 * error;
    … …  
    20192019                               psU32 maskVal)
    20202020{
    2021     PS_PTR_CHECK_NULL(out, NULL);
    2022     PS_VECTOR_CHECK_NULL(out->bounds, NULL);
    2023     PS_VECTOR_CHECK_TYPE(out->bounds, PS_TYPE_F32, NULL);
    2024     PS_INT_CHECK_NON_NEGATIVE(out->bounds->n, NULL);
    2025     PS_VECTOR_CHECK_NULL(out->nums, NULL);
    2026     PS_VECTOR_CHECK_TYPE(out->nums, PS_TYPE_F32, NULL);
    2027     PS_INT_CHECK_NON_NEGATIVE(out->nums->n, NULL);
    2028     PS_VECTOR_CHECK_NULL(in, out);
     2021    PS_ASSERT_PTR_NON_NULL(out, NULL);
     2022    PS_ASSERT_VECTOR_NON_NULL(out->bounds, NULL);
     2023    PS_ASSERT_VECTOR_TYPE(out->bounds, PS_TYPE_F32, NULL);
     2024    PS_ASSERT_INT_NONNEGATIVE(out->bounds->n, NULL);
     2025    PS_ASSERT_VECTOR_NON_NULL(out->nums, NULL);
     2026    PS_ASSERT_VECTOR_TYPE(out->nums, PS_TYPE_F32, NULL);
     2027    PS_ASSERT_INT_NONNEGATIVE(out->nums->n, NULL);
     2028    PS_ASSERT_VECTOR_NON_NULL(in, out);
    20292029    if (mask != NULL) {
    2030         PS_VECTOR_CHECK_SIZE_EQUAL(in, mask, NULL);
    2031         PS_VECTOR_CHECK_TYPE(mask, PS_TYPE_U8, NULL);
     2030        PS_ASSERT_VECTORS_SIZE_EQUAL(in, mask, NULL);
     2031        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, NULL);
    20322032    }
    20332033    if (errors != NULL) {
    2034         PS_VECTOR_CHECK_SIZE_EQUAL(in, errors, NULL);
    2035         PS_VECTOR_CHECK_TYPE(errors, in->type.type, NULL);
     2034        PS_ASSERT_VECTORS_SIZE_EQUAL(in, errors, NULL);
     2035        PS_ASSERT_VECTOR_TYPE(errors, in->type.type, NULL);
    20362036    }
    20372037
    … …  
    22162216                       psU32 maskVal)
    22172217{
    2218     PS_PTR_CHECK_NULL(stats, NULL);
    2219     PS_VECTOR_CHECK_NULL(in, stats);
     2218    PS_ASSERT_PTR_NON_NULL(stats, NULL);
     2219    PS_ASSERT_VECTOR_NON_NULL(in, stats);
    22202220    if (mask != NULL) {
    2221         PS_VECTOR_CHECK_SIZE_EQUAL(mask, in, stats);
    2222         PS_VECTOR_CHECK_TYPE(mask, PS_TYPE_U8, stats);
     2221        PS_ASSERT_VECTORS_SIZE_EQUAL(mask, in, stats);
     2222        PS_ASSERT_VECTOR_TYPE(mask, PS_TYPE_U8, stats);
    22232223    }
    22242224    if (errors != NULL) {
    2225         PS_VECTOR_CHECK_SIZE_EQUAL(errors, in, stats);
    2226         PS_VECTOR_CHECK_TYPE(errors, in->type.type, stats);
     2225        PS_ASSERT_VECTORS_SIZE_EQUAL(errors, in, stats);
     2226        PS_ASSERT_VECTOR_TYPE(errors, in->type.type, stats);
    22272227    }
    22282228

  • trunk/psLib/src/math/psUnaryOp.c

    r3887 r4029  
    3030 *  @author Robert DeSonia, MHPCC
    3131 *
    32  *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
    33  *  @date $Date: 2005-05-12 00:54:49 $
     32 *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
     33 *  @date $Date: 2005-05-25 20:26:55 $
    3434 *
    3535 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    315315    psType* psTypeIn = (psType* ) in;
    316316
    317     PS_PTR_CHECK_NULL_GENERAL(in, psUnaryOp_EXIT);
    318     PS_PTR_CHECK_NULL_GENERAL(op, psUnaryOp_EXIT);
     317    PS_ASSERT_GENERAL_PTR_NON_NULL(in, psUnaryOp_EXIT);
     318    PS_ASSERT_GENERAL_PTR_NON_NULL(op, psUnaryOp_EXIT);
    319319
    320320    psDimen dimIn = psTypeIn->dimen;

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

    r3945 r4029  
    1212*  @author Ross Harman, MHPCC
    1313*
    14 *  @version $Revision: 1.62 $ $Name: not supported by cvs2svn $
    15 *  @date $Date: 2005-05-16 19:43:53 $
     14*  @version $Revision: 1.63 $ $Name: not supported by cvs2svn $
     15*  @date $Date: 2005-05-25 20:26:55 $
    1616*
    1717*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    179179
    180180
    181     PS_PTR_CHECK_NULL(name,NULL);
     181    PS_ASSERT_PTR_NON_NULL(name,NULL);
    182182
    183183    // Allocate metadata item
    … …  
    275275    psMetadataItem *existingEntry = NULL;
    276276
    277     PS_PTR_CHECK_NULL(md,NULL);
    278     PS_PTR_CHECK_NULL(md->table,NULL);
    279     PS_PTR_CHECK_NULL(md->list,NULL);
    280     PS_PTR_CHECK_NULL(metadataItem,NULL);
    281     PS_PTR_CHECK_NULL(metadataItem->name,NULL);
     277    PS_ASSERT_PTR_NON_NULL(md,NULL);
     278    PS_ASSERT_PTR_NON_NULL(md->table,NULL);
     279    PS_ASSERT_PTR_NON_NULL(md->list,NULL);
     280    PS_ASSERT_PTR_NON_NULL(metadataItem,NULL);
     281    PS_ASSERT_PTR_NON_NULL(metadataItem->name,NULL);
    282282
    283283    mdTable = md->table;
    … …  
    410410psBool psMetadataRemove(psMetadata *md, psS32 where, const char *key)
    411411{
    412     PS_PTR_CHECK_NULL(md,NULL);
    413 
    414     PS_PTR_CHECK_NULL(md->list,NULL);
     412    PS_ASSERT_PTR_NON_NULL(md,NULL);
     413
     414    PS_ASSERT_PTR_NON_NULL(md->list,NULL);
    415415    psList* mdList = md->list;
    416416
    417     PS_PTR_CHECK_NULL(md->table,NULL);
     417    PS_ASSERT_PTR_NON_NULL(md->table,NULL);
    418418    psHash* mdTable = md->table;
    419419
    … …  
    482482
    483483
    484     PS_PTR_CHECK_NULL(md,NULL);
    485     PS_PTR_CHECK_NULL(md->table,NULL);
    486     PS_PTR_CHECK_NULL(key,NULL);
     484    PS_ASSERT_PTR_NON_NULL(md,NULL);
     485    PS_ASSERT_PTR_NON_NULL(md->table,NULL);
     486    PS_ASSERT_PTR_NON_NULL(key,NULL);
    487487
    488488    mdTable = md->table;
    … …  
    583583    psMetadataItem* entry = NULL;
    584584
    585     PS_PTR_CHECK_NULL(md,NULL);
    586     PS_PTR_CHECK_NULL(md->list,NULL);
     585    PS_ASSERT_PTR_NON_NULL(md,NULL);
     586    PS_ASSERT_PTR_NON_NULL(md->list,NULL);
    587587
    588588    entry = (psMetadataItem*) psListGet(md->list, where);
    … …  
    599599        const char* regex)
    600600{
    601     PS_PTR_CHECK_NULL(md,NULL);
    602     PS_PTR_CHECK_NULL(md->list,NULL);
     601    PS_ASSERT_PTR_NON_NULL(md,NULL);
     602    PS_ASSERT_PTR_NON_NULL(md->list,NULL);
    603603
    604604    psMetadataIterator* newIter = psAlloc(sizeof(psMetadataIterator));
    … …  
    637637    psMetadataItem* cursor;
    638638
    639     PS_PTR_CHECK_NULL(iterator,NULL);
     639    PS_ASSERT_PTR_NON_NULL(iterator,NULL);
    640640
    641641    psListIterator* iter = iterator->iter;
    642     PS_PTR_CHECK_NULL(iterator->iter,NULL);
     642    PS_ASSERT_PTR_NON_NULL(iterator->iter,NULL);
    643643
    644644    regex_t* preg = iterator->preg;
    … …  
    686686    psMetadataItem* oldValue;
    687687
    688     PS_PTR_CHECK_NULL(iterator,NULL);
     688    PS_ASSERT_PTR_NON_NULL(iterator,NULL);
    689689
    690690    psListIterator* iter = iterator->iter;
    691     PS_PTR_CHECK_NULL(iterator->iter,NULL);
     691    PS_ASSERT_PTR_NON_NULL(iterator->iter,NULL);
    692692
    693693    regex_t* preg = iterator->preg;
    … …  
    714714    psMetadataItem* oldValue;
    715715
    716     PS_PTR_CHECK_NULL(iterator,NULL);
     716    PS_ASSERT_PTR_NON_NULL(iterator,NULL);
    717717
    718718    psListIterator* iter = iterator->iter;
    719     PS_PTR_CHECK_NULL(iterator->iter,NULL);
     719    PS_ASSERT_PTR_NON_NULL(iterator->iter,NULL);
    720720
    721721    regex_t* preg = iterator->preg;

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

    r3980 r4029  
    1010*  @author Eric Van Alst, MHPCC
    1111*
    12 *  @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
    13 *  @date $Date: 2005-05-19 20:48:28 $
     12*  @version $Revision: 1.28 $ $Name: not supported by cvs2svn $
     13*  @date $Date: 2005-05-25 20:26:55 $
    1414*
    1515*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    368368    psBool success = true;
    369369
    370     PS_PTR_CHECK_NULL(fd, success);
    371     PS_PTR_CHECK_NULL(format, success);
    372     PS_PTR_CHECK_NULL(metadataItem, success);
     370    PS_ASSERT_PTR_NON_NULL(fd, success);
     371    PS_ASSERT_PTR_NON_NULL(format, success);
     372    PS_ASSERT_PTR_NON_NULL(metadataItem, success);
    373373
    374374    type = metadataItem->type;
    … …  
    469469    fitsfile *fd = NULL;
    470470
    471     PS_PTR_CHECK_NULL(fileName,NULL);
     471    PS_ASSERT_PTR_NON_NULL(fileName,NULL);
    472472
    473473    fits_open_file(&fd, fileName, READONLY, &status);
    … …  
    10861086
    10871087    // Check for NULL file name
    1088     PS_PTR_CHECK_NULL(fileName,NULL);
     1088    PS_ASSERT_PTR_NON_NULL(fileName,NULL);
    10891089
    10901090    // Check for NULL nFail
    1091     PS_PTR_CHECK_NULL(nFail,NULL);
     1091    PS_ASSERT_PTR_NON_NULL(nFail,NULL);
    10921092
    10931093    // Attempt to open specified file
    … …  
    11561156    // Get and check initial data pointers
    11571157    ctxt = (xmlParserCtxtPtr)ctx;
    1158     PS_PTR_CHECK_NULL_GENERAL(ctxt, return);
     1158    PS_ASSERT_GENERAL_PTR_NON_NULL(ctxt, return);
    11591159    md = (psMetadata*)ctxt->sax->_private;
    1160     PS_PTR_CHECK_NULL_GENERAL(md, return);
     1160    PS_ASSERT_GENERAL_PTR_NON_NULL(md, return);
    11611161    input = (xmlParserInputPtr)ctxt->input;
    1162     PS_PTR_CHECK_NULL_GENERAL(input, return);
     1162    PS_ASSERT_GENERAL_PTR_NON_NULL(input, return);
    11631163
    11641164    // Copy XML strings to psStrings to avoid libxml2/psLib memory corruption problems
    … …  
    11731173        psHashAdd(htAtts, "tagName", psTagName);
    11741174    } else {
    1175         PS_PTR_CHECK_NULL_GENERAL(psTagName, return);
     1175        PS_ASSERT_GENERAL_PTR_NON_NULL(psTagName, return);
    11761176        psFree(htAtts);
    11771177        psFree(psTagName);
    … …  
    11931193                psFree(psAttValue);
    11941194            } else {
    1195                 PS_PTR_CHECK_NULL_GENERAL(psAttValue, return);
     1195                PS_ASSERT_GENERAL_PTR_NON_NULL(psAttValue, return);
    11961196                psFree(htAtts);
    11971197                psFree(psTagName);
    … …  
    12371237    // Get and check initial data pointers
    12381238    ctxt = (xmlParserCtxtPtr)ctx;
    1239     PS_PTR_CHECK_NULL_GENERAL(ctxt, return);
     1239    PS_ASSERT_GENERAL_PTR_NON_NULL(ctxt, return);
    12401240    md = (psMetadata*)ctxt->sax->_private;
    1241     PS_PTR_CHECK_NULL_GENERAL(md, return);
     1241    PS_ASSERT_GENERAL_PTR_NON_NULL(md, return);
    12421242    input = (xmlParserInputPtr)ctxt->input;
    1243     PS_PTR_CHECK_NULL_GENERAL(input, return);
     1243    PS_ASSERT_GENERAL_PTR_NON_NULL(input, return);
    12441244    metadataItem = psMetadataLookup(md, "htAtts");
    1245     PS_PTR_CHECK_NULL_GENERAL(metadataItem, return);
    1246     PS_PTR_CHECK_NULL_GENERAL(metadataItem->data.list, return);
     1245    PS_ASSERT_GENERAL_PTR_NON_NULL(metadataItem, return);
     1246    PS_ASSERT_GENERAL_PTR_NON_NULL(metadataItem->data.list, return);
    12471247    metadataItem = (psMetadataItem*)psListGet(metadataItem->data.list,PS_LIST_TAIL);
    12481248    htAtts = (psHash*)metadataItem->data.list;
    1249     PS_PTR_CHECK_NULL_GENERAL(htAtts, return);
     1249    PS_ASSERT_GENERAL_PTR_NON_NULL(htAtts, return);
    12501250    fileName = (char*)input->filename;
    1251     PS_PTR_CHECK_NULL_GENERAL(fileName, return);
     1251    PS_ASSERT_GENERAL_PTR_NON_NULL(fileName, return);
    12521252    lineNumber = input->line;
    12531253
    … …  
    13861386    // Get and check initial data pointers
    13871387    ctxt = (xmlParserCtxtPtr)ctx;
    1388     PS_PTR_CHECK_NULL_GENERAL(ctxt, return);
     1388    PS_ASSERT_GENERAL_PTR_NON_NULL(ctxt, return);
    13891389    md = (psMetadata*)ctxt->sax->_private;
    1390     PS_PTR_CHECK_NULL_GENERAL(md, return);
     1390    PS_ASSERT_GENERAL_PTR_NON_NULL(md, return);
    13911391    input = (xmlParserInputPtr)ctxt->input;
    1392     PS_PTR_CHECK_NULL_GENERAL(input, return);
     1392    PS_ASSERT_GENERAL_PTR_NON_NULL(input, return);
    13931393    tables = psMetadataLookup(md, "htAtts");
    1394     PS_PTR_CHECK_NULL_GENERAL(tables, return);
    1395     PS_PTR_CHECK_NULL_GENERAL(tables->data.list, return);
     1394    PS_ASSERT_GENERAL_PTR_NON_NULL(tables, return);
     1395    PS_ASSERT_GENERAL_PTR_NON_NULL(tables->data.list, return);
    13961396    table = (psMetadataItem*)psListGet(tables->data.list,PS_LIST_TAIL);
    13971397    htAtts = (psHash*)table->data.list;
    1398     PS_PTR_CHECK_NULL_GENERAL(htAtts, return);
     1398    PS_ASSERT_GENERAL_PTR_NON_NULL(htAtts, return);
    13991399    fileName = (char*)input->filename;
    1400     PS_PTR_CHECK_NULL_GENERAL(fileName, return);
     1400    PS_ASSERT_GENERAL_PTR_NON_NULL(fileName, return);
    14011401    lineNumber = input->line;
    14021402
    … …  
    14271427
    14281428    strValue = psHashLookup(htAtts, "value");
    1429     PS_PTR_CHECK_NULL_GENERAL(strValue, return);
     1429    PS_ASSERT_GENERAL_PTR_NON_NULL(strValue, return);
    14301430
    14311431
    … …  
    14821482    // Get and check initial data pointers
    14831483    ctxt = (xmlParserCtxtPtr)ctx;
    1484     PS_PTR_CHECK_NULL_GENERAL(ctxt, return);
     1484    PS_ASSERT_GENERAL_PTR_NON_NULL(ctxt, return);
    14851485    md = (psMetadata*)ctxt->sax->_private;
    1486     PS_PTR_CHECK_NULL_GENERAL(md, return);
     1486    PS_ASSERT_GENERAL_PTR_NON_NULL(md, return);
    14871487    input = (xmlParserInputPtr)ctxt->input;
    1488     PS_PTR_CHECK_NULL_GENERAL(input, return);
     1488    PS_ASSERT_GENERAL_PTR_NON_NULL(input, return);
    14891489    tables = psMetadataLookup(md, "htAtts");
    1490     PS_PTR_CHECK_NULL_GENERAL(tables, return);
    1491     PS_PTR_CHECK_NULL_GENERAL(tables->data.list, return);
     1490    PS_ASSERT_GENERAL_PTR_NON_NULL(tables, return);
     1491    PS_ASSERT_GENERAL_PTR_NON_NULL(tables->data.list, return);
    14921492    table = (psMetadataItem*)psListGet(tables->data.list,PS_LIST_TAIL);
    14931493    htAtts = (psHash*)table->data.list;
    1494     PS_PTR_CHECK_NULL_GENERAL(htAtts, return);
     1494    PS_ASSERT_GENERAL_PTR_NON_NULL(htAtts, return);
    14951495
    14961496    // Copy XML strings to psStrings to avoid libxml2/psLib memory corruption problems
    … …  
    14991499    // Compare start and end tag names
    15001500    psStartTagName = psHashLookup(htAtts, "tagName");
    1501     PS_PTR_CHECK_NULL_GENERAL(psStartTagName, return);
     1501    PS_ASSERT_GENERAL_PTR_NON_NULL(psStartTagName, return);
    15021502    if(strcmp(psEndTagName, psStartTagName)) {
    15031503        psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_TAG_MISMATCH, psStartTagName, psEndTagName);
    … …  
    15271527
    15281528    // Error checks
    1529     PS_PTR_CHECK_NULL(fileName, NULL);
     1529    PS_ASSERT_PTR_NON_NULL(fileName, NULL);
    15301530
    15311531    // Allocate metadata if necessary

  • trunk/psLib/src/xml/psXML.c

    r3980 r4029  
    1010*  @author Eric Van Alst, MHPCC
    1111*
    12 *  @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
    13 *  @date $Date: 2005-05-19 20:48:28 $
     12*  @version $Revision: 1.28 $ $Name: not supported by cvs2svn $
     13*  @date $Date: 2005-05-25 20:26:55 $
    1414*
    1515*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    368368    psBool success = true;
    369369
    370     PS_PTR_CHECK_NULL(fd, success);
    371     PS_PTR_CHECK_NULL(format, success);
    372     PS_PTR_CHECK_NULL(metadataItem, success);
     370    PS_ASSERT_PTR_NON_NULL(fd, success);
     371    PS_ASSERT_PTR_NON_NULL(format, success);
     372    PS_ASSERT_PTR_NON_NULL(metadataItem, success);
    373373
    374374    type = metadataItem->type;
    … …  
    469469    fitsfile *fd = NULL;
    470470
    471     PS_PTR_CHECK_NULL(fileName,NULL);
     471    PS_ASSERT_PTR_NON_NULL(fileName,NULL);
    472472
    473473    fits_open_file(&fd, fileName, READONLY, &status);
    … …  
    10861086
    10871087    // Check for NULL file name
    1088     PS_PTR_CHECK_NULL(fileName,NULL);
     1088    PS_ASSERT_PTR_NON_NULL(fileName,NULL);
    10891089
    10901090    // Check for NULL nFail
    1091     PS_PTR_CHECK_NULL(nFail,NULL);
     1091    PS_ASSERT_PTR_NON_NULL(nFail,NULL);
    10921092
    10931093    // Attempt to open specified file
    … …  
    11561156    // Get and check initial data pointers
    11571157    ctxt = (xmlParserCtxtPtr)ctx;
    1158     PS_PTR_CHECK_NULL_GENERAL(ctxt, return);
     1158    PS_ASSERT_GENERAL_PTR_NON_NULL(ctxt, return);
    11591159    md = (psMetadata*)ctxt->sax->_private;
    1160     PS_PTR_CHECK_NULL_GENERAL(md, return);
     1160    PS_ASSERT_GENERAL_PTR_NON_NULL(md, return);
    11611161    input = (xmlParserInputPtr)ctxt->input;
    1162     PS_PTR_CHECK_NULL_GENERAL(input, return);
     1162    PS_ASSERT_GENERAL_PTR_NON_NULL(input, return);
    11631163
    11641164    // Copy XML strings to psStrings to avoid libxml2/psLib memory corruption problems
    … …  
    11731173        psHashAdd(htAtts, "tagName", psTagName);
    11741174    } else {
    1175         PS_PTR_CHECK_NULL_GENERAL(psTagName, return);
     1175        PS_ASSERT_GENERAL_PTR_NON_NULL(psTagName, return);
    11761176        psFree(htAtts);
    11771177        psFree(psTagName);
    … …  
    11931193                psFree(psAttValue);
    11941194            } else {
    1195                 PS_PTR_CHECK_NULL_GENERAL(psAttValue, return);
     1195                PS_ASSERT_GENERAL_PTR_NON_NULL(psAttValue, return);
    11961196                psFree(htAtts);
    11971197                psFree(psTagName);
    … …  
    12371237    // Get and check initial data pointers
    12381238    ctxt = (xmlParserCtxtPtr)ctx;
    1239     PS_PTR_CHECK_NULL_GENERAL(ctxt, return);
     1239    PS_ASSERT_GENERAL_PTR_NON_NULL(ctxt, return);
    12401240    md = (psMetadata*)ctxt->sax->_private;
    1241     PS_PTR_CHECK_NULL_GENERAL(md, return);
     1241    PS_ASSERT_GENERAL_PTR_NON_NULL(md, return);
    12421242    input = (xmlParserInputPtr)ctxt->input;
    1243     PS_PTR_CHECK_NULL_GENERAL(input, return);
     1243    PS_ASSERT_GENERAL_PTR_NON_NULL(input, return);
    12441244    metadataItem = psMetadataLookup(md, "htAtts");
    1245     PS_PTR_CHECK_NULL_GENERAL(metadataItem, return);
    1246     PS_PTR_CHECK_NULL_GENERAL(metadataItem->data.list, return);
     1245    PS_ASSERT_GENERAL_PTR_NON_NULL(metadataItem, return);
     1246    PS_ASSERT_GENERAL_PTR_NON_NULL(metadataItem->data.list, return);
    12471247    metadataItem = (psMetadataItem*)psListGet(metadataItem->data.list,PS_LIST_TAIL);
    12481248    htAtts = (psHash*)metadataItem->data.list;
    1249     PS_PTR_CHECK_NULL_GENERAL(htAtts, return);
     1249    PS_ASSERT_GENERAL_PTR_NON_NULL(htAtts, return);
    12501250    fileName = (char*)input->filename;
    1251     PS_PTR_CHECK_NULL_GENERAL(fileName, return);
     1251    PS_ASSERT_GENERAL_PTR_NON_NULL(fileName, return);
    12521252    lineNumber = input->line;
    12531253
    … …  
    13861386    // Get and check initial data pointers
    13871387    ctxt = (xmlParserCtxtPtr)ctx;
    1388     PS_PTR_CHECK_NULL_GENERAL(ctxt, return);
     1388    PS_ASSERT_GENERAL_PTR_NON_NULL(ctxt, return);
    13891389    md = (psMetadata*)ctxt->sax->_private;
    1390     PS_PTR_CHECK_NULL_GENERAL(md, return);
     1390    PS_ASSERT_GENERAL_PTR_NON_NULL(md, return);
    13911391    input = (xmlParserInputPtr)ctxt->input;
    1392     PS_PTR_CHECK_NULL_GENERAL(input, return);
     1392    PS_ASSERT_GENERAL_PTR_NON_NULL(input, return);
    13931393    tables = psMetadataLookup(md, "htAtts");
    1394     PS_PTR_CHECK_NULL_GENERAL(tables, return);
    1395     PS_PTR_CHECK_NULL_GENERAL(tables->data.list, return);
     1394    PS_ASSERT_GENERAL_PTR_NON_NULL(tables, return);
     1395    PS_ASSERT_GENERAL_PTR_NON_NULL(tables->data.list, return);
    13961396    table = (psMetadataItem*)psListGet(tables->data.list,PS_LIST_TAIL);
    13971397    htAtts = (psHash*)table->data.list;
    1398     PS_PTR_CHECK_NULL_GENERAL(htAtts, return);
     1398    PS_ASSERT_GENERAL_PTR_NON_NULL(htAtts, return);
    13991399    fileName = (char*)input->filename;
    1400     PS_PTR_CHECK_NULL_GENERAL(fileName, return);
     1400    PS_ASSERT_GENERAL_PTR_NON_NULL(fileName, return);
    14011401    lineNumber = input->line;
    14021402
    … …  
    14271427
    14281428    strValue = psHashLookup(htAtts, "value");
    1429     PS_PTR_CHECK_NULL_GENERAL(strValue, return);
     1429    PS_ASSERT_GENERAL_PTR_NON_NULL(strValue, return);
    14301430
    14311431
    … …  
    14821482    // Get and check initial data pointers
    14831483    ctxt = (xmlParserCtxtPtr)ctx;
    1484     PS_PTR_CHECK_NULL_GENERAL(ctxt, return);
     1484    PS_ASSERT_GENERAL_PTR_NON_NULL(ctxt, return);
    14851485    md = (psMetadata*)ctxt->sax->_private;
    1486     PS_PTR_CHECK_NULL_GENERAL(md, return);
     1486    PS_ASSERT_GENERAL_PTR_NON_NULL(md, return);
    14871487    input = (xmlParserInputPtr)ctxt->input;
    1488     PS_PTR_CHECK_NULL_GENERAL(input, return);
     1488    PS_ASSERT_GENERAL_PTR_NON_NULL(input, return);
    14891489    tables = psMetadataLookup(md, "htAtts");
    1490     PS_PTR_CHECK_NULL_GENERAL(tables, return);
    1491     PS_PTR_CHECK_NULL_GENERAL(tables->data.list, return);
     1490    PS_ASSERT_GENERAL_PTR_NON_NULL(tables, return);
     1491    PS_ASSERT_GENERAL_PTR_NON_NULL(tables->data.list, return);
    14921492    table = (psMetadataItem*)psListGet(tables->data.list,PS_LIST_TAIL);
    14931493    htAtts = (psHash*)table->data.list;
    1494     PS_PTR_CHECK_NULL_GENERAL(htAtts, return);
     1494    PS_ASSERT_GENERAL_PTR_NON_NULL(htAtts, return);
    14951495
    14961496    // Copy XML strings to psStrings to avoid libxml2/psLib memory corruption problems
    … …  
    14991499    // Compare start and end tag names
    15001500    psStartTagName = psHashLookup(htAtts, "tagName");
    1501     PS_PTR_CHECK_NULL_GENERAL(psStartTagName, return);
     1501    PS_ASSERT_GENERAL_PTR_NON_NULL(psStartTagName, return);
    15021502    if(strcmp(psEndTagName, psStartTagName)) {
    15031503        psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_TAG_MISMATCH, psStartTagName, psEndTagName);
    … …  
    15271527
    15281528    // Error checks
    1529     PS_PTR_CHECK_NULL(fileName, NULL);
     1529    PS_ASSERT_PTR_NON_NULL(fileName, NULL);
    15301530
    15311531    // Allocate metadata if necessary
Note: See TracChangeset for help on using the changeset viewer.