Index: /trunk/psLib/test/dataManip/tst_psHist02.c =================================================================== --- /trunk/psLib/test/dataManip/tst_psHist02.c (revision 1364) +++ /trunk/psLib/test/dataManip/tst_psHist02.c (revision 1365) @@ -1,7 +1,7 @@ /***************************************************************************** - This routine must ensure that the psHistogram structure is correctly - populated by the procedure psGetArrayHistogram(). - - *****************************************************************************/ + This routine must ensure that the psHistogram structure is correctly + populated by the procedure psGetArrayHistogram(). + +*****************************************************************************/ #include #include "pslib.h" @@ -16,126 +16,126 @@ int main() { - psHistogram *myHist = NULL; - psHistogram *myHist2= NULL; - psVector *myData = NULL; - psVector *myMask = NULL; - int testStatus = true; - int memLeaks = 0; - int nb = 0; - int numBins = 0; - int i = 0; - int currentId = 0; - - currentId = psMemGetId(); - + psHistogram * myHist = NULL; + psHistogram *myHist2 = NULL; + psVector *myData = NULL; + psVector *myMask = NULL; + int testStatus = true; + int memLeaks = 0; + int nb = 0; + int numBins = 0; + int i = 0; + int currentId = 0; + + currentId = psMemGetId(); + /*********************************************************************/ /* Allocate and initialize data structures */ /*********************************************************************/ - myData = psVectorAlloc(NUM_DATA, PS_TYPE_F32); + myData = psVectorAlloc( NUM_DATA, PS_TYPE_F32 ); myData->n = myData->nalloc; - for (i=0;idata.F32[i] = LOWER + ((UPPER - LOWER) / (float) NUM_DATA) * (float) i; - } - - myMask = psVectorAlloc(NUM_DATA, PS_TYPE_U8); + for ( i = 0;i < NUM_DATA;i++ ) { + myData->data.F32[ i ] = LOWER + ( ( UPPER - LOWER ) / ( float ) NUM_DATA ) * ( float ) i; + } + + myMask = psVectorAlloc( NUM_DATA, PS_TYPE_U8 ); myMask->n = myMask->nalloc; - for (i=0;i= (NUM_DATA/2)) { - myMask->data.U8[i] = 1; - } else { - myMask->data.U8[i] = 0; + for ( i = 0;i < NUM_DATA;i++ ) { + if ( i >= ( NUM_DATA / 2 ) ) { + myMask->data.U8[ i ] = 1; + } else { + myMask->data.U8[ i ] = 0; + } } - } - - for (nb=0;nb<4;nb++) { - if (nb == 0) - numBins = 1; - if (nb == 1) - numBins = 2; - if (nb == 2) - numBins = 10; - if (nb == 3) - numBins = 20; - - /*********************************************************************/ - /* Allocate and Perform Histogram, no mask */ - /*********************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "Allocate and Perform Histogram, no mask"); - - myHist = psHistogramAlloc(LOWER, UPPER, numBins); - myHist = psVectorHistogram(myHist, myData, NULL, 0); - - for (i=0;ibounds->data.F32[i], - myHist->bounds->data.F32[i+1], - myHist->nums->data.U32[i]); + + for ( nb = 0;nb < 4;nb++ ) { + if ( nb == 0 ) + numBins = 1; + if ( nb == 1 ) + numBins = 2; + if ( nb == 2 ) + numBins = 10; + if ( nb == 3 ) + numBins = 20; + + /*********************************************************************/ + /* Allocate and Perform Histogram, no mask */ + /*********************************************************************/ + printPositiveTestHeader( stdout, + "psStats functions", + "Allocate and Perform Histogram, no mask" ); + + myHist = psHistogramAlloc( LOWER, UPPER, numBins ); + myHist = psVectorHistogram( myHist, myData, NULL, 0 ); + + for ( i = 0;i < numBins;i++ ) { + printf( "Bin number %d bounds: (%.2f - %.2f) data (%d)\n", i, + myHist->bounds->data.F32[ i ], + myHist->bounds->data.F32[ i + 1 ], + myHist->nums->data.U32[ i ] ); + } + psMemCheckCorruption( 1 ); + psFree( myHist ); + psMemCheckCorruption( 1 ); + + printFooter( stdout, + "psStats functions", + "Allocate and Perform Histogram, no mask", + testStatus ); + + /*********************************************************************/ + /* Allocate and Perform Histogram with mask */ + /*********************************************************************/ + printPositiveTestHeader( stdout, + "psStats functions", + "Allocate and Perform Histogram with mask" ); + + myHist = psHistogramAlloc( LOWER, UPPER, numBins ); + myHist = psVectorHistogram( myHist, myData, myMask, 1 ); + + for ( i = 0;i < numBins;i++ ) { + printf( "Bin number %d bounds: (%6.3f - %6.3f) data (%d)\n", i, + myHist->bounds->data.F32[ i ], + myHist->bounds->data.F32[ i + 1 ], + myHist->nums->data.U32[ i ] ); + } + psMemCheckCorruption( 1 ); + psFree( myHist ); + psMemCheckCorruption( 1 ); + + printFooter( stdout, + "psStats functions", + "Allocate and Perform Histogram with mask", + testStatus ); } - psMemCheckCorruption(1); - psFree(myHist); - psMemCheckCorruption(1); - - printFooter(stdout, - "psStats functions", - "Allocate and Perform Histogram, no mask", - testStatus); - - /*********************************************************************/ - /* Allocate and Perform Histogram with mask */ - /*********************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "Allocate and Perform Histogram with mask"); - - myHist = psHistogramAlloc(LOWER, UPPER, numBins); - myHist = psVectorHistogram(myHist, myData, myMask, 1); - - for (i=0;ibounds->data.F32[i], - myHist->bounds->data.F32[i+1], - myHist->nums->data.U32[i]); - } - psMemCheckCorruption(1); - psFree(myHist); - psMemCheckCorruption(1); - - printFooter(stdout, - "psStats functions", - "Allocate and Perform Histogram with mask", - testStatus); - } - psFree(myMask); - - printPositiveTestHeader(stdout, - "psStats functions", - "Calling psVectorHistogram() with various NULL inputs."); - + psFree( myMask ); + + printPositiveTestHeader( stdout, + "psStats functions", + "Calling psVectorHistogram() with various NULL inputs." ); + // Verify the return value is null and program execution doesn't stop, // if input parameter myHist is null. - - myHist2 = psVectorHistogram(NULL, myData, NULL, 0); - if (myHist2 != NULL) { - printf("ERROR: myHist2!=NULL\n"); - testStatus = false; - } - psFree(myData); - - + + myHist2 = psVectorHistogram( NULL, myData, NULL, 0 ); + if ( myHist2 != NULL ) { + printf( "ERROR: myHist2!=NULL\n" ); + testStatus = false; + } + psFree( myData ); + + // Verify the retrun value is the same as the input parameter myHist and // program execution doesn't stop, if the input parameter myArray is // null. - - myHist = psHistogramAlloc(LOWER, UPPER, numBins); - myHist = psVectorHistogram(myHist, NULL, NULL, 0); - if (myHist == NULL) { - printf("ERROR: myHist==NULL\n"); - testStatus = false; - } - psFree(myHist); - - + + myHist = psHistogramAlloc( LOWER, UPPER, numBins ); + myHist = psVectorHistogram( myHist, NULL, NULL, 0 ); + if ( myHist == NULL ) { + printf( "ERROR: myHist==NULL\n" ); + testStatus = false; + } + psFree( myHist ); + + // Verify the return value is the same as the input parameter myHist and // program execution doesn't stop, if the input parameter myArray has no @@ -155,28 +155,28 @@ psFree(myData); */ - printFooter(stdout, - "psStats functions", - "Calling psVectorHistogram() with various NULL inputs.", - testStatus); - + printFooter( stdout, + "psStats functions", + "Calling psVectorHistogram() with various NULL inputs.", + testStatus ); + /*************************************************************************/ /* Deallocate data structures */ /*************************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "Deallocate the psHistogram structure."); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,NULL); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - psMemCheckCorruption(1); - - printFooter(stdout, - "psStats functions", - "Deallocate the psHistogram structure.", - testStatus); - - return (!testStatus); + printPositiveTestHeader( stdout, + "psStats functions", + "Deallocate the psHistogram structure." ); + + psMemCheckCorruption( 1 ); + memLeaks = psMemCheckLeaks( currentId, NULL, NULL ); + if ( 0 != memLeaks ) { + psAbort( __func__, "Memory Leaks! (%d leaks)", memLeaks ); + } + psMemCheckCorruption( 1 ); + + printFooter( stdout, + "psStats functions", + "Deallocate the psHistogram structure.", + testStatus ); + + return ( !testStatus ); } Index: /trunk/psLib/test/dataManip/tst_psMatrixVectorArithmetic02.c =================================================================== --- /trunk/psLib/test/dataManip/tst_psMatrixVectorArithmetic02.c (revision 1364) +++ /trunk/psLib/test/dataManip/tst_psMatrixVectorArithmetic02.c (revision 1365) @@ -10,6 +10,6 @@ * @author Ross Harman, MHPCC * - * @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ - * @date $Date: 2004-06-30 00:18:49 $ + * @version $Revision: 1.2 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-02 19:43:23 $ * * Copyright 2004 Maui High Performance Computing Center, University of Hawaii @@ -25,10 +25,10 @@ #define PRINT_SCALAR(SCALAR,TYPE) \ if(PS_IS_PSELEMTYPE_COMPLEX(SCALAR->type.type)) { \ - printf("%f+%fi ", creal(SCALAR->data.TYPE), cimag(SCALAR->data.TYPE)); \ -} else if(PS_IS_PSELEMTYPE_INT(SCALAR->type.type)) { \ - printf("%d", (int)SCALAR->data.TYPE); \ -} else { \ - printf("%f", (double)SCALAR->data.TYPE); \ -} \ + printf("%.2f%f+.2i ", creal(SCALAR->data.TYPE), cimag(SCALAR->data.TYPE)); \ + } else if(PS_IS_PSELEMTYPE_INT(SCALAR->type.type)) { \ + printf("%d", (int)SCALAR->data.TYPE); \ + } else { \ + printf("%.2f", (double)SCALAR->data.TYPE); \ + } \ printf("\n\n"); @@ -36,12 +36,12 @@ #define PRINT_VECTOR(VECTOR,TYPE) \ for(int i=0; in; i++) { \ - if(PS_IS_PSELEMTYPE_COMPLEX(VECTOR->type.type)) { \ - printf("%f+%fi\n", creal(VECTOR->data.TYPE[i]), cimag(VECTOR->data.TYPE[i])); \ - } else if(PS_IS_PSELEMTYPE_INT(VECTOR->type.type)) { \ - printf("%d\n", (int)VECTOR->data.TYPE[i]); \ - } else { \ - printf("%f\n", (double)VECTOR->data.TYPE[i]); \ - } \ -} \ + if(PS_IS_PSELEMTYPE_COMPLEX(VECTOR->type.type)) { \ + printf("%.2f%+.2fi\n", creal(VECTOR->data.TYPE[i]), cimag(VECTOR->data.TYPE[i])); \ + } else if(PS_IS_PSELEMTYPE_INT(VECTOR->type.type)) { \ + printf("%d\n", (int)VECTOR->data.TYPE[i]); \ + } else { \ + printf("%.2f\n", (double)VECTOR->data.TYPE[i]); \ + } \ + } \ printf("\n"); @@ -49,15 +49,15 @@ #define PRINT_MATRIX(IMAGE,TYPE) \ for(int i=IMAGE->numRows-1; i>-1; i--) { \ - for(int j=0; jnumCols; j++) { \ - if(PS_IS_PSELEMTYPE_COMPLEX(IMAGE->type.type)) { \ - printf("%f+%fi ", creal(IMAGE->data.TYPE[i][j]), cimag(IMAGE->data.TYPE[i][j])); \ - } else if(PS_IS_PSELEMTYPE_INT(IMAGE->type.type)) { \ - printf("%d ", (int)IMAGE->data.TYPE[i][j]); \ - } else { \ - printf("%f ", (double)IMAGE->data.TYPE[i][j]); \ - } \ - } \ - printf("\n"); \ -} \ + for(int j=0; jnumCols; j++) { \ + if(PS_IS_PSELEMTYPE_COMPLEX(IMAGE->type.type)) { \ + printf("%.2f%+.2fi ", creal(IMAGE->data.TYPE[i][j]), cimag(IMAGE->data.TYPE[i][j])); \ + } else if(PS_IS_PSELEMTYPE_INT(IMAGE->type.type)) { \ + printf("%d ", (int)IMAGE->data.TYPE[i][j]); \ + } else { \ + printf("%.2f ", (double)IMAGE->data.TYPE[i][j]); \ + } \ + } \ + printf("\n"); \ + } \ printf("\n"); @@ -66,6 +66,6 @@ psVector *NAME = (psVector*)psVectorAlloc(SIZE, PS_TYPE_##TYPE); \ for(int i=0; idata.TYPE[i] = VALUE; \ -} \ + NAME->data.TYPE[i] = VALUE; \ + } \ NAME->n = SIZE; @@ -74,19 +74,19 @@ psImage *NAME = (psImage*)psImageAlloc(NCOLS,NROWS,PS_TYPE_##TYPE); \ for(int i=0; inumRows; i++) { \ - for(int j=0; jnumCols; j++) { \ - NAME->data.TYPE[i][j] = VALUE; \ - } \ -} - - + for(int j=0; jnumCols; j++) { \ + NAME->data.TYPE[i][j] = VALUE; \ + } \ + } + + #define CHECK_MEMORY \ psMemCheckLeaks(0, NULL, stdout); \ int nBad = psMemCheckCorruption(0); \ if(nBad) { \ - printf("ERROR: Found %d bad memory blocks\n", nBad); \ -} - - -int main(int argc, char* argv[]) + printf("ERROR: Found %d bad memory blocks\n", nBad); \ + } + + +int main( int argc, char* argv[] ) { @@ -109,75 +109,75 @@ printFooter(stdout, "psMatrixVectorArithmetic", "Test matrix psUnaryOp", true); \ } - - testBinaryOpM(abs,S32,-10,0,3,2); - testBinaryOpM(abs,F32,-10.0,0.0,3,2); - testBinaryOpM(abs,F64,-10.0,0.0,3,2); - testBinaryOpM(abs,C32,-10.0-10.0i,0.0+0.0i,3,2); - testBinaryOpM(exp,S32,10,0,3,2); - testBinaryOpM(exp,F32,10.0,0.0,3,2); - testBinaryOpM(exp,F64,10.0,0.0,3,2); - testBinaryOpM(exp,C32,10.0+10.0i,0.0+0.0i,3,2); - testBinaryOpM(ln,S32,10,0,3,2); - testBinaryOpM(ln,F32,10.0,0.0,3,2); - testBinaryOpM(ln,F64,10.0,0.0,3,2); - testBinaryOpM(ln,C32,10.0+10.0i,0.0+0.0i,3,2); - testBinaryOpM(ten,S32,3,0,3,2); - testBinaryOpM(ten,F32,3.0,0.0,3,2); - testBinaryOpM(ten,F64,3.0,0.0,3,2); - testBinaryOpM(ten,C32,3.0+3.0i,0.0+0.0i,3,2); - testBinaryOpM(log,S32,1000,0,3,2); - testBinaryOpM(log,F32,1000.0,0.0,3,2); - testBinaryOpM(log,F64,1000.0,0.0,3,2); - testBinaryOpM(log,C32,1000.0+1000.0i,0.0+0.0i,3,2); - testBinaryOpM(sin,S32,M_PI_2,0,3,2); - testBinaryOpM(sin,F32,M_PI_2,0.0,3,2); - testBinaryOpM(sin,F64,M_PI_2,0.0,3,2); - testBinaryOpM(sin,C32,M_PI_2+1.57079632679489661923i,0.0+0.0i,3,2); - testBinaryOpM(dsin,S32,90,0,3,2); - testBinaryOpM(dsin,F32,90.0,0.0,3,2); - testBinaryOpM(dsin,F64,90.0,0.0,3,2); - testBinaryOpM(dsin,C32,90.0+90.0i,0.0+0.0i,3,2); - testBinaryOpM(cos,S32,0,0,3,2); - testBinaryOpM(cos,F32,0.0,0.0,3,2); - testBinaryOpM(cos,F64,0.0,0.0,3,2); - testBinaryOpM(cos,C32,0.0+0.0i,0.0+0.0i,3,2); - testBinaryOpM(dcos,S32,0,0,3,2); - testBinaryOpM(dcos,F32,0.0,0.0,3,2); - testBinaryOpM(dcos,F64,0.0,0.0,3,2); - testBinaryOpM(dcos,C32,0.0+0.0i,0.0+0.0i,3,2); - testBinaryOpM(tan,S32,M_PI_4,0,3,2); - testBinaryOpM(tan,F32,M_PI_4,0.0,3,2); - testBinaryOpM(tan,F64,M_PI_4,0.0,3,2); - testBinaryOpM(tan,C32,M_PI_4+0.78539816339744830962i,0.0+0.0i,3,2); - testBinaryOpM(dtan,S32,45,0,3,2); - testBinaryOpM(dtan,F32,45.0,0.0,3,2); - testBinaryOpM(dtan,F64,45.0,0.0,3,2); - testBinaryOpM(dtan,C32,45.0+45.0i,0.0+0.0i,3,2); - testBinaryOpM(asin,S32,1,0,3,2); - testBinaryOpM(asin,F32,1.0,0.0,3,2); - testBinaryOpM(asin,F64,1.0,0.0,3,2); - testBinaryOpM(asin,C32,1.0+1.0i,0.0+0.0i,3,2); - testBinaryOpM(dasin,S32,1.0,0,3,2); - testBinaryOpM(dasin,F32,1.0,0.0,3,2); - testBinaryOpM(dasin,F64,1.0,0.0,3,2); - testBinaryOpM(dasin,C32,1.0+1.0i,0.0+0.0i,3,2); - testBinaryOpM(acos,S32,0,0,3,2); - testBinaryOpM(acos,F32,0.0,0.0,3,2); - testBinaryOpM(acos,F64,0.0,0.0,3,2); - testBinaryOpM(acos,C32,0.0+0.0i,0.0+0.0i,3,2); - testBinaryOpM(dacos,S32,0,0,3,2); - testBinaryOpM(dacos,F32,0.0,0.0,3,2); - testBinaryOpM(dacos,F64,0.0,0.0,3,2); - testBinaryOpM(dacos,C32,0.0+0.0i,0.0+0.0i,3,2); - testBinaryOpM(atan,S32,1,0,3,2); - testBinaryOpM(atan,F32,1.0,0.0,3,2); - testBinaryOpM(atan,F64,1.0,0.0,3,2); - testBinaryOpM(atan,C32,1.0+1.0i,0.0+0.0i,3,2); - testBinaryOpM(datan,S32,1,0,3,2); - testBinaryOpM(datan,F32,1.0,0.0,3,2); - testBinaryOpM(datan,F64,1.0,0.0,3,2); - testBinaryOpM(datan,C32,1.0+1.0i,0.0+0.0i,3,2); - - + + testBinaryOpM( abs, S32, -10, 0, 3, 2 ); + testBinaryOpM( abs, F32, -10.0, 0.0, 3, 2 ); + testBinaryOpM( abs, F64, -10.0, 0.0, 3, 2 ); + testBinaryOpM( abs, C32, -10.0 - 10.0i, 0.0 + 0.0i, 3, 2 ); + testBinaryOpM( exp, S32, 10, 0, 3, 2 ); + testBinaryOpM( exp, F32, 10.0, 0.0, 3, 2 ); + testBinaryOpM( exp, F64, 10.0, 0.0, 3, 2 ); + testBinaryOpM( exp, C32, 10.0 + 10.0i, 0.0 + 0.0i, 3, 2 ); + testBinaryOpM( ln, S32, 10, 0, 3, 2 ); + testBinaryOpM( ln, F32, 10.0, 0.0, 3, 2 ); + testBinaryOpM( ln, F64, 10.0, 0.0, 3, 2 ); + testBinaryOpM( ln, C32, 10.0 + 10.0i, 0.0 + 0.0i, 3, 2 ); + testBinaryOpM( ten, S32, 3, 0, 3, 2 ); + testBinaryOpM( ten, F32, 3.0, 0.0, 3, 2 ); + testBinaryOpM( ten, F64, 3.0, 0.0, 3, 2 ); + testBinaryOpM( ten, C32, 3.0 + 3.0i, 0.0 + 0.0i, 3, 2 ); + testBinaryOpM( log, S32, 1000, 0, 3, 2 ); + testBinaryOpM( log, F32, 1000.0, 0.0, 3, 2 ); + testBinaryOpM( log, F64, 1000.0, 0.0, 3, 2 ); + testBinaryOpM( log, C32, 1000.0 + 1000.0i, 0.0 + 0.0i, 3, 2 ); + testBinaryOpM( sin, S32, M_PI_2, 0, 3, 2 ); + testBinaryOpM( sin, F32, M_PI_2, 0.0, 3, 2 ); + testBinaryOpM( sin, F64, M_PI_2, 0.0, 3, 2 ); + testBinaryOpM( sin, C32, M_PI_2 + 1.57079632679489661923i, 0.0 + 0.0i, 3, 2 ); + testBinaryOpM( dsin, S32, 90, 0, 3, 2 ); + testBinaryOpM( dsin, F32, 90.0, 0.0, 3, 2 ); + testBinaryOpM( dsin, F64, 90.0, 0.0, 3, 2 ); + testBinaryOpM( dsin, C32, 90.0 + 90.0i, 0.0 + 0.0i, 3, 2 ); + testBinaryOpM( cos, S32, 0, 0, 3, 2 ); + testBinaryOpM( cos, F32, 0.0, 0.0, 3, 2 ); + testBinaryOpM( cos, F64, 0.0, 0.0, 3, 2 ); + testBinaryOpM( cos, C32, 0.0 + 0.0i, 0.0 + 0.0i, 3, 2 ); + testBinaryOpM( dcos, S32, 0, 0, 3, 2 ); + testBinaryOpM( dcos, F32, 0.0, 0.0, 3, 2 ); + testBinaryOpM( dcos, F64, 0.0, 0.0, 3, 2 ); + testBinaryOpM( dcos, C32, 0.0 + 0.0i, 0.0 + 0.0i, 3, 2 ); + testBinaryOpM( tan, S32, M_PI_4, 0, 3, 2 ); + testBinaryOpM( tan, F32, M_PI_4, 0.0, 3, 2 ); + testBinaryOpM( tan, F64, M_PI_4, 0.0, 3, 2 ); + testBinaryOpM( tan, C32, M_PI_4 + 0.78539816339744830962i, 0.0 + 0.0i, 3, 2 ); + testBinaryOpM( dtan, S32, 45, 0, 3, 2 ); + testBinaryOpM( dtan, F32, 45.0, 0.0, 3, 2 ); + testBinaryOpM( dtan, F64, 45.0, 0.0, 3, 2 ); + testBinaryOpM( dtan, C32, 45.0 + 45.0i, 0.0 + 0.0i, 3, 2 ); + testBinaryOpM( asin, S32, 1, 0, 3, 2 ); + testBinaryOpM( asin, F32, 1.0, 0.0, 3, 2 ); + testBinaryOpM( asin, F64, 1.0, 0.0, 3, 2 ); + testBinaryOpM( asin, C32, 1.0 + 1.0i, 0.0 + 0.0i, 3, 2 ); + testBinaryOpM( dasin, S32, 1.0, 0, 3, 2 ); + testBinaryOpM( dasin, F32, 1.0, 0.0, 3, 2 ); + testBinaryOpM( dasin, F64, 1.0, 0.0, 3, 2 ); + testBinaryOpM( dasin, C32, 1.0 + 1.0i, 0.0 + 0.0i, 3, 2 ); + testBinaryOpM( acos, S32, 0, 0, 3, 2 ); + testBinaryOpM( acos, F32, 0.0, 0.0, 3, 2 ); + testBinaryOpM( acos, F64, 0.0, 0.0, 3, 2 ); + testBinaryOpM( acos, C32, 0.0 + 0.0i, 0.0 + 0.0i, 3, 2 ); + testBinaryOpM( dacos, S32, 0, 0, 3, 2 ); + testBinaryOpM( dacos, F32, 0.0, 0.0, 3, 2 ); + testBinaryOpM( dacos, F64, 0.0, 0.0, 3, 2 ); + testBinaryOpM( dacos, C32, 0.0 + 0.0i, 0.0 + 0.0i, 3, 2 ); + testBinaryOpM( atan, S32, 1, 0, 3, 2 ); + testBinaryOpM( atan, F32, 1.0, 0.0, 3, 2 ); + testBinaryOpM( atan, F64, 1.0, 0.0, 3, 2 ); + testBinaryOpM( atan, C32, 1.0 + 1.0i, 0.0 + 0.0i, 3, 2 ); + testBinaryOpM( datan, S32, 1, 0, 3, 2 ); + testBinaryOpM( datan, F32, 1.0, 0.0, 3, 2 ); + testBinaryOpM( datan, F64, 1.0, 0.0, 3, 2 ); + testBinaryOpM( datan, C32, 1.0 + 1.0i, 0.0 + 0.0i, 3, 2 ); + + // Test vector unary operations #define testBinaryOpV(OP,TYPE,VALUE1,VALUE2,SIZE) \ @@ -198,74 +198,74 @@ printFooter(stdout, "psMatrixVectorArithmetic", "Test vector psUnaryOp", true); \ } - - testBinaryOpV(abs,S32,-10,0,3); - testBinaryOpV(abs,F32,-10.0,0.0,3); - testBinaryOpV(abs,F64,-10.0,0.0,3); - testBinaryOpV(abs,C32,-10.0-10.0i,0.0+0.0i,3); - testBinaryOpV(exp,S32,10,0,3); - testBinaryOpV(exp,F32,10.0,0.0,3); - testBinaryOpV(exp,F64,10.0,0.0,3); - testBinaryOpV(exp,C32,10.0+10.0i,0.0+0.0i,3); - testBinaryOpV(ln,S32,10,0,3); - testBinaryOpV(ln,F32,10.0,0.0,3); - testBinaryOpV(ln,F64,10.0,0.0,3); - testBinaryOpV(ln,C32,10.0+10.0i,0.0+0.0i,3); - testBinaryOpV(ten,S32,3,0,3); - testBinaryOpV(ten,F32,3.0,0.0,3); - testBinaryOpV(ten,F64,3.0,0.0,3); - testBinaryOpV(ten,C32,3.0+3.0i,0.0+0.0i,3); - testBinaryOpV(log,S32,1000,0,3); - testBinaryOpV(log,F32,1000.0,0.0,3); - testBinaryOpV(log,F64,1000.0,0.0,3); - testBinaryOpV(log,C32,1000.0+1000.0i,0.0+0.0i,3); - testBinaryOpV(sin,S32,M_PI_2,0,3); - testBinaryOpV(sin,F32,M_PI_2,0.0,3); - testBinaryOpV(sin,F64,M_PI_2,0.0,3); - testBinaryOpV(sin,C32,M_PI_2+1.57079632679489661923i,0.0+0.0i,3); - testBinaryOpV(dsin,S32,90,0,3); - testBinaryOpV(dsin,F32,90.0,0.0,3); - testBinaryOpV(dsin,F64,90.0,0.0,3); - testBinaryOpV(dsin,C32,90.0+90.0i,0.0+0.0i,3); - testBinaryOpV(cos,S32,0,0,3); - testBinaryOpV(cos,F32,0.0,0.0,3); - testBinaryOpV(cos,F64,0.0,0.0,3); - testBinaryOpV(cos,C32,0.0+0.0i,0.0+0.0i,3); - testBinaryOpV(dcos,S32,0,0,3); - testBinaryOpV(dcos,F32,0.0,0.0,3); - testBinaryOpV(dcos,F64,0.0,0.0,3); - testBinaryOpV(dcos,C32,0.0+0.0i,0.0+0.0i,3); - testBinaryOpV(tan,S32,M_PI_4,0,3); - testBinaryOpV(tan,F32,M_PI_4,0.0,3); - testBinaryOpV(tan,F64,M_PI_4,0.0,3); - testBinaryOpV(tan,C32,M_PI_4+0.78539816339744830962i,0.0+0.0i,3); - testBinaryOpV(dtan,S32,45,0,3); - testBinaryOpV(dtan,F32,45.0,0.0,3); - testBinaryOpV(dtan,F64,45.0,0.0,3); - testBinaryOpV(dtan,C32,45.0+45.0i,0.0+0.0i,3); - testBinaryOpV(asin,S32,1,0,3); - testBinaryOpV(asin,F32,1.0,0.0,3); - testBinaryOpV(asin,F64,1.0,0.0,3); - testBinaryOpV(asin,C32,1.0+1.0i,0.0+0.0i,3); - testBinaryOpV(dasin,S32,1.0,0,3); - testBinaryOpV(dasin,F32,1.0,0.0,3); - testBinaryOpV(dasin,F64,1.0,0.0,3); - testBinaryOpV(dasin,C32,1.0+1.0i,0.0+0.0i,3); - testBinaryOpV(acos,S32,0,0,3); - testBinaryOpV(acos,F32,0.0,0.0,3); - testBinaryOpV(acos,F64,0.0,0.0,3); - testBinaryOpV(acos,C32,0.0+0.0i,0.0+0.0i,3); - testBinaryOpV(dacos,S32,0,0,3); - testBinaryOpV(dacos,F32,0.0,0.0,3); - testBinaryOpV(dacos,F64,0.0,0.0,3); - testBinaryOpV(dacos,C32,0.0+0.0i,0.0+0.0i,3); - testBinaryOpV(atan,S32,1,0,3); - testBinaryOpV(atan,F32,1.0,0.0,3); - testBinaryOpV(atan,F64,1.0,0.0,3); - testBinaryOpV(atan,C32,1.0+1.0i,0.0+0.0i,3); - testBinaryOpV(datan,S32,1,0,3); - testBinaryOpV(datan,F32,1.0,0.0,3); - testBinaryOpV(datan,F64,1.0,0.0,3); - testBinaryOpV(datan,C32,1.0+1.0i,0.0+0.0i,3); - + + testBinaryOpV( abs, S32, -10, 0, 3 ); + testBinaryOpV( abs, F32, -10.0, 0.0, 3 ); + testBinaryOpV( abs, F64, -10.0, 0.0, 3 ); + testBinaryOpV( abs, C32, -10.0 - 10.0i, 0.0 + 0.0i, 3 ); + testBinaryOpV( exp, S32, 10, 0, 3 ); + testBinaryOpV( exp, F32, 10.0, 0.0, 3 ); + testBinaryOpV( exp, F64, 10.0, 0.0, 3 ); + testBinaryOpV( exp, C32, 10.0 + 10.0i, 0.0 + 0.0i, 3 ); + testBinaryOpV( ln, S32, 10, 0, 3 ); + testBinaryOpV( ln, F32, 10.0, 0.0, 3 ); + testBinaryOpV( ln, F64, 10.0, 0.0, 3 ); + testBinaryOpV( ln, C32, 10.0 + 10.0i, 0.0 + 0.0i, 3 ); + testBinaryOpV( ten, S32, 3, 0, 3 ); + testBinaryOpV( ten, F32, 3.0, 0.0, 3 ); + testBinaryOpV( ten, F64, 3.0, 0.0, 3 ); + testBinaryOpV( ten, C32, 3.0 + 3.0i, 0.0 + 0.0i, 3 ); + testBinaryOpV( log, S32, 1000, 0, 3 ); + testBinaryOpV( log, F32, 1000.0, 0.0, 3 ); + testBinaryOpV( log, F64, 1000.0, 0.0, 3 ); + testBinaryOpV( log, C32, 1000.0 + 1000.0i, 0.0 + 0.0i, 3 ); + testBinaryOpV( sin, S32, M_PI_2, 0, 3 ); + testBinaryOpV( sin, F32, M_PI_2, 0.0, 3 ); + testBinaryOpV( sin, F64, M_PI_2, 0.0, 3 ); + testBinaryOpV( sin, C32, M_PI_2 + 1.57079632679489661923i, 0.0 + 0.0i, 3 ); + testBinaryOpV( dsin, S32, 90, 0, 3 ); + testBinaryOpV( dsin, F32, 90.0, 0.0, 3 ); + testBinaryOpV( dsin, F64, 90.0, 0.0, 3 ); + testBinaryOpV( dsin, C32, 90.0 + 90.0i, 0.0 + 0.0i, 3 ); + testBinaryOpV( cos, S32, 0, 0, 3 ); + testBinaryOpV( cos, F32, 0.0, 0.0, 3 ); + testBinaryOpV( cos, F64, 0.0, 0.0, 3 ); + testBinaryOpV( cos, C32, 0.0 + 0.0i, 0.0 + 0.0i, 3 ); + testBinaryOpV( dcos, S32, 0, 0, 3 ); + testBinaryOpV( dcos, F32, 0.0, 0.0, 3 ); + testBinaryOpV( dcos, F64, 0.0, 0.0, 3 ); + testBinaryOpV( dcos, C32, 0.0 + 0.0i, 0.0 + 0.0i, 3 ); + testBinaryOpV( tan, S32, M_PI_4, 0, 3 ); + testBinaryOpV( tan, F32, M_PI_4, 0.0, 3 ); + testBinaryOpV( tan, F64, M_PI_4, 0.0, 3 ); + testBinaryOpV( tan, C32, M_PI_4 + 0.78539816339744830962i, 0.0 + 0.0i, 3 ); + testBinaryOpV( dtan, S32, 45, 0, 3 ); + testBinaryOpV( dtan, F32, 45.0, 0.0, 3 ); + testBinaryOpV( dtan, F64, 45.0, 0.0, 3 ); + testBinaryOpV( dtan, C32, 45.0 + 45.0i, 0.0 + 0.0i, 3 ); + testBinaryOpV( asin, S32, 1, 0, 3 ); + testBinaryOpV( asin, F32, 1.0, 0.0, 3 ); + testBinaryOpV( asin, F64, 1.0, 0.0, 3 ); + testBinaryOpV( asin, C32, 1.0 + 1.0i, 0.0 + 0.0i, 3 ); + testBinaryOpV( dasin, S32, 1.0, 0, 3 ); + testBinaryOpV( dasin, F32, 1.0, 0.0, 3 ); + testBinaryOpV( dasin, F64, 1.0, 0.0, 3 ); + testBinaryOpV( dasin, C32, 1.0 + 1.0i, 0.0 + 0.0i, 3 ); + testBinaryOpV( acos, S32, 0, 0, 3 ); + testBinaryOpV( acos, F32, 0.0, 0.0, 3 ); + testBinaryOpV( acos, F64, 0.0, 0.0, 3 ); + testBinaryOpV( acos, C32, 0.0 + 0.0i, 0.0 + 0.0i, 3 ); + testBinaryOpV( dacos, S32, 0, 0, 3 ); + testBinaryOpV( dacos, F32, 0.0, 0.0, 3 ); + testBinaryOpV( dacos, F64, 0.0, 0.0, 3 ); + testBinaryOpV( dacos, C32, 0.0 + 0.0i, 0.0 + 0.0i, 3 ); + testBinaryOpV( atan, S32, 1, 0, 3 ); + testBinaryOpV( atan, F32, 1.0, 0.0, 3 ); + testBinaryOpV( atan, F64, 1.0, 0.0, 3 ); + testBinaryOpV( atan, C32, 1.0 + 1.0i, 0.0 + 0.0i, 3 ); + testBinaryOpV( datan, S32, 1, 0, 3 ); + testBinaryOpV( datan, F32, 1.0, 0.0, 3 ); + testBinaryOpV( datan, F64, 1.0, 0.0, 3 ); + testBinaryOpV( datan, C32, 1.0 + 1.0i, 0.0 + 0.0i, 3 ); + return 0; } Index: /trunk/psLib/test/dataManip/tst_psStats07.c =================================================================== --- /trunk/psLib/test/dataManip/tst_psStats07.c (revision 1364) +++ /trunk/psLib/test/dataManip/tst_psStats07.c (revision 1365) @@ -1,6 +1,6 @@ /***************************************************************************** - This routine must ensure that PS_STAT_ROBUST_QUARTILE is correctly computed - by the procedure psArrayStats(). - *****************************************************************************/ + This routine must ensure that PS_STAT_ROBUST_QUARTILE is correctly computed + by the procedure psArrayStats(). +*****************************************************************************/ #include #include "pslib.h" @@ -17,24 +17,24 @@ int main() { - psStats *myStats = NULL; - int testStatus = true; + psStats * myStats = NULL; + int testStatus = true; int globalTestStatus = true; - int i = 0; - psVector *myVector = NULL; - psVector *maskVector= NULL; + int i = 0; + psVector *myVector = NULL; + psVector *maskVector = NULL; // NOTE: These values were calculated by running the function on the data. // A: They must be changed if we adjust the number of data points. // B: We don't really know that they are correct. - int count = 0; - int currentId = psMemGetId(); - int memLeaks = 0; + int count = 0; + int currentId = psMemGetId(); + int memLeaks = 0; float realMeanNoMask = MEAN; float realMedianNoMask = MEAN; float realModeNoMask = MEAN; float realStdevNoMask = STDEV * 0.33; - float realLQNoMask = MEAN - (0.6 * STDEV); - float realUQNoMask = MEAN + (0.6 * STDEV); - float realN50NoMask = (float) N/4; - float realNfitNoMask = (float) N/4; + float realLQNoMask = MEAN - ( 0.6 * STDEV ); + float realUQNoMask = MEAN + ( 0.6 * STDEV ); + float realN50NoMask = ( float ) N / 4; + float realNfitNoMask = ( float ) N / 4; float realMeanWithMask = MEAN; float realMedianWithMask = MEAN; @@ -43,373 +43,373 @@ float realLQWithMask = MEAN; float realUQWithMask = MEAN; - float realN50WithMask = (float) N/4; - float realNfitWithMask = (float) N/4; - - + float realN50WithMask = ( float ) N / 4; + float realNfitWithMask = ( float ) N / 4; + + /*************************************************************************/ /* Allocate and initialize data structures */ /*************************************************************************/ - myStats = psStatsAlloc(PS_STAT_ROBUST_MEAN | - PS_STAT_ROBUST_MEDIAN | - PS_STAT_ROBUST_MODE | - PS_STAT_ROBUST_STDEV | - PS_STAT_ROBUST_QUARTILE); - - maskVector = psVectorAlloc(N, PS_TYPE_U8); + myStats = psStatsAlloc( PS_STAT_ROBUST_MEAN | + PS_STAT_ROBUST_MEDIAN | + PS_STAT_ROBUST_MODE | + PS_STAT_ROBUST_STDEV | + PS_STAT_ROBUST_QUARTILE ); + + maskVector = psVectorAlloc( N, PS_TYPE_U8 ); maskVector->n = N; - myVector = psGaussianDev(MEAN, STDEV, N); + myVector = psGaussianDev( MEAN, STDEV, N ); // Set the mask vector and calculate the expected maximum. - for (i=0;idata.U8[i] = 0; - count++; - } else { - maskVector->data.U8[i] = 1; - } - } + for ( i = 0;i < N;i++ ) { + if ( i < ( N / 2 ) ) { + maskVector->data.U8[ i ] = 0; + count++; + } else { + maskVector->data.U8[ i ] = 1; + } + } /*************************************************************************/ /* Call psVectorStats() with no vector mask. */ /*************************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust mean: no vector mask"); - - myStats = psVectorStats(myStats, myVector, NULL, 0); - - printf("The expected Mean was %f; the calculated Mean was %f\n", - realMeanNoMask, myStats->robustMean); - - if (fabs(myStats->robustMean - realMeanNoMask) < (ERROR_TOLERANCE * realMeanNoMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust mean: no vector mask", - testStatus); - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust Median: no vector mask"); - - printf("The expected Median was %f; the calculated Median was %f\n", - realMedianNoMask, myStats->robustMedian); - if (fabs(myStats->robustMedian - realMedianNoMask) < (ERROR_TOLERANCE * realMedianNoMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust Median: no vector mask", - testStatus); - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust Mode: no vector mask"); - - - printf("The expected Mode was %f; the calculated Mode was %f\n", - realModeNoMask, myStats->robustMode); - if (fabs(myStats->robustMode - realModeNoMask) < (ERROR_TOLERANCE * realModeNoMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust Mode: no vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust Stdev: no vector mask"); - - printf("The expected Stdev was %f; the calculated Stdev was %f\n", - realStdevNoMask, myStats->robustStdev); - if (fabs(myStats->robustStdev - realStdevNoMask) < (ERROR_TOLERANCE * realStdevNoMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust Stdev: no vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: lower quartile: no vector mask"); - - printf("The expected LQ was %f; the calculated LQ was %f\n", - realLQNoMask, myStats->robustLQ); - - if (fabs(myStats->robustLQ - realLQNoMask) < (ERROR_TOLERANCE * realLQNoMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: lower quartile: no vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: upper quartile: no vector mask"); - - printf("The expected UQ was %f; the calculated UQ was %f\n", - realUQNoMask, myStats->robustUQ); - if (fabs(myStats->robustUQ - realUQNoMask) < (ERROR_TOLERANCE * realUQNoMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: lower quartile: no vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust N50: no vector mask"); - + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: robust mean: no vector mask" ); + + myStats = psVectorStats( myStats, myVector, NULL, 0 ); + + printf( "The expected Mean was %.2f; the calculated Mean was %.2f\n", + realMeanNoMask, myStats->robustMean ); + + if ( fabs( myStats->robustMean - realMeanNoMask ) < ( ERROR_TOLERANCE * realMeanNoMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: robust mean: no vector mask", + testStatus ); + + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: robust Median: no vector mask" ); + + printf( "The expected Median was %.2f; the calculated Median was %.2f\n", + realMedianNoMask, myStats->robustMedian ); + if ( fabs( myStats->robustMedian - realMedianNoMask ) < ( ERROR_TOLERANCE * realMedianNoMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: robust Median: no vector mask", + testStatus ); + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: robust Mode: no vector mask" ); + + + printf( "The expected Mode was %.2f; the calculated Mode was %.2f\n", + realModeNoMask, myStats->robustMode ); + if ( fabs( myStats->robustMode - realModeNoMask ) < ( ERROR_TOLERANCE * realModeNoMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: robust Mode: no vector mask", + testStatus ); + + + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: robust Stdev: no vector mask" ); + + printf( "The expected Stdev was %.2f; the calculated Stdev was %.2f\n", + realStdevNoMask, myStats->robustStdev ); + if ( fabs( myStats->robustStdev - realStdevNoMask ) < ( ERROR_TOLERANCE * realStdevNoMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: robust Stdev: no vector mask", + testStatus ); + + + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: lower quartile: no vector mask" ); + + printf( "The expected LQ was %.2f; the calculated LQ was %.2f\n", + realLQNoMask, myStats->robustLQ ); + + if ( fabs( myStats->robustLQ - realLQNoMask ) < ( ERROR_TOLERANCE * realLQNoMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: lower quartile: no vector mask", + testStatus ); + + + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: upper quartile: no vector mask" ); + + printf( "The expected UQ was %.2f; the calculated UQ was %.2f\n", + realUQNoMask, myStats->robustUQ ); + if ( fabs( myStats->robustUQ - realUQNoMask ) < ( ERROR_TOLERANCE * realUQNoMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: lower quartile: no vector mask", + testStatus ); + + + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: robust N50: no vector mask" ); + // XXX: realN50NoMask = myStats->robustN50; - - printf("The expected N50 was %f; the calculated N50 was %f\n", - realN50NoMask, myStats->robustN50); - if (fabs(myStats->robustN50 - realN50NoMask) < (ERROR_TOLERANCE * realN50NoMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust N50: no vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust Nfit: no vector mask"); - + + printf( "The expected N50 was %.2f; the calculated N50 was %.2f\n", + realN50NoMask, myStats->robustN50 ); + if ( fabs( myStats->robustN50 - realN50NoMask ) < ( ERROR_TOLERANCE * realN50NoMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: robust N50: no vector mask", + testStatus ); + + + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: robust Nfit: no vector mask" ); + // XXX: realNfitNoMask = myStats->robustNfit; - - printf("The expected Nfit was %f; the calculated Nfit was %f\n", - realNfitNoMask, myStats->robustNfit); - if (fabs(myStats->robustNfit - realNfitNoMask) < (ERROR_TOLERANCE * realNfitNoMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust Nfit: no vector mask", - testStatus); - - - return(0); - + + printf( "The expected Nfit was %.2f; the calculated Nfit was %.2f\n", + realNfitNoMask, myStats->robustNfit ); + if ( fabs( myStats->robustNfit - realNfitNoMask ) < ( ERROR_TOLERANCE * realNfitNoMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: robust Nfit: no vector mask", + testStatus ); + + + return ( 0 ); + /*************************************************************************/ /* Call psVectorStats() with vector mask. */ /*************************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust mean: with vector mask"); - - printf("Calling psVectorStats() on a vector with elements masked.\n"); - myStats = psVectorStats(myStats, myVector, maskVector, 1); - printf("Called psVectorStats() on a vector with elements masked.\n"); - printf("The expected Mean was %f; the calculated Mean was %f\n", - realMeanWithMask, myStats->robustMean); - if (fabs(myStats->robustMean - realMeanWithMask) < (ERROR_TOLERANCE * realMeanWithMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust mean: with vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust Median: with vector mask"); - - printf("The expected Median was %f; the calculated Median was %f\n", - realMedianWithMask, myStats->robustMedian); - if (fabs(myStats->robustMedian - realMedianWithMask) < (ERROR_TOLERANCE * realMedianWithMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust Median: with vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust Mode: with vector mask"); - - printf("The expected Mode was %f; the calculated Mode was %f\n", - realModeWithMask, myStats->robustMode); - if (fabs(myStats->robustMode - realModeWithMask) < (ERROR_TOLERANCE * realModeWithMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust Mode: with vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust Stdev: with vector mask"); - - printf("The expected Stdev was %f; the calculated Stdev was %f\n", - realStdevWithMask, myStats->robustStdev); - if (fabs(myStats->robustStdev - realStdevWithMask) < (ERROR_TOLERANCE * realStdevWithMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust Stdev: with vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: lower quartile: with vector mask"); - - printf("The expected LQ was %f; the calculated LQ was %f\n", - realLQWithMask, myStats->robustLQ); - if (fabs(myStats->robustLQ - realLQWithMask) < (ERROR_TOLERANCE * realLQWithMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: lower quartile: with vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: upper quartile: with vector mask"); - - printf("The expected UQ was %f; the calculated UQ was %f\n", - realUQWithMask, myStats->robustUQ); - if (fabs(myStats->robustUQ - realUQWithMask) < (ERROR_TOLERANCE * realUQWithMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: lower quartile: with vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust N50: with vector mask"); - - printf("The expected N50 was %f; the calculated N50 was %f\n", - realN50WithMask, myStats->robustN50); - if (fabs(myStats->robustN50 - realN50WithMask) < (ERROR_TOLERANCE * realN50WithMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust N50: with vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust Nfit: with vector mask"); - - printf("The expected Nfit was %f; the calculated Nfit was %f\n", - realNfitWithMask, myStats->robustNfit); - if (fabs(myStats->robustNfit - realNfitWithMask) < (ERROR_TOLERANCE * realNfitWithMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust Nfit: with vector mask", - testStatus); - - - + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: robust mean: with vector mask" ); + + printf( "Calling psVectorStats() on a vector with elements masked.\n" ); + myStats = psVectorStats( myStats, myVector, maskVector, 1 ); + printf( "Called psVectorStats() on a vector with elements masked.\n" ); + printf( "The expected Mean was %.2f; the calculated Mean was %.2f\n", + realMeanWithMask, myStats->robustMean ); + if ( fabs( myStats->robustMean - realMeanWithMask ) < ( ERROR_TOLERANCE * realMeanWithMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: robust mean: with vector mask", + testStatus ); + + + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: robust Median: with vector mask" ); + + printf( "The expected Median was %.2f; the calculated Median was %.2f\n", + realMedianWithMask, myStats->robustMedian ); + if ( fabs( myStats->robustMedian - realMedianWithMask ) < ( ERROR_TOLERANCE * realMedianWithMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: robust Median: with vector mask", + testStatus ); + + + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: robust Mode: with vector mask" ); + + printf( "The expected Mode was %.2f; the calculated Mode was %.2f\n", + realModeWithMask, myStats->robustMode ); + if ( fabs( myStats->robustMode - realModeWithMask ) < ( ERROR_TOLERANCE * realModeWithMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: robust Mode: with vector mask", + testStatus ); + + + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: robust Stdev: with vector mask" ); + + printf( "The expected Stdev was %.2f; the calculated Stdev was %.2f\n", + realStdevWithMask, myStats->robustStdev ); + if ( fabs( myStats->robustStdev - realStdevWithMask ) < ( ERROR_TOLERANCE * realStdevWithMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: robust Stdev: with vector mask", + testStatus ); + + + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: lower quartile: with vector mask" ); + + printf( "The expected LQ was %.2f; the calculated LQ was %.2f\n", + realLQWithMask, myStats->robustLQ ); + if ( fabs( myStats->robustLQ - realLQWithMask ) < ( ERROR_TOLERANCE * realLQWithMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: lower quartile: with vector mask", + testStatus ); + + + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: upper quartile: with vector mask" ); + + printf( "The expected UQ was %.2f; the calculated UQ was %.2f\n", + realUQWithMask, myStats->robustUQ ); + if ( fabs( myStats->robustUQ - realUQWithMask ) < ( ERROR_TOLERANCE * realUQWithMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: lower quartile: with vector mask", + testStatus ); + + + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: robust N50: with vector mask" ); + + printf( "The expected N50 was %.2f; the calculated N50 was %.2f\n", + realN50WithMask, myStats->robustN50 ); + if ( fabs( myStats->robustN50 - realN50WithMask ) < ( ERROR_TOLERANCE * realN50WithMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: robust N50: with vector mask", + testStatus ); + + + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: robust Nfit: with vector mask" ); + + printf( "The expected Nfit was %.2f; the calculated Nfit was %.2f\n", + realNfitWithMask, myStats->robustNfit ); + if ( fabs( myStats->robustNfit - realNfitWithMask ) < ( ERROR_TOLERANCE * realNfitWithMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: robust Nfit: with vector mask", + testStatus ); + + + /*************************************************************************/ /* Deallocate data structures */ /*************************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "psStats(): deallocating memory"); - - psFree(myStats); - psFree(myVector); - psFree(maskVector); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,NULL); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psVector functions", - "psStats(): deallocating memory", - testStatus); - - return (!globalTestStatus); + printPositiveTestHeader( stdout, + "psStats functions", + "psStats(): deallocating memory" ); + + psFree( myStats ); + psFree( myVector ); + psFree( maskVector ); + + psMemCheckCorruption( 1 ); + memLeaks = psMemCheckLeaks( currentId, NULL, NULL ); + if ( 0 != memLeaks ) { + psAbort( __func__, "Memory Leaks! (%d leaks)", memLeaks ); + } + + printFooter( stdout, + "psVector functions", + "psStats(): deallocating memory", + testStatus ); + + return ( !globalTestStatus ); } Index: /trunk/psLib/test/dataManip/tst_psVectorFFT.c =================================================================== --- /trunk/psLib/test/dataManip/tst_psVectorFFT.c (revision 1364) +++ /trunk/psLib/test/dataManip/tst_psVectorFFT.c (revision 1365) @@ -1,14 +1,14 @@ /** @file tst_psVectorFFT.c - * - * @brief Contains the tests for psFFT.[ch] - * - * - * @author Robert DeSonia, MHPCC - * - * @version $Revision: 1.3 $ $Name: not supported by cvs2svn $ - * @date $Date: 2004-07-08 01:05:01 $ - * - * Copyright 2004 Maui High Performance Computing Center, University of Hawaii - */ +* +* @brief Contains the tests for psFFT.[ch] +* +* +* @author Robert DeSonia, MHPCC +* +* @version $Revision: 1.4 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-02 19:43:23 $ +* +* Copyright 2004 Maui High Performance Computing Center, University of Hawaii +*/ #include @@ -21,41 +21,50 @@ img = psImageAlloc(c,r,PS_TYPE_##TYP); \ for (unsigned int row=0;rowdata.TYP[row]; \ - for (unsigned int col=0;coldata.TYP[row]; \ + for (unsigned int col=0;coln = vec->nalloc; - for (unsigned int n = 0; n<100; n++) { - vec->data.F32[n] = sinf((psF32)n / 50.0f * M_PI); - } - + vec = psVectorAlloc( 100, PS_TYPE_F32 ); + vec->n = vec->nalloc; + for ( unsigned int n = 0; n < 100; n++ ) { + vec->data.F32[ n ] = sinf( ( psF32 ) n / 50.0f * M_PI ); + } + // 2. perform a forward transform - vec2 = psVectorFFT(NULL,vec,PS_FFT_FORWARD); - if (vec2->type.type != PS_TYPE_C32) { - psError(__func__,"FFT didn't produce complex values?"); - return 1; - } - - + vec2 = psVectorFFT( NULL, vec, PS_FFT_FORWARD ); + if ( vec2->type.type != PS_TYPE_C32 ) { + psError( __func__, "FFT didn't produce complex values?" ); + return 1; + } + + // 3. verify that the only significant component cooresponds to the freqency of the input in step 1. - for (unsigned int n = 0; n<100; n++) { - if (n==1 || n==99) { - if (fabsf(cabsf(vec2->data.C32[n]) - 50.0f) > 0.1f) { - psError(__func__,"FFT didn't work for vector (n=%d)",n); - return 2; - } - } else { - if (fabsf(cabsf(vec2->data.C32[n])) > 0.1f) { - psError(__func__,"FFT didn't work for vector (n=%d)",n); - return 3; - } - } - } - + for ( unsigned int n = 0; n < 100; n++ ) { + if ( n == 1 || n == 99 ) { + if ( fabsf( cabsf( vec2->data.C32[ n ] ) - 50.0f ) > 0.1f ) { + psError( __func__, "FFT didn't work for vector (n=%d)", n ); + return 2; + } + } else { + if ( fabsf( cabsf( vec2->data.C32[ n ] ) ) > 0.1f ) { + psError( __func__, "FFT didn't work for vector (n=%d)", n ); + return 3; + } + } + } + // 4. perform a reverse transform - vec3 = psVectorFFT(NULL,vec2,PS_FFT_REVERSE); - if (vec3->type.type != PS_TYPE_C32) { - psError(__func__,"FFT didn't produce complex values?"); - return 4; - } - for (unsigned int n = 0; n<100; n++) { - psF32 val =sinf((psF32)n / 50.0f * M_PI); - psF32 vecVal = crealf(vec3->data.C32[n])/100; - if (fabsf(vecVal - val) > 0.1f) { - psError(__func__,"Reverse FFT didn't give me the original vector back (n=%d) (%.2f vs %.2f)", - n,vecVal,val); - return 5; - } - } - - psFree(vec); - psFree(vec2); - psFree(vec3); - - return 0; -} - -int testVectorRealImaginary(void) -{ - psVector* vec = NULL; + vec3 = psVectorFFT( NULL, vec2, PS_FFT_REVERSE ); + if ( vec3->type.type != PS_TYPE_C32 ) { + psError( __func__, "FFT didn't produce complex values?" ); + return 4; + } + for ( unsigned int n = 0; n < 100; n++ ) { + psF32 val = sinf( ( psF32 ) n / 50.0f * M_PI ); + psF32 vecVal = crealf( vec3->data.C32[ n ] ) / 100; + if ( fabsf( vecVal - val ) > 0.1f ) { + psError( __func__, "Reverse FFT didn't give me the original vector back (n=%d) (%.2f vs %.2f)", + n, vecVal, val ); + return 5; + } + } + + psFree( vec ); + psFree( vec2 ); + psFree( vec3 ); + + return 0; +} + +int testVectorRealImaginary( void ) +{ + psVector * vec = NULL; psVector* vec2 = NULL; psVector* vec3 = NULL; - + /* 1. create a C32 complex vector with distinctly different real and imaginary parts. @@ -130,64 +139,64 @@ 3. compare results to the real/imaginary components of input */ - + // 1. create a C32 complex vector with distinctly different real and imaginary parts. - vec=psVectorAlloc(100,PS_TYPE_C32); - vec->n = vec->nalloc; - for (unsigned int n = 0; n<100; n++) { - vec->data.C32[n] = n + I * (n*2); - } - + vec = psVectorAlloc( 100, PS_TYPE_C32 ); + vec->n = vec->nalloc; + for ( unsigned int n = 0; n < 100; n++ ) { + vec->data.C32[ n ] = n + I * ( n * 2 ); + } + // 2. call psVectorReal and psVectorImaginary - vec2 = psVectorReal(vec2,vec); - if (vec2 == NULL) { - psError(__func__,"psVectorReal returned a NULL?"); - return 1; - } - if (vec2->type.type != PS_TYPE_F32) { - psError(__func__,"psVectorReal returned a wrong type (%d)?", - vec2->type.type); - return 2; - } - - vec3 = psVectorImaginary(vec3,vec); - if (vec3 == NULL) { - psError(__func__,"psVectorImaginary returned a NULL?"); - return 3; - } - if (vec3->type.type != PS_TYPE_F32) { - psError(__func__,"psVectorImaginary returned a wrong type (%d)?", - vec3->type.type); - return 4; - } - + vec2 = psVectorReal( vec2, vec ); + if ( vec2 == NULL ) { + psError( __func__, "psVectorReal returned a NULL?" ); + return 1; + } + if ( vec2->type.type != PS_TYPE_F32 ) { + psError( __func__, "psVectorReal returned a wrong type (%d)?", + vec2->type.type ); + return 2; + } + + vec3 = psVectorImaginary( vec3, vec ); + if ( vec3 == NULL ) { + psError( __func__, "psVectorImaginary returned a NULL?" ); + return 3; + } + if ( vec3->type.type != PS_TYPE_F32 ) { + psError( __func__, "psVectorImaginary returned a wrong type (%d)?", + vec3->type.type ); + return 4; + } + // 3. compare results to the real/imaginary components of input - for (unsigned int n = 0; n<100; n++) { - psF32 r = n; - psF32 i = (n*2); - if (fabsf(vec2->data.F32[n] -r) > FLT_EPSILON) { - psError(__func__,"psVectorReal didn't return the real portion at n=%d", - n); - return 5; - } - if (fabsf(vec3->data.F32[n] -i) > FLT_EPSILON) { - psError(__func__,"psVectorImaginary didn't return the real portion at n=%d", - n); - return 6; - } - } - - psFree(vec); - psFree(vec2); - psFree(vec3); - - return 0; -} - -int testVectorComplex(void) -{ - psVector* vec = NULL; + for ( unsigned int n = 0; n < 100; n++ ) { + psF32 r = n; + psF32 i = ( n * 2 ); + if ( fabsf( vec2->data.F32[ n ] - r ) > FLT_EPSILON ) { + psError( __func__, "psVectorReal didn't return the real portion at n=%d", + n ); + return 5; + } + if ( fabsf( vec3->data.F32[ n ] - i ) > FLT_EPSILON ) { + psError( __func__, "psVectorImaginary didn't return the real portion at n=%d", + n ); + return 6; + } + } + + psFree( vec ); + psFree( vec2 ); + psFree( vec3 ); + + return 0; +} + +int testVectorComplex( void ) +{ + psVector * vec = NULL; psVector* vec2 = NULL; psVector* vec3 = NULL; - + /* 1. create two unique psF32 vectors of the same size @@ -196,82 +205,82 @@ 4. call psVectorReal and psVectorImaginary on step 2 results 5. compare step 4 results to input. - + 6. create a psF32 and a psF64 vector of the same size 7. call psVectorComplex 8. verify that an appropriate error occurred. - + 9. create two psf32 vectors of different sizes 10. call psVectorComplex 11. verify thet an appropriate error occurred. */ - + // 1. create two unique psF32 vectors of the same size - vec=psVectorAlloc(100,PS_TYPE_F32); - vec2=psVectorAlloc(100,PS_TYPE_F32); + vec = psVectorAlloc( 100, PS_TYPE_F32 ); + vec2 = psVectorAlloc( 100, PS_TYPE_F32 ); vec->n = vec->nalloc; vec2->n = vec2->nalloc; - for (unsigned int n = 0; n<100; n++) { - vec->data.F32[n] = n; - vec2->data.F32[n] = (n*2); - } - + for ( unsigned int n = 0; n < 100; n++ ) { + vec->data.F32[ n ] = n; + vec2->data.F32[ n ] = ( n * 2 ); + } + // 2. call psVectorComplex - vec3 = psVectorComplex(vec3,vec,vec2); - + vec3 = psVectorComplex( vec3, vec, vec2 ); + // 3. verify that the result is a psC32 - if (vec3->type.type != PS_TYPE_C32) { - psError(__func__,"Vector Type from psVectorComplex is not complex? (%d)", - vec3->type.type); - return 1; - } - + if ( vec3->type.type != PS_TYPE_C32 ) { + psError( __func__, "Vector Type from psVectorComplex is not complex? (%d)", + vec3->type.type ); + return 1; + } + // 4. call psVectorReal and psVectorImaginary on step 2 results (not needed, just use crealf/cimagf) // 5. compare step 4 results to input. - for (unsigned int n = 0; n<100; n++) { - if (fabsf(crealf(vec3->data.C32[n]) - n) > FLT_EPSILON || - fabsf(cimagf(vec3->data.C32[n]) - (n*2)) > FLT_EPSILON) { - psError(__func__,"psVectorComplex result is invalid (n=%d, %.2f+%.2fi)", - n,crealf(vec3->data.C32[n]),cimagf(vec3->data.C32[n])); - return 2; - }; - } - - + for ( unsigned int n = 0; n < 100; n++ ) { + if ( fabsf( crealf( vec3->data.C32[ n ] ) - n ) > FLT_EPSILON || + fabsf( cimagf( vec3->data.C32[ n ] ) - ( n * 2 ) ) > FLT_EPSILON ) { + psError( __func__, "psVectorComplex result is invalid (n=%d, %.2f+%.2fi)", + n, crealf( vec3->data.C32[ n ] ), cimagf( vec3->data.C32[ n ] ) ); + return 2; + }; + } + + // 6. create a psF32 and a psF64 vector of the same size - vec2 = psVectorRecycle(vec2,PS_TYPE_F64, 100); - + vec2 = psVectorRecycle( vec2, PS_TYPE_F64, 100 ); + // 7. call psVectorComplex - psLogMsg(__func__,PS_LOG_INFO, "Following should be an error (type mismatch)."); - vec3 = psVectorComplex(vec3,vec,vec2); + psLogMsg( __func__, PS_LOG_INFO, "Following should be an error (type mismatch)." ); + vec3 = psVectorComplex( vec3, vec, vec2 ); // 8. verify that an appropriate error occurred. (this partially has to be done via inspection) - if (vec3 != NULL) { - psError(__func__,"psVectorComplex returned a vector though input types mismatched."); - return 3; - } - + if ( vec3 != NULL ) { + psError( __func__, "psVectorComplex returned a vector though input types mismatched." ); + return 3; + } + // 9. create two psf32 vectors of different sizes - vec2 = psVectorRecycle(vec2,PS_TYPE_F32,200); - + vec2 = psVectorRecycle( vec2, PS_TYPE_F32, 200 ); + // 10. call psVectorComplex - vec3 = psVectorComplex(vec3,vec,vec2); - + vec3 = psVectorComplex( vec3, vec, vec2 ); + // 11. verify thet an appropriate error occurred. (actually, it isn't an error...) - if (vec3->n != 100) { - psError(__func__,"psVectorComplex returned a vector though input sizes mismatched."); - return 4; - } - - psFree(vec); - psFree(vec2); - psFree(vec3); - - return 0; -} - -int testVectorConjugate(void) -{ - psVector* vec = NULL; - psVector* vec2 = NULL; - + if ( vec3->n != 100 ) { + psError( __func__, "psVectorComplex returned a larger vector than the input supported (%d).", vec3->n ); + return 4; + } + + psFree( vec ); + psFree( vec2 ); + psFree( vec3 ); + + return 0; +} + +int testVectorConjugate( void ) +{ + psVector * vec = NULL; + psVector* vec2 = NULL; + /* 1. create a psC32 with unique real and imaginary values. @@ -280,43 +289,43 @@ 4. verify each value is conjugate of input (a+bi -> a-bi) */ - + // 1. create a psC32 with unique real and imaginary values. - vec=psVectorAlloc(100,PS_TYPE_C32); - vec->n = vec->nalloc; - for (unsigned int n = 0; n<100; n++) { - vec->data.C32[n] = n + I * (n*2); - } - + vec = psVectorAlloc( 100, PS_TYPE_C32 ); + vec->n = vec->nalloc; + for ( unsigned int n = 0; n < 100; n++ ) { + vec->data.C32[ n ] = n + I * ( n * 2 ); + } + // 2. call psVectorConjugate - vec2 = psVectorConjugate(vec2,vec); - + vec2 = psVectorConjugate( vec2, vec ); + // 3. verify result is psC32 - if (vec2->type.type != PS_TYPE_C32) { - psError(__func__,"the psVectorConjugate didn't return a C32 vector"); - return 1; - } - + if ( vec2->type.type != PS_TYPE_C32 ) { + psError( __func__, "the psVectorConjugate didn't return a C32 vector" ); + return 1; + } + // 4. verify each value is conjugate of input (a+bi -> a-bi) - for (unsigned int n = 0; n<100; n++) { - 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(__func__,"psVectorComplex result is invalid (n=%d, %.2f+%.2fi)", - n,crealf(vec2->data.C32[n]),cimagf(vec2->data.C32[n])); - return 2; - }; - } - - psFree(vec); - psFree(vec2); - - return 0; -} - -int testVectorPowerSpectrum(void) -{ - psVector* vec = NULL; + for ( unsigned int n = 0; n < 100; n++ ) { + 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( __func__, "psVectorComplex result is invalid (n=%d, %.2f+%.2fi)", + n, crealf( vec2->data.C32[ n ] ), cimagf( vec2->data.C32[ n ] ) ); + return 2; + }; + } + + psFree( vec ); + psFree( vec2 ); + + return 0; +} + +int testVectorPowerSpectrum( void ) +{ + psVector * vec = NULL; psVector* vec2 = NULL; psF32 val; - + /* 1. create a psC32 vector with unique real and imaginary components @@ -325,21 +334,21 @@ 4. verify the values are the square of the absolute values of the original */ - + // 1. create a psC32 vector with unique real and imaginary components - vec=psVectorAlloc(100,PS_TYPE_C32); - vec->n = vec->nalloc; - for (unsigned int n = 0; n<100; n++) { - vec->data.C32[n] = n + I * sinf(((psF32)n) / 50.f * M_PI); - } - + vec = psVectorAlloc( 100, PS_TYPE_C32 ); + vec->n = vec->nalloc; + for ( unsigned int n = 0; n < 100; n++ ) { + vec->data.C32[ n ] = n + I * sinf( ( ( psF32 ) n ) / 50.f * M_PI ); + } + // 2. call psVectorPowerSpectrum - vec2 = psVectorPowerSpectrum(vec2,vec); - + vec2 = psVectorPowerSpectrum( vec2, vec ); + // 3. verify result is psF32 - if (vec2->type.type != PS_TYPE_F32) { - psError(__func__,"the type was not PS_TYPE_F32."); - return 1; - } - + if ( vec2->type.type != PS_TYPE_F32 ) { + psError( __func__, "the type was not PS_TYPE_F32." ); + return 1; + } + // 4. verify the values are the square of the absolute values of the original // (ADD specifies something else) @@ -348,33 +357,33 @@ // P_N/2 = |C_N/2|^2/N^2 // where j = 1,2,...,(N/2-1) - - val = cabsf(vec->data.C32[0])*cabsf(vec->data.C32[0])/100/100; - if (fabsf(vec2->data.F32[0] - val) > FLT_EPSILON) { - psError(__func__,"psVectorPowerSpectrum result is invalid (n=0, %.2f %.2f)", - vec2->data.F32[0],val); - return 2; - }; - - for (unsigned int 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; - - if (fabsf(val - vec2->data.F32[n]) > FLT_EPSILON) { - psError(__func__,"psVectorPowerSpectrum result is invalid (n=%d, %.2f %.2f)", - n,vec2->data.F32[n],val); + + val = cabsf( vec->data.C32[ 0 ] ) * cabsf( vec->data.C32[ 0 ] ) / 100 / 100; + if ( fabsf( vec2->data.F32[ 0 ] - val ) > FLT_EPSILON ) { + psError( __func__, "psVectorPowerSpectrum result is invalid (n=0, %.2f %.2f)", + vec2->data.F32[ 0 ], val ); return 2; }; - } - - val = cabsf(vec->data.C32[50])*cabsf(vec->data.C32[50])/100/100; - if (fabsf(vec2->data.F32[50] - val) > FLT_EPSILON) { - psError(__func__,"psVectorPowerSpectrum result is invalid (n=50, %.2f %.2f)", - vec2->data.F32[0],val); - return 2; - }; - - psFree(vec); - psFree(vec2); - - return 0; -} + + for ( unsigned int 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; + + if ( fabsf( val - vec2->data.F32[ n ] ) > FLT_EPSILON ) { + psError( __func__, "psVectorPowerSpectrum result is invalid (n=%d, %.2f %.2f)", + n, vec2->data.F32[ n ], val ); + return 2; + }; + } + + val = cabsf( vec->data.C32[ 50 ] ) * cabsf( vec->data.C32[ 50 ] ) / 100 / 100; + if ( fabsf( vec2->data.F32[ 50 ] - val ) > FLT_EPSILON ) { + psError( __func__, "psVectorPowerSpectrum result is invalid (n=50, %.2f %.2f)", + vec2->data.F32[ 0 ], val ); + return 2; + }; + + psFree( vec ); + psFree( vec2 ); + + return 0; +} Index: /trunk/psLib/test/dataManip/verified/tst_psHist02.stdout =================================================================== --- /trunk/psLib/test/dataManip/verified/tst_psHist02.stdout (revision 1364) +++ /trunk/psLib/test/dataManip/verified/tst_psHist02.stdout (revision 1365) @@ -5,5 +5,5 @@ \**********************************************************************************/ -Bin number 0 bounds: (20.000000 - 30.000000) data (10000) +Bin number 0 bounds: (20.00 - 30.00) data (10000) ---> TESTPOINT PASSED (psStats functions{Allocate and Perform Histogram, no mask} | tst_psHist02.c) @@ -25,6 +25,6 @@ \**********************************************************************************/ -Bin number 0 bounds: (20.000000 - 25.000000) data (5000) -Bin number 1 bounds: (25.000000 - 30.000000) data (5000) +Bin number 0 bounds: (20.00 - 25.00) data (5000) +Bin number 1 bounds: (25.00 - 30.00) data (5000) ---> TESTPOINT PASSED (psStats functions{Allocate and Perform Histogram, no mask} | tst_psHist02.c) @@ -47,14 +47,14 @@ \**********************************************************************************/ -Bin number 0 bounds: (20.000000 - 21.000000) data (1000) -Bin number 1 bounds: (21.000000 - 22.000000) data (1000) -Bin number 2 bounds: (22.000000 - 23.000000) data (1000) -Bin number 3 bounds: (23.000000 - 24.000000) data (1000) -Bin number 4 bounds: (24.000000 - 25.000000) data (1000) -Bin number 5 bounds: (25.000000 - 26.000000) data (1000) -Bin number 6 bounds: (26.000000 - 27.000000) data (1000) -Bin number 7 bounds: (27.000000 - 28.000000) data (1000) -Bin number 8 bounds: (28.000000 - 29.000002) data (1000) -Bin number 9 bounds: (29.000002 - 30.000002) data (1000) +Bin number 0 bounds: (20.00 - 21.00) data (1000) +Bin number 1 bounds: (21.00 - 22.00) data (1000) +Bin number 2 bounds: (22.00 - 23.00) data (1000) +Bin number 3 bounds: (23.00 - 24.00) data (1000) +Bin number 4 bounds: (24.00 - 25.00) data (1000) +Bin number 5 bounds: (25.00 - 26.00) data (1000) +Bin number 6 bounds: (26.00 - 27.00) data (1000) +Bin number 7 bounds: (27.00 - 28.00) data (1000) +Bin number 8 bounds: (28.00 - 29.00) data (1000) +Bin number 9 bounds: (29.00 - 30.00) data (1000) ---> TESTPOINT PASSED (psStats functions{Allocate and Perform Histogram, no mask} | tst_psHist02.c) @@ -85,24 +85,24 @@ \**********************************************************************************/ -Bin number 0 bounds: (20.000000 - 20.500000) data (500) -Bin number 1 bounds: (20.500000 - 21.000000) data (500) -Bin number 2 bounds: (21.000000 - 21.500000) data (500) -Bin number 3 bounds: (21.500000 - 22.000000) data (500) -Bin number 4 bounds: (22.000000 - 22.500000) data (500) -Bin number 5 bounds: (22.500000 - 23.000000) data (500) -Bin number 6 bounds: (23.000000 - 23.500000) data (500) -Bin number 7 bounds: (23.500000 - 24.000000) data (500) -Bin number 8 bounds: (24.000000 - 24.500002) data (500) -Bin number 9 bounds: (24.500002 - 25.000002) data (500) -Bin number 10 bounds: (25.000002 - 25.500002) data (500) -Bin number 11 bounds: (25.500002 - 26.000002) data (500) -Bin number 12 bounds: (26.000002 - 26.500002) data (500) -Bin number 13 bounds: (26.500002 - 27.000002) data (500) -Bin number 14 bounds: (27.000002 - 27.500002) data (500) -Bin number 15 bounds: (27.500002 - 28.000002) data (500) -Bin number 16 bounds: (28.000002 - 28.500002) data (500) -Bin number 17 bounds: (28.500002 - 29.000002) data (500) -Bin number 18 bounds: (29.000002 - 29.500002) data (500) -Bin number 19 bounds: (29.500002 - 30.000002) data (500) +Bin number 0 bounds: (20.00 - 20.50) data (500) +Bin number 1 bounds: (20.50 - 21.00) data (500) +Bin number 2 bounds: (21.00 - 21.50) data (500) +Bin number 3 bounds: (21.50 - 22.00) data (500) +Bin number 4 bounds: (22.00 - 22.50) data (500) +Bin number 5 bounds: (22.50 - 23.00) data (500) +Bin number 6 bounds: (23.00 - 23.50) data (500) +Bin number 7 bounds: (23.50 - 24.00) data (500) +Bin number 8 bounds: (24.00 - 24.50) data (500) +Bin number 9 bounds: (24.50 - 25.00) data (500) +Bin number 10 bounds: (25.00 - 25.50) data (500) +Bin number 11 bounds: (25.50 - 26.00) data (500) +Bin number 12 bounds: (26.00 - 26.50) data (500) +Bin number 13 bounds: (26.50 - 27.00) data (500) +Bin number 14 bounds: (27.00 - 27.50) data (500) +Bin number 15 bounds: (27.50 - 28.00) data (500) +Bin number 16 bounds: (28.00 - 28.50) data (500) +Bin number 17 bounds: (28.50 - 29.00) data (500) +Bin number 18 bounds: (29.00 - 29.50) data (500) +Bin number 19 bounds: (29.50 - 30.00) data (500) ---> TESTPOINT PASSED (psStats functions{Allocate and Perform Histogram, no mask} | tst_psHist02.c) Index: /trunk/psLib/test/dataManip/verified/tst_psMatrixVectorArithmetic02.stdout =================================================================== --- /trunk/psLib/test/dataManip/verified/tst_psMatrixVectorArithmetic02.stdout (revision 1364) +++ /trunk/psLib/test/dataManip/verified/tst_psMatrixVectorArithmetic02.stdout (revision 1365) @@ -31,16 +31,16 @@ Operation: abs Input: --10.000000 -10.000000 --10.000000 -10.000000 --10.000000 -10.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -10.000000 10.000000 -10.000000 10.000000 -10.000000 10.000000 +-10.00 -10.00 +-10.00 -10.00 +-10.00 -10.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +10.00 10.00 +10.00 10.00 +10.00 10.00 @@ -55,16 +55,16 @@ Operation: abs Input: --10.000000 -10.000000 --10.000000 -10.000000 --10.000000 -10.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -10.000000 10.000000 -10.000000 10.000000 -10.000000 10.000000 +-10.00 -10.00 +-10.00 -10.00 +-10.00 -10.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +10.00 10.00 +10.00 10.00 +10.00 10.00 @@ -79,16 +79,16 @@ Operation: abs Input: --10.000000+-10.000000i -10.000000+-10.000000i --10.000000+-10.000000i -10.000000+-10.000000i --10.000000+-10.000000i -10.000000+-10.000000i - -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i - -Output: -14.142136+0.000000i 14.142136+0.000000i -14.142136+0.000000i 14.142136+0.000000i -14.142136+0.000000i 14.142136+0.000000i +-10.00-10.00i -10.00-10.00i +-10.00-10.00i -10.00-10.00i +-10.00-10.00i -10.00-10.00i + +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i + +Output: +14.14+0.00i 14.14+0.00i +14.14+0.00i 14.14+0.00i +14.14+0.00i 14.14+0.00i @@ -127,16 +127,16 @@ Operation: exp Input: -10.000000 10.000000 -10.000000 10.000000 -10.000000 10.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -22026.464844 22026.464844 -22026.464844 22026.464844 -22026.464844 22026.464844 +10.00 10.00 +10.00 10.00 +10.00 10.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +22026.46 22026.46 +22026.46 22026.46 +22026.46 22026.46 @@ -151,16 +151,16 @@ Operation: exp Input: -10.000000 10.000000 -10.000000 10.000000 -10.000000 10.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -22026.465795 22026.465795 -22026.465795 22026.465795 -22026.465795 22026.465795 +10.00 10.00 +10.00 10.00 +10.00 10.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +22026.47 22026.47 +22026.47 22026.47 +22026.47 22026.47 @@ -175,16 +175,16 @@ Operation: exp Input: -10.000000+10.000000i 10.000000+10.000000i -10.000000+10.000000i 10.000000+10.000000i -10.000000+10.000000i 10.000000+10.000000i - -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i - -Output: --18481.781250+-11982.862305i -18481.781250+-11982.862305i --18481.781250+-11982.862305i -18481.781250+-11982.862305i --18481.781250+-11982.862305i -18481.781250+-11982.862305i +10.00+10.00i 10.00+10.00i +10.00+10.00i 10.00+10.00i +10.00+10.00i 10.00+10.00i + +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i + +Output: +-18481.78-11982.86i -18481.78-11982.86i +-18481.78-11982.86i -18481.78-11982.86i +-18481.78-11982.86i -18481.78-11982.86i @@ -223,16 +223,16 @@ Operation: ln Input: -10.000000 10.000000 -10.000000 10.000000 -10.000000 10.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -2.302585 2.302585 -2.302585 2.302585 -2.302585 2.302585 +10.00 10.00 +10.00 10.00 +10.00 10.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +2.30 2.30 +2.30 2.30 +2.30 2.30 @@ -247,16 +247,16 @@ Operation: ln Input: -10.000000 10.000000 -10.000000 10.000000 -10.000000 10.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -2.302585 2.302585 -2.302585 2.302585 -2.302585 2.302585 +10.00 10.00 +10.00 10.00 +10.00 10.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +2.30 2.30 +2.30 2.30 +2.30 2.30 @@ -271,16 +271,16 @@ Operation: ln Input: -10.000000+10.000000i 10.000000+10.000000i -10.000000+10.000000i 10.000000+10.000000i -10.000000+10.000000i 10.000000+10.000000i - -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i - -Output: -2.649159+0.785398i 2.649159+0.785398i -2.649159+0.785398i 2.649159+0.785398i -2.649159+0.785398i 2.649159+0.785398i +10.00+10.00i 10.00+10.00i +10.00+10.00i 10.00+10.00i +10.00+10.00i 10.00+10.00i + +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i + +Output: +2.65+0.79i 2.65+0.79i +2.65+0.79i 2.65+0.79i +2.65+0.79i 2.65+0.79i @@ -319,16 +319,16 @@ Operation: ten Input: -3.000000 3.000000 -3.000000 3.000000 -3.000000 3.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -1000.000000 1000.000000 -1000.000000 1000.000000 -1000.000000 1000.000000 +3.00 3.00 +3.00 3.00 +3.00 3.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +1000.00 1000.00 +1000.00 1000.00 +1000.00 1000.00 @@ -343,16 +343,16 @@ Operation: ten Input: -3.000000 3.000000 -3.000000 3.000000 -3.000000 3.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -1000.000000 1000.000000 -1000.000000 1000.000000 -1000.000000 1000.000000 +3.00 3.00 +3.00 3.00 +3.00 3.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +1000.00 1000.00 +1000.00 1000.00 +1000.00 1000.00 @@ -367,16 +367,16 @@ Operation: ten Input: -3.000000+3.000000i 3.000000+3.000000i -3.000000+3.000000i 3.000000+3.000000i -3.000000+3.000000i 3.000000+3.000000i - -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i - -Output: -811.214661+584.748474i 811.214661+584.748474i -811.214661+584.748474i 811.214661+584.748474i -811.214661+584.748474i 811.214661+584.748474i +3.00+3.00i 3.00+3.00i +3.00+3.00i 3.00+3.00i +3.00+3.00i 3.00+3.00i + +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i + +Output: +811.21+584.75i 811.21+584.75i +811.21+584.75i 811.21+584.75i +811.21+584.75i 811.21+584.75i @@ -415,16 +415,16 @@ Operation: log Input: -1000.000000 1000.000000 -1000.000000 1000.000000 -1000.000000 1000.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -3.000000 3.000000 -3.000000 3.000000 -3.000000 3.000000 +1000.00 1000.00 +1000.00 1000.00 +1000.00 1000.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +3.00 3.00 +3.00 3.00 +3.00 3.00 @@ -439,16 +439,16 @@ Operation: log Input: -1000.000000 1000.000000 -1000.000000 1000.000000 -1000.000000 1000.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -3.000000 3.000000 -3.000000 3.000000 -3.000000 3.000000 +1000.00 1000.00 +1000.00 1000.00 +1000.00 1000.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +3.00 3.00 +3.00 3.00 +3.00 3.00 @@ -463,16 +463,16 @@ Operation: log Input: -1000.000000+1000.000000i 1000.000000+1000.000000i -1000.000000+1000.000000i 1000.000000+1000.000000i -1000.000000+1000.000000i 1000.000000+1000.000000i - -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i - -Output: -3.150515+0.341094i 3.150515+0.341094i -3.150515+0.341094i 3.150515+0.341094i -3.150515+0.341094i 3.150515+0.341094i +1000.00+1000.00i 1000.00+1000.00i +1000.00+1000.00i 1000.00+1000.00i +1000.00+1000.00i 1000.00+1000.00i + +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i + +Output: +3.15+0.34i 3.15+0.34i +3.15+0.34i 3.15+0.34i +3.15+0.34i 3.15+0.34i @@ -511,16 +511,16 @@ Operation: sin Input: -1.570796 1.570796 -1.570796 1.570796 -1.570796 1.570796 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -1.000000 1.000000 -1.000000 1.000000 -1.000000 1.000000 +1.57 1.57 +1.57 1.57 +1.57 1.57 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +1.00 1.00 +1.00 1.00 +1.00 1.00 @@ -535,16 +535,16 @@ Operation: sin Input: -1.570796 1.570796 -1.570796 1.570796 -1.570796 1.570796 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -1.000000 1.000000 -1.000000 1.000000 -1.000000 1.000000 +1.57 1.57 +1.57 1.57 +1.57 1.57 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +1.00 1.00 +1.00 1.00 +1.00 1.00 @@ -559,16 +559,16 @@ Operation: sin Input: -1.570796+1.570796i 1.570796+1.570796i -1.570796+1.570796i 1.570796+1.570796i -1.570796+1.570796i 1.570796+1.570796i - -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i - -Output: -2.509179+-0.000000i 2.509179+-0.000000i -2.509179+-0.000000i 2.509179+-0.000000i -2.509179+-0.000000i 2.509179+-0.000000i +1.57+1.57i 1.57+1.57i +1.57+1.57i 1.57+1.57i +1.57+1.57i 1.57+1.57i + +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i + +Output: +2.51-0.00i 2.51-0.00i +2.51-0.00i 2.51-0.00i +2.51-0.00i 2.51-0.00i @@ -607,16 +607,16 @@ Operation: dsin Input: -90.000000 90.000000 -90.000000 90.000000 -90.000000 90.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -1.000000 1.000000 -1.000000 1.000000 -1.000000 1.000000 +90.00 90.00 +90.00 90.00 +90.00 90.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +1.00 1.00 +1.00 1.00 +1.00 1.00 @@ -631,16 +631,16 @@ Operation: dsin Input: -90.000000 90.000000 -90.000000 90.000000 -90.000000 90.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -1.000000 1.000000 -1.000000 1.000000 -1.000000 1.000000 +90.00 90.00 +90.00 90.00 +90.00 90.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +1.00 1.00 +1.00 1.00 +1.00 1.00 @@ -655,16 +655,16 @@ Operation: dsin Input: -90.000000+90.000000i 90.000000+90.000000i -90.000000+90.000000i 90.000000+90.000000i -90.000000+90.000000i 90.000000+90.000000i - -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i - -Output: -2.509178+0.000000i 2.509178+0.000000i -2.509178+0.000000i 2.509178+0.000000i -2.509178+0.000000i 2.509178+0.000000i +90.00+90.00i 90.00+90.00i +90.00+90.00i 90.00+90.00i +90.00+90.00i 90.00+90.00i + +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i + +Output: +2.51-0.00i 2.51-0.00i +2.51-0.00i 2.51-0.00i +2.51-0.00i 2.51-0.00i @@ -703,16 +703,16 @@ Operation: cos Input: -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -1.000000 1.000000 -1.000000 1.000000 -1.000000 1.000000 +0.00 0.00 +0.00 0.00 +0.00 0.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +1.00 1.00 +1.00 1.00 +1.00 1.00 @@ -727,16 +727,16 @@ Operation: cos Input: -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -1.000000 1.000000 -1.000000 1.000000 -1.000000 1.000000 +0.00 0.00 +0.00 0.00 +0.00 0.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +1.00 1.00 +1.00 1.00 +1.00 1.00 @@ -751,16 +751,16 @@ Operation: cos Input: -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i - -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i - -Output: -1.000000+-0.000000i 1.000000+-0.000000i -1.000000+-0.000000i 1.000000+-0.000000i -1.000000+-0.000000i 1.000000+-0.000000i +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i + +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i + +Output: +1.00-0.00i 1.00-0.00i +1.00-0.00i 1.00-0.00i +1.00-0.00i 1.00-0.00i @@ -799,16 +799,16 @@ Operation: dcos Input: -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -1.000000 1.000000 -1.000000 1.000000 -1.000000 1.000000 +0.00 0.00 +0.00 0.00 +0.00 0.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +1.00 1.00 +1.00 1.00 +1.00 1.00 @@ -823,16 +823,16 @@ Operation: dcos Input: -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -1.000000 1.000000 -1.000000 1.000000 -1.000000 1.000000 +0.00 0.00 +0.00 0.00 +0.00 0.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +1.00 1.00 +1.00 1.00 +1.00 1.00 @@ -847,16 +847,16 @@ Operation: dcos Input: -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i - -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i - -Output: -1.000000+-0.000000i 1.000000+-0.000000i -1.000000+-0.000000i 1.000000+-0.000000i -1.000000+-0.000000i 1.000000+-0.000000i +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i + +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i + +Output: +1.00-0.00i 1.00-0.00i +1.00-0.00i 1.00-0.00i +1.00-0.00i 1.00-0.00i @@ -895,16 +895,16 @@ Operation: tan Input: -0.785398 0.785398 -0.785398 0.785398 -0.785398 0.785398 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -1.000000 1.000000 -1.000000 1.000000 -1.000000 1.000000 +0.79 0.79 +0.79 0.79 +0.79 0.79 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +1.00 1.00 +1.00 1.00 +1.00 1.00 @@ -919,16 +919,16 @@ Operation: tan Input: -0.785398 0.785398 -0.785398 0.785398 -0.785398 0.785398 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -1.000000 1.000000 -1.000000 1.000000 -1.000000 1.000000 +0.79 0.79 +0.79 0.79 +0.79 0.79 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +1.00 1.00 +1.00 1.00 +1.00 1.00 @@ -943,16 +943,16 @@ Operation: tan Input: -0.785398+0.785398i 0.785398+0.785398i -0.785398+0.785398i 0.785398+0.785398i -0.785398+0.785398i 0.785398+0.785398i - -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i - -Output: -0.398537+0.917152i 0.398537+0.917152i -0.398537+0.917152i 0.398537+0.917152i -0.398537+0.917152i 0.398537+0.917152i +0.79+0.79i 0.79+0.79i +0.79+0.79i 0.79+0.79i +0.79+0.79i 0.79+0.79i + +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i + +Output: +0.40+0.92i 0.40+0.92i +0.40+0.92i 0.40+0.92i +0.40+0.92i 0.40+0.92i @@ -991,16 +991,16 @@ Operation: dtan Input: -45.000000 45.000000 -45.000000 45.000000 -45.000000 45.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -1.000000 1.000000 -1.000000 1.000000 -1.000000 1.000000 +45.00 45.00 +45.00 45.00 +45.00 45.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +1.00 1.00 +1.00 1.00 +1.00 1.00 @@ -1015,16 +1015,16 @@ Operation: dtan Input: -45.000000 45.000000 -45.000000 45.000000 -45.000000 45.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -1.000000 1.000000 -1.000000 1.000000 -1.000000 1.000000 +45.00 45.00 +45.00 45.00 +45.00 45.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +1.00 1.00 +1.00 1.00 +1.00 1.00 @@ -1039,16 +1039,16 @@ Operation: dtan Input: -45.000000+45.000000i 45.000000+45.000000i -45.000000+45.000000i 45.000000+45.000000i -45.000000+45.000000i 45.000000+45.000000i - -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i - -Output: -0.398537+0.917152i 0.398537+0.917152i -0.398537+0.917152i 0.398537+0.917152i -0.398537+0.917152i 0.398537+0.917152i +45.00+45.00i 45.00+45.00i +45.00+45.00i 45.00+45.00i +45.00+45.00i 45.00+45.00i + +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i + +Output: +0.40+0.92i 0.40+0.92i +0.40+0.92i 0.40+0.92i +0.40+0.92i 0.40+0.92i @@ -1087,16 +1087,16 @@ Operation: asin Input: -1.000000 1.000000 -1.000000 1.000000 -1.000000 1.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -1.570796 1.570796 -1.570796 1.570796 -1.570796 1.570796 +1.00 1.00 +1.00 1.00 +1.00 1.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +1.57 1.57 +1.57 1.57 +1.57 1.57 @@ -1111,16 +1111,16 @@ Operation: asin Input: -1.000000 1.000000 -1.000000 1.000000 -1.000000 1.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -1.570796 1.570796 -1.570796 1.570796 -1.570796 1.570796 +1.00 1.00 +1.00 1.00 +1.00 1.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +1.57 1.57 +1.57 1.57 +1.57 1.57 @@ -1135,16 +1135,16 @@ Operation: asin Input: -1.000000+1.000000i 1.000000+1.000000i -1.000000+1.000000i 1.000000+1.000000i -1.000000+1.000000i 1.000000+1.000000i - -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i - -Output: -0.666239+1.061275i 0.666239+1.061275i -0.666239+1.061275i 0.666239+1.061275i -0.666239+1.061275i 0.666239+1.061275i +1.00+1.00i 1.00+1.00i +1.00+1.00i 1.00+1.00i +1.00+1.00i 1.00+1.00i + +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i + +Output: +0.67+1.06i 0.67+1.06i +0.67+1.06i 0.67+1.06i +0.67+1.06i 0.67+1.06i @@ -1168,7 +1168,7 @@ Output: -89 89 -89 89 -89 89 +90 90 +90 90 +90 90 @@ -1183,16 +1183,16 @@ Operation: dasin Input: -1.000000 1.000000 -1.000000 1.000000 -1.000000 1.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -90.000000 90.000000 -90.000000 90.000000 -90.000000 90.000000 +1.00 1.00 +1.00 1.00 +1.00 1.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +90.00 90.00 +90.00 90.00 +90.00 90.00 @@ -1207,16 +1207,16 @@ Operation: dasin Input: -1.000000 1.000000 -1.000000 1.000000 -1.000000 1.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -90.000000 90.000000 -90.000000 90.000000 -90.000000 90.000000 +1.00 1.00 +1.00 1.00 +1.00 1.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +90.00 90.00 +90.00 90.00 +90.00 90.00 @@ -1231,16 +1231,16 @@ Operation: dasin Input: -1.000000+1.000000i 1.000000+1.000000i -1.000000+1.000000i 1.000000+1.000000i -1.000000+1.000000i 1.000000+1.000000i - -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i - -Output: -38.172707+60.806583i 38.172707+60.806583i -38.172707+60.806583i 38.172707+60.806583i -38.172707+60.806583i 38.172707+60.806583i +1.00+1.00i 1.00+1.00i +1.00+1.00i 1.00+1.00i +1.00+1.00i 1.00+1.00i + +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i + +Output: +38.17+60.81i 38.17+60.81i +38.17+60.81i 38.17+60.81i +38.17+60.81i 38.17+60.81i @@ -1279,16 +1279,16 @@ Operation: acos Input: -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -1.570796 1.570796 -1.570796 1.570796 -1.570796 1.570796 +0.00 0.00 +0.00 0.00 +0.00 0.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +1.57 1.57 +1.57 1.57 +1.57 1.57 @@ -1303,16 +1303,16 @@ Operation: acos Input: -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -1.570796 1.570796 -1.570796 1.570796 -1.570796 1.570796 +0.00 0.00 +0.00 0.00 +0.00 0.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +1.57 1.57 +1.57 1.57 +1.57 1.57 @@ -1327,16 +1327,16 @@ Operation: acos Input: -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i - -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i - -Output: -1.570796+-0.000000i 1.570796+-0.000000i -1.570796+-0.000000i 1.570796+-0.000000i -1.570796+-0.000000i 1.570796+-0.000000i +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i + +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i + +Output: +1.57-0.00i 1.57-0.00i +1.57-0.00i 1.57-0.00i +1.57-0.00i 1.57-0.00i @@ -1360,7 +1360,7 @@ Output: -89 89 -89 89 -89 89 +90 90 +90 90 +90 90 @@ -1375,16 +1375,16 @@ Operation: dacos Input: -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -90.000000 90.000000 -90.000000 90.000000 -90.000000 90.000000 +0.00 0.00 +0.00 0.00 +0.00 0.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +90.00 90.00 +90.00 90.00 +90.00 90.00 @@ -1399,16 +1399,16 @@ Operation: dacos Input: -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -90.000000 90.000000 -90.000000 90.000000 -90.000000 90.000000 +0.00 0.00 +0.00 0.00 +0.00 0.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +90.00 90.00 +90.00 90.00 +90.00 90.00 @@ -1423,16 +1423,16 @@ Operation: dacos Input: -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i - -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i - -Output: -90.000000+0.000000i 90.000000+0.000000i -90.000000+0.000000i 90.000000+0.000000i -90.000000+0.000000i 90.000000+0.000000i +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i + +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i + +Output: +90.00+0.00i 90.00+0.00i +90.00+0.00i 90.00+0.00i +90.00+0.00i 90.00+0.00i @@ -1471,16 +1471,16 @@ Operation: atan Input: -1.000000 1.000000 -1.000000 1.000000 -1.000000 1.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -0.785398 0.785398 -0.785398 0.785398 -0.785398 0.785398 +1.00 1.00 +1.00 1.00 +1.00 1.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +0.79 0.79 +0.79 0.79 +0.79 0.79 @@ -1495,16 +1495,16 @@ Operation: atan Input: -1.000000 1.000000 -1.000000 1.000000 -1.000000 1.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -0.785398 0.785398 -0.785398 0.785398 -0.785398 0.785398 +1.00 1.00 +1.00 1.00 +1.00 1.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +0.79 0.79 +0.79 0.79 +0.79 0.79 @@ -1519,16 +1519,16 @@ Operation: atan Input: -1.000000+1.000000i 1.000000+1.000000i -1.000000+1.000000i 1.000000+1.000000i -1.000000+1.000000i 1.000000+1.000000i - -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i - -Output: -1.017222+0.402359i 1.017222+0.402359i -1.017222+0.402359i 1.017222+0.402359i -1.017222+0.402359i 1.017222+0.402359i +1.00+1.00i 1.00+1.00i +1.00+1.00i 1.00+1.00i +1.00+1.00i 1.00+1.00i + +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i + +Output: +1.02+0.40i 1.02+0.40i +1.02+0.40i 1.02+0.40i +1.02+0.40i 1.02+0.40i @@ -1567,16 +1567,16 @@ Operation: datan Input: -1.000000 1.000000 -1.000000 1.000000 -1.000000 1.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -45.000000 45.000000 -45.000000 45.000000 -45.000000 45.000000 +1.00 1.00 +1.00 1.00 +1.00 1.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +45.00 45.00 +45.00 45.00 +45.00 45.00 @@ -1591,16 +1591,16 @@ Operation: datan Input: -1.000000 1.000000 -1.000000 1.000000 -1.000000 1.000000 - -0.000000 0.000000 -0.000000 0.000000 -0.000000 0.000000 - -Output: -45.000000 45.000000 -45.000000 45.000000 -45.000000 45.000000 +1.00 1.00 +1.00 1.00 +1.00 1.00 + +0.00 0.00 +0.00 0.00 +0.00 0.00 + +Output: +45.00 45.00 +45.00 45.00 +45.00 45.00 @@ -1615,16 +1615,16 @@ Operation: datan Input: -1.000000+1.000000i 1.000000+1.000000i -1.000000+1.000000i 1.000000+1.000000i -1.000000+1.000000i 1.000000+1.000000i - -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i -0.000000+0.000000i 0.000000+0.000000i - -Output: -58.282524+23.053499i 58.282524+23.053499i -58.282524+23.053499i 58.282524+23.053499i -58.282524+23.053499i 58.282524+23.053499i +1.00+1.00i 1.00+1.00i +1.00+1.00i 1.00+1.00i +1.00+1.00i 1.00+1.00i + +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i +0.00+0.00i 0.00+0.00i + +Output: +58.28+23.05i 58.28+23.05i +58.28+23.05i 58.28+23.05i +58.28+23.05i 58.28+23.05i @@ -1663,16 +1663,16 @@ Operation: abs Input: --10.000000 --10.000000 --10.000000 - -0.000000 -0.000000 -0.000000 - -Output: -10.000000 -10.000000 -10.000000 +-10.00 +-10.00 +-10.00 + +0.00 +0.00 +0.00 + +Output: +10.00 +10.00 +10.00 @@ -1687,16 +1687,16 @@ Operation: abs Input: --10.000000 --10.000000 --10.000000 - -0.000000 -0.000000 -0.000000 - -Output: -10.000000 -10.000000 -10.000000 +-10.00 +-10.00 +-10.00 + +0.00 +0.00 +0.00 + +Output: +10.00 +10.00 +10.00 @@ -1711,16 +1711,16 @@ Operation: abs Input: --10.000000+-10.000000i --10.000000+-10.000000i --10.000000+-10.000000i - -0.000000+0.000000i -0.000000+0.000000i -0.000000+0.000000i - -Output: -14.142136+0.000000i -14.142136+0.000000i -14.142136+0.000000i +-10.00-10.00i +-10.00-10.00i +-10.00-10.00i + +0.00+0.00i +0.00+0.00i +0.00+0.00i + +Output: +14.14+0.00i +14.14+0.00i +14.14+0.00i @@ -1759,16 +1759,16 @@ Operation: exp Input: -10.000000 -10.000000 -10.000000 - -0.000000 -0.000000 -0.000000 - -Output: -22026.464844 -22026.464844 -22026.464844 +10.00 +10.00 +10.00 + +0.00 +0.00 +0.00 + +Output: +22026.46 +22026.46 +22026.46 @@ -1783,16 +1783,16 @@ Operation: exp Input: -10.000000 -10.000000 -10.000000 - -0.000000 -0.000000 -0.000000 - -Output: -22026.465795 -22026.465795 -22026.465795 +10.00 +10.00 +10.00 + +0.00 +0.00 +0.00 + +Output: +22026.47 +22026.47 +22026.47 @@ -1807,16 +1807,16 @@ Operation: exp Input: -10.000000+10.000000i -10.000000+10.000000i -10.000000+10.000000i - -0.000000+0.000000i -0.000000+0.000000i -0.000000+0.000000i - -Output: --18481.781250+-11982.862305i --18481.781250+-11982.862305i --18481.781250+-11982.862305i +10.00+10.00i +10.00+10.00i +10.00+10.00i + +0.00+0.00i +0.00+0.00i +0.00+0.00i + +Output: +-18481.78-11982.86i +-18481.78-11982.86i +-18481.78-11982.86i @@ -1855,16 +1855,16 @@ Operation: ln Input: -10.000000 -10.000000 -10.000000 - -0.000000 -0.000000 -0.000000 - -Output: -2.302585 -2.302585 -2.302585 +10.00 +10.00 +10.00 + +0.00 +0.00 +0.00 + +Output: +2.30 +2.30 +2.30 @@ -1879,16 +1879,16 @@ Operation: ln Input: -10.000000 -10.000000 -10.000000 - -0.000000 -0.000000 -0.000000 - -Output: -2.302585 -2.302585 -2.302585 +10.00 +10.00 +10.00 + +0.00 +0.00 +0.00 + +Output: +2.30 +2.30 +2.30 @@ -1903,16 +1903,16 @@ Operation: ln Input: -10.000000+10.000000i -10.000000+10.000000i -10.000000+10.000000i - -0.000000+0.000000i -0.000000+0.000000i -0.000000+0.000000i - -Output: -2.649159+0.785398i -2.649159+0.785398i -2.649159+0.785398i +10.00+10.00i +10.00+10.00i +10.00+10.00i + +0.00+0.00i +0.00+0.00i +0.00+0.00i + +Output: +2.65+0.79i +2.65+0.79i +2.65+0.79i @@ -1951,16 +1951,16 @@ Operation: ten Input: -3.000000 -3.000000 -3.000000 - -0.000000 -0.000000 -0.000000 - -Output: -1000.000000 -1000.000000 -1000.000000 +3.00 +3.00 +3.00 + +0.00 +0.00 +0.00 + +Output: +1000.00 +1000.00 +1000.00 @@ -1975,16 +1975,16 @@ Operation: ten Input: -3.000000 -3.000000 -3.000000 - -0.000000 -0.000000 -0.000000 - -Output: -1000.000000 -1000.000000 -1000.000000 +3.00 +3.00 +3.00 + +0.00 +0.00 +0.00 + +Output: +1000.00 +1000.00 +1000.00 @@ -1999,16 +1999,16 @@ Operation: ten Input: -3.000000+3.000000i -3.000000+3.000000i -3.000000+3.000000i - -0.000000+0.000000i -0.000000+0.000000i -0.000000+0.000000i - -Output: -811.214661+584.748474i -811.214661+584.748474i -811.214661+584.748474i +3.00+3.00i +3.00+3.00i +3.00+3.00i + +0.00+0.00i +0.00+0.00i +0.00+0.00i + +Output: +811.21+584.75i +811.21+584.75i +811.21+584.75i @@ -2047,16 +2047,16 @@ Operation: log Input: -1000.000000 -1000.000000 -1000.000000 - -0.000000 -0.000000 -0.000000 - -Output: -3.000000 -3.000000 -3.000000 +1000.00 +1000.00 +1000.00 + +0.00 +0.00 +0.00 + +Output: +3.00 +3.00 +3.00 @@ -2071,16 +2071,16 @@ Operation: log Input: -1000.000000 -1000.000000 -1000.000000 - -0.000000 -0.000000 -0.000000 - -Output: -3.000000 -3.000000 -3.000000 +1000.00 +1000.00 +1000.00 + +0.00 +0.00 +0.00 + +Output: +3.00 +3.00 +3.00 @@ -2095,16 +2095,16 @@ Operation: log Input: -1000.000000+1000.000000i -1000.000000+1000.000000i -1000.000000+1000.000000i - -0.000000+0.000000i -0.000000+0.000000i -0.000000+0.000000i - -Output: -3.150515+0.341094i -3.150515+0.341094i -3.150515+0.341094i +1000.00+1000.00i +1000.00+1000.00i +1000.00+1000.00i + +0.00+0.00i +0.00+0.00i +0.00+0.00i + +Output: +3.15+0.34i +3.15+0.34i +3.15+0.34i @@ -2143,16 +2143,16 @@ Operation: sin Input: -1.570796 -1.570796 -1.570796 - -0.000000 -0.000000 -0.000000 - -Output: -1.000000 -1.000000 -1.000000 +1.57 +1.57 +1.57 + +0.00 +0.00 +0.00 + +Output: +1.00 +1.00 +1.00 @@ -2167,16 +2167,16 @@ Operation: sin Input: -1.570796 -1.570796 -1.570796 - -0.000000 -0.000000 -0.000000 - -Output: -1.000000 -1.000000 -1.000000 +1.57 +1.57 +1.57 + +0.00 +0.00 +0.00 + +Output: +1.00 +1.00 +1.00 @@ -2191,16 +2191,16 @@ Operation: sin Input: -1.570796+1.570796i -1.570796+1.570796i -1.570796+1.570796i - -0.000000+0.000000i -0.000000+0.000000i -0.000000+0.000000i - -Output: -2.509179+-0.000000i -2.509179+-0.000000i -2.509179+-0.000000i +1.57+1.57i +1.57+1.57i +1.57+1.57i + +0.00+0.00i +0.00+0.00i +0.00+0.00i + +Output: +2.51-0.00i +2.51-0.00i +2.51-0.00i @@ -2239,16 +2239,16 @@ Operation: dsin Input: -90.000000 -90.000000 -90.000000 - -0.000000 -0.000000 -0.000000 - -Output: -1.000000 -1.000000 -1.000000 +90.00 +90.00 +90.00 + +0.00 +0.00 +0.00 + +Output: +1.00 +1.00 +1.00 @@ -2263,16 +2263,16 @@ Operation: dsin Input: -90.000000 -90.000000 -90.000000 - -0.000000 -0.000000 -0.000000 - -Output: -1.000000 -1.000000 -1.000000 +90.00 +90.00 +90.00 + +0.00 +0.00 +0.00 + +Output: +1.00 +1.00 +1.00 @@ -2287,16 +2287,16 @@ Operation: dsin Input: -90.000000+90.000000i -90.000000+90.000000i -90.000000+90.000000i - -0.000000+0.000000i -0.000000+0.000000i -0.000000+0.000000i - -Output: -2.509178+0.000000i -2.509178+0.000000i -2.509178+0.000000i +90.00+90.00i +90.00+90.00i +90.00+90.00i + +0.00+0.00i +0.00+0.00i +0.00+0.00i + +Output: +2.51-0.00i +2.51-0.00i +2.51-0.00i @@ -2335,16 +2335,16 @@ Operation: cos Input: -0.000000 -0.000000 -0.000000 - -0.000000 -0.000000 -0.000000 - -Output: -1.000000 -1.000000 -1.000000 +0.00 +0.00 +0.00 + +0.00 +0.00 +0.00 + +Output: +1.00 +1.00 +1.00 @@ -2359,16 +2359,16 @@ Operation: cos Input: -0.000000 -0.000000 -0.000000 - -0.000000 -0.000000 -0.000000 - -Output: -1.000000 -1.000000 -1.000000 +0.00 +0.00 +0.00 + +0.00 +0.00 +0.00 + +Output: +1.00 +1.00 +1.00 @@ -2383,16 +2383,16 @@ Operation: cos Input: -0.000000+0.000000i -0.000000+0.000000i -0.000000+0.000000i - -0.000000+0.000000i -0.000000+0.000000i -0.000000+0.000000i - -Output: -1.000000+-0.000000i -1.000000+-0.000000i -1.000000+-0.000000i +0.00+0.00i +0.00+0.00i +0.00+0.00i + +0.00+0.00i +0.00+0.00i +0.00+0.00i + +Output: +1.00-0.00i +1.00-0.00i +1.00-0.00i @@ -2431,16 +2431,16 @@ Operation: dcos Input: -0.000000 -0.000000 -0.000000 - -0.000000 -0.000000 -0.000000 - -Output: -1.000000 -1.000000 -1.000000 +0.00 +0.00 +0.00 + +0.00 +0.00 +0.00 + +Output: +1.00 +1.00 +1.00 @@ -2455,16 +2455,16 @@ Operation: dcos Input: -0.000000 -0.000000 -0.000000 - -0.000000 -0.000000 -0.000000 - -Output: -1.000000 -1.000000 -1.000000 +0.00 +0.00 +0.00 + +0.00 +0.00 +0.00 + +Output: +1.00 +1.00 +1.00 @@ -2479,16 +2479,16 @@ Operation: dcos Input: -0.000000+0.000000i -0.000000+0.000000i -0.000000+0.000000i - -0.000000+0.000000i -0.000000+0.000000i -0.000000+0.000000i - -Output: -1.000000+-0.000000i -1.000000+-0.000000i -1.000000+-0.000000i +0.00+0.00i +0.00+0.00i +0.00+0.00i + +0.00+0.00i +0.00+0.00i +0.00+0.00i + +Output: +1.00-0.00i +1.00-0.00i +1.00-0.00i @@ -2527,16 +2527,16 @@ Operation: tan Input: -0.785398 -0.785398 -0.785398 - -0.000000 -0.000000 -0.000000 - -Output: -1.000000 -1.000000 -1.000000 +0.79 +0.79 +0.79 + +0.00 +0.00 +0.00 + +Output: +1.00 +1.00 +1.00 @@ -2551,16 +2551,16 @@ Operation: tan Input: -0.785398 -0.785398 -0.785398 - -0.000000 -0.000000 -0.000000 - -Output: -1.000000 -1.000000 -1.000000 +0.79 +0.79 +0.79 + +0.00 +0.00 +0.00 + +Output: +1.00 +1.00 +1.00 @@ -2575,16 +2575,16 @@ Operation: tan Input: -0.785398+0.785398i -0.785398+0.785398i -0.785398+0.785398i - -0.000000+0.000000i -0.000000+0.000000i -0.000000+0.000000i - -Output: -0.398537+0.917152i -0.398537+0.917152i -0.398537+0.917152i +0.79+0.79i +0.79+0.79i +0.79+0.79i + +0.00+0.00i +0.00+0.00i +0.00+0.00i + +Output: +0.40+0.92i +0.40+0.92i +0.40+0.92i @@ -2623,16 +2623,16 @@ Operation: dtan Input: -45.000000 -45.000000 -45.000000 - -0.000000 -0.000000 -0.000000 - -Output: -1.000000 -1.000000 -1.000000 +45.00 +45.00 +45.00 + +0.00 +0.00 +0.00 + +Output: +1.00 +1.00 +1.00 @@ -2647,16 +2647,16 @@ Operation: dtan Input: -45.000000 -45.000000 -45.000000 - -0.000000 -0.000000 -0.000000 - -Output: -1.000000 -1.000000 -1.000000 +45.00 +45.00 +45.00 + +0.00 +0.00 +0.00 + +Output: +1.00 +1.00 +1.00 @@ -2671,16 +2671,16 @@ Operation: dtan Input: -45.000000+45.000000i -45.000000+45.000000i -45.000000+45.000000i - -0.000000+0.000000i -0.000000+0.000000i -0.000000+0.000000i - -Output: -0.398537+0.917152i -0.398537+0.917152i -0.398537+0.917152i +45.00+45.00i +45.00+45.00i +45.00+45.00i + +0.00+0.00i +0.00+0.00i +0.00+0.00i + +Output: +0.40+0.92i +0.40+0.92i +0.40+0.92i @@ -2719,16 +2719,16 @@ Operation: asin Input: -1.000000 -1.000000 -1.000000 - -0.000000 -0.000000 -0.000000 - -Output: -1.570796 -1.570796 -1.570796 +1.00 +1.00 +1.00 + +0.00 +0.00 +0.00 + +Output: +1.57 +1.57 +1.57 @@ -2743,16 +2743,16 @@ Operation: asin Input: -1.000000 -1.000000 -1.000000 - -0.000000 -0.000000 -0.000000 - -Output: -1.570796 -1.570796 -1.570796 +1.00 +1.00 +1.00 + +0.00 +0.00 +0.00 + +Output: +1.57 +1.57 +1.57 @@ -2767,16 +2767,16 @@ Operation: asin Input: -1.000000+1.000000i -1.000000+1.000000i -1.000000+1.000000i - -0.000000+0.000000i -0.000000+0.000000i -0.000000+0.000000i - -Output: -0.666239+1.061275i -0.666239+1.061275i -0.666239+1.061275i +1.00+1.00i +1.00+1.00i +1.00+1.00i + +0.00+0.00i +0.00+0.00i +0.00+0.00i + +Output: +0.67+1.06i +0.67+1.06i +0.67+1.06i @@ -2800,7 +2800,7 @@ Output: -89 -89 -89 +90 +90 +90 @@ -2815,16 +2815,16 @@ Operation: dasin Input: -1.000000 -1.000000 -1.000000 - -0.000000 -0.000000 -0.000000 - -Output: -90.000000 -90.000000 -90.000000 +1.00 +1.00 +1.00 + +0.00 +0.00 +0.00 + +Output: +90.00 +90.00 +90.00 @@ -2839,16 +2839,16 @@ Operation: dasin Input: -1.000000 -1.000000 -1.000000 - -0.000000 -0.000000 -0.000000 - -Output: -90.000000 -90.000000 -90.000000 +1.00 +1.00 +1.00 + +0.00 +0.00 +0.00 + +Output: +90.00 +90.00 +90.00 @@ -2863,16 +2863,16 @@ Operation: dasin Input: -1.000000+1.000000i -1.000000+1.000000i -1.000000+1.000000i - -0.000000+0.000000i -0.000000+0.000000i -0.000000+0.000000i - -Output: -38.172707+60.806583i -38.172707+60.806583i -38.172707+60.806583i +1.00+1.00i +1.00+1.00i +1.00+1.00i + +0.00+0.00i +0.00+0.00i +0.00+0.00i + +Output: +38.17+60.81i +38.17+60.81i +38.17+60.81i @@ -2911,16 +2911,16 @@ Operation: acos Input: -0.000000 -0.000000 -0.000000 - -0.000000 -0.000000 -0.000000 - -Output: -1.570796 -1.570796 -1.570796 +0.00 +0.00 +0.00 + +0.00 +0.00 +0.00 + +Output: +1.57 +1.57 +1.57 @@ -2935,16 +2935,16 @@ Operation: acos Input: -0.000000 -0.000000 -0.000000 - -0.000000 -0.000000 -0.000000 - -Output: -1.570796 -1.570796 -1.570796 +0.00 +0.00 +0.00 + +0.00 +0.00 +0.00 + +Output: +1.57 +1.57 +1.57 @@ -2959,16 +2959,16 @@ Operation: acos Input: -0.000000+0.000000i -0.000000+0.000000i -0.000000+0.000000i - -0.000000+0.000000i -0.000000+0.000000i -0.000000+0.000000i - -Output: -1.570796+-0.000000i -1.570796+-0.000000i -1.570796+-0.000000i +0.00+0.00i +0.00+0.00i +0.00+0.00i + +0.00+0.00i +0.00+0.00i +0.00+0.00i + +Output: +1.57-0.00i +1.57-0.00i +1.57-0.00i @@ -2992,7 +2992,7 @@ Output: -89 -89 -89 +90 +90 +90 @@ -3007,16 +3007,16 @@ Operation: dacos Input: -0.000000 -0.000000 -0.000000 - -0.000000 -0.000000 -0.000000 - -Output: -90.000000 -90.000000 -90.000000 +0.00 +0.00 +0.00 + +0.00 +0.00 +0.00 + +Output: +90.00 +90.00 +90.00 @@ -3031,16 +3031,16 @@ Operation: dacos Input: -0.000000 -0.000000 -0.000000 - -0.000000 -0.000000 -0.000000 - -Output: -90.000000 -90.000000 -90.000000 +0.00 +0.00 +0.00 + +0.00 +0.00 +0.00 + +Output: +90.00 +90.00 +90.00 @@ -3055,16 +3055,16 @@ Operation: dacos Input: -0.000000+0.000000i -0.000000+0.000000i -0.000000+0.000000i - -0.000000+0.000000i -0.000000+0.000000i -0.000000+0.000000i - -Output: -90.000000+0.000000i -90.000000+0.000000i -90.000000+0.000000i +0.00+0.00i +0.00+0.00i +0.00+0.00i + +0.00+0.00i +0.00+0.00i +0.00+0.00i + +Output: +90.00+0.00i +90.00+0.00i +90.00+0.00i @@ -3103,16 +3103,16 @@ Operation: atan Input: -1.000000 -1.000000 -1.000000 - -0.000000 -0.000000 -0.000000 - -Output: -0.785398 -0.785398 -0.785398 +1.00 +1.00 +1.00 + +0.00 +0.00 +0.00 + +Output: +0.79 +0.79 +0.79 @@ -3127,16 +3127,16 @@ Operation: atan Input: -1.000000 -1.000000 -1.000000 - -0.000000 -0.000000 -0.000000 - -Output: -0.785398 -0.785398 -0.785398 +1.00 +1.00 +1.00 + +0.00 +0.00 +0.00 + +Output: +0.79 +0.79 +0.79 @@ -3151,16 +3151,16 @@ Operation: atan Input: -1.000000+1.000000i -1.000000+1.000000i -1.000000+1.000000i - -0.000000+0.000000i -0.000000+0.000000i -0.000000+0.000000i - -Output: -1.017222+0.402359i -1.017222+0.402359i -1.017222+0.402359i +1.00+1.00i +1.00+1.00i +1.00+1.00i + +0.00+0.00i +0.00+0.00i +0.00+0.00i + +Output: +1.02+0.40i +1.02+0.40i +1.02+0.40i @@ -3199,16 +3199,16 @@ Operation: datan Input: -1.000000 -1.000000 -1.000000 - -0.000000 -0.000000 -0.000000 - -Output: -45.000000 -45.000000 -45.000000 +1.00 +1.00 +1.00 + +0.00 +0.00 +0.00 + +Output: +45.00 +45.00 +45.00 @@ -3223,16 +3223,16 @@ Operation: datan Input: -1.000000 -1.000000 -1.000000 - -0.000000 -0.000000 -0.000000 - -Output: -45.000000 -45.000000 -45.000000 +1.00 +1.00 +1.00 + +0.00 +0.00 +0.00 + +Output: +45.00 +45.00 +45.00 @@ -3247,18 +3247,18 @@ Operation: datan Input: -1.000000+1.000000i -1.000000+1.000000i -1.000000+1.000000i - -0.000000+0.000000i -0.000000+0.000000i -0.000000+0.000000i - -Output: -58.282524+23.053499i -58.282524+23.053499i -58.282524+23.053499i - - ----> TESTPOINT PASSED (psMatrixVectorArithmetic{Test vector psUnaryOp} | tst_psMatrixVectorArithmetic02.c) - +1.00+1.00i +1.00+1.00i +1.00+1.00i + +0.00+0.00i +0.00+0.00i +0.00+0.00i + +Output: +58.28+23.05i +58.28+23.05i +58.28+23.05i + + +---> TESTPOINT PASSED (psMatrixVectorArithmetic{Test vector psUnaryOp} | tst_psMatrixVectorArithmetic02.c) + Index: /trunk/psLib/test/dataManip/verified/tst_psStats07.stdout =================================================================== --- /trunk/psLib/test/dataManip/verified/tst_psStats07.stdout (revision 1364) +++ /trunk/psLib/test/dataManip/verified/tst_psStats07.stdout (revision 1365) @@ -6,5 +6,5 @@ (LQBinNum, UQBinNum, maxBinNum) is (15, 35, 27) -The expected Mean was 32.000000; the calculated Mean was 32.588161 +The expected Mean was 32.00; the calculated Mean was 32.59 ---> TESTPOINT PASSED (psVector functions{PS_STAT_ROBUST_STATS: robust mean: no vector mask} | tst_psStats07.c) @@ -16,5 +16,5 @@ \**********************************************************************************/ -The expected Median was 32.000000; the calculated Median was 32.485466 +The expected Median was 32.00; the calculated Median was 32.49 ---> TESTPOINT PASSED (psVector functions{PS_STAT_ROBUST_STATS: robust Median: no vector mask} | tst_psStats07.c) @@ -26,5 +26,5 @@ \**********************************************************************************/ -The expected Mode was 32.000000; the calculated Mode was 32.588655 +The expected Mode was 32.00; the calculated Mode was 32.59 ---> TESTPOINT PASSED (psVector functions{PS_STAT_ROBUST_STATS: robust Mode: no vector mask} | tst_psStats07.c) @@ -36,5 +36,5 @@ \**********************************************************************************/ -The expected Stdev was 0.660000; the calculated Stdev was 0.655572 +The expected Stdev was 0.66; the calculated Stdev was 0.66 ---> TESTPOINT PASSED (psVector functions{PS_STAT_ROBUST_STATS: robust Stdev: no vector mask} | tst_psStats07.c) @@ -46,5 +46,5 @@ \**********************************************************************************/ -The expected LQ was 30.799999; the calculated LQ was 30.018070 +The expected LQ was 30.80; the calculated LQ was 30.02 ---> TESTPOINT PASSED (psVector functions{PS_STAT_ROBUST_STATS: lower quartile: no vector mask} | tst_psStats07.c) @@ -56,5 +56,5 @@ \**********************************************************************************/ -The expected UQ was 33.200001; the calculated UQ was 34.325886 +The expected UQ was 33.20; the calculated UQ was 34.33 ---> TESTPOINT PASSED (psVector functions{PS_STAT_ROBUST_STATS: lower quartile: no vector mask} | tst_psStats07.c) @@ -66,5 +66,5 @@ \**********************************************************************************/ -The expected N50 was 143.000000; the calculated N50 was 143.000000 +The expected N50 was 143.00; the calculated N50 was 143.00 ---> TESTPOINT PASSED (psVector functions{PS_STAT_ROBUST_STATS: robust N50: no vector mask} | tst_psStats07.c) @@ -76,5 +76,5 @@ \**********************************************************************************/ -The expected Nfit was 80.000000; the calculated Nfit was 80.000000 +The expected Nfit was 80.00; the calculated Nfit was 80.00 ---> TESTPOINT PASSED (psVector functions{PS_STAT_ROBUST_STATS: robust Nfit: no vector mask} | tst_psStats07.c) Index: /trunk/psLib/test/image/tst_psImageStats00.c =================================================================== --- /trunk/psLib/test/image/tst_psImageStats00.c (revision 1364) +++ /trunk/psLib/test/image/tst_psImageStats00.c (revision 1365) @@ -1,6 +1,6 @@ /***************************************************************************** - This routine must ensure that the psHistogram structure is correctly - allocated and populated by the psImageHistogram() function. - *****************************************************************************/ + This routine must ensure that the psHistogram structure is correctly + allocated and populated by the psImageHistogram() function. +*****************************************************************************/ #include #include "pslib.h" @@ -16,168 +16,168 @@ int main() { - psHistogram *myHist = NULL; - psHistogram *myHist2= NULL; - psImage *tmpImage = NULL; - psImage *tmpMask = NULL; - int testStatus = true; - int memLeaks = 0; - int nb = 0; - int i = 0; - int j = 0; - int IMAGE_X_SIZE = 0; - int IMAGE_Y_SIZE = 0; - int currentId = 0; - - currentId = psMemGetId(); - for (nb=0;nb<6;nb++) { - if (nb == 0) { - IMAGE_X_SIZE = 1; - IMAGE_Y_SIZE = 1; + psHistogram * myHist = NULL; + psHistogram *myHist2 = NULL; + psImage *tmpImage = NULL; + psImage *tmpMask = NULL; + int testStatus = true; + int memLeaks = 0; + int nb = 0; + int i = 0; + int j = 0; + int IMAGE_X_SIZE = 0; + int IMAGE_Y_SIZE = 0; + int currentId = 0; + + currentId = psMemGetId(); + for ( nb = 0;nb < 6;nb++ ) { + if ( nb == 0 ) { + IMAGE_X_SIZE = 1; + IMAGE_Y_SIZE = 1; + } + if ( nb == 1 ) { + IMAGE_X_SIZE = 1; + IMAGE_Y_SIZE = N; + } + if ( nb == 2 ) { + IMAGE_X_SIZE = N; + IMAGE_Y_SIZE = 1; + } + if ( nb == 3 ) { + IMAGE_X_SIZE = N; + IMAGE_Y_SIZE = N; + } + if ( nb == 4 ) { + IMAGE_X_SIZE = N; + IMAGE_Y_SIZE = M; + } + if ( nb == 5 ) { + IMAGE_X_SIZE = M; + IMAGE_Y_SIZE = N; + } + printf( "*******************************\n" ); + printf( "* IMAGE SIZE is (%d by %d)\n", IMAGE_X_SIZE, IMAGE_Y_SIZE ); + printf( "*******************************\n" ); + /*********************************************************************/ + /* Allocate and initialize data structures */ + /*********************************************************************/ + tmpImage = psImageAlloc( IMAGE_X_SIZE, IMAGE_Y_SIZE, PS_TYPE_F32 ); + + for ( i = 0;i < tmpImage->numRows;i++ ) { + for ( j = 0;j < tmpImage->numCols;j++ ) { + tmpImage->data.F32[ i ][ j ] = ( float ) ( i + j + 0.1 ); + } + } + tmpMask = psImageAlloc( IMAGE_X_SIZE, IMAGE_Y_SIZE, PS_TYPE_U8 ); + for ( i = 0;i < tmpMask->numRows;i++ ) { + for ( j = 0;j < tmpMask->numCols;j++ ) { + if ( ( i > ( tmpMask->numRows / 2 ) ) && + ( j > ( tmpMask->numCols / 2 ) ) ) { + tmpMask->data.U8[ i ][ j ] = 1; + } else { + tmpMask->data.U8[ i ][ j ] = 0; + } + } + } + + /*************************************************************************/ + /* Calculate Histogram with no mask */ + /*************************************************************************/ + printPositiveTestHeader( stdout, + "psImageStats functions", + "Calculate Histogram, no mask" ); + + myHist = psHistogramAlloc( 0.0, ( float ) ( IMAGE_X_SIZE + IMAGE_Y_SIZE ), + NUM_BINS ); + myHist = psImageHistogram( myHist, tmpImage, NULL, 0 ); + for ( i = 0;i < NUM_BINS;i++ ) { + printf( "Bin number %d bounds: (%.1f - %.1f) data (%d)\n", i, + myHist->bounds->data.F32[ i ], + myHist->bounds->data.F32[ i + 1 ], + myHist->nums->data.S32[ i ] ); + } + psFree( myHist ); + + psMemCheckCorruption( 1 ); + printFooter( stdout, + "psImageStats functions", + "Calculate Histogram, no mask", + testStatus ); + + /*************************************************************************/ + /* Calculate Histogram with mask */ + /*************************************************************************/ + printPositiveTestHeader( stdout, + "psImageStats functions", + "Calculate Histogram with mask" ); + + myHist = psHistogramAlloc( 0.0, ( float ) ( IMAGE_X_SIZE + IMAGE_Y_SIZE ), + NUM_BINS ); + myHist = psImageHistogram( myHist, tmpImage, tmpMask, 1 ); + for ( i = 0;i < NUM_BINS;i++ ) { + printf( "Bin number %d bounds: (%.2f - %.2f) data (%d)\n", i, + myHist->bounds->data.F32[ i ], + myHist->bounds->data.F32[ i + 1 ], + myHist->nums->data.S32[ i ] ); + } + + psMemCheckCorruption( 1 ); + printFooter( stdout, + "psImageStats functions", + "Calculate Histogram with mask", + testStatus ); + + /*************************************************************************/ + /* Deallocate data structures */ + /*************************************************************************/ + printPositiveTestHeader( stdout, + "psImageStats functions", + "Deallocate the psHistogram/psImage structure." ); + psFree( myHist ); + psFree( tmpImage ); + psFree( tmpMask ); + + psMemCheckCorruption( 1 ); + memLeaks = psMemCheckLeaks( currentId, NULL, NULL ); + if ( 0 != memLeaks ) { + psAbort( __func__, "Memory Leaks! (%d leaks)", memLeaks ); + } + + printFooter( stdout, + "psImageStats functions", + "Deallocate the psHistogram/psImage structure.", + testStatus ); } - if (nb == 1) { - IMAGE_X_SIZE = 1; - IMAGE_Y_SIZE = N; + printPositiveTestHeader( stdout, + "psImageStats functions", + "Calling psImageHistogram() with NULL parameters" ); + + tmpImage = psImageAlloc( IMAGE_X_SIZE, IMAGE_Y_SIZE, PS_TYPE_F32 ); + myHist = psHistogramAlloc( 0.0, ( float ) ( IMAGE_X_SIZE + IMAGE_Y_SIZE ), + NUM_BINS ); + myHist2 = psImageHistogram( NULL, tmpImage, NULL, 0 ); + if ( myHist2 != NULL ) { + printf( "ERROR: myHist2 not equal to NULL\n" ); } - if (nb == 2) { - IMAGE_X_SIZE = N; - IMAGE_Y_SIZE = 1; + + myHist2 = psImageHistogram( myHist, NULL, NULL, 0 ); + myHist2 = psImageHistogram( NULL, tmpImage, NULL, 0 ); + if ( myHist2 != NULL ) { + printf( "ERROR: myHist2 not equal to NULL\n" ); } - if (nb == 3) { - IMAGE_X_SIZE = N; - IMAGE_Y_SIZE = N; + + psMemCheckCorruption( 1 ); + psFree( myHist ); + psFree( tmpImage ); + psMemCheckCorruption( 1 ); + memLeaks = psMemCheckLeaks( currentId, NULL, NULL ); + if ( 0 != memLeaks ) { + psAbort( __func__, "Memory Leaks! (%d leaks)", memLeaks ); } - if (nb == 4) { - IMAGE_X_SIZE = N; - IMAGE_Y_SIZE = M; - } - if (nb == 5) { - IMAGE_X_SIZE = M; - IMAGE_Y_SIZE = N; - } - printf("*******************************\n"); - printf("* IMAGE SIZE is (%d by %d)\n", IMAGE_X_SIZE, IMAGE_Y_SIZE); - printf("*******************************\n"); - /*********************************************************************/ - /* Allocate and initialize data structures */ - /*********************************************************************/ - tmpImage = psImageAlloc(IMAGE_X_SIZE, IMAGE_Y_SIZE, PS_TYPE_F32); - - for (i=0;inumRows;i++) { - for (j=0;jnumCols;j++) { - tmpImage->data.F32[i][j] = (float) (i + j + 0.1); - } - } - tmpMask = psImageAlloc(IMAGE_X_SIZE, IMAGE_Y_SIZE, PS_TYPE_U8); - for (i=0;inumRows;i++) { - for (j=0;jnumCols;j++) { - if ((i > (tmpMask->numRows/2)) && - (j > (tmpMask->numCols/2))) { - tmpMask->data.U8[i][j] = 1; - } else { - tmpMask->data.U8[i][j] = 0; - } - } - } - - /*************************************************************************/ - /* Calculate Histogram with no mask */ - /*************************************************************************/ - printPositiveTestHeader(stdout, - "psImageStats functions", - "Calculate Histogram, no mask"); - - myHist = psHistogramAlloc(0.0, (float) (IMAGE_X_SIZE + IMAGE_Y_SIZE), - NUM_BINS); - myHist = psImageHistogram(myHist, tmpImage, NULL, 0); - for (i=0;ibounds->data.F32[i], - myHist->bounds->data.F32[i+1], - myHist->nums->data.S32[i]); - } - psFree(myHist); - - psMemCheckCorruption(1); - printFooter(stdout, - "psImageStats functions", - "Calculate Histogram, no mask", - testStatus); - - /*************************************************************************/ - /* Calculate Histogram with mask */ - /*************************************************************************/ - printPositiveTestHeader(stdout, - "psImageStats functions", - "Calculate Histogram with mask"); - - myHist = psHistogramAlloc(0.0, (float) (IMAGE_X_SIZE + IMAGE_Y_SIZE), - NUM_BINS); - myHist = psImageHistogram(myHist, tmpImage, tmpMask, 1); - for (i=0;ibounds->data.F32[i], - myHist->bounds->data.F32[i+1], - myHist->nums->data.S32[i]); - } - - psMemCheckCorruption(1); - printFooter(stdout, - "psImageStats functions", - "Calculate Histogram with mask", - testStatus); - - /*************************************************************************/ - /* Deallocate data structures */ - /*************************************************************************/ - printPositiveTestHeader(stdout, - "psImageStats functions", - "Deallocate the psHistogram/psImage structure."); - psFree(myHist); - psFree(tmpImage); - psFree(tmpMask); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,NULL); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psImageStats functions", - "Deallocate the psHistogram/psImage structure.", - testStatus); - } - printPositiveTestHeader(stdout, - "psImageStats functions", - "Calling psImageHistogram() with NULL parameters"); - - tmpImage = psImageAlloc(IMAGE_X_SIZE, IMAGE_Y_SIZE, PS_TYPE_F32); - myHist = psHistogramAlloc(0.0, (float) (IMAGE_X_SIZE + IMAGE_Y_SIZE), - NUM_BINS); - myHist2 = psImageHistogram(NULL, tmpImage, NULL, 0); - if (myHist2 != NULL) { - printf("ERROR: myHist2 not equal to NULL\n"); - } - - myHist2 = psImageHistogram(myHist, NULL, NULL, 0); - myHist2 = psImageHistogram(NULL, tmpImage, NULL, 0); - if (myHist2 != NULL) { - printf("ERROR: myHist2 not equal to NULL\n"); - } - - psMemCheckCorruption(1); - psFree(myHist); - psFree(tmpImage); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,NULL); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psImageStats functions", - "Calling psImageHistogram() with NULL parameters", - testStatus); - - return (!testStatus); + + printFooter( stdout, + "psImageStats functions", + "Calling psImageHistogram() with NULL parameters", + testStatus ); + + return ( !testStatus ); } Index: /trunk/psLib/test/image/tst_psImageStats01.c =================================================================== --- /trunk/psLib/test/image/tst_psImageStats01.c (revision 1364) +++ /trunk/psLib/test/image/tst_psImageStats01.c (revision 1365) @@ -1,8 +1,8 @@ /***************************************************************************** - This routine must ensure that the psImageStats() routine can correctly - call the psVectorStats() routine. Since the psVectorStats() will be - thouroughly tested elsewhere, we will only test psImageStats() with - the PS_STAT_SAMPLE_MEAN here. - *****************************************************************************/ + This routine must ensure that the psImageStats() routine can correctly + call the psVectorStats() routine. Since the psVectorStats() will be + thouroughly tested elsewhere, we will only test psImageStats() with + the PS_STAT_SAMPLE_MEAN here. +*****************************************************************************/ #include #include "pslib.h" @@ -17,163 +17,163 @@ int main() { - psStats *myStats = NULL; - psStats *myStats2 = NULL; - psImage *tmpImage = NULL; - psImage *tmpMask = NULL; - int testStatus = true; - int memLeaks = 0; - int nb = 0; - int i = 0; - int j = 0; - int IMAGE_X_SIZE = 0; - int IMAGE_Y_SIZE = 0; - int currentId = 0; - - currentId = psMemGetId(); - for (nb=0;nb<6;nb++) { - if (nb == 0) { - IMAGE_X_SIZE = 1; - IMAGE_Y_SIZE = 1; + psStats * myStats = NULL; + psStats *myStats2 = NULL; + psImage *tmpImage = NULL; + psImage *tmpMask = NULL; + int testStatus = true; + int memLeaks = 0; + int nb = 0; + int i = 0; + int j = 0; + int IMAGE_X_SIZE = 0; + int IMAGE_Y_SIZE = 0; + int currentId = 0; + + currentId = psMemGetId(); + for ( nb = 0;nb < 6;nb++ ) { + if ( nb == 0 ) { + IMAGE_X_SIZE = 1; + IMAGE_Y_SIZE = 1; + } + if ( nb == 1 ) { + IMAGE_X_SIZE = 1; + IMAGE_Y_SIZE = N; + } + if ( nb == 2 ) { + IMAGE_X_SIZE = N; + IMAGE_Y_SIZE = 1; + } + if ( nb == 3 ) { + IMAGE_X_SIZE = N; + IMAGE_Y_SIZE = N; + } + if ( nb == 4 ) { + IMAGE_X_SIZE = N; + IMAGE_Y_SIZE = M; + } + if ( nb == 5 ) { + IMAGE_X_SIZE = M; + IMAGE_Y_SIZE = N; + } + printf( "*******************************\n" ); + printf( "* IMAGE SIZE is (%d by %d)\n", IMAGE_X_SIZE, IMAGE_Y_SIZE ); + printf( "*******************************\n" ); + + /*************************************************************************/ + /* Allocate and initialize data structures */ + /*************************************************************************/ + tmpImage = psImageAlloc( IMAGE_X_SIZE, IMAGE_Y_SIZE, PS_TYPE_F32 ); + + for ( i = 0;i < tmpImage->numRows;i++ ) { + for ( j = 0;j < tmpImage->numCols;j++ ) { + tmpImage->data.F32[ i ][ j ] = ( float ) ( i + j ); + } + } + tmpMask = psImageAlloc( IMAGE_X_SIZE, IMAGE_Y_SIZE, PS_TYPE_U8 ); + for ( i = 0;i < tmpMask->numRows;i++ ) { + for ( j = 0;j < tmpMask->numCols;j++ ) { + if ( ( i > ( tmpMask->numRows / 2 ) ) && + ( j > ( tmpMask->numCols / 2 ) ) ) { + tmpMask->data.U8[ i ][ j ] = 1; + } else { + tmpMask->data.U8[ i ][ j ] = 0; + } + } + } + + myStats = psStatsAlloc( PS_STAT_SAMPLE_MEAN ); + /*************************************************************************/ + /* Calculate Sample Mean with no mask */ + /*************************************************************************/ + printPositiveTestHeader( stdout, + "psImageStats functions", + "Calculate Sample Mean, no mask %d" ); + + myStats = psImageStats( myStats, tmpImage, NULL, 0 ); + printf( "The sample mean was %.2f\n", myStats->sampleMean ); + + psMemCheckCorruption( 1 ); + + printFooter( stdout, + "psImageStats functions", + "Calculate Sample Mean, no mask", + testStatus ); + + /*************************************************************************/ + /* Calculate Sample Mean with mask */ + /*************************************************************************/ + printPositiveTestHeader( stdout, + "psImageStats functions", + "Calculate Sample Mean with mask" ); + + myStats = psImageStats( myStats, tmpImage, tmpMask, 1 ); + printf( "The sample mean was %.2f\n", myStats->sampleMean ); + + psMemCheckCorruption( 1 ); + + printFooter( stdout, + "psImageStats functions", + "Calculate Sample Mean with mask", + testStatus ); + + /*************************************************************************/ + /* Deallocate data structures */ + /*************************************************************************/ + printPositiveTestHeader( stdout, + "psImageStats functions", + "Deallocate the psStats/psImage structure." ); + psFree( myStats ); + psFree( tmpImage ); + psFree( tmpMask ); + + psMemCheckCorruption( 1 ); + memLeaks = psMemCheckLeaks( currentId, NULL, NULL ); + if ( 0 != memLeaks ) { + psAbort( __func__, "Memory Leaks! (%d leaks)", memLeaks ); + } + + printFooter( stdout, + "psImageStats functions", + "Deallocate the psStats/psImage structure.", + testStatus ); } - if (nb == 1) { - IMAGE_X_SIZE = 1; - IMAGE_Y_SIZE = N; - } - if (nb == 2) { - IMAGE_X_SIZE = N; - IMAGE_Y_SIZE = 1; - } - if (nb == 3) { - IMAGE_X_SIZE = N; - IMAGE_Y_SIZE = N; - } - if (nb == 4) { - IMAGE_X_SIZE = N; - IMAGE_Y_SIZE = M; - } - if (nb == 5) { - IMAGE_X_SIZE = M; - IMAGE_Y_SIZE = N; - } - printf("*******************************\n"); - printf("* IMAGE SIZE is (%d by %d)\n", IMAGE_X_SIZE, IMAGE_Y_SIZE); - printf("*******************************\n"); - - /*************************************************************************/ - /* Allocate and initialize data structures */ - /*************************************************************************/ - tmpImage = psImageAlloc(IMAGE_X_SIZE, IMAGE_Y_SIZE, PS_TYPE_F32); - - for (i=0;inumRows;i++) { - for (j=0;jnumCols;j++) { - tmpImage->data.F32[i][j] = (float) (i + j); - } - } - tmpMask = psImageAlloc(IMAGE_X_SIZE, IMAGE_Y_SIZE, PS_TYPE_U8); - for (i=0;inumRows;i++) { - for (j=0;jnumCols;j++) { - if ((i > (tmpMask->numRows/2)) && - (j > (tmpMask->numCols/2))) { - tmpMask->data.U8[i][j] = 1; - } else { - tmpMask->data.U8[i][j] = 0; - } - } - } - - myStats = psStatsAlloc(PS_STAT_SAMPLE_MEAN); - /*************************************************************************/ - /* Calculate Sample Mean with no mask */ - /*************************************************************************/ - printPositiveTestHeader(stdout, - "psImageStats functions", - "Calculate Sample Mean, no mask %d"); - - myStats = psImageStats(myStats, tmpImage, NULL, 0); - printf("The sample mean was %f\n", myStats->sampleMean); - - psMemCheckCorruption(1); - - printFooter(stdout, - "psImageStats functions", - "Calculate Sample Mean, no mask", - testStatus); - - /*************************************************************************/ - /* Calculate Sample Mean with mask */ - /*************************************************************************/ - printPositiveTestHeader(stdout, - "psImageStats functions", - "Calculate Sample Mean with mask"); - - myStats = psImageStats(myStats, tmpImage, tmpMask, 1); - printf("The sample mean was %f\n", myStats->sampleMean); - - psMemCheckCorruption(1); - - printFooter(stdout, - "psImageStats functions", - "Calculate Sample Mean with mask", - testStatus); - - /*************************************************************************/ - /* Deallocate data structures */ - /*************************************************************************/ - printPositiveTestHeader(stdout, - "psImageStats functions", - "Deallocate the psStats/psImage structure."); - psFree(myStats); - psFree(tmpImage); - psFree(tmpMask); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,NULL); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psImageStats functions", - "Deallocate the psStats/psImage structure.", - testStatus); - } - + /*************************************************************************/ /* Test With Various Null Inputs */ /*************************************************************************/ - printPositiveTestHeader(stdout, - "psImageStats functions", - "Test With Various Null Inputs"); - - tmpImage = psImageAlloc(IMAGE_X_SIZE, IMAGE_Y_SIZE, PS_TYPE_F32); - tmpMask = psImageAlloc(IMAGE_X_SIZE, IMAGE_Y_SIZE, PS_TYPE_U8); - myStats = psStatsAlloc(0); - - myStats2 = psImageStats(myStats, NULL, NULL, 0); - if (myStats2 != NULL) { - printf("ERROR: myStats2 = psImageStats(myStats, NULL, NULL, 0) != NULL\n"); - } - - myStats2 = psImageStats(NULL, tmpImage, NULL, 0); - if (myStats2 != NULL) { - printf("ERROR: myStats2 = psImageStats(NULL, tmpImage, NULL, 0) != NULL\n"); - } - - myStats2 = psImageStats(myStats, tmpImage, NULL, 0); - - psFree(myStats); - psFree(tmpImage); - psFree(tmpMask); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,NULL); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psImageStats functions", - "Test With Various Null Inputs", - testStatus); - return (!testStatus); + printPositiveTestHeader( stdout, + "psImageStats functions", + "Test With Various Null Inputs" ); + + tmpImage = psImageAlloc( IMAGE_X_SIZE, IMAGE_Y_SIZE, PS_TYPE_F32 ); + tmpMask = psImageAlloc( IMAGE_X_SIZE, IMAGE_Y_SIZE, PS_TYPE_U8 ); + myStats = psStatsAlloc( 0 ); + + myStats2 = psImageStats( myStats, NULL, NULL, 0 ); + if ( myStats2 != NULL ) { + printf( "ERROR: myStats2 = psImageStats(myStats, NULL, NULL, 0) != NULL\n" ); + } + + myStats2 = psImageStats( NULL, tmpImage, NULL, 0 ); + if ( myStats2 != NULL ) { + printf( "ERROR: myStats2 = psImageStats(NULL, tmpImage, NULL, 0) != NULL\n" ); + } + + myStats2 = psImageStats( myStats, tmpImage, NULL, 0 ); + + psFree( myStats ); + psFree( tmpImage ); + psFree( tmpMask ); + + psMemCheckCorruption( 1 ); + memLeaks = psMemCheckLeaks( currentId, NULL, NULL ); + if ( 0 != memLeaks ) { + psAbort( __func__, "Memory Leaks! (%d leaks)", memLeaks ); + } + + printFooter( stdout, + "psImageStats functions", + "Test With Various Null Inputs", + testStatus ); + return ( !testStatus ); } Index: /trunk/psLib/test/image/tst_psImageStats02.c =================================================================== --- /trunk/psLib/test/image/tst_psImageStats02.c (revision 1364) +++ /trunk/psLib/test/image/tst_psImageStats02.c (revision 1365) @@ -1,11 +1,11 @@ /***************************************************************************** - This routine must ensure that the psImageStats() routine can correctly - call the psVectorStats() routine. Since the psVectorStats() will be - thouroughly tested elsewhere, we will only test psImageStats() with - the PS_STAT_SAMPLE_MEAN here. - - NOTE: After you debug, set CHEBY_X_DIM != CHEBY_Y_DIM. - Also, uses non-square images. - *****************************************************************************/ + This routine must ensure that the psImageStats() routine can correctly + call the psVectorStats() routine. Since the psVectorStats() will be + thouroughly tested elsewhere, we will only test psImageStats() with + the PS_STAT_SAMPLE_MEAN here. + + NOTE: After you debug, set CHEBY_X_DIM != CHEBY_Y_DIM. + Also, uses non-square images. +*****************************************************************************/ #include #include "pslib.h" @@ -19,103 +19,103 @@ #define CHEBY_X_DIM 8 #define CHEBY_Y_DIM 8 -#define THRESHOLD 1.0 +#define THRESHOLD 10 int main() { - psStats *myStats = NULL; - psImage *tmpImage = NULL; - psImage *outImage = NULL; + psStats * myStats = NULL; + psImage *tmpImage = NULL; + psImage *outImage = NULL; psPolynomial2D *my2DPoly = NULL; - int testStatus = true; - int memLeaks = 0; - int i = 0; - int j = 0; - int rc = 0; - int currentId = 0; - - currentId = psMemGetId(); + int testStatus = true; + int memLeaks = 0; + int i = 0; + int j = 0; + int rc = 0; + int currentId = 0; + + currentId = psMemGetId(); /*************************************************************************/ /* Allocate and initialize data structures */ /*************************************************************************/ - tmpImage = psImageAlloc(IMAGE_SIZE, IMAGE_SIZE, PS_TYPE_F32); - outImage = psImageAlloc(IMAGE_SIZE, IMAGE_SIZE, PS_TYPE_F32); - for (i=0;idata.F32[i][j] = 4.0; - tmpImage->data.F32[i][j] = (float) (i + j); - tmpImage->data.F32[i][j] = (float) (i + j) + (4.0 * (float) i); - outImage->data.F32[i][j] = 0.0; + tmpImage = psImageAlloc( IMAGE_SIZE, IMAGE_SIZE, PS_TYPE_F32 ); + outImage = psImageAlloc( IMAGE_SIZE, IMAGE_SIZE, PS_TYPE_F32 ); + for ( i = 0;i < IMAGE_SIZE;i++ ) { + for ( j = 0;j < IMAGE_SIZE;j++ ) { + tmpImage->data.F32[ i ][ j ] = 4.0; + tmpImage->data.F32[ i ][ j ] = ( float ) ( i + j ); + tmpImage->data.F32[ i ][ j ] = ( float ) ( i + j ) + ( 4.0 * ( float ) i ); + outImage->data.F32[ i ][ j ] = 0.0; + } } - } - my2DPoly = psPolynomial2DAlloc(CHEBY_X_DIM, CHEBY_Y_DIM); + my2DPoly = psPolynomial2DAlloc( CHEBY_X_DIM, CHEBY_Y_DIM ); /*************************************************************************/ /* Calculate Chebyshev Polynomials, no mask */ /*************************************************************************/ - printPositiveTestHeader(stdout, - "psImageStats functions", - "Calculate Chebyshev Polynomials, no mask"); - - my2DPoly = psImageFitPolynomial(tmpImage, my2DPoly); - for (i=0;icoeff[i][j]); + printPositiveTestHeader( stdout, + "psImageStats functions", + "Calculate Chebyshev Polynomials, no mask" ); + + my2DPoly = psImageFitPolynomial( tmpImage, my2DPoly ); + for ( i = 0;i < CHEBY_X_DIM;i++ ) { + for ( j = 0;j < CHEBY_Y_DIM;j++ ) { + printf( "Cheby Polynomial (%d, %d) coefficient is %.2f\n", i, j, my2DPoly->coeff[ i ][ j ] ); + } } - } - - psMemCheckCorruption(1); - printFooter(stdout, - "psImageStats functions", - "Calculate Chebyshev Polynomials, no mask", - testStatus); + + psMemCheckCorruption( 1 ); + printFooter( stdout, + "psImageStats functions", + "Calculate Chebyshev Polynomials, no mask", + testStatus ); /*************************************************************************/ /* Evaluate Chebyshev Polynomials, no mask */ /*************************************************************************/ - printPositiveTestHeader(stdout, - "psImageStats functions", - "Calculate Chebyshev Polynomials, no mask"); - - rc = psImageEvalPolynomial(outImage, my2DPoly); - for (i=0;idata.F32[i][j], - // outImage->data.F32[i][j]); - if (fabs(outImage->data.F32[i][j] - tmpImage->data.F32[i][j]) > THRESHOLD) { - printf("Pixel (%d, %d) is %f, should be %f\n", i, j, - outImage->data.F32[i][j], - tmpImage->data.F32[i][j]); - } - + printPositiveTestHeader( stdout, + "psImageStats functions", + "Calculate Chebyshev Polynomials, no mask" ); + + rc = psImageEvalPolynomial( outImage, my2DPoly ); + for ( i = 0;i < IMAGE_SIZE;i++ ) { + for ( j = 0;j < IMAGE_SIZE;j++ ) { + + // printf("pixel[%d][%d] is (%f, %f)\n", i, j, + // tmpImage->data.F32[i][j], + // outImage->data.F32[i][j]); + if ( fabs( outImage->data.F32[ i ][ j ] - tmpImage->data.F32[ i ][ j ] ) > THRESHOLD ) { + printf( "Pixel (%d, %d) is %.2f, should be %.2f\n", i, j, + outImage->data.F32[ i ][ j ], + tmpImage->data.F32[ i ][ j ] ); + } + + } } - } - - psMemCheckCorruption(1); - printFooter(stdout, - "psImageStats functions", - "Calculate Chebyshev Polynomials, no mask", - testStatus); - + + psMemCheckCorruption( 1 ); + printFooter( stdout, + "psImageStats functions", + "Calculate Chebyshev Polynomials, no mask", + testStatus ); + /*************************************************************************/ /* Deallocate data structures */ /*************************************************************************/ - printPositiveTestHeader(stdout, - "psImageStats functions", - "Deallocate the psStats/psImage structure."); - psFree(myStats); - psFree(tmpImage); - psFree(outImage); - psFree(my2DPoly); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,NULL); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psImageStats functions", - "Deallocate the psStats/psImage structure.", - testStatus); - - return (!testStatus); + printPositiveTestHeader( stdout, + "psImageStats functions", + "Deallocate the psStats/psImage structure." ); + psFree( myStats ); + psFree( tmpImage ); + psFree( outImage ); + psFree( my2DPoly ); + + psMemCheckCorruption( 1 ); + memLeaks = psMemCheckLeaks( currentId, NULL, NULL ); + if ( 0 != memLeaks ) { + psAbort( __func__, "Memory Leaks! (%d leaks)", memLeaks ); + } + + printFooter( stdout, + "psImageStats functions", + "Deallocate the psStats/psImage structure.", + testStatus ); + + return ( !testStatus ); } Index: /trunk/psLib/test/image/verified/tst_psImageExtraction.stderr =================================================================== --- /trunk/psLib/test/image/verified/tst_psImageExtraction.stderr (revision 1365) +++ /trunk/psLib/test/image/verified/tst_psImageExtraction.stderr (revision 1365) @@ -0,0 +1,27 @@ +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_psImageExtraction.c * +* TestPoint: psImage{psImageSlice} * +* TestType: Positive * +\**********************************************************************************/ + +