IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Feb 23, 2005, 2:19:51 PM (21 years ago)
Author:
desonia
Message:

changed psMatrix tests so that functions return NULL on error.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r3290 r3313  
    2121 *  @author Robert DeSonia, MHPCC
    2222 *
    23  *  @version $Revision: 1.24 $ $Name: not supported by cvs2svn $
    24  *  @date $Date: 2005-02-19 00:30:07 $
     23 *  @version $Revision: 1.25 $ $Name: not supported by cvs2svn $
     24 *  @date $Date: 2005-02-24 00:19:51 $
    2525 *
    2626 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    5050
    5151/** Preprocessor macro to generate error for image dimensionality not set to PS_DIMEN_IMAGE */
    52 #define PS_CHECK_DIMEN_AND_TYPE(NAME, PS_DIMEN, RETURN)                                             \
     52#define PS_CHECK_DIMEN_AND_TYPE(NAME, PS_DIMEN, CLEANUP)                                             \
    5353if (NAME->type.dimen != PS_DIMEN) {                                                                 \
    5454    psError(PS_ERR_BAD_PARAMETER_TYPE, true,                                                        \
    5555            "Invalid operation. %s has incorrect dimensionality %d.", #NAME, PS_DIMEN);             \
    56     return RETURN;                                                                                  \
     56    CLEANUP;                                                                                  \
    5757} else if(NAME->type.type!=PS_TYPE_F64 && NAME->type.type!=PS_TYPE_F32) {                           \
    5858    psError(PS_ERR_BAD_PARAMETER_TYPE, true,                                                        \
    5959            "Invalid operation. %s not PS_TYPE_F64.", #NAME);                                       \
    60     return RETURN;                                                                                  \
     60    CLEANUP;                                                                                  \
    6161}
    6262
    6363/** Preprocessor macro to check that input is not equal to output */
    64 #define PS_CHECK_POINTERS(NAME1, NAME2, RETURN)                                                     \
     64#define PS_CHECK_POINTERS(NAME1, NAME2, CLEANUP)                                                     \
    6565if (NAME1 == NAME2) {                                                                               \
    6666    psError(PS_ERR_BAD_PARAMETER_VALUE, true,                                                       \
    6767            "Invalid operation: Pointer to %s is same as %s.", #NAME1, #NAME2);                     \
    68     return RETURN;                                                                                  \
     68    CLEANUP;                                                                                  \
    6969}
    7070
    7171/** Preprocessor macro to check that an image is square */
    72 #define PS_CHECK_SQUARE(NAME, RETURN)                                                               \
     72#define PS_CHECK_SQUARE(NAME, CLEANUP)                                                               \
    7373if (NAME->numCols != NAME->numRows) {                                                               \
    7474    psError(PS_ERR_BAD_PARAMETER_SIZE, true, "Invalid operation: %s not square array.", #NAME);     \
    75     return RETURN;                                                                                  \
     75    CLEANUP;                                                                                  \
    7676}
    7777
    … …  
    189189    // Error checks
    190190    PS_IMAGE_CHECK_NULL_GENERAL(inImage, psMatrixLUD_EXIT);
    191     PS_CHECK_POINTERS(inImage, outImage, outImage);
    192     PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, outImage);
     191    PS_CHECK_POINTERS(inImage, outImage, psMatrixLUD_EXIT);
     192    PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, psMatrixLUD_EXIT);
    193193    PS_PTR_CHECK_NULL_GENERAL(outPerm, psMatrixLUD_EXIT);
    194194
    195195    outImage = psImageRecycle(outImage, inImage->numCols, inImage->numRows, inImage->type.type);
    196196
    197     PS_CHECK_SQUARE(inImage, outImage);
    198     PS_CHECK_SQUARE(outImage, outImage);
     197    PS_CHECK_SQUARE(inImage, psMatrixLUD_EXIT);
     198    PS_CHECK_SQUARE(outImage, psMatrixLUD_EXIT);
    199199
    200200    // Initialize data
    … …  
    244244    gsl_vector *x = NULL;
    245245
    246     // Error checks
    247     PS_CHECK_POINTERS(outVector, inVector, outVector);
    248     PS_CHECK_POINTERS(inVector, inPerm, outVector);
    249     PS_CHECK_POINTERS(outVector, inPerm, outVector);
    250     PS_IMAGE_CHECK_NULL(inImage, outVector);
    251     PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, outVector);
    252     PS_IMAGE_CHECK_EMPTY(inImage, outVector);
    253     PS_VECTOR_CHECK_NULL(outVector, outVector);
    254     PS_CHECK_DIMEN_AND_TYPE(outVector, PS_DIMEN_VECTOR, outVector);
    255     PS_VECTOR_CHECK_NULL(inVector, outVector);
    256     PS_CHECK_DIMEN_AND_TYPE(inVector, PS_DIMEN_VECTOR, outVector);
    257     PS_VECTOR_CHECK_NULL(inPerm, outVector);
    258     psVectorRecycle(outVector, inImage->numRows, inImage->type.type);
     246    #define LUSOLVE_CLEANUP {psFree(outVector); return NULL;}
     247
     248    // Error checks
     249    PS_IMAGE_CHECK_NULL_GENERAL(inImage, LUSOLVE_CLEANUP);
     250    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);
     253    PS_CHECK_DIMEN_AND_TYPE(inVector, PS_DIMEN_VECTOR, LUSOLVE_CLEANUP);
     254    PS_VECTOR_CHECK_NULL_GENERAL(inPerm, LUSOLVE_CLEANUP);
     255
     256    outVector = psVectorRecycle(outVector, inImage->numRows, inImage->type.type);
     257
     258    PS_CHECK_POINTERS(outVector, inVector, LUSOLVE_CLEANUP);
     259    PS_CHECK_POINTERS(inVector, inPerm, LUSOLVE_CLEANUP);
     260    PS_CHECK_POINTERS(outVector, inPerm, LUSOLVE_CLEANUP);
    259261
    260262    // Initialize data
    … …  
    296298    gsl_permutation *perm = NULL;
    297299
    298     // Error checks
    299     PS_PTR_CHECK_NULL(det, outImage);
    300     PS_CHECK_POINTERS(inImage, outImage, outImage);
    301     PS_IMAGE_CHECK_NULL(inImage, outImage);
    302     PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, outImage);
    303     PS_IMAGE_CHECK_EMPTY(inImage, outImage);
     300    #define INVERT_CLEANUP { psFree(outImage); return NULL; }
     301    // Error checks
     302    PS_PTR_CHECK_NULL_GENERAL(det, INVERT_CLEANUP);
     303    PS_IMAGE_CHECK_NULL_GENERAL(inImage, INVERT_CLEANUP);
     304    PS_CHECK_POINTERS(inImage, outImage, INVERT_CLEANUP);
     305    PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, INVERT_CLEANUP);
     306    PS_IMAGE_CHECK_EMPTY_GENERAL(inImage, INVERT_CLEANUP);
     307
    304308    outImage = psImageRecycle(outImage, inImage->numCols, inImage->numRows, inImage->type.type);
    305     PS_CHECK_SQUARE(inImage, outImage);
    306     PS_CHECK_SQUARE(outImage, outImage);
     309
     310    PS_CHECK_SQUARE(inImage, INVERT_CLEANUP);
     311    PS_CHECK_SQUARE(outImage, INVERT_CLEANUP);
    307312
    308313    // Initialize data
    … …  
    341346    gsl_permutation *perm = NULL;
    342347
    343     // Error checks
    344     PS_IMAGE_CHECK_NULL(inImage, NULL);
    345     PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, NULL);
    346     PS_IMAGE_CHECK_EMPTY(inImage, NULL);
    347     PS_CHECK_SQUARE(inImage, 0);
     348    #define DETERMINANT_EXIT { return NULL; }
     349    // Error checks
     350    PS_IMAGE_CHECK_NULL_GENERAL(inImage, DETERMINANT_EXIT);
     351    PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, DETERMINANT_EXIT);
     352    PS_IMAGE_CHECK_EMPTY_GENERAL(inImage, DETERMINANT_EXIT);
     353    PS_CHECK_SQUARE(inImage, DETERMINANT_EXIT);
    348354
    349355    // Initialize data
    … …  
    376382    gsl_matrix *m3 = NULL;
    377383
    378     // Error checks
    379     PS_CHECK_POINTERS(inImage1, outImage, outImage);
    380     PS_CHECK_POINTERS(inImage1, inImage2, outImage);
    381     PS_IMAGE_CHECK_NULL(inImage1, outImage);
    382     PS_CHECK_DIMEN_AND_TYPE(inImage1, PS_DIMEN_IMAGE, outImage);
    383     PS_IMAGE_CHECK_EMPTY(inImage1, outImage);
    384     PS_IMAGE_CHECK_NULL(inImage2, outImage);
    385     PS_CHECK_DIMEN_AND_TYPE(inImage2, PS_DIMEN_IMAGE, outImage);
    386     PS_IMAGE_CHECK_EMPTY(inImage2, outImage);
    387     PS_CHECK_DIMEN_AND_TYPE(inImage1, PS_DIMEN_IMAGE, outImage);
     384    #define MULTIPLY_CLEANUP { psFree(outImage); return NULL; }
     385
     386    // Error checks
     387    PS_IMAGE_CHECK_NULL_GENERAL(inImage1, MULTIPLY_CLEANUP);
     388    PS_IMAGE_CHECK_NULL_GENERAL(inImage2, MULTIPLY_CLEANUP);
     389    PS_IMAGE_CHECK_EMPTY_GENERAL(inImage1, MULTIPLY_CLEANUP);
     390    PS_IMAGE_CHECK_EMPTY_GENERAL(inImage2, MULTIPLY_CLEANUP);
     391    PS_CHECK_DIMEN_AND_TYPE(inImage1, PS_DIMEN_IMAGE, MULTIPLY_CLEANUP);
     392    PS_CHECK_DIMEN_AND_TYPE(inImage2, PS_DIMEN_IMAGE, MULTIPLY_CLEANUP);
     393    PS_CHECK_POINTERS(inImage1, outImage, MULTIPLY_CLEANUP);
     394    PS_CHECK_POINTERS(inImage1, inImage2, MULTIPLY_CLEANUP);
    388395
    389396    outImage = psImageRecycle(outImage, inImage2->numCols, inImage2->numRows, inImage2->type.type);
    390397
    391     PS_CHECK_SQUARE(inImage1, outImage);
    392     PS_CHECK_SQUARE(inImage2, outImage);
    393     PS_CHECK_SQUARE(outImage, outImage);
     398    PS_CHECK_SQUARE(inImage1, MULTIPLY_CLEANUP);
     399    PS_CHECK_SQUARE(inImage2, MULTIPLY_CLEANUP);
     400    PS_CHECK_SQUARE(outImage, MULTIPLY_CLEANUP);
    394401
    395402    // Initialize data
    … …  
    428435    psS32 numColsOut = 0;
    429436
    430 
    431     // Error checks
    432     PS_CHECK_POINTERS(inImage, outImage, outImage);
    433     PS_IMAGE_CHECK_NULL(inImage, outImage);
    434     PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, outImage);
    435     PS_IMAGE_CHECK_EMPTY(inImage, outImage);
     437    #define TRANSPOSE_CLEANUP { psFree(outImage); return NULL; }
     438    // Error checks
     439    PS_IMAGE_CHECK_NULL_GENERAL(inImage, TRANSPOSE_CLEANUP);
     440    PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, TRANSPOSE_CLEANUP);
     441    PS_IMAGE_CHECK_EMPTY_GENERAL(inImage, TRANSPOSE_CLEANUP);
     442    PS_CHECK_POINTERS(inImage, outImage, TRANSPOSE_CLEANUP);
     443
    436444    outImage = psImageRecycle(outImage, inImage->numCols, inImage->numRows, inImage->type.type);
    437445
    … …  
    472480    gsl_matrix *in = NULL;
    473481
    474 
    475     // Error checks
    476     PS_CHECK_POINTERS(inImage, outImage, outImage);
    477     PS_IMAGE_CHECK_NULL(inImage, outImage);
    478     PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, outImage);
    479     PS_IMAGE_CHECK_EMPTY(inImage, outImage);
     482    #define EIGENVECTORS_CLEANUP { psFree(outImage); return NULL; }
     483    // Error checks
     484    PS_IMAGE_CHECK_NULL_GENERAL(inImage, EIGENVECTORS_CLEANUP);
     485    PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, EIGENVECTORS_CLEANUP);
     486    PS_IMAGE_CHECK_EMPTY_GENERAL(inImage, EIGENVECTORS_CLEANUP);
     487    PS_CHECK_POINTERS(inImage, outImage, EIGENVECTORS_CLEANUP);
    480488
    481489    outImage = psImageRecycle(outImage, inImage->numCols, inImage->numRows, inImage->type.type);
    … …  
    494502
    495503    // Non-square matrices not allowed
    496     PS_CHECK_SQUARE(inImage, outImage);
    497     PS_CHECK_SQUARE(outImage, outImage);
     504    PS_CHECK_SQUARE(inImage, EIGENVECTORS_CLEANUP);
     505    PS_CHECK_SQUARE(outImage, EIGENVECTORS_CLEANUP);
    498506
    499507    // Calculate Eigenvalues and Eigenvectors...Eigenvalues not currently used
    … …  
    520528    // Error checks
    521529    PS_IMAGE_CHECK_NULL_GENERAL(inImage, psMatrixToVector_EXIT);
    522     PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, outVector);
     530    PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, psMatrixToVector_EXIT);
    523531    PS_IMAGE_CHECK_EMPTY_GENERAL(inImage, psMatrixToVector_EXIT);
    524532
    525533    if (inImage->numRows == 1) {
    526534        // Create transposed row vector
    527         psVectorRecycle(outVector, inImage->numCols, inImage->type.type);
     535        outVector = psVectorRecycle(outVector, inImage->numCols, inImage->type.type);
    528536        outVector->type.dimen = PS_DIMEN_TRANSV;
    529537    } else if (inImage->numCols == 1) {
    530538        // Create non-transposed column vector
    531         psVectorRecycle(outVector, inImage->numRows, inImage->type.type);
     539        outVector = psVectorRecycle(outVector, inImage->numRows, inImage->type.type);
    532540    } else {
    533541        psError(PS_ERR_BAD_PARAMETER_SIZE, true,
    … …  
    537545    }
    538546
    539     PS_VECTOR_CHECK_NULL(outVector, outVector);
    540 
    541547    // More checks
    542548    if (outVector->type.dimen == PS_DIMEN_VECTOR) {
    543         PS_CHECK_DIMEN_AND_TYPE(outVector, PS_DIMEN_VECTOR, outVector);
     549        PS_CHECK_DIMEN_AND_TYPE(outVector, PS_DIMEN_VECTOR, psMatrixToVector_EXIT);
    544550
    545551        if (outVector->n == 0) {
    … …  
    557563
    558564    } else if (outVector->type.dimen == PS_DIMEN_TRANSV) {
    559         PS_CHECK_DIMEN_AND_TYPE(outVector, PS_DIMEN_TRANSV, outVector);
     565        PS_CHECK_DIMEN_AND_TYPE(outVector, PS_DIMEN_TRANSV, psMatrixToVector_EXIT);
    560566
    561567        if (outVector->n == 0) {
    … …  
    582588    psS32 size = 0;
    583589
    584     // Error checks
    585     PS_VECTOR_CHECK_NULL(inVector, outImage);
     590    #define VECTORTOMATRIX_CLEANUP {psFree(outImage); return NULL; }
     591    // Error checks
     592    PS_VECTOR_CHECK_NULL_GENERAL(inVector, VECTORTOMATRIX_CLEANUP);
    586593
    587594    if (inVector->type.dimen == PS_DIMEN_VECTOR) {
    588         PS_CHECK_DIMEN_AND_TYPE(inVector, PS_DIMEN_VECTOR, outImage);
    589         PS_VECTOR_CHECK_EMPTY(inVector, outImage);
     595        PS_CHECK_DIMEN_AND_TYPE(inVector, PS_DIMEN_VECTOR, VECTORTOMATRIX_CLEANUP);
     596        PS_VECTOR_CHECK_EMPTY_GENERAL(inVector, VECTORTOMATRIX_CLEANUP);
     597
    590598        outImage = psImageRecycle(outImage, 1, inVector->n, inVector->type.type);
     599
    591600        // More checks for PS_DIMEN_VECTOR
    592601        if (outImage->numCols > 1) {
    … …  
    605614
    606615    } else if (inVector->type.dimen == PS_DIMEN_TRANSV) {
    607         PS_CHECK_DIMEN_AND_TYPE(inVector, PS_DIMEN_TRANSV, outImage);
    608         PS_VECTOR_CHECK_EMPTY(inVector, outImage);
     616        PS_CHECK_DIMEN_AND_TYPE(inVector, PS_DIMEN_TRANSV, VECTORTOMATRIX_CLEANUP);
     617        PS_VECTOR_CHECK_EMPTY_GENERAL(inVector, VECTORTOMATRIX_CLEANUP);
    609618        outImage = psImageRecycle(outImage, inVector->n, 1, inVector->type.type);
    610619        // More checks for PS_DIMEN_TRANSV
    … …  
    624633    }
    625634
    626     PS_IMAGE_CHECK_NULL(outImage, outImage);
    627     PS_CHECK_DIMEN_AND_TYPE(outImage, PS_DIMEN_IMAGE, outImage);
     635    PS_IMAGE_CHECK_NULL_GENERAL(outImage, VECTORTOMATRIX_CLEANUP);
     636    PS_CHECK_DIMEN_AND_TYPE(outImage, PS_DIMEN_IMAGE, VECTORTOMATRIX_CLEANUP);
    628637
    629638    memcpy(outImage->data.V[0], inVector->data.V, size);
Note: See TracChangeset for help on using the changeset viewer.