IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Aug 2, 2004, 9:43:23 AM (22 years ago)
Author:
desonia
Message:

adjusted output precision to allow tests to pass on x86_64, etc.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r1193 r1365  
    11/** @file  tst_psVectorFFT.c
    2  *
    3  *  @brief Contains the tests for psFFT.[ch]
    4  *
    5  *
    6  *  @author Robert DeSonia, MHPCC
    7  *
    8  *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2004-07-08 01:05:01 $
    10  *
    11  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    12  */
     2*
     3*  @brief Contains the tests for psFFT.[ch]
     4*
     5*
     6*  @author Robert DeSonia, MHPCC
     7*
     8*  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
     9*  @date $Date: 2004-08-02 19:43:23 $
     10*
     11*  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
     12*/
    1313
    1414#include <math.h>
    … …  
    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 
    29 static int testVectorFFT(void);
    30 static int testVectorRealImaginary(void);
    31 static int testVectorComplex(void);
    32 static int testVectorConjugate(void);
    33 static int testVectorPowerSpectrum(void);
     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   
     29static int testVectorFFT( void );
     30static int testVectorRealImaginary( void );
     31static int testVectorComplex( void );
     32static int testVectorConjugate( void );
     33static int testVectorPowerSpectrum( void );
    3434
    3535testDescription tests[] = {
    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}
     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                              }
    4254                          };
    43 
    44 int main(int argc, char* argv[])
    45 {
    46     psLogSetLevel(PS_LOG_INFO);
    47 
    48     if (! runTestSuite(stderr,"psFFT",tests,argc,argv) ) {
    49         psAbort(__FILE__,"One or more tests failed");
    50     }
    51     return 0;
    52 }
    53 
    54 int testVectorFFT(void)
    55 {
    56     psVector* vec = NULL;
     55                         
     56int main( int argc, char* argv[] )
     57{
     58    psLogSetLevel( PS_LOG_INFO );
     59   
     60    return ( ! runTestSuite( stderr, "psFFT", tests, argc, argv ) );
     61}
     62
     63int testVectorFFT( void )
     64{
     65    psVector * vec = NULL;
    5766    psVector* vec2 = NULL;
    5867    psVector* vec3 = NULL;
    59 
     68   
    6069    /*
    6170    1. assign a vector to a sinisoid
    … …  
    6574    5. compare to original (should be equal to within a reasonable error)
    6675    */
    67 
     76   
    6877    // 1. assign a vector to a sinisoid
    69     vec=psVectorAlloc(100,PS_TYPE_F32);
    70     vec->n = vec->nalloc;
    71     for (unsigned int n = 0; n<100; n++) {
    72         vec->data.F32[n] = sinf((psF32)n / 50.0f * M_PI);
    73     }
    74 
     78    vec = psVectorAlloc( 100, PS_TYPE_F32 );
     79    vec->n = vec->nalloc;
     80    for ( unsigned int n = 0; n < 100; n++ ) {
     81            vec->data.F32[ n ] = sinf( ( psF32 ) n / 50.0f * M_PI );
     82        }
     83       
    7584    // 2. perform a forward transform
    76     vec2 = psVectorFFT(NULL,vec,PS_FFT_FORWARD);
    77     if (vec2->type.type != PS_TYPE_C32) {
    78         psError(__func__,"FFT didn't produce complex values?");
    79         return 1;
    80     }
    81 
    82 
     85    vec2 = psVectorFFT( NULL, vec, PS_FFT_FORWARD );
     86    if ( vec2->type.type != PS_TYPE_C32 ) {
     87            psError( __func__, "FFT didn't produce complex values?" );
     88            return 1;
     89        }
     90       
     91       
    8392    // 3. verify that the only significant component cooresponds to the freqency of the input in step 1.
    84     for (unsigned int n = 0; n<100; n++) {
    85         if (n==1 || n==99) {
    86             if (fabsf(cabsf(vec2->data.C32[n]) - 50.0f) > 0.1f) {
    87                 psError(__func__,"FFT didn't work for vector (n=%d)",n);
    88                 return 2;
    89             }
    90         } else {
    91             if (fabsf(cabsf(vec2->data.C32[n])) > 0.1f) {
    92                 psError(__func__,"FFT didn't work for vector (n=%d)",n);
    93                 return 3;
    94             }
    95         }
    96     }
    97 
     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       
    98107    // 4. perform a reverse transform
    99     vec3 = psVectorFFT(NULL,vec2,PS_FFT_REVERSE);
    100     if (vec3->type.type != PS_TYPE_C32) {
    101         psError(__func__,"FFT didn't produce complex values?");
    102         return 4;
    103     }
    104     for (unsigned int n = 0; n<100; n++) {
    105         psF32 val =sinf((psF32)n / 50.0f * M_PI);
    106         psF32 vecVal = crealf(vec3->data.C32[n])/100;
    107         if (fabsf(vecVal - val) > 0.1f) {
    108             psError(__func__,"Reverse FFT didn't give me the original vector back (n=%d) (%.2f vs %.2f)",
    109                     n,vecVal,val);
    110             return 5;
    111         }
    112     }
    113 
    114     psFree(vec);
    115     psFree(vec2);
    116     psFree(vec3);
    117 
    118     return 0;
    119 }
    120 
    121 int testVectorRealImaginary(void)
    122 {
    123     psVector* vec = NULL;
     108    vec3 = psVectorFFT( NULL, vec2, PS_FFT_REVERSE );
     109    if ( vec3->type.type != PS_TYPE_C32 ) {
     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;
     120                }
     121        }
     122       
     123    psFree( vec );
     124    psFree( vec2 );
     125    psFree( vec3 );
     126   
     127    return 0;
     128}
     129
     130int testVectorRealImaginary( void )
     131{
     132    psVector * vec = NULL;
    124133    psVector* vec2 = NULL;
    125134    psVector* vec3 = NULL;
    126 
     135   
    127136    /*
    128137    1. create a C32 complex vector with distinctly different real and imaginary parts.
    … …  
    130139    3. compare results to the real/imaginary components of input
    131140    */
    132 
     141   
    133142    // 1. create a C32 complex vector with distinctly different real and imaginary parts.
    134     vec=psVectorAlloc(100,PS_TYPE_C32);
    135     vec->n = vec->nalloc;
    136     for (unsigned int n = 0; n<100; n++) {
    137         vec->data.C32[n] = n + I * (n*2);
    138     }
    139 
     143    vec = psVectorAlloc( 100, PS_TYPE_C32 );
     144    vec->n = vec->nalloc;
     145    for ( unsigned int n = 0; n < 100; n++ ) {
     146            vec->data.C32[ n ] = n + I * ( n * 2 );
     147        }
     148       
    140149    // 2. call psVectorReal and psVectorImaginary
    141     vec2 = psVectorReal(vec2,vec);
    142     if (vec2 == NULL) {
    143         psError(__func__,"psVectorReal returned a NULL?");
    144         return 1;
    145     }
    146     if (vec2->type.type != PS_TYPE_F32) {
    147         psError(__func__,"psVectorReal returned a wrong type (%d)?",
    148                 vec2->type.type);
    149         return 2;
    150     }
    151 
    152     vec3 = psVectorImaginary(vec3,vec);
    153     if (vec3 == NULL) {
    154         psError(__func__,"psVectorImaginary returned a NULL?");
    155         return 3;
    156     }
    157     if (vec3->type.type != PS_TYPE_F32) {
    158         psError(__func__,"psVectorImaginary returned a wrong type (%d)?",
    159                 vec3->type.type);
    160         return 4;
    161     }
    162 
     150    vec2 = psVectorReal( vec2, vec );
     151    if ( vec2 == NULL ) {
     152            psError( __func__, "psVectorReal returned a NULL?" );
     153            return 1;
     154        }
     155    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       
     161    vec3 = psVectorImaginary( vec3, vec );
     162    if ( vec3 == NULL ) {
     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       
    163172    // 3. compare results to the real/imaginary components of input
    164     for (unsigned int n = 0; n<100; n++) {
    165         psF32 r = n;
    166         psF32 i = (n*2);
    167         if (fabsf(vec2->data.F32[n] -r) > FLT_EPSILON) {
    168             psError(__func__,"psVectorReal didn't return the real portion at n=%d",
    169                     n);
    170             return 5;
    171         }
    172         if (fabsf(vec3->data.F32[n] -i) > FLT_EPSILON) {
    173             psError(__func__,"psVectorImaginary didn't return the real portion at n=%d",
    174                     n);
    175             return 6;
    176         }
    177     }
    178 
    179     psFree(vec);
    180     psFree(vec2);
    181     psFree(vec3);
    182 
    183     return 0;
    184 }
    185 
    186 int testVectorComplex(void)
    187 {
    188     psVector* vec = NULL;
     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       
     188    psFree( vec );
     189    psFree( vec2 );
     190    psFree( vec3 );
     191   
     192    return 0;
     193}
     194
     195int testVectorComplex( void )
     196{
     197    psVector * vec = NULL;
    189198    psVector* vec2 = NULL;
    190199    psVector* vec3 = NULL;
    191 
     200   
    192201    /*
    193202    1. create two unique psF32 vectors of the same size
    … …  
    196205    4. call psVectorReal and psVectorImaginary on step 2 results
    197206    5. compare step 4 results to input.
    198 
     207   
    199208    6. create a psF32 and a psF64 vector of the same size
    200209    7. call psVectorComplex
    201210    8. verify that an appropriate error occurred.
    202 
     211   
    203212    9. create two psf32 vectors of different sizes
    204213    10. call psVectorComplex
    205214    11. verify thet an appropriate error occurred.
    206215    */
    207 
     216   
    208217    // 1. create two unique psF32 vectors of the same size
    209     vec=psVectorAlloc(100,PS_TYPE_F32);
    210     vec2=psVectorAlloc(100,PS_TYPE_F32);
     218    vec = psVectorAlloc( 100, PS_TYPE_F32 );
     219    vec2 = psVectorAlloc( 100, PS_TYPE_F32 );
    211220    vec->n = vec->nalloc;
    212221    vec2->n = vec2->nalloc;
    213     for (unsigned int n = 0; n<100; n++) {
    214         vec->data.F32[n] = n;
    215         vec2->data.F32[n] = (n*2);
    216     }
    217 
     222    for ( unsigned int n = 0; n < 100; n++ ) {
     223            vec->data.F32[ n ] = n;
     224            vec2->data.F32[ n ] = ( n * 2 );
     225        }
     226       
    218227    // 2. call psVectorComplex
    219     vec3 = psVectorComplex(vec3,vec,vec2);
    220 
     228    vec3 = psVectorComplex( vec3, vec, vec2 );
     229   
    221230    // 3. verify that the result is a psC32
    222     if (vec3->type.type != PS_TYPE_C32) {
    223         psError(__func__,"Vector Type from psVectorComplex is not complex? (%d)",
    224                 vec3->type.type);
    225         return 1;
    226     }
    227 
     231    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       
    228237    // 4. call psVectorReal and psVectorImaginary on step 2 results (not needed, just use crealf/cimagf)
    229238    // 5. compare step 4 results to input.
    230     for (unsigned int n = 0; n<100; n++) {
    231         if (fabsf(crealf(vec3->data.C32[n]) - n) > FLT_EPSILON ||
    232                 fabsf(cimagf(vec3->data.C32[n]) - (n*2)) > FLT_EPSILON) {
    233             psError(__func__,"psVectorComplex result is invalid (n=%d, %.2f+%.2fi)",
    234                     n,crealf(vec3->data.C32[n]),cimagf(vec3->data.C32[n]));
    235             return 2;
    236         };
    237     }
    238 
    239 
     239    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       
    240249    // 6. create a psF32 and a psF64 vector of the same size
    241     vec2 = psVectorRecycle(vec2,PS_TYPE_F64, 100);
    242 
     250    vec2 = psVectorRecycle( vec2, PS_TYPE_F64, 100 );
     251   
    243252    // 7. call psVectorComplex
    244     psLogMsg(__func__,PS_LOG_INFO, "Following should be an error (type mismatch).");
    245     vec3 = psVectorComplex(vec3,vec,vec2);
     253    psLogMsg( __func__, PS_LOG_INFO, "Following should be an error (type mismatch)." );
     254    vec3 = psVectorComplex( vec3, vec, vec2 );
    246255    // 8. verify that an appropriate error occurred. (this partially has to be done via inspection)
    247     if (vec3 != NULL) {
    248         psError(__func__,"psVectorComplex returned a vector though input types mismatched.");
    249         return 3;
    250     }
    251 
     256    if ( vec3 != NULL ) {
     257            psError( __func__, "psVectorComplex returned a vector though input types mismatched." );
     258            return 3;
     259        }
     260       
    252261    // 9. create two psf32 vectors of different sizes
    253     vec2 = psVectorRecycle(vec2,PS_TYPE_F32,200);
    254 
     262    vec2 = psVectorRecycle( vec2, PS_TYPE_F32, 200 );
     263   
    255264    // 10. call psVectorComplex
    256     vec3 = psVectorComplex(vec3,vec,vec2);
    257 
     265    vec3 = psVectorComplex( vec3, vec, vec2 );
     266   
    258267    // 11. verify thet an appropriate error occurred. (actually, it isn't an error...)
    259     if (vec3->n != 100) {
    260         psError(__func__,"psVectorComplex returned a vector though input sizes mismatched.");
    261         return 4;
    262     }
    263 
    264     psFree(vec);
    265     psFree(vec2);
    266     psFree(vec3);
    267 
    268     return 0;
    269 }
    270 
    271 int testVectorConjugate(void)
    272 {
    273     psVector* vec = NULL;
    274     psVector* vec2 = NULL;
    275 
     268    if ( vec3->n != 100 ) {
     269            psError( __func__, "psVectorComplex returned a larger vector than the input supported (%d).", vec3->n );
     270            return 4;
     271        }
     272       
     273    psFree( vec );
     274    psFree( vec2 );
     275    psFree( vec3 );
     276   
     277    return 0;
     278}
     279
     280int testVectorConjugate( void )
     281{
     282    psVector * vec = NULL;
     283    psVector* vec2 = NULL;
     284   
    276285    /*
    277286    1. create a psC32 with unique real and imaginary values.
    … …  
    280289    4. verify each value is conjugate of input (a+bi -> a-bi)
    281290    */
    282 
     291   
    283292    // 1. create a psC32 with unique real and imaginary values.
    284     vec=psVectorAlloc(100,PS_TYPE_C32);
    285     vec->n = vec->nalloc;
    286     for (unsigned int n = 0; n<100; n++) {
    287         vec->data.C32[n] = n + I * (n*2);
    288     }
    289 
     293    vec = psVectorAlloc( 100, PS_TYPE_C32 );
     294    vec->n = vec->nalloc;
     295    for ( unsigned int n = 0; n < 100; n++ ) {
     296            vec->data.C32[ n ] = n + I * ( n * 2 );
     297        }
     298       
    290299    // 2. call psVectorConjugate
    291     vec2 = psVectorConjugate(vec2,vec);
    292 
     300    vec2 = psVectorConjugate( vec2, vec );
     301   
    293302    // 3. verify result is psC32
    294     if (vec2->type.type != PS_TYPE_C32) {
    295         psError(__func__,"the psVectorConjugate didn't return a C32 vector");
    296         return 1;
    297     }
    298 
     303    if ( vec2->type.type != PS_TYPE_C32 ) {
     304            psError( __func__, "the psVectorConjugate didn't return a C32 vector" );
     305            return 1;
     306        }
     307       
    299308    // 4. verify each value is conjugate of input (a+bi -> a-bi)
    300     for (unsigned int n = 0; n<100; n++) {
    301         if (fabsf(crealf(vec->data.C32[n]) - crealf(vec2->data.C32[n])) > FLT_EPSILON ||
    302                 fabsf(cimagf(vec->data.C32[n]) + cimagf(vec2->data.C32[n])) > FLT_EPSILON) {
    303             psError(__func__,"psVectorComplex result is invalid (n=%d, %.2f+%.2fi)",
    304                     n,crealf(vec2->data.C32[n]),cimagf(vec2->data.C32[n]));
    305             return 2;
    306         };
    307     }
    308 
    309     psFree(vec);
    310     psFree(vec2);
    311 
    312     return 0;
    313 }
    314 
    315 int testVectorPowerSpectrum(void)
    316 {
    317     psVector* vec = NULL;
     309    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   
     321    return 0;
     322}
     323
     324int testVectorPowerSpectrum( void )
     325{
     326    psVector * vec = NULL;
    318327    psVector* vec2 = NULL;
    319328    psF32 val;
    320 
     329   
    321330    /*
    322331    1. create a psC32 vector with unique real and imaginary components
    … …  
    325334    4. verify the values are the square of the absolute values of the original
    326335    */
    327 
     336   
    328337    // 1. create a psC32 vector with unique real and imaginary components
    329     vec=psVectorAlloc(100,PS_TYPE_C32);
    330     vec->n = vec->nalloc;
    331     for (unsigned int n = 0; n<100; n++) {
    332         vec->data.C32[n] = n + I * sinf(((psF32)n) / 50.f * M_PI);
    333     }
    334 
     338    vec = psVectorAlloc( 100, PS_TYPE_C32 );
     339    vec->n = vec->nalloc;
     340    for ( unsigned int n = 0; n < 100; n++ ) {
     341            vec->data.C32[ n ] = n + I * sinf( ( ( psF32 ) n ) / 50.f * M_PI );
     342        }
     343       
    335344    // 2. call psVectorPowerSpectrum
    336     vec2 = psVectorPowerSpectrum(vec2,vec);
    337 
     345    vec2 = psVectorPowerSpectrum( vec2, vec );
     346   
    338347    // 3. verify result is psF32
    339     if (vec2->type.type != PS_TYPE_F32) {
    340         psError(__func__,"the type was not PS_TYPE_F32.");
    341         return 1;
    342     }
    343 
     348    if ( vec2->type.type != PS_TYPE_F32 ) {
     349            psError( __func__, "the type was not PS_TYPE_F32." );
     350            return 1;
     351        }
     352       
    344353    // 4. verify the values are the square of the absolute values of the original
    345354    //   (ADD specifies something else)
    … …  
    348357    //   P_N/2 = |C_N/2|^2/N^2
    349358    //  where j = 1,2,...,(N/2-1)
    350 
    351     val = cabsf(vec->data.C32[0])*cabsf(vec->data.C32[0])/100/100;
    352     if (fabsf(vec2->data.F32[0] - val) > FLT_EPSILON) {
    353         psError(__func__,"psVectorPowerSpectrum result is invalid (n=0, %.2f %.2f)",
    354                 vec2->data.F32[0],val);
    355         return 2;
    356     };
    357 
    358     for (unsigned int n = 1; n<50; n++) {
    359         val = ( cabsf(vec->data.C32[n])*cabsf(vec->data.C32[n])+
    360                 cabsf(vec->data.C32[100-n])*cabsf(vec->data.C32[100-n]) ) /100/100;
    361 
    362         if (fabsf(val - vec2->data.F32[n]) > FLT_EPSILON) {
    363             psError(__func__,"psVectorPowerSpectrum result is invalid (n=%d, %.2f %.2f)",
    364                     n,vec2->data.F32[n],val);
     359   
     360    val = cabsf( vec->data.C32[ 0 ] ) * cabsf( vec->data.C32[ 0 ] ) / 100 / 100;
     361    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 );
    365364            return 2;
    366365        };
    367     }
    368 
    369     val = cabsf(vec->data.C32[50])*cabsf(vec->data.C32[50])/100/100;
    370     if (fabsf(vec2->data.F32[50] - val) > FLT_EPSILON) {
    371         psError(__func__,"psVectorPowerSpectrum result is invalid (n=50, %.2f %.2f)",
    372                 vec2->data.F32[0],val);
    373         return 2;
    374     };
    375 
    376     psFree(vec);
    377     psFree(vec2);
    378 
    379     return 0;
    380 }
     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       
     378    val = cabsf( vec->data.C32[ 50 ] ) * cabsf( vec->data.C32[ 50 ] ) / 100 / 100;
     379    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}
Note: See TracChangeset for help on using the changeset viewer.