IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 2713


Ignore:
Timestamp:
Dec 14, 2004, 11:16:28 AM (22 years ago)
Author:
evanalst
Message:

Update test to increase test coverage.

Location:
trunk/psLib/test/dataManip
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/test/dataManip/tst_psVectorFFT.c

    r2284 r2713  
    66*  @author Robert DeSonia, MHPCC
    77*
    8 *  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
    9 *  @date $Date: 2004-11-04 23:12:10 $
     8*  @version $Revision: 1.10 $ $Name: not supported by cvs2svn $
     9*  @date $Date: 2004-12-14 21:16:28 $
    1010*
    1111*  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    3434
    3535testDescription tests[] = {
    36                               {
    37                                   testVectorFFT, 600, "psVectorFFT", 0, false
    38                               },
    39                               {
    40                                   testVectorRealImaginary, 601, "psVectorRealImaginary", 0, false
    41                               },
    42                               {
    43                                   testVectorComplex, 602, "psVectorComplex", 0, false
    44                               },
    45                               {
    46                                   testVectorConjugate, 603, "psVectorConjugate", 0, false
    47                               },
    48                               {
    49                                   testVectorPowerSpectrum, 604, "psVectorPowerSpectrum", 0, false
    50                               },
    51                               {
    52                                   NULL
    53                               }
     36                              {testVectorFFT, 600, "psVectorFFT", 0, false},
     37                              {testVectorRealImaginary, 601, "psVectorRealImaginary", 0, false},
     38                              {testVectorComplex, 602, "psVectorComplex", 0, false},
     39                              {testVectorConjugate, 603, "psVectorConjugate", 0, false},
     40                              {testVectorPowerSpectrum, 604, "psVectorPowerSpectrum", 0, false},
     41                              {NULL}
    5442                          };
    5543
    … …  
    6654    psVector* vec2 = NULL;
    6755    psVector* vec3 = NULL;
     56    psVector* vec4 = NULL;
    6857
    6958    /*
    … …  
    131120    }
    132121
     122    // Perform a reverse transform with real flag set
     123    vec4 = psVectorFFT(NULL,vec2, (PS_FFT_REVERSE | PS_FFT_REAL_RESULT));
     124    if(vec4->type.type != PS_TYPE_F32) {
     125        psError(PS_ERR_UNKNOWN,true,"FFT with real result did not produce real values");
     126        return 80;
     127    }
     128
     129    // Perform vector FFT with invalid direction flags
     130    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message.");
     131    if ( psVectorFFT(NULL,vec2,(psFFTFlags)0) != NULL) {
     132        psError(PS_ERR_UNKNOWN,true,"Did not return NULL with invalid direction");
     133        return 70;
     134    }
     135
    133136    psFree( vec );
    134137    psFree( vec2 );
    135138    psFree( vec3 );
     139    psFree( vec4 );
     140
     141    // Perform vector FFT with null input
     142    if ( psVectorFFT(NULL,NULL,PS_FFT_FORWARD) != NULL) {
     143        psError(PS_ERR_UNKNOWN,true,"Did not return NULL with null input vector");
     144        return 64;
     145    }
    136146
    137147    return 0;
    … …  
    143153    psVector* vec2 = NULL;
    144154    psVector* vec3 = NULL;
     155    psVector* vec4 = NULL;
     156    psVector* vec5 = NULL;
     157    psVector* vec6 = NULL;
     158    psVector* vec7 = NULL;
     159    psVector* vec8 = NULL;
     160    psVector* vec9 = NULL;
     161    psVector* vec10 = NULL;
     162    psVector* vec11 = NULL;
    145163
    146164    /*
    … …  
    152170    // 1. create a C32 complex vector with distinctly different real and imaginary parts.
    153171    vec = psVectorAlloc( 100, PS_TYPE_C32 );
    154     vec->n = vec->nalloc;
     172    vec8 = psVectorAlloc( 100, PS_TYPE_C64 );
     173    vec10 = psVectorAlloc( 100, PS_TYPE_C64 );
     174    vec->n = vec->nalloc;
     175    vec8->n = vec8->nalloc;
     176    vec10->n = vec10->nalloc;
    155177    for ( psU32 n = 0; n < 100; n++ ) {
    156178        vec->data.C32[ n ] = n + I * ( n * 2 );
     179        vec8->data.C64[n] = n + I * ( n * 2 );
     180        vec10->data.C64[n] = n + I * ( n * 2 );
     181    }
     182    vec4 = psVectorAlloc( 100, PS_TYPE_F32);
     183    vec4->n = vec4->nalloc;
     184    vec6 = psVectorAlloc( 100, PS_TYPE_F32);
     185    vec6->n = vec6->nalloc;
     186    for ( psU32 n = 0; n < 100; n++ ) {
     187        vec4->data.F32[n] = n;
     188        vec6->data.F32[n] = n;
    157189    }
    158190
    … …  
    169201    }
    170202
     203    psLogMsg(__func__,PS_LOG_INFO,"Following should generate a warning.");
     204    vec5 = psVectorReal(vec5, vec4);
     205    if (vec5 == NULL) {
     206        psError(PS_ERR_UNKNOWN,true,"psVectorReal returned NULL");
     207        return 10;
     208    }
     209    if ( vec5->type.type != PS_TYPE_F32) {
     210        psError(PS_ERR_UNKNOWN,true,"psVectorReal returned the wrong type");
     211        return 11;
     212    }
     213
     214    vec9 = psVectorReal(vec9,vec8);
     215    if(vec9 == NULL) {
     216        psError(PS_ERR_UNKNOWN,true,"psVectorReal returned NULL");
     217        return 20;
     218    }
     219    if(vec9->type.type != PS_TYPE_F64) {
     220        psError(PS_ERR_UNKNOWN,true,"psVectorReal returned the wrong type");
     221        return 21;
     222    }
     223
     224    psLogMsg(__func__,PS_LOG_INFO,"Following should generate a warning.");
    171225    vec3 = psVectorImaginary( vec3, vec );
    172226    if ( vec3 == NULL ) {
    … …  
    180234    }
    181235
     236    vec7 = psVectorImaginary(vec7, vec6);
     237    if(vec7 == NULL) {
     238        psError(PS_ERR_UNKNOWN,true,"psVectorImage returned NULL");
     239        return 12;
     240    }
     241    if(vec7->type.type != PS_TYPE_F32) {
     242        psError(PS_ERR_UNKNOWN,true,"psVectorImaginary returned the wrong type");
     243        return 13;
     244    }
     245
     246    vec11 = psVectorImaginary(vec11, vec10);
     247    if(vec11 == NULL) {
     248        psError(PS_ERR_UNKNOWN,true,"psVectorImaginary returned NULL");
     249        return 14;
     250    }
     251    if(vec11->type.type != PS_TYPE_F64) {
     252        psError(PS_ERR_UNKNOWN,true,"psVectorImaginary returned the wrong type");
     253        return 15;
     254    }
     255
    182256    // 3. compare results to the real/imaginary components of input
    183257    for ( psU32 n = 0; n < 100; n++ ) {
    184258        psF32 r = n;
    185259        psF32 i = ( n * 2 );
     260        psF64 rr = n;
     261        psF64 ii = ( n * 2 );
    186262        if ( fabsf( vec2->data.F32[ n ] - r ) > FLT_EPSILON ) {
    187263            psError(PS_ERR_UNKNOWN,true, "psVectorReal didn't return the real portion at n=%d",
    … …  
    194270            return 6;
    195271        }
     272        if ( fabsf( vec5->data.F32[n] - r) > FLT_EPSILON) {
     273            psError(PS_ERR_UNKNOWN,true,"psVectorReal didn't return the real portion at n=%d",n);
     274            return 50;
     275        }
     276        if ( fabsf( vec7->data.F32[n] - 0) > FLT_EPSILON) {
     277            psError(PS_ERR_UNKNOWN,true,"psVectorImaginary did not return the imaginary portion at n=%d",n);
     278            return 51;
     279        }
     280        if ( fabsf(vec9->data.F64[n] - rr) > FLT_EPSILON ) {
     281            psError(PS_ERR_UNKNOWN,true,"psVectorReal did not return the real portion at n=%d",n);
     282            return 52;
     283        }
     284        if ( fabsf(vec11->data.F64[n] - ii) > FLT_EPSILON) {
     285            psError(PS_ERR_UNKNOWN,true,"psVectorImaginary did not return the imaginary portion at n=%d",n);
     286            return 53;
     287        }
    196288    }
    197289
    … …  
    199291    psFree( vec2 );
    200292    psFree( vec3 );
     293    psFree( vec4 );
     294    psFree( vec5 );
     295    psFree( vec6 );
     296    psFree( vec7 );
     297    psFree( vec8 );
     298    psFree( vec9 );
     299    psFree( vec10 );
     300    psFree( vec11 );
     301
     302    // Perform vector Real with null input
     303    if ( psVectorReal(NULL,NULL) != NULL) {
     304        psError(PS_ERR_UNKNOWN,true,"Did not return NULL with null input vector");
     305        return 63;
     306    }
     307    // Perform vector Imaginary with null input
     308    if ( psVectorImaginary(NULL,NULL) != NULL) {
     309        psError(PS_ERR_UNKNOWN,true,"Did not return NULL with null input vector");
     310        return 73;
     311    }
    201312
    202313    return 0;
    … …  
    208319    psVector* vec2 = NULL;
    209320    psVector* vec3 = NULL;
     321    psVector* vec4 = NULL;
     322    psVector* vec5 = NULL;
     323    psVector* vec6 = NULL;
    210324
    211325    /*
    … …  
    228342    vec = psVectorAlloc( 100, PS_TYPE_F32 );
    229343    vec2 = psVectorAlloc( 100, PS_TYPE_F32 );
     344    vec4 = psVectorAlloc( 100, PS_TYPE_F64 );
     345    vec5 = psVectorAlloc( 100, PS_TYPE_F64 );
    230346    vec->n = vec->nalloc;
    231347    vec2->n = vec2->nalloc;
     348    vec4->n = vec4->nalloc;
     349    vec5->n = vec5->nalloc;
    232350    for ( psU32 n = 0; n < 100; n++ ) {
    233351        vec->data.F32[ n ] = n;
    234352        vec2->data.F32[ n ] = ( n * 2 );
     353        vec4->data.F64[ n ] = n;
     354        vec5->data.F64[ n ] = ( n * 2 );
    235355    }
    236356
    … …  
    281401    }
    282402
     403    // Verify the function works with psF64 type
     404    vec6 = psVectorComplex(vec6, vec4, vec5);
     405    if( vec6->type.type != PS_TYPE_C64 ) {
     406        psError(PS_ERR_UNKNOWN,true,"Vector return type is not complex");
     407        return 40;
     408    }
     409
     410    // Verify error message generated with input of invalid type
     411    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message.");
     412    vec4->type.type = PS_TYPE_S8;
     413    vec5->type.type = PS_TYPE_S8;
     414    vec6 = psVectorComplex(vec6, vec4, vec5);
     415    if(vec6 != NULL) {
     416        psError(PS_ERR_UNKNOWN,true,"Did not return NULL for invalid type");
     417        return 50;
     418    }
     419    vec4->type.type = PS_TYPE_F64;
     420    vec5->type.type = PS_TYPE_F64;
     421
    283422    psFree( vec );
    284423    psFree( vec2 );
    285424    psFree( vec3 );
     425    psFree( vec4 );
     426    psFree( vec5 );
     427
     428    // Perform vector complex with null input
     429    if ( psVectorComplex(NULL,NULL,NULL) != NULL) {
     430        psError(PS_ERR_UNKNOWN,true,"Did not return NULL with null input vector");
     431        return 62;
     432    }
    286433
    287434    return 0;
    … …  
    320467        if ( fabsf( crealf( vec->data.C32[ n ] ) - crealf( vec2->data.C32[ n ] ) ) > FLT_EPSILON ||
    321468                fabsf( cimagf( vec->data.C32[ n ] ) + cimagf( vec2->data.C32[ n ] ) ) > FLT_EPSILON ) {
    322             psError(PS_ERR_UNKNOWN,true, "psVectorComplex result is invalid (n=%d, %.2f+%.2fi)",
     469            psError(PS_ERR_UNKNOWN,true, "psVectorConjugate result is invalid (n=%d, %.2f+%.2fi)",
    323470                    n, crealf( vec2->data.C32[ n ] ), cimagf( vec2->data.C32[ n ] ) );
    324471            return 2;
    … …  
    328475    psFree( vec );
    329476    psFree( vec2 );
     477
     478    // Perform conjugate for non-complex number
     479    vec = psVectorAlloc( 100, PS_TYPE_F32 );
     480    vec->n = vec->nalloc;
     481    for ( psU32 n = 0; n < 100; n++ ) {
     482        vec->data.F32[ n ] = n;
     483    }
     484    psLogMsg(__func__,PS_LOG_INFO,"Following should generate a warning message.");
     485    vec2 = psVectorConjugate(vec2,vec);
     486    if(vec2->type.type != PS_TYPE_F32) {
     487        psError(PS_ERR_UNKNOWN,true,"psVectorConjugate did not return a F32 vector");
     488        return 10;
     489    }
     490    for ( psU32 n = 0; n < 100; n++ ) {
     491        if( vec->data.F32[n] != vec2->data.F32[n] ) {
     492            psError(PS_ERR_UNKNOWN,true,"psVectorConjugate result is invalid (n=%d)",n);
     493            return 11;
     494        }
     495    }
     496    psFree(vec);
     497
     498    // Perform vector conjugate with C64 type
     499    vec = psVectorAlloc( 100, PS_TYPE_C64 );
     500    vec->n = vec->nalloc;
     501    for ( psU32 n = 0; n < 100; n++ ) {
     502        vec->data.C64[n] = n + I * ( n * 2 );
     503    }
     504    vec2 = psVectorConjugate(vec2,vec);
     505    if(vec2->type.type != PS_TYPE_C64) {
     506        psError(PS_ERR_UNKNOWN,true,"psVectorConjugate did not return a C64 vector");
     507        return 12;
     508    }
     509    for ( psU32 n = 0; n < 100; n++ ) {
     510        if ( fabsf( crealf(vec->data.C64[n]) - crealf(vec2->data.C64[n])) > FLT_EPSILON ||
     511                fabsf( cimagf(vec->data.C64[n]) - cimagf(vec2->data.C64[n])) > FLT_EPSILON ) {
     512            psError(PS_ERR_UNKNOWN,true,"psVectorConjugate result is invalid (n=%d)",n);
     513            return 13;
     514        }
     515    }
     516    psFree(vec);
     517
     518    // Perform vector conjugate with null input
     519    if ( psVectorConjugate(NULL,NULL) != NULL) {
     520        psError(PS_ERR_UNKNOWN,true,"Did not return NULL with null input vector");
     521        return 61;
     522    }
    330523
    331524    return 0;
    … …  
    336529    psVector * vec = NULL;
    337530    psVector* vec2 = NULL;
     531    psVector* vec3 = NULL;
     532    psVector* vec4 = NULL;
     533
    338534    psF32 val;
     535    psF64 val1;
    339536
    340537    /*
    … …  
    348545    vec = psVectorAlloc( 100, PS_TYPE_C32 );
    349546    vec->n = vec->nalloc;
     547    vec3 = psVectorAlloc(100,PS_TYPE_C64);
     548    vec3->n = vec3->nalloc;
    350549    for ( psU32 n = 0; n < 100; n++ ) {
    351550        vec->data.C32[ n ] = n + I * sinf( ( ( psF32 ) n ) / 50.f * M_PI );
     551        vec3->data.C64[ n ] = n + I * sinf( ( ( psF64 ) n ) / 50.f * M_PI );
    352552    }
    353553
    354554    // 2. call psVectorPowerSpectrum
    355555    vec2 = psVectorPowerSpectrum( vec2, vec );
     556    vec4 = psVectorPowerSpectrum( vec4, vec3 );
    356557
    357558    // 3. verify result is psF32
    … …  
    359560        psError(PS_ERR_UNKNOWN,true, "the type was not PS_TYPE_F32." );
    360561        return 1;
     562    }
     563    if ( vec4->type.type != PS_TYPE_F64 ) {
     564        psError(PS_ERR_UNKNOWN,true,"psPowerSpectrum did not return type PS_TYPE_F64 type = %d",vec4->type.type);
     565        return 20;
    361566    }
    362567
    … …  
    376581
    377582    val = cabsf( vec->data.C32[ 0 ] ) * cabsf( vec->data.C32[ 0 ] ) / 100 / 100;
     583    val1= cabsf( vec3->data.C64[0] ) * cabsf(vec3->data.C64[0])/100/100;
    378584    if ( fabsf( vec2->data.F32[ 0 ] - val ) > FLT_EPSILON ) {
    379585        psError(PS_ERR_UNKNOWN,true, "psVectorPowerSpectrum result is invalid (n=0, %.2f %.2f)",
    380586                vec2->data.F32[ 0 ], val );
    381587        return 2;
    382     };
     588    }
     589    if ( fabsf( vec4->data.C64[0] - val1 ) > FLT_EPSILON ) {
     590        psError(PS_ERR_UNKNOWN,true,"psVectorPowerSpectrum result is invalid (n=0)");
     591        return 21;
     592    }
    383593
    384594    for ( psU32 n = 1; n < 50; n++ ) {
    385595        val = ( cabsf( vec->data.C32[ n ] ) * cabsf( vec->data.C32[ n ] ) +
    386596                cabsf( vec->data.C32[ 100 - n ] ) * cabsf( vec->data.C32[ 100 - n ] ) ) / 100 / 100;
    387 
     597        val1 = (cabsf(vec3->data.C64[n]) * cabsf(vec3->data.C64[n]) +
     598                cabsf(vec3->data.C64[100-n]) * cabsf(vec3->data.C64[100-n]))/100/100;
    388599        if ( fabsf( val - vec2->data.F32[ n ] ) > FLT_EPSILON ) {
    389600            psError(PS_ERR_UNKNOWN,true, "psVectorPowerSpectrum result is invalid (n=%d, %.2f %.2f)",
    390601                    n, vec2->data.F32[ n ], val );
    391602            return 2;
    392         };
     603        }
     604        if (fabsf(val1 - vec4->data.F64[n]) > FLT_EPSILON) {
     605            psError(PS_ERR_UNKNOWN,true,"psVectorPowerSpectrum result is invalid (n=%d, %.2f %.2f)",n,vec4->data.F64[n],val1);
     606            return 22;
     607        }
    393608    }
    394609
    … …  
    402617    psFree( vec );
    403618    psFree( vec2 );
     619    psFree( vec3 );
     620    psFree( vec4 );
     621
     622    // Perform vector power spectrum with non-complex number
     623    vec = psVectorAlloc(100,PS_TYPE_F32);
     624    vec->n = vec->nalloc;
     625    for( psU32 n=0; n<100; n++) {
     626        vec->data.F32[n] = n;
     627    }
     628    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message.");
     629    if(psVectorPowerSpectrum(NULL,vec) != NULL) {
     630        psError(PS_ERR_UNKNOWN,true,"psVectorPowerSpectrum did not return a null vector.");
     631        return 10;
     632    }
     633
     634    // Perform vector power spectrum with null input
     635    if ( psVectorPowerSpectrum(NULL,NULL) != NULL) {
     636        psError(PS_ERR_UNKNOWN,true,"Did not return NULL with null input vector");
     637        return 60;
     638    }
     639
     640    psFree(vec);
    404641
    405642    return 0;

  • trunk/psLib/test/dataManip/verified/tst_psVectorFFT.stderr

    r2284 r2713  
    55\**********************************************************************************/
    66
     7<DATE><TIME>|<HOST>|I|testVectorFFT
     8    Following should generate an error message.
     9<DATE><TIME>|<HOST>|E|psVectorFFT (psVectorFFT.c:<LINENO>)
     10    Must specify the direction as either PS_FFT_FORWARD or PS_FFT_REVERSE.
    711
    812---> TESTPOINT PASSED (psFFT{psVectorFFT} | tst_psVectorFFT.c)
    … …  
    1418\**********************************************************************************/
    1519
     20<DATE><TIME>|<HOST>|I|testVectorRealImaginary
     21    Following should generate a warning.
     22<DATE><TIME>|<HOST>|W|psVectorReal
     23    Real portion of a non-Complex type called called for. Just a vector copy was performed.
     24<DATE><TIME>|<HOST>|I|testVectorRealImaginary
     25    Following should generate a warning.
     26<DATE><TIME>|<HOST>|W|psVectorImaginary
     27    Imaginary portion of a non-Complex type called for. A zeroed vector was returned.
    1628
    1729---> TESTPOINT PASSED (psFFT{psVectorRealImaginary} | tst_psVectorFFT.c)
    … …  
    2739<DATE><TIME>|<HOST>|E|psVectorComplex (psVectorFFT.c:<LINENO>)
    2840    Real psVector type, psF32, and imaginary psVector type, psF64, must be the same.
     41<DATE><TIME>|<HOST>|I|testVectorComplex
     42    Following should generate an error message.
     43<DATE><TIME>|<HOST>|E|psVectorComplex (psVectorFFT.c:<LINENO>)
     44    Input psVector type, psS8, is required to be either psF32 or psF64.
    2945
    3046---> TESTPOINT PASSED (psFFT{psVectorComplex} | tst_psVectorFFT.c)
    … …  
    3652\**********************************************************************************/
    3753
     54<DATE><TIME>|<HOST>|I|testVectorConjugate
     55    Following should generate a warning message.
     56<DATE><TIME>|<HOST>|W|psVectorConjugate
     57    Complex Conjugate of a non-Complex type called for. Vector copy was performed instead.
    3858
    3959---> TESTPOINT PASSED (psFFT{psVectorConjugate} | tst_psVectorFFT.c)
    … …  
    4565\**********************************************************************************/
    4666
     67<DATE><TIME>|<HOST>|I|testVectorPowerSpectrum
     68    Following should generate an error message.
     69<DATE><TIME>|<HOST>|E|psVectorPowerSpectrum (psVectorFFT.c:<LINENO>)
     70    Input psVector type, psF32, is required to be either psC32 or psC64.
    4771
    4872---> TESTPOINT PASSED (psFFT{psVectorPowerSpectrum} | tst_psVectorFFT.c)
Note: See TracChangeset for help on using the changeset viewer.