IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Aug 6, 2004, 11:50:14 AM (22 years ago)
Author:
desonia
Message:

modified runTest / FullUnitTest to suppress line numbers in messages.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r1365 r1404  
    66*  @author Robert DeSonia, MHPCC
    77*
    8 *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
    9 *  @date $Date: 2004-08-02 19:43:23 $
     8*  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
     9*  @date $Date: 2004-08-06 21:50:13 $
    1010*
    1111*  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    2121img = psImageAlloc(c,r,PS_TYPE_##TYP); \
    2222for (unsigned int row=0;row<r;row++) { \
    23         ps##TYP* imgRow = img->data.TYP[row]; \
    24         for (unsigned int col=0;col<c;col++) { \
    25                 imgRow[col] = (ps##TYP)(valueFcn); \
    26             } \
    27     }
    28    
     23    ps##TYP* imgRow = img->data.TYP[row]; \
     24    for (unsigned int col=0;col<c;col++) { \
     25        imgRow[col] = (ps##TYP)(valueFcn); \
     26    } \
     27}
     28
    2929static int testVectorFFT( void );
    3030static int testVectorRealImaginary( void );
    … …  
    5353                              }
    5454                          };
    55                          
     55
    5656int main( int argc, char* argv[] )
    5757{
    5858    psLogSetLevel( PS_LOG_INFO );
    59    
     59
    6060    return ( ! runTestSuite( stderr, "psFFT", tests, argc, argv ) );
    6161}
    … …  
    6666    psVector* vec2 = NULL;
    6767    psVector* vec3 = NULL;
    68    
     68
    6969    /*
    7070    1. assign a vector to a sinisoid
    … …  
    7474    5. compare to original (should be equal to within a reasonable error)
    7575    */
    76    
     76
    7777    // 1. assign a vector to a sinisoid
    7878    vec = psVectorAlloc( 100, PS_TYPE_F32 );
    7979    vec->n = vec->nalloc;
    8080    for ( unsigned int n = 0; n < 100; n++ ) {
    81             vec->data.F32[ n ] = sinf( ( psF32 ) n / 50.0f * M_PI );
    82         }
    83        
     81        vec->data.F32[ n ] = sinf( ( psF32 ) n / 50.0f * M_PI );
     82    }
     83
    8484    // 2. perform a forward transform
    8585    vec2 = psVectorFFT( NULL, vec, PS_FFT_FORWARD );
    8686    if ( vec2->type.type != PS_TYPE_C32 ) {
    87             psError( __func__, "FFT didn't produce complex values?" );
    88             return 1;
     87        psError( __func__, "FFT didn't produce complex values?" );
     88        return 1;
     89    }
     90
     91
     92    // 3. verify that the only significant component cooresponds to the freqency of the input in step 1.
     93    for ( unsigned int n = 0; n < 100; n++ ) {
     94        if ( n == 1 || n == 99 ) {
     95            if ( fabsf( cabsf( vec2->data.C32[ n ] ) - 50.0f ) > 0.1f ) {
     96                psError( __func__, "FFT didn't work for vector (n=%d)", n );
     97                return 2;
     98            }
     99        } else {
     100            if ( fabsf( cabsf( vec2->data.C32[ n ] ) ) > 0.1f ) {
     101                psError( __func__, "FFT didn't work for vector (n=%d)", n );
     102                return 3;
     103            }
    89104        }
    90        
    91        
    92     // 3. verify that the only significant component cooresponds to the freqency of the input in step 1.
    93     for ( unsigned int n = 0; n < 100; n++ ) {
    94             if ( n == 1 || n == 99 ) {
    95                     if ( fabsf( cabsf( vec2->data.C32[ n ] ) - 50.0f ) > 0.1f ) {
    96                             psError( __func__, "FFT didn't work for vector (n=%d)", n );
    97                             return 2;
    98                         }
    99                 } else {
    100                     if ( fabsf( cabsf( vec2->data.C32[ n ] ) ) > 0.1f ) {
    101                             psError( __func__, "FFT didn't work for vector (n=%d)", n );
    102                             return 3;
    103                         }
    104                 }
    105         }
    106        
     105    }
     106
    107107    // 4. perform a reverse transform
    108108    vec3 = psVectorFFT( NULL, vec2, PS_FFT_REVERSE );
    109109    if ( vec3->type.type != PS_TYPE_C32 ) {
    110             psError( __func__, "FFT didn't produce complex values?" );
    111             return 4;
     110        psError( __func__, "FFT didn't produce complex values?" );
     111        return 4;
     112    }
     113    for ( unsigned int n = 0; n < 100; n++ ) {
     114        psF32 val = sinf( ( psF32 ) n / 50.0f * M_PI );
     115        psF32 vecVal = crealf( vec3->data.C32[ n ] ) / 100;
     116        if ( fabsf( vecVal - val ) > 0.1f ) {
     117            psError( __func__, "Reverse FFT didn't give me the original vector back (n=%d) (%.2f vs %.2f)",
     118                     n, vecVal, val );
     119            return 5;
    112120        }
    113     for ( unsigned int n = 0; n < 100; n++ ) {
    114             psF32 val = sinf( ( psF32 ) n / 50.0f * M_PI );
    115             psF32 vecVal = crealf( vec3->data.C32[ n ] ) / 100;
    116             if ( fabsf( vecVal - val ) > 0.1f ) {
    117                     psError( __func__, "Reverse FFT didn't give me the original vector back (n=%d) (%.2f vs %.2f)",
    118                              n, vecVal, val );
    119                     return 5;
    120                 }
    121         }
    122        
     121    }
     122
    123123    psFree( vec );
    124124    psFree( vec2 );
    125125    psFree( vec3 );
    126    
     126
    127127    return 0;
    128128}
    … …  
    133133    psVector* vec2 = NULL;
    134134    psVector* vec3 = NULL;
    135    
     135
    136136    /*
    137137    1. create a C32 complex vector with distinctly different real and imaginary parts.
    … …  
    139139    3. compare results to the real/imaginary components of input
    140140    */
    141    
     141
    142142    // 1. create a C32 complex vector with distinctly different real and imaginary parts.
    143143    vec = psVectorAlloc( 100, PS_TYPE_C32 );
    144144    vec->n = vec->nalloc;
    145145    for ( unsigned int n = 0; n < 100; n++ ) {
    146             vec->data.C32[ n ] = n + I * ( n * 2 );
    147         }
    148        
     146        vec->data.C32[ n ] = n + I * ( n * 2 );
     147    }
     148
    149149    // 2. call psVectorReal and psVectorImaginary
    150150    vec2 = psVectorReal( vec2, vec );
    151151    if ( vec2 == NULL ) {
    152             psError( __func__, "psVectorReal returned a NULL?" );
    153             return 1;
    154         }
     152        psError( __func__, "psVectorReal returned a NULL?" );
     153        return 1;
     154    }
    155155    if ( vec2->type.type != PS_TYPE_F32 ) {
    156             psError( __func__, "psVectorReal returned a wrong type (%d)?",
    157                      vec2->type.type );
    158             return 2;
    159         }
    160        
     156        psError( __func__, "psVectorReal returned a wrong type (%d)?",
     157                 vec2->type.type );
     158        return 2;
     159    }
     160
    161161    vec3 = psVectorImaginary( vec3, vec );
    162162    if ( vec3 == NULL ) {
    163             psError( __func__, "psVectorImaginary returned a NULL?" );
    164             return 3;
     163        psError( __func__, "psVectorImaginary returned a NULL?" );
     164        return 3;
     165    }
     166    if ( vec3->type.type != PS_TYPE_F32 ) {
     167        psError( __func__, "psVectorImaginary returned a wrong type (%d)?",
     168                 vec3->type.type );
     169        return 4;
     170    }
     171
     172    // 3. compare results to the real/imaginary components of input
     173    for ( unsigned int n = 0; n < 100; n++ ) {
     174        psF32 r = n;
     175        psF32 i = ( n * 2 );
     176        if ( fabsf( vec2->data.F32[ n ] - r ) > FLT_EPSILON ) {
     177            psError( __func__, "psVectorReal didn't return the real portion at n=%d",
     178                     n );
     179            return 5;
    165180        }
    166     if ( vec3->type.type != PS_TYPE_F32 ) {
    167             psError( __func__, "psVectorImaginary returned a wrong type (%d)?",
    168                      vec3->type.type );
    169             return 4;
     181        if ( fabsf( vec3->data.F32[ n ] - i ) > FLT_EPSILON ) {
     182            psError( __func__, "psVectorImaginary didn't return the real portion at n=%d",
     183                     n );
     184            return 6;
    170185        }
    171        
    172     // 3. compare results to the real/imaginary components of input
    173     for ( unsigned int n = 0; n < 100; n++ ) {
    174             psF32 r = n;
    175             psF32 i = ( n * 2 );
    176             if ( fabsf( vec2->data.F32[ n ] - r ) > FLT_EPSILON ) {
    177                     psError( __func__, "psVectorReal didn't return the real portion at n=%d",
    178                              n );
    179                     return 5;
    180                 }
    181             if ( fabsf( vec3->data.F32[ n ] - i ) > FLT_EPSILON ) {
    182                     psError( __func__, "psVectorImaginary didn't return the real portion at n=%d",
    183                              n );
    184                     return 6;
    185                 }
    186         }
    187        
     186    }
     187
    188188    psFree( vec );
    189189    psFree( vec2 );
    190190    psFree( vec3 );
    191    
     191
    192192    return 0;
    193193}
    … …  
    198198    psVector* vec2 = NULL;
    199199    psVector* vec3 = NULL;
    200    
     200
    201201    /*
    202202    1. create two unique psF32 vectors of the same size
    … …  
    205205    4. call psVectorReal and psVectorImaginary on step 2 results
    206206    5. compare step 4 results to input.
    207    
     207
    208208    6. create a psF32 and a psF64 vector of the same size
    209209    7. call psVectorComplex
    210210    8. verify that an appropriate error occurred.
    211    
     211
    212212    9. create two psf32 vectors of different sizes
    213213    10. call psVectorComplex
    214214    11. verify thet an appropriate error occurred.
    215215    */
    216    
     216
    217217    // 1. create two unique psF32 vectors of the same size
    218218    vec = psVectorAlloc( 100, PS_TYPE_F32 );
    … …  
    221221    vec2->n = vec2->nalloc;
    222222    for ( unsigned int n = 0; n < 100; n++ ) {
    223             vec->data.F32[ n ] = n;
    224             vec2->data.F32[ n ] = ( n * 2 );
    225         }
    226        
     223        vec->data.F32[ n ] = n;
     224        vec2->data.F32[ n ] = ( n * 2 );
     225    }
     226
    227227    // 2. call psVectorComplex
    228228    vec3 = psVectorComplex( vec3, vec, vec2 );
    229    
     229
    230230    // 3. verify that the result is a psC32
    231231    if ( vec3->type.type != PS_TYPE_C32 ) {
    232             psError( __func__, "Vector Type from psVectorComplex is not complex? (%d)",
    233                      vec3->type.type );
    234             return 1;
    235         }
    236        
     232        psError( __func__, "Vector Type from psVectorComplex is not complex? (%d)",
     233                 vec3->type.type );
     234        return 1;
     235    }
     236
    237237    // 4. call psVectorReal and psVectorImaginary on step 2 results (not needed, just use crealf/cimagf)
    238238    // 5. compare step 4 results to input.
    239239    for ( unsigned int n = 0; n < 100; n++ ) {
    240             if ( fabsf( crealf( vec3->data.C32[ n ] ) - n ) > FLT_EPSILON ||
    241                     fabsf( cimagf( vec3->data.C32[ n ] ) - ( n * 2 ) ) > FLT_EPSILON ) {
    242                     psError( __func__, "psVectorComplex result is invalid (n=%d, %.2f+%.2fi)",
    243                              n, crealf( vec3->data.C32[ n ] ), cimagf( vec3->data.C32[ n ] ) );
    244                     return 2;
    245                 };
    246         }
    247        
    248        
     240        if ( fabsf( crealf( vec3->data.C32[ n ] ) - n ) > FLT_EPSILON ||
     241                fabsf( cimagf( vec3->data.C32[ n ] ) - ( n * 2 ) ) > FLT_EPSILON ) {
     242            psError( __func__, "psVectorComplex result is invalid (n=%d, %.2f+%.2fi)",
     243                     n, crealf( vec3->data.C32[ n ] ), cimagf( vec3->data.C32[ n ] ) );
     244            return 2;
     245        };
     246    }
     247
     248
    249249    // 6. create a psF32 and a psF64 vector of the same size
    250     vec2 = psVectorRecycle( vec2, PS_TYPE_F64, 100 );
    251    
     250    vec2 = psVectorRecycle( vec2, 100, PS_TYPE_F64 );
     251
    252252    // 7. call psVectorComplex
    253253    psLogMsg( __func__, PS_LOG_INFO, "Following should be an error (type mismatch)." );
    … …  
    255255    // 8. verify that an appropriate error occurred. (this partially has to be done via inspection)
    256256    if ( vec3 != NULL ) {
    257             psError( __func__, "psVectorComplex returned a vector though input types mismatched." );
    258             return 3;
    259         }
    260        
     257        psError( __func__, "psVectorComplex returned a vector though input types mismatched." );
     258        return 3;
     259    }
     260
    261261    // 9. create two psf32 vectors of different sizes
    262     vec2 = psVectorRecycle( vec2, PS_TYPE_F32, 200 );
    263    
     262    vec2 = psVectorRecycle( vec2, 200, PS_TYPE_F32 );
     263
    264264    // 10. call psVectorComplex
    265265    vec3 = psVectorComplex( vec3, vec, vec2 );
    266    
     266
    267267    // 11. verify thet an appropriate error occurred. (actually, it isn't an error...)
    268268    if ( vec3->n != 100 ) {
    269             psError( __func__, "psVectorComplex returned a larger vector than the input supported (%d).", vec3->n );
    270             return 4;
    271         }
    272        
     269        psError( __func__, "psVectorComplex returned a larger vector than the input supported (%d).", vec3->n );
     270        return 4;
     271    }
     272
    273273    psFree( vec );
    274274    psFree( vec2 );
    275275    psFree( vec3 );
    276    
     276
    277277    return 0;
    278278}
    … …  
    282282    psVector * vec = NULL;
    283283    psVector* vec2 = NULL;
    284    
     284
    285285    /*
    286286    1. create a psC32 with unique real and imaginary values.
    … …  
    289289    4. verify each value is conjugate of input (a+bi -> a-bi)
    290290    */
    291    
     291
    292292    // 1. create a psC32 with unique real and imaginary values.
    293293    vec = psVectorAlloc( 100, PS_TYPE_C32 );
    294294    vec->n = vec->nalloc;
    295295    for ( unsigned int n = 0; n < 100; n++ ) {
    296             vec->data.C32[ n ] = n + I * ( n * 2 );
    297         }
    298        
     296        vec->data.C32[ n ] = n + I * ( n * 2 );
     297    }
     298
    299299    // 2. call psVectorConjugate
    300300    vec2 = psVectorConjugate( vec2, vec );
    301    
     301
    302302    // 3. verify result is psC32
    303303    if ( vec2->type.type != PS_TYPE_C32 ) {
    304             psError( __func__, "the psVectorConjugate didn't return a C32 vector" );
    305             return 1;
    306         }
    307        
     304        psError( __func__, "the psVectorConjugate didn't return a C32 vector" );
     305        return 1;
     306    }
     307
    308308    // 4. verify each value is conjugate of input (a+bi -> a-bi)
    309309    for ( unsigned int n = 0; n < 100; n++ ) {
    310             if ( fabsf( crealf( vec->data.C32[ n ] ) - crealf( vec2->data.C32[ n ] ) ) > FLT_EPSILON ||
    311                     fabsf( cimagf( vec->data.C32[ n ] ) + cimagf( vec2->data.C32[ n ] ) ) > FLT_EPSILON ) {
    312                     psError( __func__, "psVectorComplex result is invalid (n=%d, %.2f+%.2fi)",
    313                              n, crealf( vec2->data.C32[ n ] ), cimagf( vec2->data.C32[ n ] ) );
    314                     return 2;
    315                 };
    316         }
    317        
    318     psFree( vec );
    319     psFree( vec2 );
    320    
     310        if ( fabsf( crealf( vec->data.C32[ n ] ) - crealf( vec2->data.C32[ n ] ) ) > FLT_EPSILON ||
     311                fabsf( cimagf( vec->data.C32[ n ] ) + cimagf( vec2->data.C32[ n ] ) ) > FLT_EPSILON ) {
     312            psError( __func__, "psVectorComplex result is invalid (n=%d, %.2f+%.2fi)",
     313                     n, crealf( vec2->data.C32[ n ] ), cimagf( vec2->data.C32[ n ] ) );
     314            return 2;
     315        };
     316    }
     317
     318    psFree( vec );
     319    psFree( vec2 );
     320
    321321    return 0;
    322322}
    … …  
    327327    psVector* vec2 = NULL;
    328328    psF32 val;
    329    
     329
    330330    /*
    331331    1. create a psC32 vector with unique real and imaginary components
    … …  
    334334    4. verify the values are the square of the absolute values of the original
    335335    */
    336    
     336
    337337    // 1. create a psC32 vector with unique real and imaginary components
    338338    vec = psVectorAlloc( 100, PS_TYPE_C32 );
    339339    vec->n = vec->nalloc;
    340340    for ( unsigned int n = 0; n < 100; n++ ) {
    341             vec->data.C32[ n ] = n + I * sinf( ( ( psF32 ) n ) / 50.f * M_PI );
    342         }
    343        
     341        vec->data.C32[ n ] = n + I * sinf( ( ( psF32 ) n ) / 50.f * M_PI );
     342    }
     343
    344344    // 2. call psVectorPowerSpectrum
    345345    vec2 = psVectorPowerSpectrum( vec2, vec );
    346    
     346
    347347    // 3. verify result is psF32
    348348    if ( vec2->type.type != PS_TYPE_F32 ) {
    349             psError( __func__, "the type was not PS_TYPE_F32." );
    350             return 1;
    351         }
    352        
     349        psError( __func__, "the type was not PS_TYPE_F32." );
     350        return 1;
     351    }
     352
    353353    // 4. verify the values are the square of the absolute values of the original
    354354    //   (ADD specifies something else)
    … …  
    357357    //   P_N/2 = |C_N/2|^2/N^2
    358358    //  where j = 1,2,...,(N/2-1)
    359    
     359
    360360    val = cabsf( vec->data.C32[ 0 ] ) * cabsf( vec->data.C32[ 0 ] ) / 100 / 100;
    361361    if ( fabsf( vec2->data.F32[ 0 ] - val ) > FLT_EPSILON ) {
    362             psError( __func__, "psVectorPowerSpectrum result is invalid (n=0, %.2f %.2f)",
    363                      vec2->data.F32[ 0 ], val );
     362        psError( __func__, "psVectorPowerSpectrum result is invalid (n=0, %.2f %.2f)",
     363                 vec2->data.F32[ 0 ], val );
     364        return 2;
     365    };
     366
     367    for ( unsigned int n = 1; n < 50; n++ ) {
     368        val = ( cabsf( vec->data.C32[ n ] ) * cabsf( vec->data.C32[ n ] ) +
     369                cabsf( vec->data.C32[ 100 - n ] ) * cabsf( vec->data.C32[ 100 - n ] ) ) / 100 / 100;
     370
     371        if ( fabsf( val - vec2->data.F32[ n ] ) > FLT_EPSILON ) {
     372            psError( __func__, "psVectorPowerSpectrum result is invalid (n=%d, %.2f %.2f)",
     373                     n, vec2->data.F32[ n ], val );
    364374            return 2;
    365375        };
    366        
    367     for ( unsigned int n = 1; n < 50; n++ ) {
    368             val = ( cabsf( vec->data.C32[ n ] ) * cabsf( vec->data.C32[ n ] ) +
    369                     cabsf( vec->data.C32[ 100 - n ] ) * cabsf( vec->data.C32[ 100 - n ] ) ) / 100 / 100;
    370                    
    371             if ( fabsf( val - vec2->data.F32[ n ] ) > FLT_EPSILON ) {
    372                     psError( __func__, "psVectorPowerSpectrum result is invalid (n=%d, %.2f %.2f)",
    373                              n, vec2->data.F32[ n ], val );
    374                     return 2;
    375                 };
    376         }
    377        
     376    }
     377
    378378    val = cabsf( vec->data.C32[ 50 ] ) * cabsf( vec->data.C32[ 50 ] ) / 100 / 100;
    379379    if ( fabsf( vec2->data.F32[ 50 ] - val ) > FLT_EPSILON ) {
    380             psError( __func__, "psVectorPowerSpectrum result is invalid (n=50, %.2f %.2f)",
    381                      vec2->data.F32[ 0 ], val );
    382             return 2;
    383         };
    384        
    385     psFree( vec );
    386     psFree( vec2 );
    387    
    388     return 0;
    389 }
     380        psError( __func__, "psVectorPowerSpectrum result is invalid (n=50, %.2f %.2f)",
     381                 vec2->data.F32[ 0 ], val );
     382        return 2;
     383    };
     384
     385    psFree( vec );
     386    psFree( vec2 );
     387
     388    return 0;
     389}
Note: See TracChangeset for help on using the changeset viewer.