Index: /trunk/psLib/test/dataManip/tst_psVectorFFT.c
===================================================================
--- /trunk/psLib/test/dataManip/tst_psVectorFFT.c	(revision 2712)
+++ /trunk/psLib/test/dataManip/tst_psVectorFFT.c	(revision 2713)
@@ -6,6 +6,6 @@
 *  @author Robert DeSonia, MHPCC
 *
-*  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2004-11-04 23:12:10 $
+*  @version $Revision: 1.10 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2004-12-14 21:16:28 $
 *
 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -34,22 +34,10 @@
 
 testDescription tests[] = {
-                              {
-                                  testVectorFFT, 600, "psVectorFFT", 0, false
-                              },
-                              {
-                                  testVectorRealImaginary, 601, "psVectorRealImaginary", 0, false
-                              },
-                              {
-                                  testVectorComplex, 602, "psVectorComplex", 0, false
-                              },
-                              {
-                                  testVectorConjugate, 603, "psVectorConjugate", 0, false
-                              },
-                              {
-                                  testVectorPowerSpectrum, 604, "psVectorPowerSpectrum", 0, false
-                              },
-                              {
-                                  NULL
-                              }
+                              {testVectorFFT, 600, "psVectorFFT", 0, false},
+                              {testVectorRealImaginary, 601, "psVectorRealImaginary", 0, false},
+                              {testVectorComplex, 602, "psVectorComplex", 0, false},
+                              {testVectorConjugate, 603, "psVectorConjugate", 0, false},
+                              {testVectorPowerSpectrum, 604, "psVectorPowerSpectrum", 0, false},
+                              {NULL}
                           };
 
@@ -66,4 +54,5 @@
     psVector* vec2 = NULL;
     psVector* vec3 = NULL;
+    psVector* vec4 = NULL;
 
     /*
@@ -131,7 +120,28 @@
     }
 
+    // Perform a reverse transform with real flag set
+    vec4 = psVectorFFT(NULL,vec2, (PS_FFT_REVERSE | PS_FFT_REAL_RESULT));
+    if(vec4->type.type != PS_TYPE_F32) {
+        psError(PS_ERR_UNKNOWN,true,"FFT with real result did not produce real values");
+        return 80;
+    }
+
+    // Perform vector FFT with invalid direction flags
+    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message.");
+    if ( psVectorFFT(NULL,vec2,(psFFTFlags)0) != NULL) {
+        psError(PS_ERR_UNKNOWN,true,"Did not return NULL with invalid direction");
+        return 70;
+    }
+
     psFree( vec );
     psFree( vec2 );
     psFree( vec3 );
+    psFree( vec4 );
+
+    // Perform vector FFT with null input
+    if ( psVectorFFT(NULL,NULL,PS_FFT_FORWARD) != NULL) {
+        psError(PS_ERR_UNKNOWN,true,"Did not return NULL with null input vector");
+        return 64;
+    }
 
     return 0;
@@ -143,4 +153,12 @@
     psVector* vec2 = NULL;
     psVector* vec3 = NULL;
+    psVector* vec4 = NULL;
+    psVector* vec5 = NULL;
+    psVector* vec6 = NULL;
+    psVector* vec7 = NULL;
+    psVector* vec8 = NULL;
+    psVector* vec9 = NULL;
+    psVector* vec10 = NULL;
+    psVector* vec11 = NULL;
 
     /*
@@ -152,7 +170,21 @@
     // 1. create a C32 complex vector with distinctly different real and imaginary parts.
     vec = psVectorAlloc( 100, PS_TYPE_C32 );
-    vec->n = vec->nalloc;
+    vec8 = psVectorAlloc( 100, PS_TYPE_C64 );
+    vec10 = psVectorAlloc( 100, PS_TYPE_C64 );
+    vec->n = vec->nalloc;
+    vec8->n = vec8->nalloc;
+    vec10->n = vec10->nalloc;
     for ( psU32 n = 0; n < 100; n++ ) {
         vec->data.C32[ n ] = n + I * ( n * 2 );
+        vec8->data.C64[n] = n + I * ( n * 2 );
+        vec10->data.C64[n] = n + I * ( n * 2 );
+    }
+    vec4 = psVectorAlloc( 100, PS_TYPE_F32);
+    vec4->n = vec4->nalloc;
+    vec6 = psVectorAlloc( 100, PS_TYPE_F32);
+    vec6->n = vec6->nalloc;
+    for ( psU32 n = 0; n < 100; n++ ) {
+        vec4->data.F32[n] = n;
+        vec6->data.F32[n] = n;
     }
 
@@ -169,4 +201,26 @@
     }
 
+    psLogMsg(__func__,PS_LOG_INFO,"Following should generate a warning.");
+    vec5 = psVectorReal(vec5, vec4);
+    if (vec5 == NULL) {
+        psError(PS_ERR_UNKNOWN,true,"psVectorReal returned NULL");
+        return 10;
+    }
+    if ( vec5->type.type != PS_TYPE_F32) {
+        psError(PS_ERR_UNKNOWN,true,"psVectorReal returned the wrong type");
+        return 11;
+    }
+
+    vec9 = psVectorReal(vec9,vec8);
+    if(vec9 == NULL) {
+        psError(PS_ERR_UNKNOWN,true,"psVectorReal returned NULL");
+        return 20;
+    }
+    if(vec9->type.type != PS_TYPE_F64) {
+        psError(PS_ERR_UNKNOWN,true,"psVectorReal returned the wrong type");
+        return 21;
+    }
+
+    psLogMsg(__func__,PS_LOG_INFO,"Following should generate a warning.");
     vec3 = psVectorImaginary( vec3, vec );
     if ( vec3 == NULL ) {
@@ -180,8 +234,30 @@
     }
 
+    vec7 = psVectorImaginary(vec7, vec6);
+    if(vec7 == NULL) {
+        psError(PS_ERR_UNKNOWN,true,"psVectorImage returned NULL");
+        return 12;
+    }
+    if(vec7->type.type != PS_TYPE_F32) {
+        psError(PS_ERR_UNKNOWN,true,"psVectorImaginary returned the wrong type");
+        return 13;
+    }
+
+    vec11 = psVectorImaginary(vec11, vec10);
+    if(vec11 == NULL) {
+        psError(PS_ERR_UNKNOWN,true,"psVectorImaginary returned NULL");
+        return 14;
+    }
+    if(vec11->type.type != PS_TYPE_F64) {
+        psError(PS_ERR_UNKNOWN,true,"psVectorImaginary returned the wrong type");
+        return 15;
+    }
+
     // 3. compare results to the real/imaginary components of input
     for ( psU32 n = 0; n < 100; n++ ) {
         psF32 r = n;
         psF32 i = ( n * 2 );
+        psF64 rr = n;
+        psF64 ii = ( n * 2 );
         if ( fabsf( vec2->data.F32[ n ] - r ) > FLT_EPSILON ) {
             psError(PS_ERR_UNKNOWN,true, "psVectorReal didn't return the real portion at n=%d",
@@ -194,4 +270,20 @@
             return 6;
         }
+        if ( fabsf( vec5->data.F32[n] - r) > FLT_EPSILON) {
+            psError(PS_ERR_UNKNOWN,true,"psVectorReal didn't return the real portion at n=%d",n);
+            return 50;
+        }
+        if ( fabsf( vec7->data.F32[n] - 0) > FLT_EPSILON) {
+            psError(PS_ERR_UNKNOWN,true,"psVectorImaginary did not return the imaginary portion at n=%d",n);
+            return 51;
+        }
+        if ( fabsf(vec9->data.F64[n] - rr) > FLT_EPSILON ) {
+            psError(PS_ERR_UNKNOWN,true,"psVectorReal did not return the real portion at n=%d",n);
+            return 52;
+        }
+        if ( fabsf(vec11->data.F64[n] - ii) > FLT_EPSILON) {
+            psError(PS_ERR_UNKNOWN,true,"psVectorImaginary did not return the imaginary portion at n=%d",n);
+            return 53;
+        }
     }
 
@@ -199,4 +291,23 @@
     psFree( vec2 );
     psFree( vec3 );
+    psFree( vec4 );
+    psFree( vec5 );
+    psFree( vec6 );
+    psFree( vec7 );
+    psFree( vec8 );
+    psFree( vec9 );
+    psFree( vec10 );
+    psFree( vec11 );
+
+    // Perform vector Real with null input
+    if ( psVectorReal(NULL,NULL) != NULL) {
+        psError(PS_ERR_UNKNOWN,true,"Did not return NULL with null input vector");
+        return 63;
+    }
+    // Perform vector Imaginary with null input
+    if ( psVectorImaginary(NULL,NULL) != NULL) {
+        psError(PS_ERR_UNKNOWN,true,"Did not return NULL with null input vector");
+        return 73;
+    }
 
     return 0;
@@ -208,4 +319,7 @@
     psVector* vec2 = NULL;
     psVector* vec3 = NULL;
+    psVector* vec4 = NULL;
+    psVector* vec5 = NULL;
+    psVector* vec6 = NULL;
 
     /*
@@ -228,9 +342,15 @@
     vec = psVectorAlloc( 100, PS_TYPE_F32 );
     vec2 = psVectorAlloc( 100, PS_TYPE_F32 );
+    vec4 = psVectorAlloc( 100, PS_TYPE_F64 );
+    vec5 = psVectorAlloc( 100, PS_TYPE_F64 );
     vec->n = vec->nalloc;
     vec2->n = vec2->nalloc;
+    vec4->n = vec4->nalloc;
+    vec5->n = vec5->nalloc;
     for ( psU32 n = 0; n < 100; n++ ) {
         vec->data.F32[ n ] = n;
         vec2->data.F32[ n ] = ( n * 2 );
+        vec4->data.F64[ n ] = n;
+        vec5->data.F64[ n ] = ( n * 2 );
     }
 
@@ -281,7 +401,34 @@
     }
 
+    // Verify the function works with psF64 type
+    vec6 = psVectorComplex(vec6, vec4, vec5);
+    if( vec6->type.type != PS_TYPE_C64 ) {
+        psError(PS_ERR_UNKNOWN,true,"Vector return type is not complex");
+        return 40;
+    }
+
+    // Verify error message generated with input of invalid type
+    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message.");
+    vec4->type.type = PS_TYPE_S8;
+    vec5->type.type = PS_TYPE_S8;
+    vec6 = psVectorComplex(vec6, vec4, vec5);
+    if(vec6 != NULL) {
+        psError(PS_ERR_UNKNOWN,true,"Did not return NULL for invalid type");
+        return 50;
+    }
+    vec4->type.type = PS_TYPE_F64;
+    vec5->type.type = PS_TYPE_F64;
+
     psFree( vec );
     psFree( vec2 );
     psFree( vec3 );
+    psFree( vec4 );
+    psFree( vec5 );
+
+    // Perform vector complex with null input
+    if ( psVectorComplex(NULL,NULL,NULL) != NULL) {
+        psError(PS_ERR_UNKNOWN,true,"Did not return NULL with null input vector");
+        return 62;
+    }
 
     return 0;
@@ -320,5 +467,5 @@
         if ( fabsf( crealf( vec->data.C32[ n ] ) - crealf( vec2->data.C32[ n ] ) ) > FLT_EPSILON ||
                 fabsf( cimagf( vec->data.C32[ n ] ) + cimagf( vec2->data.C32[ n ] ) ) > FLT_EPSILON ) {
-            psError(PS_ERR_UNKNOWN,true, "psVectorComplex result is invalid (n=%d, %.2f+%.2fi)",
+            psError(PS_ERR_UNKNOWN,true, "psVectorConjugate result is invalid (n=%d, %.2f+%.2fi)",
                     n, crealf( vec2->data.C32[ n ] ), cimagf( vec2->data.C32[ n ] ) );
             return 2;
@@ -328,4 +475,50 @@
     psFree( vec );
     psFree( vec2 );
+
+    // Perform conjugate for non-complex number
+    vec = psVectorAlloc( 100, PS_TYPE_F32 );
+    vec->n = vec->nalloc;
+    for ( psU32 n = 0; n < 100; n++ ) {
+        vec->data.F32[ n ] = n;
+    }
+    psLogMsg(__func__,PS_LOG_INFO,"Following should generate a warning message.");
+    vec2 = psVectorConjugate(vec2,vec);
+    if(vec2->type.type != PS_TYPE_F32) {
+        psError(PS_ERR_UNKNOWN,true,"psVectorConjugate did not return a F32 vector");
+        return 10;
+    }
+    for ( psU32 n = 0; n < 100; n++ ) {
+        if( vec->data.F32[n] != vec2->data.F32[n] ) {
+            psError(PS_ERR_UNKNOWN,true,"psVectorConjugate result is invalid (n=%d)",n);
+            return 11;
+        }
+    }
+    psFree(vec);
+
+    // Perform vector conjugate with C64 type
+    vec = psVectorAlloc( 100, PS_TYPE_C64 );
+    vec->n = vec->nalloc;
+    for ( psU32 n = 0; n < 100; n++ ) {
+        vec->data.C64[n] = n + I * ( n * 2 );
+    }
+    vec2 = psVectorConjugate(vec2,vec);
+    if(vec2->type.type != PS_TYPE_C64) {
+        psError(PS_ERR_UNKNOWN,true,"psVectorConjugate did not return a C64 vector");
+        return 12;
+    }
+    for ( psU32 n = 0; n < 100; n++ ) {
+        if ( fabsf( crealf(vec->data.C64[n]) - crealf(vec2->data.C64[n])) > FLT_EPSILON ||
+                fabsf( cimagf(vec->data.C64[n]) - cimagf(vec2->data.C64[n])) > FLT_EPSILON ) {
+            psError(PS_ERR_UNKNOWN,true,"psVectorConjugate result is invalid (n=%d)",n);
+            return 13;
+        }
+    }
+    psFree(vec);
+
+    // Perform vector conjugate with null input
+    if ( psVectorConjugate(NULL,NULL) != NULL) {
+        psError(PS_ERR_UNKNOWN,true,"Did not return NULL with null input vector");
+        return 61;
+    }
 
     return 0;
@@ -336,5 +529,9 @@
     psVector * vec = NULL;
     psVector* vec2 = NULL;
+    psVector* vec3 = NULL;
+    psVector* vec4 = NULL;
+
     psF32 val;
+    psF64 val1;
 
     /*
@@ -348,10 +545,14 @@
     vec = psVectorAlloc( 100, PS_TYPE_C32 );
     vec->n = vec->nalloc;
+    vec3 = psVectorAlloc(100,PS_TYPE_C64);
+    vec3->n = vec3->nalloc;
     for ( psU32 n = 0; n < 100; n++ ) {
         vec->data.C32[ n ] = n + I * sinf( ( ( psF32 ) n ) / 50.f * M_PI );
+        vec3->data.C64[ n ] = n + I * sinf( ( ( psF64 ) n ) / 50.f * M_PI );
     }
 
     // 2. call psVectorPowerSpectrum
     vec2 = psVectorPowerSpectrum( vec2, vec );
+    vec4 = psVectorPowerSpectrum( vec4, vec3 );
 
     // 3. verify result is psF32
@@ -359,4 +560,8 @@
         psError(PS_ERR_UNKNOWN,true, "the type was not PS_TYPE_F32." );
         return 1;
+    }
+    if ( vec4->type.type != PS_TYPE_F64 ) {
+        psError(PS_ERR_UNKNOWN,true,"psPowerSpectrum did not return type PS_TYPE_F64 type = %d",vec4->type.type);
+        return 20;
     }
 
@@ -376,19 +581,29 @@
 
     val = cabsf( vec->data.C32[ 0 ] ) * cabsf( vec->data.C32[ 0 ] ) / 100 / 100;
+    val1= cabsf( vec3->data.C64[0] ) * cabsf(vec3->data.C64[0])/100/100;
     if ( fabsf( vec2->data.F32[ 0 ] - val ) > FLT_EPSILON ) {
         psError(PS_ERR_UNKNOWN,true, "psVectorPowerSpectrum result is invalid (n=0, %.2f %.2f)",
                 vec2->data.F32[ 0 ], val );
         return 2;
-    };
+    }
+    if ( fabsf( vec4->data.C64[0] - val1 ) > FLT_EPSILON ) {
+        psError(PS_ERR_UNKNOWN,true,"psVectorPowerSpectrum result is invalid (n=0)");
+        return 21;
+    }
 
     for ( psU32 n = 1; n < 50; n++ ) {
         val = ( cabsf( vec->data.C32[ n ] ) * cabsf( vec->data.C32[ n ] ) +
                 cabsf( vec->data.C32[ 100 - n ] ) * cabsf( vec->data.C32[ 100 - n ] ) ) / 100 / 100;
-
+        val1 = (cabsf(vec3->data.C64[n]) * cabsf(vec3->data.C64[n]) +
+                cabsf(vec3->data.C64[100-n]) * cabsf(vec3->data.C64[100-n]))/100/100;
         if ( fabsf( val - vec2->data.F32[ n ] ) > FLT_EPSILON ) {
             psError(PS_ERR_UNKNOWN,true, "psVectorPowerSpectrum result is invalid (n=%d, %.2f %.2f)",
                     n, vec2->data.F32[ n ], val );
             return 2;
-        };
+        }
+        if (fabsf(val1 - vec4->data.F64[n]) > FLT_EPSILON) {
+            psError(PS_ERR_UNKNOWN,true,"psVectorPowerSpectrum result is invalid (n=%d, %.2f %.2f)",n,vec4->data.F64[n],val1);
+            return 22;
+        }
     }
 
@@ -402,4 +617,26 @@
     psFree( vec );
     psFree( vec2 );
+    psFree( vec3 );
+    psFree( vec4 );
+
+    // Perform vector power spectrum with non-complex number
+    vec = psVectorAlloc(100,PS_TYPE_F32);
+    vec->n = vec->nalloc;
+    for( psU32 n=0; n<100; n++) {
+        vec->data.F32[n] = n;
+    }
+    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message.");
+    if(psVectorPowerSpectrum(NULL,vec) != NULL) {
+        psError(PS_ERR_UNKNOWN,true,"psVectorPowerSpectrum did not return a null vector.");
+        return 10;
+    }
+
+    // Perform vector power spectrum with null input
+    if ( psVectorPowerSpectrum(NULL,NULL) != NULL) {
+        psError(PS_ERR_UNKNOWN,true,"Did not return NULL with null input vector");
+        return 60;
+    }
+
+    psFree(vec);
 
     return 0;
Index: /trunk/psLib/test/dataManip/verified/tst_psVectorFFT.stderr
===================================================================
--- /trunk/psLib/test/dataManip/verified/tst_psVectorFFT.stderr	(revision 2712)
+++ /trunk/psLib/test/dataManip/verified/tst_psVectorFFT.stderr	(revision 2713)
@@ -5,4 +5,8 @@
 \**********************************************************************************/
 
+<DATE><TIME>|<HOST>|I|testVectorFFT
+    Following should generate an error message.
+<DATE><TIME>|<HOST>|E|psVectorFFT (psVectorFFT.c:<LINENO>)
+    Must specify the direction as either PS_FFT_FORWARD or PS_FFT_REVERSE.
 
 ---> TESTPOINT PASSED (psFFT{psVectorFFT} | tst_psVectorFFT.c)
@@ -14,4 +18,12 @@
 \**********************************************************************************/
 
+<DATE><TIME>|<HOST>|I|testVectorRealImaginary
+    Following should generate a warning.
+<DATE><TIME>|<HOST>|W|psVectorReal
+    Real portion of a non-Complex type called called for. Just a vector copy was performed.
+<DATE><TIME>|<HOST>|I|testVectorRealImaginary
+    Following should generate a warning.
+<DATE><TIME>|<HOST>|W|psVectorImaginary
+    Imaginary portion of a non-Complex type called for. A zeroed vector was returned.
 
 ---> TESTPOINT PASSED (psFFT{psVectorRealImaginary} | tst_psVectorFFT.c)
@@ -27,4 +39,8 @@
 <DATE><TIME>|<HOST>|E|psVectorComplex (psVectorFFT.c:<LINENO>)
     Real psVector type, psF32, and imaginary psVector type, psF64, must be the same.
+<DATE><TIME>|<HOST>|I|testVectorComplex
+    Following should generate an error message.
+<DATE><TIME>|<HOST>|E|psVectorComplex (psVectorFFT.c:<LINENO>)
+    Input psVector type, psS8, is required to be either psF32 or psF64.
 
 ---> TESTPOINT PASSED (psFFT{psVectorComplex} | tst_psVectorFFT.c)
@@ -36,4 +52,8 @@
 \**********************************************************************************/
 
+<DATE><TIME>|<HOST>|I|testVectorConjugate
+    Following should generate a warning message.
+<DATE><TIME>|<HOST>|W|psVectorConjugate
+    Complex Conjugate of a non-Complex type called for. Vector copy was performed instead.
 
 ---> TESTPOINT PASSED (psFFT{psVectorConjugate} | tst_psVectorFFT.c)
@@ -45,4 +65,8 @@
 \**********************************************************************************/
 
+<DATE><TIME>|<HOST>|I|testVectorPowerSpectrum
+    Following should generate an error message.
+<DATE><TIME>|<HOST>|E|psVectorPowerSpectrum (psVectorFFT.c:<LINENO>)
+    Input psVector type, psF32, is required to be either psC32 or psC64.
 
 ---> TESTPOINT PASSED (psFFT{psVectorPowerSpectrum} | tst_psVectorFFT.c)