IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Sep 22, 2005, 10:45:43 AM (21 years ago)
Author:
gusciora
Message:

Implementing the polynomial nTerm -> nOrder switch,

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/test/math/tst_psFunc11.c

    r5090 r5092  
    44*  ORD and CHEB type polynomials.
    55*
    6 *  @version  $Revision: 1.4 $  $Name: not supported by cvs2svn $
    7 *  @date  $Date: 2005-09-22 02:47:16 $
     6*  @version  $Revision: 1.5 $  $Name: not supported by cvs2svn $
     7*  @date  $Date: 2005-09-22 20:45:43 $
    88*
    99* Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
    … …  
    1919
    2020static psS32 testPoly4DEval(void);
    21 static psS32 testPoly4DEvalVector(void);
     21//static psS32 testPoly4DEvalVector(void);
    2222
    2323testDescription tests[] = {
    24                               {testPoly4DEval,583,"psPolynomial4DEval",0,false},
    25                               {testPoly4DEvalVector,000,"psPolynomial4DEvalVector",0,false},
     24                              {testPoly4DEval,583,"psPolynomial4DEval",true,false},
     25                              //                              {testPoly4DEvalVector,000,"psPolynomial4DEvalVector",true,false},
    2626                              {NULL}
    2727                          };
    … …  
    374374}
    375375
    376 // This test will verify operation of 1D polynomial evaluation
    377 /*psS32 testPoly4DEval(void)
    378 {
    379     psF32  result;
    380     psF32  resultCheb;
    381  
    382     // Allocate polynomial structure
    383     psPolynomial4D*  polyOrd  = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_ORD);
    384     psPolynomial4D*  polyCheb = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_CHEB);
    385     // Set polynomial members
    386     for(psS32 i = 0; i < TERMS; i++) {
    387         for(psS32 j = 0; j < TERMS; j++) {
    388             for(psS32 k = 0; k < TERMS; k++) {
    389                 for(psS32 l = 0; l < TERMS; l++) {
    390                     polyOrd->coeff[i][j][k][l] = poly4DCoeff[i][j][k][l];
    391                     polyOrd->mask[i][j][k][l]  = poly4DMask[i][j][k][l];
    392                     polyCheb->coeff[i][j][k][l] = 1.0;
    393                     polyCheb->mask[i][j][k][l]  = poly4DMask[i][j][k][l];
    394                 }
    395             }
    396         }
    397     }
    398     // Evaluate test points and verify results
    399     for(psS32 i = 0; i < TESTPOINTS; i++) {
    400         result = psPolynomial4DEval(polyOrd,poly4DWXYZValue[i][0],poly4DWXYZValue[i][1],
    401                                     poly4DWXYZValue[i][2], poly4DWXYZValue[i][3]);
    402         if(fabs(poly4DResult[i]-result) > ERROR_TOL ) {
    403             psError(PS_ERR_UNKNOWN,true,"Evaluated value %g not as expected %g",
    404                     result, poly4DResult[i]);
    405             return i;
    406         }
    407         resultCheb = psPolynomial4DEval(polyCheb,poly4DWXYZChebValue[i][0], poly4DWXYZChebValue[i][1],
    408                                         poly4DWXYZChebValue[i][2], poly4DWXYZChebValue[i][3]);
    409         if(fabs(poly4DChebResult[i]-resultCheb) > ERROR_TOL ) {
    410             psError(PS_ERR_UNKNOWN,true,"Evaluated Chebyshev value %lg not as expected %lg",
    411                     resultCheb, poly4DChebResult[i]);
    412             return 5*i;
    413         }
    414     }
    415     psFree(polyOrd);
    416     psFree(polyCheb);
    417  
    418     // Allocate polynomial with invalid type
    419     polyOrd = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, 99);
    420     // Attempt to evaluation invalid polynomial type
    421     psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
    422     result = psPolynomial4DEval(polyOrd,0.0, 0.0, 0.0, 0.0);
    423     if ( !isnan(result) ) {
    424         psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid polynomial type");
    425         return 20;
    426     }
    427     psFree(polyOrd);
    428  
    429     return 0;
    430 }
    431 */
    432 // This test will verify operation of 1D polynomial evaluation
     376// This test will verify operation of 4D polynomial evaluation
    433377psS32 testPoly4DEval(void)
    434378{
    435     psF64  result;
    436     psF64  resultCheb;
     379    psBool testStatus = true;
    437380
    438381    // Allocate polynomial structure
    … …  
    452395        }
    453396    }
     397
    454398    // Evaluate test points and verify results
    455399    for(psS32 i = 0; i < TESTPOINTS; i++) {
    456         result = psPolynomial4DEval(polyOrd,Dpoly4DWXYZValue[i][0],Dpoly4DWXYZValue[i][1],
    457                                     Dpoly4DWXYZValue[i][2],Dpoly4DWXYZValue[i][3]);
     400        psF64 result = psPolynomial4DEval(polyOrd,Dpoly4DWXYZValue[i][0],Dpoly4DWXYZValue[i][1],
     401                                          Dpoly4DWXYZValue[i][2],Dpoly4DWXYZValue[i][3]);
    458402        if(fabs(Dpoly4DResult[i]-result) > ERROR_TOL ) {
    459             psError(PS_ERR_UNKNOWN,true,"Evaluated value %lg not as expected %lg",
    460                     result, Dpoly4DResult[i]);
    461             return i;
     403            printf("TEST ERROR: Evaluated value %lg not as expected %lg.\n",
     404                   result, Dpoly4DResult[i]);
     405            testStatus = false;
    462406        }
    463         resultCheb = psPolynomial4DEval(polyCheb,Dpoly4DWXYZChebValue[i][0],Dpoly4DWXYZChebValue[i][1],
    464                                         Dpoly4DWXYZChebValue[i][2],Dpoly4DWXYZChebValue[i][3]);
     407
     408        psF64 resultCheb = psPolynomial4DEval(polyCheb,Dpoly4DWXYZChebValue[i][0],Dpoly4DWXYZChebValue[i][1],
     409                                              Dpoly4DWXYZChebValue[i][2],Dpoly4DWXYZChebValue[i][3]);
    465410        if(fabs(Dpoly4DChebResult[i]-resultCheb) > ERROR_TOL ) {
    466             psError(PS_ERR_UNKNOWN,true,"Evaluated Chebyshev value %lg not as expected %lg",
    467                     resultCheb, Dpoly4DChebResult[i]);
    468             return 5*i;
     411            printf("TEST ERROR: Evaluated Chebyshev value %lg not as expected %lg.\n",
     412                   resultCheb, Dpoly4DChebResult[i]);
     413            testStatus = false;
    469414        }
    470415    }
     416
    471417    psFree(polyOrd);
    472418    psFree(polyCheb);
    … …  
    476422    // Attempt to evaluation invalid polynomial type
    477423    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
    478     result = psPolynomial4DEval(polyOrd,0.0, 0.0, 0.0, 0.0);
     424    psF64 result = psPolynomial4DEval(polyOrd,0.0, 0.0, 0.0, 0.0);
    479425    if ( !isnan(result) ) {
    480         psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid polynomial type");
    481         return 20;
     426        printf("TEST ERROR: Did not return NAN for invalid polynomial type");
     427        testStatus = false;
    482428    }
    483429    psFree(polyOrd);
    484430
    485     return 0;
     431    return(testStatus);
    486432}
    487 
    488 /*psS32 testPoly4DEvalVector(void)
    489 {
    490     // Allocate polynomial
    491     psPolynomial4D* polyOrd  = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_ORD);
    492     psPolynomial4D* polyCheb = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_CHEB);
    493  
    494     // Set polynomial members
    495     for(psS32 i = 0; i < TERMS; i++) {
    496         for(psS32 j = 0; j < TERMS; j++) {
    497             for(psS32 k = 0; k < TERMS; k++) {
    498                 for(psS32 l = 0; l < TERMS; l++) {
    499                     polyOrd->coeff[i][j][k][l] = poly4DCoeff[i][j][k][l];
    500                     polyOrd->mask[i][j][k][l]  = poly4DMask[i][j][k][l];
    501                     polyCheb->coeff[i][j][k][l] = 1.0;
    502                     polyCheb->mask[i][j][k][l]  = poly4DMask[i][j][k][l];
    503                 }
    504             }
    505         }
    506     }
    507  
    508     // Create input vectors
    509     psVector* inputOrdW  = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
    510     psVector* inputOrdX  = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
    511     psVector* inputOrdY  = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
    512     psVector* inputOrdZ  = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
    513     psVector* inputChebW = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
    514     psVector* inputChebX = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
    515     psVector* inputChebY = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
    516     psVector* inputChebZ = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
    517     for(psS32 i = 0; i < TESTPOINTS; i++) {
    518         inputOrdW->data.F32[i] = poly4DWXYZValue[i][0];
    519         inputOrdX->data.F32[i] = poly4DWXYZValue[i][1];
    520         inputOrdY->data.F32[i] = poly4DWXYZValue[i][2];
    521         inputOrdZ->data.F32[i] = poly4DWXYZValue[i][3];
    522         inputChebW->data.F32[i] = poly4DWXYZChebValue[i][0];
    523         inputChebX->data.F32[i] = poly4DWXYZChebValue[i][1];
    524         inputChebY->data.F32[i] = poly4DWXYZChebValue[i][2];
    525         inputChebZ->data.F32[i] = poly4DWXYZChebValue[i][3];
    526     }
    527  
    528     // Evaluate the vectors
    529     psVector* outputOrd = psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ);
    530     if(outputOrd == NULL) {
    531         psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
    532         return 1;
    533     }
    534     if(outputOrd->type.type != PS_TYPE_F32) {
    535         psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d",
    536                 outputOrd->type.type, PS_TYPE_F32);
    537         return 2;
    538     }
    539     psVector* outputCheb = psPolynomial4DEvalVector(polyCheb,inputChebW,inputChebX,inputChebY,inputChebZ);
    540     if(outputCheb == NULL) {
    541         psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
    542         return 1;
    543     }
    544     if(outputCheb->type.type != PS_TYPE_F32) {
    545         psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d",
    546                 outputCheb->type.type, PS_TYPE_F32);
    547         return 2;
    548     }
    549  
    550     // Verify the results
    551     for(psS32 i = 0; i < TESTPOINTS; i++) {
    552         if(fabs(poly4DResult[i]-outputOrd->data.F32[i]) > ERROR_TOL) {
    553             psError(PS_ERR_UNKNOWN,true,"Result[%d] %g not equal to expected %g",
    554                     i, outputOrd->data.F32[i], poly4DResult[i]);
    555             return i*5;
    556         }
    557         if(fabs(poly4DChebResult[i]-outputCheb->data.F32[i]) > ERROR_TOL) {
    558             psError(PS_ERR_UNKNOWN,true,"ResultCheb[%d] %g not equal to expected %g",
    559                     i, outputCheb->data.F32[i], poly4DChebResult[i]);
    560             return i*10;
    561         }
    562     }
    563  
    564     // Attempt to invoke function with null polynomial
    565     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
    566     if(psPolynomial4DEvalVector(NULL, inputOrdW, inputOrdX, inputOrdY, inputOrdZ) != NULL) {
    567         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL polynomial");
    568         return 60;
    569     }
    570  
    571     // Attempt to invoke function with null input vector
    572     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
    573     if(psPolynomial4DEvalVector(polyOrd,NULL,inputOrdX, inputOrdY,inputOrdZ) != NULL) {
    574         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
    575         return 61;
    576     }
    577     // Attempt to invoke function with null input vector
    578     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
    579     if(psPolynomial4DEvalVector(polyOrd, inputOrdW, NULL, inputOrdY, inputOrdZ) != NULL) {
    580         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
    581         return 62;
    582     }
    583     // Attempt to invoke function with null input vector
    584     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
    585     if(psPolynomial4DEvalVector(polyOrd, inputOrdW, inputOrdX,NULL,inputOrdZ) != NULL) {
    586         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
    587         return 63;
    588     }
    589     // Attempt to invoke function with null input vector
    590     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
    591     if(psPolynomial4DEvalVector(polyOrd, inputOrdW, inputOrdX,inputOrdY,NULL) != NULL) {
    592         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
    593         return 64;
    594     }
    595  
    596     // Attempt to invoke function with a non F32 type input vector
    597     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
    598     inputOrdX->type.type = PS_TYPE_U8;
    599     if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
    600         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F32 input vector");
    601         return 65;
    602     }
    603     inputOrdX->type.type = PS_TYPE_F32;
    604     // Attempt to invoke function with a non F32 type input vector
    605     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
    606     inputOrdY->type.type = PS_TYPE_U8;
    607     if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
    608         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F32 input vector");
    609         return 66;
    610     }
    611     inputOrdY->type.type = PS_TYPE_F32;
    612     // Attempt to invoke function with a non F32 type input vector
    613     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
    614     inputOrdZ->type.type = PS_TYPE_U8;
    615     if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
    616         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F32 input vector");
    617         return 67;
    618     }
    619     inputOrdZ->type.type = PS_TYPE_F32;
    620     // Attempt to invoke function with a non F32 type input vector
    621     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
    622     inputOrdW->type.type = PS_TYPE_U8;
    623     if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
    624         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F32 input vector");
    625         return 68;
    626     }
    627     inputOrdW->type.type = PS_TYPE_F32;
    628  
    629     psFree(inputOrdW);
    630     psFree(inputOrdX);
    631     psFree(inputOrdY);
    632     psFree(inputOrdZ);
    633     psFree(inputChebW);
    634     psFree(inputChebX);
    635     psFree(inputChebY);
    636     psFree(inputChebZ);
    637     psFree(outputOrd);
    638     psFree(outputCheb);
    639     psFree(polyOrd);
    640     psFree(polyCheb);
    641  
    642     return 0;
    643 }
    644 */
     433/*
    645434psS32 testPoly4DEvalVector(void)
    646435{
    … …  
    648437    psPolynomial4D* polyOrd = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_ORD);
    649438    psPolynomial4D* polyCheb = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_CHEB);
    650 
     439 
    651440    // Set polynomial members
    652441    for(psS32 i = 0; i < TERMS; i++) {
    … …  
    662451        }
    663452    }
    664 
     453 
    665454    // Create input vectors
    666455    psVector* inputOrdW  = psVectorAlloc(TESTPOINTS, PS_TYPE_F64);
    … …  
    682471        inputChebZ->data.F64[i] = Dpoly4DWXYZChebValue[i][3];
    683472    }
    684 
     473 
    685474    // Evaluate the vectors
    686475    psVector* outputOrd = psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ);
    687476    if(outputOrd == NULL) {
    688         psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
    689         return 1;
     477        printf("TEST ERROR: Unexpected return of NULL.");
     478        testStatus = false;
    690479    }
    691480    if(outputOrd->type.type != PS_TYPE_F64) {
    692         psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d",
     481        printf("TEST ERROR: Output vector of type %d expected %d",
    693482                outputOrd->type.type, PS_TYPE_F64);
    694         return 2;
     483        testStatus = false;
    695484    }
    696485    psVector* outputCheb = psPolynomial4DEvalVector(polyCheb,inputChebW,inputChebX,inputChebY,inputChebZ);
    697486    if(outputCheb == NULL) {
    698         psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
    699         return 1;
     487        printf("TEST ERROR: Unexpected return of NULL.");
     488        testStatus = false;
    700489    }
    701490    if(outputCheb->type.type != PS_TYPE_F64) {
    702         psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d",
     491        printf("TEST ERROR: Output vector of type %d expected %d",
    703492                outputCheb->type.type, PS_TYPE_F64);
    704         return 2;
    705     }
    706 
     493        testStatus = false;
     494    }
     495 
    707496    // Verify the results
    708497    for(psS32 i = 0; i < TESTPOINTS; i++) {
    709498        if(fabs(Dpoly4DResult[i]-outputOrd->data.F64[i]) > ERROR_TOL) {
    710             psError(PS_ERR_UNKNOWN,true,"Result[%d] %lg not equal to expected %lg",
     499            printf("TEST ERROR: Result[%d] %lg not equal to expected %lg",
    711500                    i, outputOrd->data.F64[i], Dpoly4DResult[i]);
    712             return i*5;
     501            testStatus = false;
    713502        }
    714503        if(fabs(Dpoly4DChebResult[i]-outputCheb->data.F64[i]) > ERROR_TOL) {
    715             psError(PS_ERR_UNKNOWN,true,"ResultCheb[%d] %lg not equal to expected %lg",
     504            printf("TEST ERROR: ResultCheb[%d] %lg not equal to expected %lg",
    716505                    i, outputCheb->data.F64[i], Dpoly4DChebResult[i]);
    717             return i*10;
     506            testStatus = false;
    718507        }
    719508    }
    720 
     509 
    721510    // Attempt to invoke function with null polynomial
    722511    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
    723512    if(psPolynomial4DEvalVector(NULL,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
    724         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL polynomial");
    725         return 60;
    726     }
    727 
     513        printf("TEST ERROR: Return of NULL expected for NULL polynomial");
     514        testStatus = false;
     515    }
     516 
    728517    // Attempt to invoke function with null input vector
    729518    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
    730519    if(psPolynomial4DEvalVector(polyOrd,NULL,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
    731         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
    732         return 61;
     520        printf("TEST ERROR: Return of NULL expected for NULL input vector");
     521        testStatus = false;
    733522    }
    734523    // Attempt to invoke function with null input vector
    735524    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
    736525    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,NULL,inputOrdY,inputOrdZ) != NULL) {
    737         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
    738         return 62;
     526        printf("TEST ERROR: Return of NULL expected for NULL input vector");
     527        testStatus = false;
    739528    }
    740529    // Attempt to invoke function with null input vector
    741530    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
    742531    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,NULL,inputOrdZ) != NULL) {
    743         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
    744         return 63;
     532        printf("TEST ERROR: Return of NULL expected for NULL input vector");
     533        testStatus = false;
    745534    }
    746535    // Attempt to invoke function with null input vector
    747536    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
    748537    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,NULL) != NULL) {
    749         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
    750         return 64;
    751     }
    752 
     538        printf("TEST ERROR: Return of NULL expected for NULL input vector");
     539        testStatus = false;
     540    }
     541 
    753542    // Attempt to invoke function with a non F64 type input vector
    754543    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
    755544    inputOrdX->type.type = PS_TYPE_U8;
    756545    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
    757         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
    758         return 65;
     546        printf("TEST ERROR: Return NULL expected for non-F64 input vector");
     547        testStatus = false;
    759548    }
    760549    inputOrdX->type.type = PS_TYPE_F64;
    … …  
    763552    inputOrdY->type.type = PS_TYPE_U8;
    764553    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
    765         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
    766         return 66;
     554        printf("TEST ERROR: Return NULL expected for non-F64 input vector");
     555        testStatus = false;
    767556    }
    768557    inputOrdY->type.type = PS_TYPE_F64;
    … …  
    771560    inputOrdZ->type.type = PS_TYPE_U8;
    772561    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
    773         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
    774         return 67;
     562        printf("TEST ERROR: Return NULL expected for non-F64 input vector");
     563        testStatus = false;
    775564    }
    776565    inputOrdZ->type.type = PS_TYPE_F64;
    … …  
    779568    inputOrdW->type.type = PS_TYPE_U8;
    780569    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
    781         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
    782         return 68;
     570        printf("TEST ERROR: Return NULL expected for non-F64 input vector");
     571        testStatus = false;
    783572    }
    784573    inputOrdW->type.type = PS_TYPE_F64;
    785 
     574 
    786575    psFree(inputOrdX);
    787576    psFree(inputOrdY);
    … …  
    796585    psFree(polyOrd);
    797586    psFree(polyCheb);
    798 
    799     return 0;
     587 
     588    return(testStatus);
    800589}
    801 
     590 
     591*/
Note: See TracChangeset for help on using the changeset viewer.