IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 4581 for trunk/psLib/test/math


Ignore:
Timestamp:
Jul 19, 2005, 3:21:13 PM (21 years ago)
Author:
drobbin
Message:

changed psPolynomial fxns to use F64 and removed psDPoly fxns

Location:
trunk/psLib/test/math
Files:
10 edited

Legend:

Unmodified
Added
Removed

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

    r4547 r4581  
    44*    allocated and deallocated by the psPolynomialXXXlloc() procedures.
    55*    It also calls the various psPolynomialXXXEval() procedures.
    6 * 
     6*
    77*    The F32 and F64 polynomials are tested for all orders (1 - 4) and for
    88*    both ordinary and chebyshev polynomials.
    9 * 
     9*
    1010*    NOTE: This test code requries the stdout file to verify that the results
    1111*    are good.
    12 * 
     12*
    1313*    XXX: Modify these tests so that polynomials with a variety of different
    1414*    orders are created.
    15 * 
    16 *    @version $Revision: 1.1 $  $Name: not supported by cvs2svn $
    17 *    @date $Date: 2005-07-13 02:47:00 $
     15*
     16*    @version $Revision: 1.2 $  $Name: not supported by cvs2svn $
     17*    @date $Date: 2005-07-20 01:21:13 $
    1818*
    1919*  Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
    20 *   
     20*
    2121*****************************************************************************/
    2222#include <stdio.h>
    … …  
    3131static psS32 testPolynomial3DAlloc(void);
    3232static psS32 testPolynomial4DAlloc(void);
    33 static psS32 testDPolynomial1DAlloc(void);
    34 static psS32 testDPolynomial2DAlloc(void);
    35 static psS32 testDPolynomial3DAlloc(void);
    36 static psS32 testDPolynomial4DAlloc(void);
    3733
    3834testDescription tests[] = {
    … …  
    4137                              {testPolynomial3DAlloc,578,"psPolynomial3DAlloc",0,false},
    4238                              {testPolynomial4DAlloc,578,"psPolynomial4DAlloc",0,false},
    43                               {testDPolynomial1DAlloc,579,"psDPolynomial1DAlloc",0,false},
    44                               {testDPolynomial2DAlloc,579,"psDPolynomial2DAlloc",0,false},
    45                               {testDPolynomial3DAlloc,579,"psDPolynomial3DAlloc",0,false},
    46                               {testDPolynomial4DAlloc,579,"psDPolynomial4DAlloc",0,false},
    4739                              {NULL}
    4840                          };
    … …  
    109101}
    110102
    111 // This test will allocate a 1D polynomial and verify the structure allocated
    112 psS32 testDPolynomial1DAlloc(void)
    113 {
    114     psDPolynomial1D*  my1DDPoly  = NULL;
    115 
    116     // Allocate polynomial
    117     my1DDPoly = psDPolynomial1DAlloc(ORDER,PS_POLYNOMIAL_CHEB);
    118     // Verify structure allocated
    119     if(my1DDPoly == NULL) {
    120         psError(PS_ERR_UNKNOWN,true,"Returned NULL not expected");
    121         return 1;
    122     }
    123     // Verify polynomial structure members set properly
    124     if(my1DDPoly->n != ORDER) {
    125         psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
    126                 my1DDPoly->n, ORDER);
    127         return 2;
    128     }
    129     if(my1DDPoly->type != PS_POLYNOMIAL_CHEB) {
    130         psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d",
    131                 my1DDPoly->type, PS_POLYNOMIAL_CHEB);
    132         return 3;
    133     }
    134     for(psS32 i = 0; i < ORDER; i++) {
    135         if(my1DDPoly->coeff[i] != 0.0) {
    136             psError(PS_ERR_UNKNOWN,true,"Coeff[%d] %lg not as expected %lg",
    137                     i, my1DDPoly->coeff[i], 0.0);
    138             return 4;
    139         }
    140         if(my1DDPoly->coeffErr[i] != 0.0) {
    141             psError(PS_ERR_UNKNOWN,true,"CoeffErr[%d] %lg not as expected %lg",
    142                     i, my1DDPoly->coeffErr[i], 0.0);
    143             return 5;
    144         }
    145         if(my1DDPoly->mask[i] != 0) {
    146             psError(PS_ERR_UNKNOWN,true,"Mask[%d] %d not as expected %d",
    147                     i, my1DDPoly->mask[i], 0);
    148             return 6;
    149         }
    150     }
    151     psFree(my1DDPoly);
    152 
    153     /*    // Attempt to allocate with negative order
    154         psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
    155         if(psDPolynomial1DAlloc(-1,PS_POLYNOMIAL_ORD) != NULL) {
    156             psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
    157             return 7;
    158         }
    159     */
    160     return 0;
    161 }
    162 
    163103// This test will allocate a 2D polynomial and verify the structure allocated
    164104psS32 testPolynomial2DAlloc(void)
    … …  
    220160        psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
    221161        if(psPolynomial2DAlloc(1,-1,PS_POLYNOMIAL_ORD) != NULL) {
    222             psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
    223             return 9;
    224         }
    225     */
    226     return 0;
    227 }
    228 
    229 // This test will allocate a 2D polynomial and verify the structure allocated
    230 psS32 testDPolynomial2DAlloc(void)
    231 {
    232     psDPolynomial2D* my2DDPoly = NULL;
    233 
    234     // Allocate polynomial
    235     my2DDPoly = psDPolynomial2DAlloc(ORDER,ORDER+1,PS_POLYNOMIAL_CHEB);
    236     // Verify structure allocated
    237     if(my2DDPoly == NULL) {
    238         psError(PS_ERR_UNKNOWN,true,"Returned NULL not expected");
    239         return 1;
    240     }
    241     // Verify polynomial structure members set properly
    242     if(my2DDPoly->nX != ORDER) {
    243         psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
    244                 my2DDPoly->nX, ORDER);
    245         return 2;
    246     }
    247     // Verify polynomial structure members set properly
    248     if(my2DDPoly->nY != ORDER+1) {
    249         psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
    250                 my2DDPoly->nY, ORDER+1);
    251         return 3;
    252     }
    253     if(my2DDPoly->type != PS_POLYNOMIAL_CHEB) {
    254         psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d",
    255                 my2DDPoly->type, PS_POLYNOMIAL_ORD);
    256         return 4;
    257     }
    258     for(psS32 i = 0; i < ORDER; i++) {
    259         for(psS32 j = 0; j < ORDER+1; j++) {
    260             if(my2DDPoly->coeff[i][j] != 0.0) {
    261                 psError(PS_ERR_UNKNOWN,true,"Coeff[%d][%d] %lg not as expected %lg",
    262                         i, j, my2DDPoly->coeff[i][j], 0.0);
    263                 return 5;
    264             }
    265             if(my2DDPoly->coeffErr[i][j] != 0.0) {
    266                 psError(PS_ERR_UNKNOWN,true,"CoeffErr[%d][%d] %lg not as expected %lg",
    267                         i, j, my2DDPoly->coeffErr[i][j], 0.0);
    268                 return 6;
    269             }
    270             if(my2DDPoly->mask[i][j] != 0) {
    271                 psError(PS_ERR_UNKNOWN,true,"Mask[%d][%d] %d not as expected %d",
    272                         i, j, my2DDPoly->mask[i][j], 0);
    273                 return 7;
    274             }
    275         }
    276     }
    277     psFree(my2DDPoly);
    278     /*
    279         // Attempt to allocate with negative order
    280         psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
    281         if(psDPolynomial2DAlloc(-1,1,PS_POLYNOMIAL_ORD) != NULL) {
    282             psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
    283             return 8;
    284         }
    285         // Attempt to allocate with negative order
    286         psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
    287         if(psDPolynomial2DAlloc(1,-1,PS_POLYNOMIAL_ORD) != NULL) {
    288162            psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
    289163            return 9;
    … …  
    366240        psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
    367241        if(psPolynomial3DAlloc(1,1,-1,PS_POLYNOMIAL_ORD) != NULL) {
    368             psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
    369             return 11;
    370         }
    371     */
    372     return 0;
    373 }
    374 
    375 // This test will allocate a 3D polynomial and verify the structure allocated
    376 psS32 testDPolynomial3DAlloc(void)
    377 {
    378     psDPolynomial3D* my3DDPoly = NULL;
    379 
    380     // Allocate polynomial
    381     my3DDPoly = psDPolynomial3DAlloc(ORDER,ORDER+1,ORDER+2,PS_POLYNOMIAL_CHEB);
    382     // Verify structure allocated
    383     if(my3DDPoly == NULL) {
    384         psError(PS_ERR_UNKNOWN,true,"Returned NULL not expected");
    385         return 1;
    386     }
    387     // Verify polynomial structure members set properly
    388     if(my3DDPoly->nX != ORDER) {
    389         psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
    390                 my3DDPoly->nX, ORDER);
    391         return 2;
    392     }
    393     // Verify polynomial structure members set properly
    394     if(my3DDPoly->nY != ORDER+1) {
    395         psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
    396                 my3DDPoly->nY, ORDER+1);
    397         return 3;
    398     }
    399     // Verify polynomial structure members set properly
    400     if(my3DDPoly->nZ != ORDER+2) {
    401         psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
    402                 my3DDPoly->nZ, ORDER+2);
    403         return 4;
    404     }
    405     if(my3DDPoly->type != PS_POLYNOMIAL_CHEB) {
    406         psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d",
    407                 my3DDPoly->type, PS_POLYNOMIAL_ORD);
    408         return 5;
    409     }
    410     for(psS32 i = 0; i < ORDER; i++) {
    411         for(psS32 j = 0; j < ORDER+1; j++) {
    412             for(psS32 k = 0; k < ORDER+2; k++) {
    413                 if(my3DDPoly->coeff[i][j][k] != 0.0) {
    414                     psError(PS_ERR_UNKNOWN,true,"Coeff[%d][%d][%d] %lg not as expected %lg",
    415                             i, j, k, my3DDPoly->coeff[i][j][k], 0.0);
    416                     return 6;
    417                 }
    418                 if(my3DDPoly->coeffErr[i][j][k] != 0.0) {
    419                     psError(PS_ERR_UNKNOWN,true,"CoeffErr[%d][%d][%d] %lg not as expected %lg",
    420                             i, j, k, my3DDPoly->coeffErr[i][j][k], 0.0);
    421                     return 7;
    422                 }
    423                 if(my3DDPoly->mask[i][j][k] != 0) {
    424                     psError(PS_ERR_UNKNOWN,true,"Mask[%d][%d] %d not as expected %d",
    425                             i, j, k, my3DDPoly->mask[i][j][k], 0);
    426                     return 8;
    427                 }
    428             }
    429         }
    430     }
    431     psFree(my3DDPoly);
    432 
    433     /*    // Attempt to allocate with negative order
    434         psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
    435         if(psDPolynomial3DAlloc(-1,1,1,PS_POLYNOMIAL_ORD) != NULL) {
    436             psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
    437             return 9;
    438         }
    439         // Attempt to allocate with negative order
    440         psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
    441         if(psDPolynomial3DAlloc(1,-1,1,PS_POLYNOMIAL_ORD) != NULL) {
    442             psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
    443             return 10;
    444         }
    445         // Attempt to allocate with negative order
    446         psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
    447         if(psDPolynomial3DAlloc(1,1,-1,PS_POLYNOMIAL_ORD) != NULL) {
    448242            psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
    449243            return 11;
    … …  
    547341}
    548342
    549 // This test will allocate a 4D polynomial and verify the structure allocated
    550 psS32 testDPolynomial4DAlloc(void)
    551 {
    552     psDPolynomial4D* my4DDPoly = NULL;
    553 
    554     // Allocate polynomial
    555     my4DDPoly = psDPolynomial4DAlloc(ORDER+3,ORDER,ORDER+1,ORDER+2,PS_POLYNOMIAL_ORD);
    556     // Verify structure allocated
    557     if(my4DDPoly == NULL) {
    558         psError(PS_ERR_UNKNOWN,true,"Returned NULL not expected");
    559         return 1;
    560     }
    561     // Verify polynomial structure members set properly
    562     if(my4DDPoly->nY != ORDER) {
    563         psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
    564                 my4DDPoly->nY, ORDER);
    565         return 2;
    566     }
    567     // Verify polynomial structure members set properly
    568     if(my4DDPoly->nZ != ORDER+1) {
    569         psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
    570                 my4DDPoly->nZ, ORDER+1);
    571         return 3;
    572     }
    573     // Verify polynomial structure members set properly
    574     if(my4DDPoly->nT != ORDER+2) {
    575         psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
    576                 my4DDPoly->nT, ORDER+2);
    577         return 4;
    578     }
    579     // Verify polynomial structure members set properly
    580     if(my4DDPoly->nX != ORDER+3) {
    581         psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
    582                 my4DDPoly->nX, ORDER+3);
    583         return 5;
    584     }
    585     if(my4DDPoly->type != PS_POLYNOMIAL_ORD) {
    586         psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d",
    587                 my4DDPoly->type, PS_POLYNOMIAL_ORD);
    588         return 6;
    589     }
    590     for(psS32 i = 0; i < ORDER+3; i++) {
    591         for(psS32 j = 0; j < ORDER; j++) {
    592             for(psS32 k = 0; k < ORDER+1; k++) {
    593                 for(psS32 l = 0; l < ORDER+2; l++) {
    594                     if(my4DDPoly->coeff[i][j][k][l] != 0.0) {
    595                         psError(PS_ERR_UNKNOWN,true,"Coeff[%d][%d][%d][%d] %lg not as expected %lg",
    596                                 i, j, k, l, my4DDPoly->coeff[i][j][k][l], 0.0);
    597                         return 7;
    598                     }
    599                     if(my4DDPoly->coeffErr[i][j][k][l] != 0.0) {
    600                         psError(PS_ERR_UNKNOWN,true,"CoeffErr[%d][%d][%d][l] %lg not as expected %lg",
    601                                 i, j, k, l, my4DDPoly->coeffErr[i][j][k][l], 0.0);
    602                         return 8;
    603                     }
    604                     if(my4DDPoly->mask[i][j][k][l] != 0) {
    605                         psError(PS_ERR_UNKNOWN,true,"Mask[%d][%d][%d][%d] %d not as expected %d",
    606                                 i, j, k, l, my4DDPoly->mask[i][j][k][l], 0);
    607                         return 9;
    608                     }
    609                 }
    610             }
    611         }
    612     }
    613     psFree(my4DDPoly);
    614 
    615     /*    // Attempt to allocate with negative order
    616         psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
    617         if(psDPolynomial4DAlloc(-1,1,1,1,PS_POLYNOMIAL_ORD) != NULL) {
    618             psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
    619             return 10;
    620         }
    621         // Attempt to allocate with negative order
    622         psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
    623         if(psDPolynomial4DAlloc(1,-1,1,1,PS_POLYNOMIAL_ORD) != NULL) {
    624             psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
    625             return 11;
    626         }
    627         // Attempt to allocate with negative order
    628         psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
    629         if(psDPolynomial4DAlloc(1,1,-1,1,PS_POLYNOMIAL_ORD) != NULL) {
    630             psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
    631             return 12;
    632         }
    633         // Attempt to allocate with negative order
    634         psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
    635         if(psDPolynomial4DAlloc(1,1,1,-1,PS_POLYNOMIAL_ORD) != NULL) {
    636             psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
    637             return 13;
    638         }
    639     */
    640     return 0;
    641 }
    642 

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

    r4547 r4581  
    44*  ORD and CHEB type polynomials.
    55*
    6 *  @version  $Revision: 1.1 $  $Name: not supported by cvs2svn $
    7 *  @date  $Date: 2005-07-13 02:47:00 $
     6*  @version  $Revision: 1.2 $  $Name: not supported by cvs2svn $
     7*  @date  $Date: 2005-07-20 01:21:13 $
    88*
    99*  XXX: Probably should test single- and multi-dimensional polynomials in
    … …  
    2222
    2323static psS32 testPoly1DEval(void);
    24 static psS32 testDPoly1DEval(void);
    2524static psS32 testPoly1DEvalVector(void);
    26 static psS32 testDPoly1DEvalVector(void);
    2725
    2826testDescription tests[] = {
    2927                              {testPoly1DEval,000,"psPolynomial1DEval",0,false},
    30                               {testDPoly1DEval,000,"psDPolynomial1DEval",0,false},
    3128                              {testPoly1DEvalVector,000,"psPolynomial1DEvalVector",0,false},
    32                               {testDPoly1DEvalVector,000,"psDPolynomial1DEvalVector",0,false},
    3329                              {NULL}
    3430                          };
    … …  
    5854psS32 testPoly1DEval(void)
    5955{
    60     psF32  result;
    61     psF32  resultCheb;
     56    psF64  result;
     57    psF64  resultCheb;
    6258
    6359    // Allocate polynomial structure
    … …  
    10399}
    104100
    105 // This test will verify operation of 1D polynomial evaluation
    106 psS32 testDPoly1DEval(void)
    107 {
    108     psF64  result;
    109     psF64  resultCheb;
    110 
    111     // Allocate polynomial structure
    112     psDPolynomial1D*  polyOrd = psDPolynomial1DAlloc(TERMS, PS_POLYNOMIAL_ORD);
    113     psDPolynomial1D*  polyCheb = psDPolynomial1DAlloc(TERMS, PS_POLYNOMIAL_CHEB);
    114     // Set polynomial members
    115     for(psS32 i = 0; i < TERMS; i++) {
    116         polyOrd->coeff[i] = Dpoly1DCoeff[i];
    117         polyOrd->mask[i]  = poly1DMask[i];
    118         polyCheb->coeff[i] = 1.0;
    119         polyCheb->mask[i]  = poly1DMask[i];
    120     }
    121     // Evaluate test points and verify results
    122     for(psS32 i = 0; i < TESTPOINTS; i++) {
    123         result = psDPolynomial1DEval(polyOrd,Dpoly1DXValue[i]);
    124         if(fabs(Dpoly1DXResult[i]-result) > ERROR_TOL ) {
    125             psError(PS_ERR_UNKNOWN,true,"Evaluated value %lg not as expected %lg",
    126                     result, Dpoly1DXResult[i]);
    127             return i;
    128         }
    129         resultCheb = psDPolynomial1DEval(polyCheb,Dpoly1DXChebValue[i]);
    130         if(fabs(Dpoly1DXChebResult[i]-resultCheb) > ERROR_TOL ) {
    131             psError(PS_ERR_UNKNOWN,true,"Evaluated Chebyshev value %lg not as expected %lg",
    132                     resultCheb, Dpoly1DXChebResult[i]);
    133             return 5*i;
    134         }
    135     }
    136     psFree(polyOrd);
    137     psFree(polyCheb);
    138 
    139     // Allocate polynomial with invalid type
    140     polyOrd = psDPolynomial1DAlloc(TERMS, 99);
    141     // Attempt to evaluation invalid polynomial type
    142     psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
    143     result = psDPolynomial1DEval(polyOrd,0.0);
    144     if ( !isnan(result) ) {
    145         psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid polynomial type");
    146         return 20;
    147     }
    148     psFree(polyOrd);
    149 
    150     return 0;
    151 }
    152101
    153102psS32 testPoly1DEvalVector(void)
    … …  
    156105    psPolynomial1D* polyOrd = psPolynomial1DAlloc(TERMS,PS_POLYNOMIAL_ORD);
    157106    psPolynomial1D* polyCheb = psPolynomial1DAlloc(TERMS,PS_POLYNOMIAL_CHEB);
    158 
    159     // Set polynomial members
    160     for(psS32 i = 0; i < TERMS; i++) {
    161         polyOrd->coeff[i] = poly1DCoeff[i];
    162         polyOrd->mask[i]  = poly1DMask[i];
    163         polyCheb->coeff[i] = 1.0;
    164         polyCheb->mask[i]  = poly1DMask[i];
    165     }
    166 
    167     // Create input vectors
    168     psVector* inputOrd = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
    169     psVector* inputCheb = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
    170     for(psS32 i = 0; i < TESTPOINTS; i++) {
    171         inputOrd->data.F32[i] = poly1DXValue[i];
    172         inputCheb->data.F32[i] = poly1DXChebValue[i];
    173     }
    174 
    175     // Evaluate the vectors
    176     psVector* outputOrd = psPolynomial1DEvalVector(polyOrd, inputOrd);
    177     if(outputOrd == NULL) {
    178         psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
    179         return 1;
    180     }
    181     if(outputOrd->type.type != PS_TYPE_F32) {
    182         psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d",
    183                 outputOrd->type.type, PS_TYPE_F32);
    184         return 2;
    185     }
    186     psVector* outputCheb = psPolynomial1DEvalVector(polyCheb, inputCheb);
    187     if(outputCheb == NULL) {
    188         psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
    189         return 1;
    190     }
    191     if(outputCheb->type.type != PS_TYPE_F32) {
    192         psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d",
    193                 outputCheb->type.type, PS_TYPE_F32);
    194         return 2;
    195     }
    196 
    197     // Verify the results
    198     for(psS32 i = 0; i < TESTPOINTS; i++) {
    199         if(fabs(poly1DXResult[i]-outputOrd->data.F32[i]) > ERROR_TOL) {
    200             psError(PS_ERR_UNKNOWN,true,"Result[%d] %g not equal to expected %g",
    201                     i, outputOrd->data.F32[i], poly1DXResult[i]);
    202             return i*5;
    203         }
    204         if(fabs(poly1DXChebResult[i]-outputCheb->data.F32[i]) > ERROR_TOL) {
    205             psError(PS_ERR_UNKNOWN,true,"ResultCheb[%d] %g not equal to expected %g",
    206                     i, outputCheb->data.F32[i], poly1DXChebResult[i]);
    207             return i*10;
    208         }
    209     }
    210 
    211     // Attempt to invoke function with null polynomial
    212     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
    213     if(psPolynomial1DEvalVector(NULL, inputOrd) != NULL) {
    214         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL polynomial");
    215         return 60;
    216     }
    217 
    218     // Attempt to invoke function with null input vector
    219     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
    220     if(psPolynomial1DEvalVector(polyOrd,NULL) != NULL) {
    221         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
    222         return 61;
    223     }
    224 
    225     // Attempt to invoke function with a non F32 type input vector
    226     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
    227     inputOrd->type.type = PS_TYPE_U8;
    228     if(psPolynomial1DEvalVector(polyOrd,inputOrd) != NULL) {
    229         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F32 input vector");
    230         return 62;
    231     }
    232     inputOrd->type.type = PS_TYPE_F32;
    233 
    234     psFree(inputOrd);
    235     psFree(inputCheb);
    236     psFree(outputOrd);
    237     psFree(outputCheb);
    238     psFree(polyOrd);
    239     psFree(polyCheb);
    240 
    241     return 0;
    242 }
    243 
    244 psS32 testDPoly1DEvalVector(void)
    245 {
    246     // Allocate polynomial
    247     psDPolynomial1D* polyOrd = psDPolynomial1DAlloc(TERMS,PS_POLYNOMIAL_ORD);
    248     psDPolynomial1D* polyCheb = psDPolynomial1DAlloc(TERMS,PS_POLYNOMIAL_CHEB);
    249107
    250108    // Set polynomial members
    … …  
    265123
    266124    // Evaluate the vectors
    267     psVector* outputOrd = psDPolynomial1DEvalVector(polyOrd, inputOrd);
     125    psVector* outputOrd = psPolynomial1DEvalVector(polyOrd, inputOrd);
    268126    if(outputOrd == NULL) {
    269127        psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
    … …  
    275133        return 2;
    276134    }
    277     psVector* outputCheb = psDPolynomial1DEvalVector(polyCheb, inputCheb);
     135    psVector* outputCheb = psPolynomial1DEvalVector(polyCheb, inputCheb);
    278136    if(outputCheb == NULL) {
    279137        psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
    … …  
    302160    // Attempt to invoke function with null polynomial
    303161    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
    304     if(psDPolynomial1DEvalVector(NULL, inputOrd) != NULL) {
     162    if(psPolynomial1DEvalVector(NULL, inputOrd) != NULL) {
    305163        psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL polynomial");
    306164        return 60;
    … …  
    309167    // Attempt to invoke function with null input vector
    310168    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
    311     if(psDPolynomial1DEvalVector(polyOrd,NULL) != NULL) {
     169    if(psPolynomial1DEvalVector(polyOrd,NULL) != NULL) {
    312170        psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
    313171        return 61;
    … …  
    317175    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
    318176    inputOrd->type.type = PS_TYPE_U8;
    319     if(psDPolynomial1DEvalVector(polyOrd,inputOrd) != NULL) {
     177    if(psPolynomial1DEvalVector(polyOrd,inputOrd) != NULL) {
    320178        psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
    321179        return 62;

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

    r4547 r4581  
    44*  ORD and CHEB type polynomials.
    55*
    6 *  @version  $Revision: 1.1 $  $Name: not supported by cvs2svn $
    7 *  @date  $Date: 2005-07-13 02:47:00 $
     6*  @version  $Revision: 1.2 $  $Name: not supported by cvs2svn $
     7*  @date  $Date: 2005-07-20 01:21:13 $
    88*
    99* Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
    … …  
    1919
    2020static psS32 testPoly2DEval(void);
    21 static psS32 testDPoly2DEval(void);
    2221static psS32 testPoly2DEvalVector(void);
    23 static psS32 testDPoly2DEvalVector(void);
    2422
    2523testDescription tests[] = {
    2624                              {testPoly2DEval,583,"psPolynomial2DEval",0,false},
    27                               {testDPoly2DEval,582,"psDPolynomial2DEval",0,false},
    2825                              {testPoly2DEvalVector,000,"psPolynomial2DEvalVector",0,false},
    29                               {testDPoly2DEvalVector,000,"psDPolynomial2DEvalVector",0,false},
    3026                              {NULL}
    3127                          };
    … …  
    8581
    8682// This test will verify operation of 1D polynomial evaluation
    87 psS32 testPoly2DEval(void)
     83/*psS32 testPoly2DEval(void)
    8884{
    8985    psF32  result;
    9086    psF32  resultCheb;
    91 
     87 
    9288    // Allocate polynomial structure
    9389    psPolynomial2D*  polyOrd = psPolynomial2DAlloc(TERMS, TERMS, PS_POLYNOMIAL_ORD);
    … …  
    119115    psFree(polyOrd);
    120116    psFree(polyCheb);
    121 
     117 
    122118    // Allocate polynomial with invalid type
    123119    polyOrd = psPolynomial2DAlloc(TERMS, TERMS, 99);
    … …  
    130126    }
    131127    psFree(polyOrd);
    132 
     128 
    133129    return 0;
    134130}
    135 
     131*/
    136132// This test will verify operation of 1D polynomial evaluation
    137 psS32 testDPoly2DEval(void)
     133psS32 testPoly2DEval(void)
    138134{
    139135    psF64  result;
    … …  
    141137
    142138    // Allocate polynomial structure
    143     psDPolynomial2D*  polyOrd = psDPolynomial2DAlloc(TERMS, TERMS, PS_POLYNOMIAL_ORD);
    144     psDPolynomial2D*  polyCheb = psDPolynomial2DAlloc(TERMS, TERMS, PS_POLYNOMIAL_CHEB);
     139    psPolynomial2D*  polyOrd = psPolynomial2DAlloc(TERMS, TERMS, PS_POLYNOMIAL_ORD);
     140    psPolynomial2D*  polyCheb = psPolynomial2DAlloc(TERMS, TERMS, PS_POLYNOMIAL_CHEB);
    145141    // Set polynomial members
    146142    for(psS32 i = 0; i < TERMS; i++) {
    … …  
    154150    // Evaluate test points and verify results
    155151    for(psS32 i = 0; i < TESTPOINTS; i++) {
    156         result = psDPolynomial2DEval(polyOrd,Dpoly2DXYValue[i][0],Dpoly2DXYValue[i][1]);
     152        result = psPolynomial2DEval(polyOrd,Dpoly2DXYValue[i][0],Dpoly2DXYValue[i][1]);
    157153        if(fabs(Dpoly2DResult[i]-result) > ERROR_TOL ) {
    158154            psError(PS_ERR_UNKNOWN,true,"Evaluated value %lg not as expected %lg",
    … …  
    160156            return i;
    161157        }
    162         resultCheb = psDPolynomial2DEval(polyCheb,Dpoly2DXYChebValue[i][0],Dpoly2DXYChebValue[i][1]);
     158        resultCheb = psPolynomial2DEval(polyCheb,Dpoly2DXYChebValue[i][0],Dpoly2DXYChebValue[i][1]);
    163159        if(fabs(Dpoly2DChebResult[i]-resultCheb) > ERROR_TOL ) {
    164160            psError(PS_ERR_UNKNOWN,true,"Evaluated Chebyshev value %lg not as expected %lg",
    … …  
    171167
    172168    // Allocate polynomial with invalid type
    173     polyOrd = psDPolynomial2DAlloc(TERMS, TERMS, 99);
     169    polyOrd = psPolynomial2DAlloc(TERMS, TERMS, 99);
    174170    // Attempt to evaluation invalid polynomial type
    175171    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
    176     result = psDPolynomial2DEval(polyOrd,0.0, 0.0);
     172    result = psPolynomial2DEval(polyOrd,0.0, 0.0);
    177173    if ( !isnan(result) ) {
    178174        psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid polynomial type");
    … …  
    184180}
    185181
    186 psS32 testPoly2DEvalVector(void)
     182/*psS32 testPoly2DEvalVector(void)
    187183{
    188184    // Allocate polynomial
    189185    psPolynomial2D* polyOrd = psPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_ORD);
    190186    psPolynomial2D* polyCheb = psPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_CHEB);
    191 
     187 
    192188    // Set polynomial members
    193189    for(psS32 i = 0; i < TERMS; i++) {
    … …  
    199195        }
    200196    }
    201 
     197 
    202198    // Create input vectors
    203199    psVector* inputOrdX  = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
    … …  
    211207        inputChebY->data.F32[i] = poly2DXYChebValue[i][1];
    212208    }
    213 
     209 
    214210    // Evaluate the vectors
    215211    psVector* outputOrd = psPolynomial2DEvalVector(polyOrd, inputOrdX, inputOrdY);
    … …  
    233229        return 2;
    234230    }
    235 
     231 
    236232    // Verify the results
    237233    for(psS32 i = 0; i < TESTPOINTS; i++) {
    … …  
    247243        }
    248244    }
    249 
     245 
    250246    // Attempt to invoke function with null polynomial
    251247    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
    … …  
    254250        return 60;
    255251    }
    256 
     252 
    257253    // Attempt to invoke function with null input vector
    258254    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
    … …  
    267263        return 62;
    268264    }
    269 
     265 
    270266    // Attempt to invoke function with a non F32 type input vector
    271267    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
    … …  
    284280    }
    285281    inputOrdY->type.type = PS_TYPE_F32;
    286 
     282 
    287283    psFree(inputOrdX);
    288284    psFree(inputOrdY);
    … …  
    293289    psFree(polyOrd);
    294290    psFree(polyCheb);
    295 
     291 
    296292    return 0;
    297293}
    298 
    299 psS32 testDPoly2DEvalVector(void)
     294*/
     295psS32 testPoly2DEvalVector(void)
    300296{
    301297    // Allocate polynomial
    302     psDPolynomial2D* polyOrd = psDPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_ORD);
    303     psDPolynomial2D* polyCheb = psDPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_CHEB);
     298    psPolynomial2D* polyOrd = psPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_ORD);
     299    psPolynomial2D* polyCheb = psPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_CHEB);
    304300
    305301    // Set polynomial members
    … …  
    326322
    327323    // Evaluate the vectors
    328     psVector* outputOrd = psDPolynomial2DEvalVector(polyOrd, inputOrdX, inputOrdY);
     324    psVector* outputOrd = psPolynomial2DEvalVector(polyOrd, inputOrdX, inputOrdY);
    329325    if(outputOrd == NULL) {
    330326        psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
    … …  
    336332        return 2;
    337333    }
    338     psVector* outputCheb = psDPolynomial2DEvalVector(polyCheb, inputChebX, inputChebY);
     334    psVector* outputCheb = psPolynomial2DEvalVector(polyCheb, inputChebX, inputChebY);
    339335    if(outputCheb == NULL) {
    340336        psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
    … …  
    363359    // Attempt to invoke function with null polynomial
    364360    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
    365     if(psDPolynomial2DEvalVector(NULL, inputOrdX, inputOrdY) != NULL) {
     361    if(psPolynomial2DEvalVector(NULL, inputOrdX, inputOrdY) != NULL) {
    366362        psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL polynomial");
    367363        return 60;
    … …  
    370366    // Attempt to invoke function with null input vector
    371367    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
    372     if(psDPolynomial2DEvalVector(polyOrd,NULL,inputOrdY) != NULL) {
     368    if(psPolynomial2DEvalVector(polyOrd,NULL,inputOrdY) != NULL) {
    373369        psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
    374370        return 61;
    … …  
    376372    // Attempt to invoke function with null input vector
    377373    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
    378     if(psDPolynomial2DEvalVector(polyOrd,inputOrdX,NULL) != NULL) {
     374    if(psPolynomial2DEvalVector(polyOrd,inputOrdX,NULL) != NULL) {
    379375        psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
    380376        return 62;
    … …  
    384380    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
    385381    inputOrdX->type.type = PS_TYPE_U8;
    386     if(psDPolynomial2DEvalVector(polyOrd,inputOrdX, inputOrdY) != NULL) {
     382    if(psPolynomial2DEvalVector(polyOrd,inputOrdX, inputOrdY) != NULL) {
    387383        psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
    388384        return 63;
    … …  
    392388    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
    393389    inputOrdY->type.type = PS_TYPE_U8;
    394     if(psDPolynomial2DEvalVector(polyOrd,inputOrdX, inputOrdY) != NULL) {
     390    if(psPolynomial2DEvalVector(polyOrd,inputOrdX, inputOrdY) != NULL) {
    395391        psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
    396392        return 64;

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

    r4547 r4581  
    44*  ORD and CHEB type polynomials.
    55*
    6 *  @version  $Revision: 1.1 $  $Name: not supported by cvs2svn $
    7 *  @date  $Date: 2005-07-13 02:47:00 $
     6*  @version  $Revision: 1.2 $  $Name: not supported by cvs2svn $
     7*  @date  $Date: 2005-07-20 01:21:13 $
    88*
    99* Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
    … …  
    1919
    2020static psS32 testPoly3DEval(void);
    21 static psS32 testDPoly3DEval(void);
    2221static psS32 testPoly3DEvalVector(void);
    23 static psS32 testDPoly3DEvalVector(void);
    2422
    2523testDescription tests[] = {
    2624                              {testPoly3DEval,583,"psPolynomial3DEval",0,false},
    27                               {testDPoly3DEval,582,"psDPolynomial3DEval",0,false},
    2825                              {testPoly3DEvalVector,000,"psPolynomial3DEvalVector",0,false},
    29                               {testDPoly3DEvalVector,000,"psDPolynomial3DEvalVector",0,false},
    3026                              {NULL}
    3127                          };
    … …  
    136132
    137133// This test will verify operation of 1D polynomial evaluation
    138 psS32 testPoly3DEval(void)
     134/*psS32 testPoly3DEval(void)
    139135{
    140136    psF32  result;
    141137    psF32  resultCheb;
    142 
     138 
    143139    // Allocate polynomial structure
    144140    psPolynomial3D*  polyOrd = psPolynomial3DAlloc(TERMS, TERMS, TERMS, PS_POLYNOMIAL_ORD);
    … …  
    174170    psFree(polyOrd);
    175171    psFree(polyCheb);
    176 
     172 
    177173    // Allocate polynomial with invalid type
    178174    polyOrd = psPolynomial3DAlloc(TERMS, TERMS, TERMS, 99);
    … …  
    185181    }
    186182    psFree(polyOrd);
    187 
     183 
    188184    return 0;
    189185}
    190 
     186*/
    191187// This test will verify operation of 1D polynomial evaluation
    192 psS32 testDPoly3DEval(void)
     188psS32 testPoly3DEval(void)
    193189{
    194190    psF64  result;
    … …  
    196192
    197193    // Allocate polynomial structure
    198     psDPolynomial3D*  polyOrd = psDPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
    199     psDPolynomial3D*  polyCheb = psDPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
     194    psPolynomial3D*  polyOrd = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
     195    psPolynomial3D*  polyCheb = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
    200196    // Set polynomial members
    201197    for(psS32 i = 0; i < TERMS; i++) {
    … …  
    211207    // Evaluate test points and verify results
    212208    for(psS32 i = 0; i < TESTPOINTS; i++) {
    213         result = psDPolynomial3DEval(polyOrd,Dpoly3DXYZValue[i][0],Dpoly3DXYZValue[i][1],
    214                                      Dpoly3DXYZValue[i][2]);
     209        result = psPolynomial3DEval(polyOrd,Dpoly3DXYZValue[i][0],Dpoly3DXYZValue[i][1],
     210                                    Dpoly3DXYZValue[i][2]);
    215211        if(fabs(Dpoly3DResult[i]-result) > ERROR_TOL ) {
    216212            psError(PS_ERR_UNKNOWN,true,"Evaluated value %lg not as expected %lg",
    … …  
    218214            return i;
    219215        }
    220         resultCheb = psDPolynomial3DEval(polyCheb,Dpoly3DXYZChebValue[i][0],Dpoly3DXYZChebValue[i][1],
    221                                          Dpoly3DXYZChebValue[i][2]);
     216        resultCheb = psPolynomial3DEval(polyCheb,Dpoly3DXYZChebValue[i][0],Dpoly3DXYZChebValue[i][1],
     217                                        Dpoly3DXYZChebValue[i][2]);
    222218        if(fabs(Dpoly3DChebResult[i]-resultCheb) > ERROR_TOL ) {
    223219            psError(PS_ERR_UNKNOWN,true,"Evaluated Chebyshev value %lg not as expected %lg",
    … …  
    230226
    231227    // Allocate polynomial with invalid type
    232     polyOrd = psDPolynomial3DAlloc(TERMS, TERMS, TERMS, 99);
     228    polyOrd = psPolynomial3DAlloc(TERMS, TERMS, TERMS, 99);
    233229    // Attempt to evaluation invalid polynomial type
    234230    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
    235     result = psDPolynomial3DEval(polyOrd,0.0, 0.0, 0.0);
     231    result = psPolynomial3DEval(polyOrd,0.0, 0.0, 0.0);
    236232    if ( !isnan(result) ) {
    237233        psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid polynomial type");
    … …  
    243239}
    244240
    245 psS32 testPoly3DEvalVector(void)
     241/*psS32 testPoly3DEvalVector(void)
    246242{
    247243    // Allocate polynomial
    248244    psPolynomial3D* polyOrd  = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
    249245    psPolynomial3D* polyCheb = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
    250 
     246 
    251247    // Set polynomial members
    252248    for(psS32 i = 0; i < TERMS; i++) {
    … …  
    260256        }
    261257    }
    262 
     258 
    263259    // Create input vectors
    264260    psVector* inputOrdX  = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
    … …  
    276272        inputChebZ->data.F32[i] = poly3DXYZChebValue[i][2];
    277273    }
    278 
     274 
    279275    // Evaluate the vectors
    280276    psVector* outputOrd = psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ);
    … …  
    298294        return 2;
    299295    }
    300 
     296 
    301297    // Verify the results
    302298    for(psS32 i = 0; i < TESTPOINTS; i++) {
    … …  
    312308        }
    313309    }
    314 
     310 
    315311    // Attempt to invoke function with null polynomial
    316312    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
    … …  
    319315        return 60;
    320316    }
    321 
     317 
    322318    // Attempt to invoke function with null input vector
    323319    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
    … …  
    338334        return 63;
    339335    }
    340 
     336 
    341337    // Attempt to invoke function with a non F32 type input vector
    342338    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
    … …  
    363359    }
    364360    inputOrdZ->type.type = PS_TYPE_F32;
    365 
     361 
    366362    psFree(inputOrdX);
    367363    psFree(inputOrdY);
    … …  
    374370    psFree(polyOrd);
    375371    psFree(polyCheb);
    376 
     372 
    377373    return 0;
    378374}
    379 
    380 psS32 testDPoly3DEvalVector(void)
     375*/
     376psS32 testPoly3DEvalVector(void)
    381377{
    382378    // Allocate polynomial
    383     psDPolynomial3D* polyOrd = psDPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
    384     psDPolynomial3D* polyCheb = psDPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
     379    psPolynomial3D* polyOrd = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
     380    psPolynomial3D* polyCheb = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
    385381
    386382    // Set polynomial members
    … …  
    413409
    414410    // Evaluate the vectors
    415     psVector* outputOrd = psDPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ);
     411    psVector* outputOrd = psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ);
    416412    if(outputOrd == NULL) {
    417413        psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
    … …  
    423419        return 2;
    424420    }
    425     psVector* outputCheb = psDPolynomial3DEvalVector(polyCheb,inputChebX,inputChebY,inputChebZ);
     421    psVector* outputCheb = psPolynomial3DEvalVector(polyCheb,inputChebX,inputChebY,inputChebZ);
    426422    if(outputCheb == NULL) {
    427423        psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
    … …  
    450446    // Attempt to invoke function with null polynomial
    451447    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
    452     if(psDPolynomial3DEvalVector(NULL,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
     448    if(psPolynomial3DEvalVector(NULL,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
    453449        psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL polynomial");
    454450        return 60;
    … …  
    457453    // Attempt to invoke function with null input vector
    458454    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
    459     if(psDPolynomial3DEvalVector(polyOrd,NULL,inputOrdY,inputOrdZ) != NULL) {
     455    if(psPolynomial3DEvalVector(polyOrd,NULL,inputOrdY,inputOrdZ) != NULL) {
    460456        psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
    461457        return 61;
    … …  
    463459    // Attempt to invoke function with null input vector
    464460    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
    465     if(psDPolynomial3DEvalVector(polyOrd,inputOrdX,NULL,inputOrdZ) != NULL) {
     461    if(psPolynomial3DEvalVector(polyOrd,inputOrdX,NULL,inputOrdZ) != NULL) {
    466462        psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
    467463        return 62;
    … …  
    469465    // Attempt to invoke function with null input vector
    470466    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
    471     if(psDPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,NULL) != NULL) {
     467    if(psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,NULL) != NULL) {
    472468        psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
    473469        return 63;
    … …  
    477473    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
    478474    inputOrdX->type.type = PS_TYPE_U8;
    479     if(psDPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
     475    if(psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
    480476        psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
    481477        return 64;
    … …  
    485481    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
    486482    inputOrdY->type.type = PS_TYPE_U8;
    487     if(psDPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
     483    if(psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
    488484        psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
    489485        return 65;
    … …  
    493489    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
    494490    inputOrdZ->type.type = PS_TYPE_U8;
    495     if(psDPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
     491    if(psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
    496492        psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
    497493        return 66;

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

    r4547 r4581  
    44*  ORD and CHEB type polynomials.
    55*
    6 *  @version  $Revision: 1.1 $  $Name: not supported by cvs2svn $
    7 *  @date  $Date: 2005-07-13 02:47:00 $
     6*  @version  $Revision: 1.2 $  $Name: not supported by cvs2svn $
     7*  @date  $Date: 2005-07-20 01:21:13 $
    88*
    99* Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
    … …  
    1919
    2020static psS32 testPoly4DEval(void);
    21 static psS32 testDPoly4DEval(void);
    2221static psS32 testPoly4DEvalVector(void);
    23 static psS32 testDPoly4DEvalVector(void);
    2422
    2523testDescription tests[] = {
    2624                              {testPoly4DEval,583,"psPolynomial4DEval",0,false},
    27                               {testDPoly4DEval,582,"psDPolynomial4DEval",0,false},
    2825                              {testPoly4DEvalVector,000,"psPolynomial4DEvalVector",0,false},
    29                               {testDPoly4DEvalVector,000,"psDPolynomial4DEvalVector",0,false},
    3026                              {NULL}
    3127                          };
    … …  
    378374
    379375// This test will verify operation of 1D polynomial evaluation
    380 psS32 testPoly4DEval(void)
     376/*psS32 testPoly4DEval(void)
    381377{
    382378    psF32  result;
    383379    psF32  resultCheb;
    384 
     380 
    385381    // Allocate polynomial structure
    386382    psPolynomial4D*  polyOrd  = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
    … …  
    418414    psFree(polyOrd);
    419415    psFree(polyCheb);
    420 
     416 
    421417    // Allocate polynomial with invalid type
    422418    polyOrd = psPolynomial4DAlloc(TERMS, TERMS, TERMS, TERMS, 99);
    … …  
    429425    }
    430426    psFree(polyOrd);
    431 
     427 
    432428    return 0;
    433429}
    434 
     430*/
    435431// This test will verify operation of 1D polynomial evaluation
    436 psS32 testDPoly4DEval(void)
     432psS32 testPoly4DEval(void)
    437433{
    438434    psF64  result;
    … …  
    440436
    441437    // Allocate polynomial structure
    442     psDPolynomial4D*  polyOrd = psDPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
    443     psDPolynomial4D*  polyCheb = psDPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
     438    psPolynomial4D*  polyOrd = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
     439    psPolynomial4D*  polyCheb = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
    444440    // Set polynomial members
    445441    for(psS32 i = 0; i < TERMS; i++) {
    … …  
    457453    // Evaluate test points and verify results
    458454    for(psS32 i = 0; i < TESTPOINTS; i++) {
    459         result = psDPolynomial4DEval(polyOrd,Dpoly4DWXYZValue[i][0],Dpoly4DWXYZValue[i][1],
    460                                      Dpoly4DWXYZValue[i][2],Dpoly4DWXYZValue[i][3]);
     455        result = psPolynomial4DEval(polyOrd,Dpoly4DWXYZValue[i][0],Dpoly4DWXYZValue[i][1],
     456                                    Dpoly4DWXYZValue[i][2],Dpoly4DWXYZValue[i][3]);
    461457        if(fabs(Dpoly4DResult[i]-result) > ERROR_TOL ) {
    462458            psError(PS_ERR_UNKNOWN,true,"Evaluated value %lg not as expected %lg",
    … …  
    464460            return i;
    465461        }
    466         resultCheb = psDPolynomial4DEval(polyCheb,Dpoly4DWXYZChebValue[i][0],Dpoly4DWXYZChebValue[i][1],
    467                                          Dpoly4DWXYZChebValue[i][2],Dpoly4DWXYZChebValue[i][3]);
     462        resultCheb = psPolynomial4DEval(polyCheb,Dpoly4DWXYZChebValue[i][0],Dpoly4DWXYZChebValue[i][1],
     463                                        Dpoly4DWXYZChebValue[i][2],Dpoly4DWXYZChebValue[i][3]);
    468464        if(fabs(Dpoly4DChebResult[i]-resultCheb) > ERROR_TOL ) {
    469465            psError(PS_ERR_UNKNOWN,true,"Evaluated Chebyshev value %lg not as expected %lg",
    … …  
    476472
    477473    // Allocate polynomial with invalid type
    478     polyOrd = psDPolynomial4DAlloc(TERMS, TERMS, TERMS, TERMS, 99);
     474    polyOrd = psPolynomial4DAlloc(TERMS, TERMS, TERMS, TERMS, 99);
    479475    // Attempt to evaluation invalid polynomial type
    480476    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
    481     result = psDPolynomial4DEval(polyOrd,0.0, 0.0, 0.0, 0.0);
     477    result = psPolynomial4DEval(polyOrd,0.0, 0.0, 0.0, 0.0);
    482478    if ( !isnan(result) ) {
    483479        psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid polynomial type");
    … …  
    489485}
    490486
    491 psS32 testPoly4DEvalVector(void)
     487/*psS32 testPoly4DEvalVector(void)
    492488{
    493489    // Allocate polynomial
    494490    psPolynomial4D* polyOrd  = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
    495491    psPolynomial4D* polyCheb = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
    496 
     492 
    497493    // Set polynomial members
    498494    for(psS32 i = 0; i < TERMS; i++) {
    … …  
    508504        }
    509505    }
    510 
     506 
    511507    // Create input vectors
    512508    psVector* inputOrdW  = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
    … …  
    528524        inputChebZ->data.F32[i] = poly4DWXYZChebValue[i][3];
    529525    }
    530 
     526 
    531527    // Evaluate the vectors
    532528    psVector* outputOrd = psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ);
    … …  
    550546        return 2;
    551547    }
    552 
     548 
    553549    // Verify the results
    554550    for(psS32 i = 0; i < TESTPOINTS; i++) {
    … …  
    564560        }
    565561    }
    566 
     562 
    567563    // Attempt to invoke function with null polynomial
    568564    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
    … …  
    571567        return 60;
    572568    }
    573 
     569 
    574570    // Attempt to invoke function with null input vector
    575571    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
    … …  
    596592        return 64;
    597593    }
    598 
     594 
    599595    // Attempt to invoke function with a non F32 type input vector
    600596    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
    … …  
    629625    }
    630626    inputOrdW->type.type = PS_TYPE_F32;
    631 
     627 
    632628    psFree(inputOrdW);
    633629    psFree(inputOrdX);
    … …  
    642638    psFree(polyOrd);
    643639    psFree(polyCheb);
    644 
     640 
    645641    return 0;
    646642}
    647 
    648 psS32 testDPoly4DEvalVector(void)
     643*/
     644psS32 testPoly4DEvalVector(void)
    649645{
    650646    // Allocate polynomial
    651     psDPolynomial4D* polyOrd = psDPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
    652     psDPolynomial4D* polyCheb = psDPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
     647    psPolynomial4D* polyOrd = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
     648    psPolynomial4D* polyCheb = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
    653649
    654650    // Set polynomial members
    … …  
    687683
    688684    // Evaluate the vectors
    689     psVector* outputOrd = psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ);
     685    psVector* outputOrd = psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ);
    690686    if(outputOrd == NULL) {
    691687        psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
    … …  
    697693        return 2;
    698694    }
    699     psVector* outputCheb = psDPolynomial4DEvalVector(polyCheb,inputChebW,inputChebX,inputChebY,inputChebZ);
     695    psVector* outputCheb = psPolynomial4DEvalVector(polyCheb,inputChebW,inputChebX,inputChebY,inputChebZ);
    700696    if(outputCheb == NULL) {
    701697        psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
    … …  
    724720    // Attempt to invoke function with null polynomial
    725721    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
    726     if(psDPolynomial4DEvalVector(NULL,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
     722    if(psPolynomial4DEvalVector(NULL,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
    727723        psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL polynomial");
    728724        return 60;
    … …  
    731727    // Attempt to invoke function with null input vector
    732728    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
    733     if(psDPolynomial4DEvalVector(polyOrd,NULL,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
     729    if(psPolynomial4DEvalVector(polyOrd,NULL,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
    734730        psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
    735731        return 61;
    … …  
    737733    // Attempt to invoke function with null input vector
    738734    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
    739     if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,NULL,inputOrdY,inputOrdZ) != NULL) {
     735    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,NULL,inputOrdY,inputOrdZ) != NULL) {
    740736        psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
    741737        return 62;
    … …  
    743739    // Attempt to invoke function with null input vector
    744740    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
    745     if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,NULL,inputOrdZ) != NULL) {
     741    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,NULL,inputOrdZ) != NULL) {
    746742        psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
    747743        return 63;
    … …  
    749745    // Attempt to invoke function with null input vector
    750746    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
    751     if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,NULL) != NULL) {
     747    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,NULL) != NULL) {
    752748        psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
    753749        return 64;
    … …  
    757753    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
    758754    inputOrdX->type.type = PS_TYPE_U8;
    759     if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
     755    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
    760756        psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
    761757        return 65;
    … …  
    765761    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
    766762    inputOrdY->type.type = PS_TYPE_U8;
    767     if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
     763    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
    768764        psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
    769765        return 66;
    … …  
    773769    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
    774770    inputOrdZ->type.type = PS_TYPE_U8;
    775     if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
     771    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
    776772        psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
    777773        return 67;
    … …  
    781777    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
    782778    inputOrdW->type.type = PS_TYPE_U8;
    783     if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
     779    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
    784780        psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
    785781        return 68;

  • trunk/psLib/test/math/verified/tst_psFunc00.stderr

    r4547 r4581  
    3535---> TESTPOINT PASSED (psPolynomialXD{psPolynomial4DAlloc} | tst_psFunc00.c)
    3636
    37 /***************************** TESTPOINT ******************************************\
    38 *             TestFile: tst_psFunc00.c                                             *
    39 *            TestPoint: psPolynomialXD{psDPolynomial1DAlloc}                       *
    40 *             TestType: Positive                                                   *
    41 \**********************************************************************************/
    42 
    43 
    44 ---> TESTPOINT PASSED (psPolynomialXD{psDPolynomial1DAlloc} | tst_psFunc00.c)
    45 
    46 /***************************** TESTPOINT ******************************************\
    47 *             TestFile: tst_psFunc00.c                                             *
    48 *            TestPoint: psPolynomialXD{psDPolynomial2DAlloc}                       *
    49 *             TestType: Positive                                                   *
    50 \**********************************************************************************/
    51 
    52 
    53 ---> TESTPOINT PASSED (psPolynomialXD{psDPolynomial2DAlloc} | tst_psFunc00.c)
    54 
    55 /***************************** TESTPOINT ******************************************\
    56 *             TestFile: tst_psFunc00.c                                             *
    57 *            TestPoint: psPolynomialXD{psDPolynomial3DAlloc}                       *
    58 *             TestType: Positive                                                   *
    59 \**********************************************************************************/
    60 
    61 
    62 ---> TESTPOINT PASSED (psPolynomialXD{psDPolynomial3DAlloc} | tst_psFunc00.c)
    63 
    64 /***************************** TESTPOINT ******************************************\
    65 *             TestFile: tst_psFunc00.c                                             *
    66 *            TestPoint: psPolynomialXD{psDPolynomial4DAlloc}                       *
    67 *             TestType: Positive                                                   *
    68 \**********************************************************************************/
    69 
    70 
    71 ---> TESTPOINT PASSED (psPolynomialXD{psDPolynomial4DAlloc} | tst_psFunc00.c)
    72 

  • trunk/psLib/test/math/verified/tst_psFunc08.stderr

    r4547 r4581  
    1111
    1212---> TESTPOINT PASSED (psPolynomialXDEval{psPolynomial1DEval} | tst_psFunc08.c)
    13 
    14 /***************************** TESTPOINT ******************************************\
    15 *             TestFile: tst_psFunc08.c                                             *
    16 *            TestPoint: psPolynomialXDEval{psDPolynomial1DEval}                    *
    17 *             TestType: Positive                                                   *
    18 \**********************************************************************************/
    19 
    20 <DATE><TIME>|<HOST>|I|testDPoly1DEval
    21     Following should generate error message invalid type
    22 <DATE><TIME>|<HOST>|E|psDPolynomial1DEval (FILE:LINENO)
    23     Unknown polynomial type 0x63 found.  Evaluation failed.
    24 
    25 ---> TESTPOINT PASSED (psPolynomialXDEval{psDPolynomial1DEval} | tst_psFunc08.c)
    2613
    2714/***************************** TESTPOINT ******************************************\
    … …  
    4633---> TESTPOINT PASSED (psPolynomialXDEval{psPolynomial1DEvalVector} | tst_psFunc08.c)
    4734
    48 /***************************** TESTPOINT ******************************************\
    49 *             TestFile: tst_psFunc08.c                                             *
    50 *            TestPoint: psPolynomialXDEval{psDPolynomial1DEvalVector}              *
    51 *             TestType: Positive                                                   *
    52 \**********************************************************************************/
    53 
    54 <DATE><TIME>|<HOST>|I|testDPoly1DEvalVector
    55     Following should generate an error message for NULL polynomial
    56 <DATE><TIME>|<HOST>|E|psDPolynomial1DEvalVector (FILE:LINENO)
    57     Unallowable operation: polynomial poly or its coeffs is NULL.
    58 <DATE><TIME>|<HOST>|I|testDPoly1DEvalVector
    59     Following should generate an error message for NULL input vector
    60 <DATE><TIME>|<HOST>|E|psDPolynomial1DEvalVector (FILE:LINENO)
    61     Unallowable operation: psVector x or its data is NULL.
    62 <DATE><TIME>|<HOST>|I|testDPoly1DEvalVector
    63     Following should generate an error message for invalid input type
    64 <DATE><TIME>|<HOST>|E|psDPolynomial1DEvalVector (FILE:LINENO)
    65     Unallowable operation: psVector x has incorrect type.
    66 
    67 ---> TESTPOINT PASSED (psPolynomialXDEval{psDPolynomial1DEvalVector} | tst_psFunc08.c)
    68 

  • trunk/psLib/test/math/verified/tst_psFunc09.stderr

    r4547 r4581  
    1111
    1212---> TESTPOINT PASSED (psPolynomialXDEval{psPolynomial2DEval} | tst_psFunc09.c)
    13 
    14 /***************************** TESTPOINT ******************************************\
    15 *             TestFile: tst_psFunc09.c                                             *
    16 *            TestPoint: psPolynomialXDEval{psDPolynomial2DEval}                    *
    17 *             TestType: Positive                                                   *
    18 \**********************************************************************************/
    19 
    20 <DATE><TIME>|<HOST>|I|testDPoly2DEval
    21     Following should generate error message invalid type
    22 <DATE><TIME>|<HOST>|E|psDPolynomial2DEval (FILE:LINENO)
    23     Unknown polynomial type 0x63 found.  Evaluation failed.
    24 
    25 ---> TESTPOINT PASSED (psPolynomialXDEval{psDPolynomial2DEval} | tst_psFunc09.c)
    2613
    2714/***************************** TESTPOINT ******************************************\
    … …  
    5441---> TESTPOINT PASSED (psPolynomialXDEval{psPolynomial2DEvalVector} | tst_psFunc09.c)
    5542
    56 /***************************** TESTPOINT ******************************************\
    57 *             TestFile: tst_psFunc09.c                                             *
    58 *            TestPoint: psPolynomialXDEval{psDPolynomial2DEvalVector}              *
    59 *             TestType: Positive                                                   *
    60 \**********************************************************************************/
    61 
    62 <DATE><TIME>|<HOST>|I|testDPoly2DEvalVector
    63     Following should generate an error message for NULL polynomial
    64 <DATE><TIME>|<HOST>|E|psDPolynomial2DEvalVector (FILE:LINENO)
    65     Unallowable operation: polynomial poly or its coeffs is NULL.
    66 <DATE><TIME>|<HOST>|I|testDPoly2DEvalVector
    67     Following should generate an error message for NULL input vector
    68 <DATE><TIME>|<HOST>|E|psDPolynomial2DEvalVector (FILE:LINENO)
    69     Unallowable operation: psVector x or its data is NULL.
    70 <DATE><TIME>|<HOST>|I|testDPoly2DEvalVector
    71     Following should generate an error message for NULL input vector
    72 <DATE><TIME>|<HOST>|E|psDPolynomial2DEvalVector (FILE:LINENO)
    73     Unallowable operation: psVector y or its data is NULL.
    74 <DATE><TIME>|<HOST>|I|testDPoly2DEvalVector
    75     Following should generate an error message for invalid input type
    76 <DATE><TIME>|<HOST>|E|psDPolynomial2DEvalVector (FILE:LINENO)
    77     Unallowable operation: psVector x has incorrect type.
    78 <DATE><TIME>|<HOST>|I|testDPoly2DEvalVector
    79     Following should generate an error message for invalid input type
    80 <DATE><TIME>|<HOST>|E|psDPolynomial2DEvalVector (FILE:LINENO)
    81     Unallowable operation: psVector y has incorrect type.
    82 
    83 ---> TESTPOINT PASSED (psPolynomialXDEval{psDPolynomial2DEvalVector} | tst_psFunc09.c)
    84 

  • trunk/psLib/test/math/verified/tst_psFunc10.stderr

    r4547 r4581  
    1111
    1212---> TESTPOINT PASSED (psPolynomialXDEval{psPolynomial3DEval} | tst_psFunc10.c)
    13 
    14 /***************************** TESTPOINT ******************************************\
    15 *             TestFile: tst_psFunc10.c                                             *
    16 *            TestPoint: psPolynomialXDEval{psDPolynomial3DEval}                    *
    17 *             TestType: Positive                                                   *
    18 \**********************************************************************************/
    19 
    20 <DATE><TIME>|<HOST>|I|testDPoly3DEval
    21     Following should generate error message invalid type
    22 <DATE><TIME>|<HOST>|E|psDPolynomial3DEval (FILE:LINENO)
    23     Unknown polynomial type 0x63 found.  Evaluation failed.
    24 
    25 ---> TESTPOINT PASSED (psPolynomialXDEval{psDPolynomial3DEval} | tst_psFunc10.c)
    2613
    2714/***************************** TESTPOINT ******************************************\
    … …  
    6249---> TESTPOINT PASSED (psPolynomialXDEval{psPolynomial3DEvalVector} | tst_psFunc10.c)
    6350
    64 /***************************** TESTPOINT ******************************************\
    65 *             TestFile: tst_psFunc10.c                                             *
    66 *            TestPoint: psPolynomialXDEval{psDPolynomial3DEvalVector}              *
    67 *             TestType: Positive                                                   *
    68 \**********************************************************************************/
    69 
    70 <DATE><TIME>|<HOST>|I|testDPoly3DEvalVector
    71     Following should generate an error message for NULL polynomial
    72 <DATE><TIME>|<HOST>|E|psDPolynomial3DEvalVector (FILE:LINENO)
    73     Unallowable operation: polynomial poly or its coeffs is NULL.
    74 <DATE><TIME>|<HOST>|I|testDPoly3DEvalVector
    75     Following should generate an error message for NULL input vector
    76 <DATE><TIME>|<HOST>|E|psDPolynomial3DEvalVector (FILE:LINENO)
    77     Unallowable operation: psVector x or its data is NULL.
    78 <DATE><TIME>|<HOST>|I|testDPoly3DEvalVector
    79     Following should generate an error message for NULL input vector
    80 <DATE><TIME>|<HOST>|E|psDPolynomial3DEvalVector (FILE:LINENO)
    81     Unallowable operation: psVector y or its data is NULL.
    82 <DATE><TIME>|<HOST>|I|testDPoly3DEvalVector
    83     Following should generate an error message for NULL input vector
    84 <DATE><TIME>|<HOST>|E|psDPolynomial3DEvalVector (FILE:LINENO)
    85     Unallowable operation: psVector z or its data is NULL.
    86 <DATE><TIME>|<HOST>|I|testDPoly3DEvalVector
    87     Following should generate an error message for invalid input type
    88 <DATE><TIME>|<HOST>|E|psDPolynomial3DEvalVector (FILE:LINENO)
    89     Unallowable operation: psVector x has incorrect type.
    90 <DATE><TIME>|<HOST>|I|testDPoly3DEvalVector
    91     Following should generate an error message for invalid input type
    92 <DATE><TIME>|<HOST>|E|psDPolynomial3DEvalVector (FILE:LINENO)
    93     Unallowable operation: psVector y has incorrect type.
    94 <DATE><TIME>|<HOST>|I|testDPoly3DEvalVector
    95     Following should generate an error message for invalid input type
    96 <DATE><TIME>|<HOST>|E|psDPolynomial3DEvalVector (FILE:LINENO)
    97     Unallowable operation: psVector z has incorrect type.
    98 
    99 ---> TESTPOINT PASSED (psPolynomialXDEval{psDPolynomial3DEvalVector} | tst_psFunc10.c)
    100 

  • trunk/psLib/test/math/verified/tst_psFunc11.stderr

    r4547 r4581  
    1111
    1212---> TESTPOINT PASSED (psPolynomialXDEval{psPolynomial4DEval} | tst_psFunc11.c)
    13 
    14 /***************************** TESTPOINT ******************************************\
    15 *             TestFile: tst_psFunc11.c                                             *
    16 *            TestPoint: psPolynomialXDEval{psDPolynomial4DEval}                    *
    17 *             TestType: Positive                                                   *
    18 \**********************************************************************************/
    19 
    20 <DATE><TIME>|<HOST>|I|testDPoly4DEval
    21     Following should generate error message invalid type
    22 <DATE><TIME>|<HOST>|E|psDPolynomial4DEval (FILE:LINENO)
    23     Unknown polynomial type 0x63 found.  Evaluation failed.
    24 
    25 ---> TESTPOINT PASSED (psPolynomialXDEval{psDPolynomial4DEval} | tst_psFunc11.c)
    2613
    2714/***************************** TESTPOINT ******************************************\
    … …  
    7057---> TESTPOINT PASSED (psPolynomialXDEval{psPolynomial4DEvalVector} | tst_psFunc11.c)
    7158
    72 /***************************** TESTPOINT ******************************************\
    73 *             TestFile: tst_psFunc11.c                                             *
    74 *            TestPoint: psPolynomialXDEval{psDPolynomial4DEvalVector}              *
    75 *             TestType: Positive                                                   *
    76 \**********************************************************************************/
    77 
    78 <DATE><TIME>|<HOST>|I|testDPoly4DEvalVector
    79     Following should generate an error message for NULL polynomial
    80 <DATE><TIME>|<HOST>|E|psDPolynomial4DEvalVector (FILE:LINENO)
    81     Unallowable operation: polynomial poly or its coeffs is NULL.
    82 <DATE><TIME>|<HOST>|I|testDPoly4DEvalVector
    83     Following should generate an error message for NULL input vector
    84 <DATE><TIME>|<HOST>|E|psDPolynomial4DEvalVector (FILE:LINENO)
    85     Unallowable operation: psVector x or its data is NULL.
    86 <DATE><TIME>|<HOST>|I|testDPoly4DEvalVector
    87     Following should generate an error message for NULL input vector
    88 <DATE><TIME>|<HOST>|E|psDPolynomial4DEvalVector (FILE:LINENO)
    89     Unallowable operation: psVector y or its data is NULL.
    90 <DATE><TIME>|<HOST>|I|testDPoly4DEvalVector
    91     Following should generate an error message for NULL input vector
    92 <DATE><TIME>|<HOST>|E|psDPolynomial4DEvalVector (FILE:LINENO)
    93     Unallowable operation: psVector z or its data is NULL.
    94 <DATE><TIME>|<HOST>|I|testDPoly4DEvalVector
    95     Following should generate an error message for NULL input vector
    96 <DATE><TIME>|<HOST>|E|psDPolynomial4DEvalVector (FILE:LINENO)
    97     Unallowable operation: psVector t or its data is NULL.
    98 <DATE><TIME>|<HOST>|I|testDPoly4DEvalVector
    99     Following should generate an error message for invalid input type
    100 <DATE><TIME>|<HOST>|E|psDPolynomial4DEvalVector (FILE:LINENO)
    101     Unallowable operation: psVector y has incorrect type.
    102 <DATE><TIME>|<HOST>|I|testDPoly4DEvalVector
    103     Following should generate an error message for invalid input type
    104 <DATE><TIME>|<HOST>|E|psDPolynomial4DEvalVector (FILE:LINENO)
    105     Unallowable operation: psVector z has incorrect type.
    106 <DATE><TIME>|<HOST>|I|testDPoly4DEvalVector
    107     Following should generate an error message for invalid input type
    108 <DATE><TIME>|<HOST>|E|psDPolynomial4DEvalVector (FILE:LINENO)
    109     Unallowable operation: psVector t has incorrect type.
    110 <DATE><TIME>|<HOST>|I|testDPoly4DEvalVector
    111     Following should generate an error message for invalid input type
    112 <DATE><TIME>|<HOST>|E|psDPolynomial4DEvalVector (FILE:LINENO)
    113     Unallowable operation: psVector x has incorrect type.
    114 
    115 ---> TESTPOINT PASSED (psPolynomialXDEval{psDPolynomial4DEvalVector} | tst_psFunc11.c)
    116 
Note: See TracChangeset for help on using the changeset viewer.