Changeset 1365

Timestamp:

Aug 2, 2004, 9:43:23 AM (22 years ago)

Author:

desonia

Message:

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

Location:

trunk/psLib/test

Files:

• dataManip/tst_psHist02.c (modified) (3 diffs)
• dataManip/tst_psMatrixVectorArithmetic02.c (modified) (8 diffs)
• dataManip/tst_psStats07.c (modified) (3 diffs)
• dataManip/tst_psVectorFFT.c (modified) (8 diffs)
• dataManip/verified/tst_psHist02.stdout (modified) (4 diffs)
• dataManip/verified/tst_psMatrixVectorArithmetic02.stdout (modified) (106 diffs)
• dataManip/verified/tst_psStats07.stdout (modified) (8 diffs)
• image/tst_psImageStats00.c (modified) (2 diffs)
• image/tst_psImageStats01.c (modified) (2 diffs)
• image/tst_psImageStats02.c (modified) (2 diffs)
• image/verified/tst_psImageExtraction.stderr (added)
• image/verified/tst_psImageStats00.stderr (added)
• image/verified/tst_psImageStats00.stdout (modified) (6 diffs)
• image/verified/tst_psImageStats01.stderr (added)
• image/verified/tst_psImageStats01.stdout (modified) (6 diffs)
• image/verified/tst_psImageStats02.stdout (modified) (2 diffs)
• sysUtils/tst_psMemory.c (modified) (7 diffs)
• sysUtils/verified/tst_psMemory.stderr (modified) (5 diffs)

trunk/psLib/test/dataManip/tst_psHist02.c

@@ -1 +1 @@
 /*****************************************************************************
-    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 <stdio.h>
 #include "pslib.h"
@@ -16 +16 @@
 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;i<NUM_DATA;i++) {
-        myData->data.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;i++) {
-        if (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;i<numBins;i++) {
-            printf("Bin number %d bounds: (%f - %f) data (%d)\n", i,
-                   myHist->bounds->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;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);
-    }
-    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 +155 @@
     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 );
 }

trunk/psLib/test/dataManip/tst_psMatrixVectorArithmetic02.c

@@ -10 +10 @@
  *  @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 +25 @@
 #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 +36 @@
 #define PRINT_VECTOR(VECTOR,TYPE)                                                                            \
 for(int i=0; i<VECTOR->n; 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 +49 @@
 #define PRINT_MATRIX(IMAGE,TYPE)                                                                             \
 for(int i=IMAGE->numRows-1; i>-1; i--) {                                                                     \
-    for(int j=0; j<IMAGE->numCols; 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; j<IMAGE->numCols; 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 +66 @@
 psVector *NAME = (psVector*)psVectorAlloc(SIZE, PS_TYPE_##TYPE);                                             \
 for(int i=0; i<SIZE; i++) {                                                                                  \
-    NAME->data.TYPE[i] = VALUE;                                                                              \
-}                                                                                                            \
+        NAME->data.TYPE[i] = VALUE;                                                                              \
+    }                                                                                                            \
 NAME->n = SIZE;
 
@@ -74 +74 @@
 psImage *NAME = (psImage*)psImageAlloc(NCOLS,NROWS,PS_TYPE_##TYPE);                                          \
 for(int i=0; i<NAME->numRows; i++) {                                                                         \
-    for(int j=0; j<NAME->numCols; j++) {                                                                     \
-        NAME->data.TYPE[i][j] = VALUE;                                                                       \
-    }                                                                                                        \
-}
-
-
+        for(int j=0; j<NAME->numCols; 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 +109 @@
         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 +198 @@
         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;
 }

trunk/psLib/test/dataManip/tst_psStats07.c

@@ -1 +1 @@
 /*****************************************************************************
-    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 <stdio.h>
 #include "pslib.h"
@@ -17 +17 @@
 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 +43 @@
     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;i<N;i++) {
-        if (i < (N/2)) {
-            maskVector->data.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 );
 }

trunk/psLib/test/dataManip/tst_psVectorFFT.c

@@ -1 +1 @@
 /** @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 <math.h>
@@ -21 +21 @@
 img = psImageAlloc(c,r,PS_TYPE_##TYP); \
 for (unsigned int row=0;row<r;row++) { \
-    ps##TYP* imgRow = img->data.TYP[row]; \
-    for (unsigned int col=0;col<c;col++) { \
-        imgRow[col] = (ps##TYP)(valueFcn); \
-    } \
-}
-
-static int testVectorFFT(void);
-static int testVectorRealImaginary(void);
-static int testVectorComplex(void);
-static int testVectorConjugate(void);
-static int testVectorPowerSpectrum(void);
+        ps##TYP* imgRow = img->data.TYP[row]; \
+        for (unsigned int col=0;col<c;col++) { \
+                imgRow[col] = (ps##TYP)(valueFcn); \
+            } \
+    }
+    
+static int testVectorFFT( void );
+static int testVectorRealImaginary( void );
+static int testVectorComplex( void );
+static int testVectorConjugate( void );
+static int testVectorPowerSpectrum( void );
 
 testDescription tests[] = {
-                              {testVectorFFT,600,"psVectorFFT",0,false},
-                              {testVectorRealImaginary,601,"psVectorRealImaginary",0,false},
-                              {testVectorComplex,602,"psVectorComplex",0,false},
-                              {testVectorConjugate,603,"psVectorConjugate",0,false},
-                              {testVectorPowerSpectrum,604,"psVectorPowerSpectrum",0,false},
-                              {NULL}
+                              {
+                                  testVectorFFT, 600, "psVectorFFT", 0, false
+                              },
+                              {
+                                  testVectorRealImaginary, 601, "psVectorRealImaginary", 0, false
+                              },
+                              {
+                                  testVectorComplex, 602, "psVectorComplex", 0, false
+                              },
+                              {
+                                  testVectorConjugate, 603, "psVectorConjugate", 0, false
+                              },
+                              {
+                                  testVectorPowerSpectrum, 604, "psVectorPowerSpectrum", 0, false
+                              },
+                              {
+                                  NULL
+                              }
                           };
-
-int main(int argc, char* argv[])
-{
-    psLogSetLevel(PS_LOG_INFO);
-
-    if (! runTestSuite(stderr,"psFFT",tests,argc,argv) ) {
-        psAbort(__FILE__,"One or more tests failed");
-    }
-    return 0;
-}
-
-int testVectorFFT(void)
-{
-    psVector* vec = NULL;
+                          
+int main( int argc, char* argv[] )
+{
+    psLogSetLevel( PS_LOG_INFO );
+    
+    return ( ! runTestSuite( stderr, "psFFT", tests, argc, argv ) );
+}
+
+int testVectorFFT( void )
+{
+    psVector * vec = NULL;
     psVector* vec2 = NULL;
     psVector* vec3 = NULL;
-
+    
     /*
     1. assign a vector to a sinisoid
@@ -65 +74 @@
     5. compare to original (should be equal to within a reasonable error)
     */
-
+    
     // 1. assign a vector to a sinisoid
-    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);
-    }
-
+    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 +139 @@
     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 +205 @@
     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 +289 @@
     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 +334 @@
     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 +357 @@
     //   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;
+}

trunk/psLib/test/dataManip/verified/tst_psHist02.stdout

@@ -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 +25 @@
 \**********************************************************************************/
 
-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 +47 @@
 \**********************************************************************************/
 
-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 +85 @@
 \**********************************************************************************/
 
-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)

trunk/psLib/test/dataManip/verified/tst_psMatrixVectorArithmetic02.stdout

@@ -31 +31 @@
 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 +55 @@
 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 +79 @@
 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 +127 @@
 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 +151 @@
 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 +175 @@
 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 +223 @@
 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 +247 @@
 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 +271 @@
 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 +319 @@
 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 +343 @@
 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 +367 @@
 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 +415 @@
 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 +439 @@
 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 +463 @@
 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 +511 @@
 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 +535 @@
 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 +559 @@
 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 +607 @@
 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 +631 @@
 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 +655 @@
 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 +703 @@
 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 +727 @@
 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 +751 @@
 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 +799 @@
 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 +823 @@
 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 +847 @@
 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 +895 @@
 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 +919 @@
 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 +943 @@
 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 +991 @@
 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 +1015 @@
 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 +1039 @@
 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 +1087 @@
 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 +1111 @@
 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 +1135 @@
 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 +1168 @@
 
 Output:
-89 89 
-89 89 
-89 89 
+90 90 
+90 90 
+90 90 
 
 
@@ -1183 +1183 @@
 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 +1207 @@
 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 +1231 @@
 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 +1279 @@
 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 +1303 @@
 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 +1327 @@
 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 +1360 @@
 
 Output:
-89 89 
-89 89 
-89 89 
+90 90 
+90 90 
+90 90 
 
 
@@ -1375 +1375 @@
 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 +1399 @@
 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 +1423 @@
 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 +1471 @@
 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 +1495 @@
 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 +1519 @@
 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 +1567 @@
 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 +1591 @@
 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 +1615 @@
 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 +1663 @@
 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 +1687 @@
 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 +1711 @@
 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 +1759 @@
 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 +1783 @@
 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 +1807 @@
 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 +1855 @@
 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 +1879 @@
 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 +1903 @@
 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 +1951 @@
 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 +1975 @@
 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 +1999 @@
 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 +2047 @@
 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 +2071 @@
 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 +2095 @@
 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 +2143 @@
 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 +2167 @@
 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 +2191 @@
 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 +2239 @@
 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 +2263 @@
 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 +2287 @@
 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 +2335 @@
 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 +2359 @@
 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 +2383 @@
 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 +2431 @@
 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 +2455 @@
 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 +2479 @@
 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 +2527 @@
 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 +2551 @@
 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 +2575 @@
 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 +2623 @@
 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 +2647 @@
 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 +2671 @@
 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 +2719 @@
 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 +2743 @@
 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 +2767 @@
 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 +2800 @@
 
 Output:
-89
-89
-89
+90
+90
+90
 
 
@@ -2815 +2815 @@
 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 +2839 @@
 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 +2863 @@
 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 +2911 @@
 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 +2935 @@
 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 +2959 @@
 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 +2992 @@
 
 Output:
-89
-89
-89
+90
+90
+90
 
 
@@ -3007 +3007 @@
 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 +3031 @@
 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 +3055 @@
 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 +3103 @@
 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 +3127 @@
 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 +3151 @@
 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 +3199 @@
 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 +3223 @@
 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 +3247 @@
 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)
+

trunk/psLib/test/dataManip/verified/tst_psStats07.stdout

@@ -6 +6 @@
 
 (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 +16 @@
 \**********************************************************************************/
 
-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 +26 @@
 \**********************************************************************************/
 
-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 +36 @@
 \**********************************************************************************/
 
-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 +46 @@
 \**********************************************************************************/
 
-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 +56 @@
 \**********************************************************************************/
 
-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 +66 @@
 \**********************************************************************************/
 
-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 +76 @@
 \**********************************************************************************/
 
-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)

trunk/psLib/test/image/tst_psImageStats00.c

@@ -1 +1 @@
 /*****************************************************************************
-    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 <stdio.h>
 #include "pslib.h"
@@ -16 +16 @@
 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;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: (%f - %f) 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: (%f - %f) 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);
-    }
-    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 );
 }

trunk/psLib/test/image/tst_psImageStats01.c

@@ -1 +1 @@
 /*****************************************************************************
-    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 <stdio.h>
 #include "pslib.h"
@@ -17 +17 @@
 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;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 %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 );
 }

trunk/psLib/test/image/tst_psImageStats02.c

@@ -1 +1 @@
 /*****************************************************************************
-    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 <stdio.h>
 #include "pslib.h"
@@ -19 +19 @@
 #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;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;
+    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;i<CHEBY_X_DIM;i++) {
-        for (j=0;j<CHEBY_Y_DIM;j++) {
-            printf("Cheby Polynomial (%d, %d) coefficient is %f\n", i, j, my2DPoly->coeff[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;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 %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 );
 }

trunk/psLib/test/image/verified/tst_psImageStats00.stdout

@@ -8 +8 @@
 \**********************************************************************************/
 
-Bin number 0 bounds: (0.000000 - 0.100000) data (0)
-Bin number 1 bounds: (0.100000 - 0.200000) data (1)
-Bin number 2 bounds: (0.200000 - 0.300000) data (0)
-Bin number 3 bounds: (0.300000 - 0.400000) data (0)
-Bin number 4 bounds: (0.400000 - 0.500000) data (0)
-Bin number 5 bounds: (0.500000 - 0.600000) data (0)
-Bin number 6 bounds: (0.600000 - 0.700000) data (0)
-Bin number 7 bounds: (0.700000 - 0.800000) data (0)
-Bin number 8 bounds: (0.800000 - 0.900000) data (0)
-Bin number 9 bounds: (0.900000 - 1.000000) data (0)
-Bin number 10 bounds: (1.000000 - 1.100000) data (0)
-Bin number 11 bounds: (1.100000 - 1.200000) data (0)
-Bin number 12 bounds: (1.200000 - 1.300000) data (0)
-Bin number 13 bounds: (1.300000 - 1.400000) data (0)
-Bin number 14 bounds: (1.400000 - 1.500000) data (0)
-Bin number 15 bounds: (1.500000 - 1.600000) data (0)
-Bin number 16 bounds: (1.600000 - 1.700000) data (0)
-Bin number 17 bounds: (1.700000 - 1.800000) data (0)
-Bin number 18 bounds: (1.800000 - 1.900000) data (0)
-Bin number 19 bounds: (1.900000 - 2.000000) data (0)
-
----> TESTPOINT PASSED (psImageStats functions{Calculate Histogram, no mask} | tst_psImageStats00.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psImageStats00.c                                       *
-*            TestPoint: psImageStats functions{Calculate Histogram with mask}      *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-Bin number 0 bounds: (0.000000 - 0.100000) data (0)
-Bin number 1 bounds: (0.100000 - 0.200000) data (1)
-Bin number 2 bounds: (0.200000 - 0.300000) data (0)
-Bin number 3 bounds: (0.300000 - 0.400000) data (0)
-Bin number 4 bounds: (0.400000 - 0.500000) data (0)
-Bin number 5 bounds: (0.500000 - 0.600000) data (0)
-Bin number 6 bounds: (0.600000 - 0.700000) data (0)
-Bin number 7 bounds: (0.700000 - 0.800000) data (0)
-Bin number 8 bounds: (0.800000 - 0.900000) data (0)
-Bin number 9 bounds: (0.900000 - 1.000000) data (0)
-Bin number 10 bounds: (1.000000 - 1.100000) data (0)
-Bin number 11 bounds: (1.100000 - 1.200000) data (0)
-Bin number 12 bounds: (1.200000 - 1.300000) data (0)
-Bin number 13 bounds: (1.300000 - 1.400000) data (0)
-Bin number 14 bounds: (1.400000 - 1.500000) data (0)
-Bin number 15 bounds: (1.500000 - 1.600000) data (0)
-Bin number 16 bounds: (1.600000 - 1.700000) data (0)
-Bin number 17 bounds: (1.700000 - 1.800000) data (0)
-Bin number 18 bounds: (1.800000 - 1.900000) data (0)
-Bin number 19 bounds: (1.900000 - 2.000000) data (0)
+Bin number 0 bounds: (0.0 - 0.1) data (1)
+Bin number 1 bounds: (0.1 - 0.2) data (0)
+Bin number 2 bounds: (0.2 - 0.3) data (0)
+Bin number 3 bounds: (0.3 - 0.4) data (0)
+Bin number 4 bounds: (0.4 - 0.5) data (0)
+Bin number 5 bounds: (0.5 - 0.6) data (0)
+Bin number 6 bounds: (0.6 - 0.7) data (0)
+Bin number 7 bounds: (0.7 - 0.8) data (0)
+Bin number 8 bounds: (0.8 - 0.9) data (0)
+Bin number 9 bounds: (0.9 - 1.0) data (0)
+Bin number 10 bounds: (1.0 - 1.1) data (0)
+Bin number 11 bounds: (1.1 - 1.2) data (0)
+Bin number 12 bounds: (1.2 - 1.3) data (0)
+Bin number 13 bounds: (1.3 - 1.4) data (0)
+Bin number 14 bounds: (1.4 - 1.5) data (0)
+Bin number 15 bounds: (1.5 - 1.6) data (0)
+Bin number 16 bounds: (1.6 - 1.7) data (0)
+Bin number 17 bounds: (1.7 - 1.8) data (0)
+Bin number 18 bounds: (1.8 - 1.9) data (0)
+Bin number 19 bounds: (1.9 - 2.0) data (0)
+
+---> TESTPOINT PASSED (psImageStats functions{Calculate Histogram, no mask} | tst_psImageStats00.c)
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psImageStats00.c                                       *
+*            TestPoint: psImageStats functions{Calculate Histogram with mask}      *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+Bin number 0 bounds: (0.00 - 0.10) data (1)
+Bin number 1 bounds: (0.10 - 0.20) data (0)
+Bin number 2 bounds: (0.20 - 0.30) data (0)
+Bin number 3 bounds: (0.30 - 0.40) data (0)
+Bin number 4 bounds: (0.40 - 0.50) data (0)
+Bin number 5 bounds: (0.50 - 0.60) data (0)
+Bin number 6 bounds: (0.60 - 0.70) data (0)
+Bin number 7 bounds: (0.70 - 0.80) data (0)
+Bin number 8 bounds: (0.80 - 0.90) data (0)
+Bin number 9 bounds: (0.90 - 1.00) data (0)
+Bin number 10 bounds: (1.00 - 1.10) data (0)
+Bin number 11 bounds: (1.10 - 1.20) data (0)
+Bin number 12 bounds: (1.20 - 1.30) data (0)
+Bin number 13 bounds: (1.30 - 1.40) data (0)
+Bin number 14 bounds: (1.40 - 1.50) data (0)
+Bin number 15 bounds: (1.50 - 1.60) data (0)
+Bin number 16 bounds: (1.60 - 1.70) data (0)
+Bin number 17 bounds: (1.70 - 1.80) data (0)
+Bin number 18 bounds: (1.80 - 1.90) data (0)
+Bin number 19 bounds: (1.90 - 2.00) data (0)
 
 ---> TESTPOINT PASSED (psImageStats functions{Calculate Histogram with mask} | tst_psImageStats00.c)
@@ -78 +78 @@
 \**********************************************************************************/
 
-Bin number 0 bounds: (0.000000 - 1.650000) data (2)
-Bin number 1 bounds: (1.650000 - 3.300000) data (2)
-Bin number 2 bounds: (3.300000 - 4.950000) data (1)
-Bin number 3 bounds: (4.950000 - 6.600000) data (2)
-Bin number 4 bounds: (6.600000 - 8.250000) data (2)
-Bin number 5 bounds: (8.250000 - 9.900000) data (1)
-Bin number 6 bounds: (9.900000 - 11.550000) data (2)
-Bin number 7 bounds: (11.550000 - 13.200000) data (2)
-Bin number 8 bounds: (13.200000 - 14.849999) data (1)
-Bin number 9 bounds: (14.849999 - 16.500000) data (2)
-Bin number 10 bounds: (16.500000 - 18.150000) data (2)
-Bin number 11 bounds: (18.150000 - 19.799999) data (1)
-Bin number 12 bounds: (19.799999 - 21.449999) data (2)
-Bin number 13 bounds: (21.449999 - 23.100000) data (1)
-Bin number 14 bounds: (23.100000 - 24.750000) data (2)
-Bin number 15 bounds: (24.750000 - 26.400000) data (2)
-Bin number 16 bounds: (26.400000 - 28.049999) data (1)
-Bin number 17 bounds: (28.049999 - 29.699999) data (2)
-Bin number 18 bounds: (29.699999 - 31.350000) data (2)
-Bin number 19 bounds: (31.350000 - 33.000000) data (0)
-
----> TESTPOINT PASSED (psImageStats functions{Calculate Histogram, no mask} | tst_psImageStats00.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psImageStats00.c                                       *
-*            TestPoint: psImageStats functions{Calculate Histogram with mask}      *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-Bin number 0 bounds: (0.000000 - 1.650000) data (2)
-Bin number 1 bounds: (1.650000 - 3.300000) data (2)
-Bin number 2 bounds: (3.300000 - 4.950000) data (1)
-Bin number 3 bounds: (4.950000 - 6.600000) data (2)
-Bin number 4 bounds: (6.600000 - 8.250000) data (2)
-Bin number 5 bounds: (8.250000 - 9.900000) data (1)
-Bin number 6 bounds: (9.900000 - 11.550000) data (2)
-Bin number 7 bounds: (11.550000 - 13.200000) data (2)
-Bin number 8 bounds: (13.200000 - 14.849999) data (1)
-Bin number 9 bounds: (14.849999 - 16.500000) data (2)
-Bin number 10 bounds: (16.500000 - 18.150000) data (2)
-Bin number 11 bounds: (18.150000 - 19.799999) data (1)
-Bin number 12 bounds: (19.799999 - 21.449999) data (2)
-Bin number 13 bounds: (21.449999 - 23.100000) data (1)
-Bin number 14 bounds: (23.100000 - 24.750000) data (2)
-Bin number 15 bounds: (24.750000 - 26.400000) data (2)
-Bin number 16 bounds: (26.400000 - 28.049999) data (1)
-Bin number 17 bounds: (28.049999 - 29.699999) data (2)
-Bin number 18 bounds: (29.699999 - 31.350000) data (2)
-Bin number 19 bounds: (31.350000 - 33.000000) data (0)
+Bin number 0 bounds: (0.0 - 1.7) data (2)
+Bin number 1 bounds: (1.7 - 3.3) data (2)
+Bin number 2 bounds: (3.3 - 5.0) data (1)
+Bin number 3 bounds: (5.0 - 6.6) data (2)
+Bin number 4 bounds: (6.6 - 8.2) data (2)
+Bin number 5 bounds: (8.2 - 9.9) data (1)
+Bin number 6 bounds: (9.9 - 11.6) data (2)
+Bin number 7 bounds: (11.6 - 13.2) data (2)
+Bin number 8 bounds: (13.2 - 14.9) data (1)
+Bin number 9 bounds: (14.9 - 16.5) data (2)
+Bin number 10 bounds: (16.5 - 18.2) data (2)
+Bin number 11 bounds: (18.2 - 19.8) data (1)
+Bin number 12 bounds: (19.8 - 21.5) data (2)
+Bin number 13 bounds: (21.5 - 23.1) data (2)
+Bin number 14 bounds: (23.1 - 24.8) data (1)
+Bin number 15 bounds: (24.8 - 26.4) data (2)
+Bin number 16 bounds: (26.4 - 28.1) data (1)
+Bin number 17 bounds: (28.1 - 29.7) data (2)
+Bin number 18 bounds: (29.7 - 31.4) data (2)
+Bin number 19 bounds: (31.4 - 33.0) data (0)
+
+---> TESTPOINT PASSED (psImageStats functions{Calculate Histogram, no mask} | tst_psImageStats00.c)
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psImageStats00.c                                       *
+*            TestPoint: psImageStats functions{Calculate Histogram with mask}      *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+Bin number 0 bounds: (0.00 - 1.65) data (2)
+Bin number 1 bounds: (1.65 - 3.30) data (2)
+Bin number 2 bounds: (3.30 - 4.95) data (1)
+Bin number 3 bounds: (4.95 - 6.60) data (2)
+Bin number 4 bounds: (6.60 - 8.25) data (2)
+Bin number 5 bounds: (8.25 - 9.90) data (1)
+Bin number 6 bounds: (9.90 - 11.55) data (2)
+Bin number 7 bounds: (11.55 - 13.20) data (2)
+Bin number 8 bounds: (13.20 - 14.85) data (1)
+Bin number 9 bounds: (14.85 - 16.50) data (2)
+Bin number 10 bounds: (16.50 - 18.15) data (2)
+Bin number 11 bounds: (18.15 - 19.80) data (1)
+Bin number 12 bounds: (19.80 - 21.45) data (2)
+Bin number 13 bounds: (21.45 - 23.10) data (2)
+Bin number 14 bounds: (23.10 - 24.75) data (1)
+Bin number 15 bounds: (24.75 - 26.40) data (2)
+Bin number 16 bounds: (26.40 - 28.05) data (1)
+Bin number 17 bounds: (28.05 - 29.70) data (2)
+Bin number 18 bounds: (29.70 - 31.35) data (2)
+Bin number 19 bounds: (31.35 - 33.00) data (0)
 
 ---> TESTPOINT PASSED (psImageStats functions{Calculate Histogram with mask} | tst_psImageStats00.c)
@@ -148 +148 @@
 \**********************************************************************************/
 
-Bin number 0 bounds: (0.000000 - 1.650000) data (2)
-Bin number 1 bounds: (1.650000 - 3.300000) data (2)
-Bin number 2 bounds: (3.300000 - 4.950000) data (1)
-Bin number 3 bounds: (4.950000 - 6.600000) data (2)
-Bin number 4 bounds: (6.600000 - 8.250000) data (2)
-Bin number 5 bounds: (8.250000 - 9.900000) data (1)
-Bin number 6 bounds: (9.900000 - 11.550000) data (2)
-Bin number 7 bounds: (11.550000 - 13.200000) data (2)
-Bin number 8 bounds: (13.200000 - 14.849999) data (1)
-Bin number 9 bounds: (14.849999 - 16.500000) data (2)
-Bin number 10 bounds: (16.500000 - 18.150000) data (2)
-Bin number 11 bounds: (18.150000 - 19.799999) data (1)
-Bin number 12 bounds: (19.799999 - 21.449999) data (2)
-Bin number 13 bounds: (21.449999 - 23.100000) data (1)
-Bin number 14 bounds: (23.100000 - 24.750000) data (2)
-Bin number 15 bounds: (24.750000 - 26.400000) data (2)
-Bin number 16 bounds: (26.400000 - 28.049999) data (1)
-Bin number 17 bounds: (28.049999 - 29.699999) data (2)
-Bin number 18 bounds: (29.699999 - 31.350000) data (2)
-Bin number 19 bounds: (31.350000 - 33.000000) data (0)
-
----> TESTPOINT PASSED (psImageStats functions{Calculate Histogram, no mask} | tst_psImageStats00.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psImageStats00.c                                       *
-*            TestPoint: psImageStats functions{Calculate Histogram with mask}      *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-Bin number 0 bounds: (0.000000 - 1.650000) data (2)
-Bin number 1 bounds: (1.650000 - 3.300000) data (2)
-Bin number 2 bounds: (3.300000 - 4.950000) data (1)
-Bin number 3 bounds: (4.950000 - 6.600000) data (2)
-Bin number 4 bounds: (6.600000 - 8.250000) data (2)
-Bin number 5 bounds: (8.250000 - 9.900000) data (1)
-Bin number 6 bounds: (9.900000 - 11.550000) data (2)
-Bin number 7 bounds: (11.550000 - 13.200000) data (2)
-Bin number 8 bounds: (13.200000 - 14.849999) data (1)
-Bin number 9 bounds: (14.849999 - 16.500000) data (2)
-Bin number 10 bounds: (16.500000 - 18.150000) data (2)
-Bin number 11 bounds: (18.150000 - 19.799999) data (1)
-Bin number 12 bounds: (19.799999 - 21.449999) data (2)
-Bin number 13 bounds: (21.449999 - 23.100000) data (1)
-Bin number 14 bounds: (23.100000 - 24.750000) data (2)
-Bin number 15 bounds: (24.750000 - 26.400000) data (2)
-Bin number 16 bounds: (26.400000 - 28.049999) data (1)
-Bin number 17 bounds: (28.049999 - 29.699999) data (2)
-Bin number 18 bounds: (29.699999 - 31.350000) data (2)
-Bin number 19 bounds: (31.350000 - 33.000000) data (0)
+Bin number 0 bounds: (0.0 - 1.7) data (2)
+Bin number 1 bounds: (1.7 - 3.3) data (2)
+Bin number 2 bounds: (3.3 - 5.0) data (1)
+Bin number 3 bounds: (5.0 - 6.6) data (2)
+Bin number 4 bounds: (6.6 - 8.2) data (2)
+Bin number 5 bounds: (8.2 - 9.9) data (1)
+Bin number 6 bounds: (9.9 - 11.6) data (2)
+Bin number 7 bounds: (11.6 - 13.2) data (2)
+Bin number 8 bounds: (13.2 - 14.9) data (1)
+Bin number 9 bounds: (14.9 - 16.5) data (2)
+Bin number 10 bounds: (16.5 - 18.2) data (2)
+Bin number 11 bounds: (18.2 - 19.8) data (1)
+Bin number 12 bounds: (19.8 - 21.5) data (2)
+Bin number 13 bounds: (21.5 - 23.1) data (2)
+Bin number 14 bounds: (23.1 - 24.8) data (1)
+Bin number 15 bounds: (24.8 - 26.4) data (2)
+Bin number 16 bounds: (26.4 - 28.1) data (1)
+Bin number 17 bounds: (28.1 - 29.7) data (2)
+Bin number 18 bounds: (29.7 - 31.4) data (2)
+Bin number 19 bounds: (31.4 - 33.0) data (0)
+
+---> TESTPOINT PASSED (psImageStats functions{Calculate Histogram, no mask} | tst_psImageStats00.c)
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psImageStats00.c                                       *
+*            TestPoint: psImageStats functions{Calculate Histogram with mask}      *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+Bin number 0 bounds: (0.00 - 1.65) data (2)
+Bin number 1 bounds: (1.65 - 3.30) data (2)
+Bin number 2 bounds: (3.30 - 4.95) data (1)
+Bin number 3 bounds: (4.95 - 6.60) data (2)
+Bin number 4 bounds: (6.60 - 8.25) data (2)
+Bin number 5 bounds: (8.25 - 9.90) data (1)
+Bin number 6 bounds: (9.90 - 11.55) data (2)
+Bin number 7 bounds: (11.55 - 13.20) data (2)
+Bin number 8 bounds: (13.20 - 14.85) data (1)
+Bin number 9 bounds: (14.85 - 16.50) data (2)
+Bin number 10 bounds: (16.50 - 18.15) data (2)
+Bin number 11 bounds: (18.15 - 19.80) data (1)
+Bin number 12 bounds: (19.80 - 21.45) data (2)
+Bin number 13 bounds: (21.45 - 23.10) data (2)
+Bin number 14 bounds: (23.10 - 24.75) data (1)
+Bin number 15 bounds: (24.75 - 26.40) data (2)
+Bin number 16 bounds: (26.40 - 28.05) data (1)
+Bin number 17 bounds: (28.05 - 29.70) data (2)
+Bin number 18 bounds: (29.70 - 31.35) data (2)
+Bin number 19 bounds: (31.35 - 33.00) data (0)
 
 ---> TESTPOINT PASSED (psImageStats functions{Calculate Histogram with mask} | tst_psImageStats00.c)
@@ -218 +218 @@
 \**********************************************************************************/
 
-Bin number 0 bounds: (0.000000 - 3.200000) data (10)
-Bin number 1 bounds: (3.200000 - 6.400000) data (18)
-Bin number 2 bounds: (6.400000 - 9.600000) data (27)
-Bin number 3 bounds: (9.600000 - 12.800000) data (36)
-Bin number 4 bounds: (12.800000 - 16.000000) data (45)
-Bin number 5 bounds: (16.000000 - 19.200001) data (74)
-Bin number 6 bounds: (19.200001 - 22.400000) data (66)
-Bin number 7 bounds: (22.400000 - 25.600000) data (75)
-Bin number 8 bounds: (25.600000 - 28.800001) data (84)
-Bin number 9 bounds: (28.800001 - 32.000000) data (93)
-Bin number 10 bounds: (32.000000 - 35.200001) data (118)
-Bin number 11 bounds: (35.200001 - 38.400002) data (78)
-Bin number 12 bounds: (38.400002 - 41.600002) data (69)
-Bin number 13 bounds: (41.600002 - 44.799999) data (60)
-Bin number 14 bounds: (44.799999 - 48.000000) data (51)
-Bin number 15 bounds: (48.000000 - 51.200001) data (54)
-Bin number 16 bounds: (51.200001 - 54.400002) data (30)
-Bin number 17 bounds: (54.400002 - 57.600002) data (21)
-Bin number 18 bounds: (57.600002 - 60.799999) data (12)
-Bin number 19 bounds: (60.799999 - 64.000000) data (3)
-
----> TESTPOINT PASSED (psImageStats functions{Calculate Histogram, no mask} | tst_psImageStats00.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psImageStats00.c                                       *
-*            TestPoint: psImageStats functions{Calculate Histogram with mask}      *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-Bin number 0 bounds: (0.000000 - 3.200000) data (10)
-Bin number 1 bounds: (3.200000 - 6.400000) data (18)
-Bin number 2 bounds: (6.400000 - 9.600000) data (27)
-Bin number 3 bounds: (9.600000 - 12.800000) data (36)
-Bin number 4 bounds: (12.800000 - 16.000000) data (45)
-Bin number 5 bounds: (16.000000 - 19.200001) data (74)
-Bin number 6 bounds: (19.200001 - 22.400000) data (66)
-Bin number 7 bounds: (22.400000 - 25.600000) data (75)
-Bin number 8 bounds: (25.600000 - 28.800001) data (84)
-Bin number 9 bounds: (28.800001 - 32.000000) data (93)
-Bin number 10 bounds: (32.000000 - 35.200001) data (115)
-Bin number 11 bounds: (35.200001 - 38.400002) data (66)
-Bin number 12 bounds: (38.400002 - 41.600002) data (48)
-Bin number 13 bounds: (41.600002 - 44.799999) data (30)
-Bin number 14 bounds: (44.799999 - 48.000000) data (12)
-Bin number 15 bounds: (48.000000 - 51.200001) data (0)
-Bin number 16 bounds: (51.200001 - 54.400002) data (0)
-Bin number 17 bounds: (54.400002 - 57.600002) data (0)
-Bin number 18 bounds: (57.600002 - 60.799999) data (0)
-Bin number 19 bounds: (60.799999 - 64.000000) data (0)
+Bin number 0 bounds: (0.0 - 3.2) data (10)
+Bin number 1 bounds: (3.2 - 6.4) data (18)
+Bin number 2 bounds: (6.4 - 9.6) data (27)
+Bin number 3 bounds: (9.6 - 12.8) data (36)
+Bin number 4 bounds: (12.8 - 16.0) data (45)
+Bin number 5 bounds: (16.0 - 19.2) data (74)
+Bin number 6 bounds: (19.2 - 22.4) data (66)
+Bin number 7 bounds: (22.4 - 25.6) data (75)
+Bin number 8 bounds: (25.6 - 28.8) data (84)
+Bin number 9 bounds: (28.8 - 32.0) data (93)
+Bin number 10 bounds: (32.0 - 35.2) data (118)
+Bin number 11 bounds: (35.2 - 38.4) data (78)
+Bin number 12 bounds: (38.4 - 41.6) data (69)
+Bin number 13 bounds: (41.6 - 44.8) data (60)
+Bin number 14 bounds: (44.8 - 48.0) data (51)
+Bin number 15 bounds: (48.0 - 51.2) data (54)
+Bin number 16 bounds: (51.2 - 54.4) data (30)
+Bin number 17 bounds: (54.4 - 57.6) data (21)
+Bin number 18 bounds: (57.6 - 60.8) data (12)
+Bin number 19 bounds: (60.8 - 64.0) data (3)
+
+---> TESTPOINT PASSED (psImageStats functions{Calculate Histogram, no mask} | tst_psImageStats00.c)
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psImageStats00.c                                       *
+*            TestPoint: psImageStats functions{Calculate Histogram with mask}      *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+Bin number 0 bounds: (0.00 - 3.20) data (10)
+Bin number 1 bounds: (3.20 - 6.40) data (18)
+Bin number 2 bounds: (6.40 - 9.60) data (27)
+Bin number 3 bounds: (9.60 - 12.80) data (36)
+Bin number 4 bounds: (12.80 - 16.00) data (45)
+Bin number 5 bounds: (16.00 - 19.20) data (74)
+Bin number 6 bounds: (19.20 - 22.40) data (66)
+Bin number 7 bounds: (22.40 - 25.60) data (75)
+Bin number 8 bounds: (25.60 - 28.80) data (84)
+Bin number 9 bounds: (28.80 - 32.00) data (93)
+Bin number 10 bounds: (32.00 - 35.20) data (115)
+Bin number 11 bounds: (35.20 - 38.40) data (66)
+Bin number 12 bounds: (38.40 - 41.60) data (48)
+Bin number 13 bounds: (41.60 - 44.80) data (30)
+Bin number 14 bounds: (44.80 - 48.00) data (12)
+Bin number 15 bounds: (48.00 - 51.20) data (0)
+Bin number 16 bounds: (51.20 - 54.40) data (0)
+Bin number 17 bounds: (54.40 - 57.60) data (0)
+Bin number 18 bounds: (57.60 - 60.80) data (0)
+Bin number 19 bounds: (60.80 - 64.00) data (0)
 
 ---> TESTPOINT PASSED (psImageStats functions{Calculate Histogram with mask} | tst_psImageStats00.c)
@@ -288 +288 @@
 \**********************************************************************************/
 
-Bin number 0 bounds: (0.000000 - 4.800000) data (15)
-Bin number 1 bounds: (4.800000 - 9.600000) data (40)
-Bin number 2 bounds: (9.600000 - 14.400001) data (65)
-Bin number 3 bounds: (14.400001 - 19.200001) data (90)
-Bin number 4 bounds: (19.200001 - 24.000000) data (90)
-Bin number 5 bounds: (24.000000 - 28.800001) data (135)
-Bin number 6 bounds: (28.800001 - 33.600002) data (157)
-Bin number 7 bounds: (33.600002 - 38.400002) data (160)
-Bin number 8 bounds: (38.400002 - 43.200001) data (160)
-Bin number 9 bounds: (43.200001 - 48.000000) data (128)
-Bin number 10 bounds: (48.000000 - 52.800003) data (160)
-Bin number 11 bounds: (52.800003 - 57.600002) data (160)
-Bin number 12 bounds: (57.600002 - 62.400002) data (160)
-Bin number 13 bounds: (62.400002 - 67.200005) data (150)
-Bin number 14 bounds: (67.200005 - 72.000000) data (102)
-Bin number 15 bounds: (72.000000 - 76.800003) data (105)
-Bin number 16 bounds: (76.800003 - 81.600006) data (80)
-Bin number 17 bounds: (81.600006 - 86.400002) data (55)
-Bin number 18 bounds: (86.400002 - 91.200005) data (30)
-Bin number 19 bounds: (91.200005 - 96.000000) data (6)
-
----> TESTPOINT PASSED (psImageStats functions{Calculate Histogram, no mask} | tst_psImageStats00.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psImageStats00.c                                       *
-*            TestPoint: psImageStats functions{Calculate Histogram with mask}      *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-Bin number 0 bounds: (0.000000 - 4.800000) data (15)
-Bin number 1 bounds: (4.800000 - 9.600000) data (40)
-Bin number 2 bounds: (9.600000 - 14.400001) data (65)
-Bin number 3 bounds: (14.400001 - 19.200001) data (90)
-Bin number 4 bounds: (19.200001 - 24.000000) data (90)
-Bin number 5 bounds: (24.000000 - 28.800001) data (135)
-Bin number 6 bounds: (28.800001 - 33.600002) data (157)
-Bin number 7 bounds: (33.600002 - 38.400002) data (160)
-Bin number 8 bounds: (38.400002 - 43.200001) data (160)
-Bin number 9 bounds: (43.200001 - 48.000000) data (128)
-Bin number 10 bounds: (48.000000 - 52.800003) data (154)
-Bin number 11 bounds: (52.800003 - 57.600002) data (130)
-Bin number 12 bounds: (57.600002 - 62.400002) data (105)
-Bin number 13 bounds: (62.400002 - 67.200005) data (76)
-Bin number 14 bounds: (67.200005 - 72.000000) data (42)
-Bin number 15 bounds: (72.000000 - 76.800003) data (30)
-Bin number 16 bounds: (76.800003 - 81.600006) data (6)
-Bin number 17 bounds: (81.600006 - 86.400002) data (0)
-Bin number 18 bounds: (86.400002 - 91.200005) data (0)
-Bin number 19 bounds: (91.200005 - 96.000000) data (0)
+Bin number 0 bounds: (0.0 - 4.8) data (15)
+Bin number 1 bounds: (4.8 - 9.6) data (40)
+Bin number 2 bounds: (9.6 - 14.4) data (65)
+Bin number 3 bounds: (14.4 - 19.2) data (90)
+Bin number 4 bounds: (19.2 - 24.0) data (90)
+Bin number 5 bounds: (24.0 - 28.8) data (135)
+Bin number 6 bounds: (28.8 - 33.6) data (157)
+Bin number 7 bounds: (33.6 - 38.4) data (160)
+Bin number 8 bounds: (38.4 - 43.2) data (160)
+Bin number 9 bounds: (43.2 - 48.0) data (128)
+Bin number 10 bounds: (48.0 - 52.8) data (160)
+Bin number 11 bounds: (52.8 - 57.6) data (160)
+Bin number 12 bounds: (57.6 - 62.4) data (160)
+Bin number 13 bounds: (62.4 - 67.2) data (150)
+Bin number 14 bounds: (67.2 - 72.0) data (102)
+Bin number 15 bounds: (72.0 - 76.8) data (105)
+Bin number 16 bounds: (76.8 - 81.6) data (80)
+Bin number 17 bounds: (81.6 - 86.4) data (55)
+Bin number 18 bounds: (86.4 - 91.2) data (30)
+Bin number 19 bounds: (91.2 - 96.0) data (6)
+
+---> TESTPOINT PASSED (psImageStats functions{Calculate Histogram, no mask} | tst_psImageStats00.c)
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psImageStats00.c                                       *
+*            TestPoint: psImageStats functions{Calculate Histogram with mask}      *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+Bin number 0 bounds: (0.00 - 4.80) data (15)
+Bin number 1 bounds: (4.80 - 9.60) data (40)
+Bin number 2 bounds: (9.60 - 14.40) data (65)
+Bin number 3 bounds: (14.40 - 19.20) data (90)
+Bin number 4 bounds: (19.20 - 24.00) data (90)
+Bin number 5 bounds: (24.00 - 28.80) data (135)
+Bin number 6 bounds: (28.80 - 33.60) data (157)
+Bin number 7 bounds: (33.60 - 38.40) data (160)
+Bin number 8 bounds: (38.40 - 43.20) data (160)
+Bin number 9 bounds: (43.20 - 48.00) data (128)
+Bin number 10 bounds: (48.00 - 52.80) data (154)
+Bin number 11 bounds: (52.80 - 57.60) data (130)
+Bin number 12 bounds: (57.60 - 62.40) data (105)
+Bin number 13 bounds: (62.40 - 67.20) data (76)
+Bin number 14 bounds: (67.20 - 72.00) data (42)
+Bin number 15 bounds: (72.00 - 76.80) data (30)
+Bin number 16 bounds: (76.80 - 81.60) data (6)
+Bin number 17 bounds: (81.60 - 86.40) data (0)
+Bin number 18 bounds: (86.40 - 91.20) data (0)
+Bin number 19 bounds: (91.20 - 96.00) data (0)
 
 ---> TESTPOINT PASSED (psImageStats functions{Calculate Histogram with mask} | tst_psImageStats00.c)
@@ -358 +358 @@
 \**********************************************************************************/
 
-Bin number 0 bounds: (0.000000 - 4.800000) data (15)
-Bin number 1 bounds: (4.800000 - 9.600000) data (40)
-Bin number 2 bounds: (9.600000 - 14.400001) data (65)
-Bin number 3 bounds: (14.400001 - 19.200001) data (90)
-Bin number 4 bounds: (19.200001 - 24.000000) data (90)
-Bin number 5 bounds: (24.000000 - 28.800001) data (135)
-Bin number 6 bounds: (28.800001 - 33.600002) data (157)
-Bin number 7 bounds: (33.600002 - 38.400002) data (160)
-Bin number 8 bounds: (38.400002 - 43.200001) data (160)
-Bin number 9 bounds: (43.200001 - 48.000000) data (128)
-Bin number 10 bounds: (48.000000 - 52.800003) data (160)
-Bin number 11 bounds: (52.800003 - 57.600002) data (160)
-Bin number 12 bounds: (57.600002 - 62.400002) data (160)
-Bin number 13 bounds: (62.400002 - 67.200005) data (150)
-Bin number 14 bounds: (67.200005 - 72.000000) data (102)
-Bin number 15 bounds: (72.000000 - 76.800003) data (105)
-Bin number 16 bounds: (76.800003 - 81.600006) data (80)
-Bin number 17 bounds: (81.600006 - 86.400002) data (55)
-Bin number 18 bounds: (86.400002 - 91.200005) data (30)
-Bin number 19 bounds: (91.200005 - 96.000000) data (6)
-
----> TESTPOINT PASSED (psImageStats functions{Calculate Histogram, no mask} | tst_psImageStats00.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psImageStats00.c                                       *
-*            TestPoint: psImageStats functions{Calculate Histogram with mask}      *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-Bin number 0 bounds: (0.000000 - 4.800000) data (15)
-Bin number 1 bounds: (4.800000 - 9.600000) data (40)
-Bin number 2 bounds: (9.600000 - 14.400001) data (65)
-Bin number 3 bounds: (14.400001 - 19.200001) data (90)
-Bin number 4 bounds: (19.200001 - 24.000000) data (90)
-Bin number 5 bounds: (24.000000 - 28.800001) data (135)
-Bin number 6 bounds: (28.800001 - 33.600002) data (157)
-Bin number 7 bounds: (33.600002 - 38.400002) data (160)
-Bin number 8 bounds: (38.400002 - 43.200001) data (160)
-Bin number 9 bounds: (43.200001 - 48.000000) data (128)
-Bin number 10 bounds: (48.000000 - 52.800003) data (154)
-Bin number 11 bounds: (52.800003 - 57.600002) data (130)
-Bin number 12 bounds: (57.600002 - 62.400002) data (105)
-Bin number 13 bounds: (62.400002 - 67.200005) data (76)
-Bin number 14 bounds: (67.200005 - 72.000000) data (42)
-Bin number 15 bounds: (72.000000 - 76.800003) data (30)
-Bin number 16 bounds: (76.800003 - 81.600006) data (6)
-Bin number 17 bounds: (81.600006 - 86.400002) data (0)
-Bin number 18 bounds: (86.400002 - 91.200005) data (0)
-Bin number 19 bounds: (91.200005 - 96.000000) data (0)
+Bin number 0 bounds: (0.0 - 4.8) data (15)
+Bin number 1 bounds: (4.8 - 9.6) data (40)
+Bin number 2 bounds: (9.6 - 14.4) data (65)
+Bin number 3 bounds: (14.4 - 19.2) data (90)
+Bin number 4 bounds: (19.2 - 24.0) data (90)
+Bin number 5 bounds: (24.0 - 28.8) data (135)
+Bin number 6 bounds: (28.8 - 33.6) data (157)
+Bin number 7 bounds: (33.6 - 38.4) data (160)
+Bin number 8 bounds: (38.4 - 43.2) data (160)
+Bin number 9 bounds: (43.2 - 48.0) data (128)
+Bin number 10 bounds: (48.0 - 52.8) data (160)
+Bin number 11 bounds: (52.8 - 57.6) data (160)
+Bin number 12 bounds: (57.6 - 62.4) data (160)
+Bin number 13 bounds: (62.4 - 67.2) data (150)
+Bin number 14 bounds: (67.2 - 72.0) data (102)
+Bin number 15 bounds: (72.0 - 76.8) data (105)
+Bin number 16 bounds: (76.8 - 81.6) data (80)
+Bin number 17 bounds: (81.6 - 86.4) data (55)
+Bin number 18 bounds: (86.4 - 91.2) data (30)
+Bin number 19 bounds: (91.2 - 96.0) data (6)
+
+---> TESTPOINT PASSED (psImageStats functions{Calculate Histogram, no mask} | tst_psImageStats00.c)
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psImageStats00.c                                       *
+*            TestPoint: psImageStats functions{Calculate Histogram with mask}      *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+Bin number 0 bounds: (0.00 - 4.80) data (15)
+Bin number 1 bounds: (4.80 - 9.60) data (40)
+Bin number 2 bounds: (9.60 - 14.40) data (65)
+Bin number 3 bounds: (14.40 - 19.20) data (90)
+Bin number 4 bounds: (19.20 - 24.00) data (90)
+Bin number 5 bounds: (24.00 - 28.80) data (135)
+Bin number 6 bounds: (28.80 - 33.60) data (157)
+Bin number 7 bounds: (33.60 - 38.40) data (160)
+Bin number 8 bounds: (38.40 - 43.20) data (160)
+Bin number 9 bounds: (43.20 - 48.00) data (128)
+Bin number 10 bounds: (48.00 - 52.80) data (154)
+Bin number 11 bounds: (52.80 - 57.60) data (130)
+Bin number 12 bounds: (57.60 - 62.40) data (105)
+Bin number 13 bounds: (62.40 - 67.20) data (76)
+Bin number 14 bounds: (67.20 - 72.00) data (42)
+Bin number 15 bounds: (72.00 - 76.80) data (30)
+Bin number 16 bounds: (76.80 - 81.60) data (6)
+Bin number 17 bounds: (81.60 - 86.40) data (0)
+Bin number 18 bounds: (86.40 - 91.20) data (0)
+Bin number 19 bounds: (91.20 - 96.00) data (0)
 
 ---> TESTPOINT PASSED (psImageStats functions{Calculate Histogram with mask} | tst_psImageStats00.c)

trunk/psLib/test/image/verified/tst_psImageStats01.stdout

@@ -8 +8 @@
 \**********************************************************************************/
 
-The sample mean was 0.000000
-
----> TESTPOINT PASSED (psImageStats functions{Calculate Sample Mean, no mask} | tst_psImageStats01.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psImageStats01.c                                       *
-*            TestPoint: psImageStats functions{Calculate Sample Mean with mask}    *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-The sample mean was 0.000000
+The sample mean was 0.00
+
+---> TESTPOINT PASSED (psImageStats functions{Calculate Sample Mean, no mask} | tst_psImageStats01.c)
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psImageStats01.c                                       *
+*            TestPoint: psImageStats functions{Calculate Sample Mean with mask}    *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+The sample mean was 0.00
 
 ---> TESTPOINT PASSED (psImageStats functions{Calculate Sample Mean with mask} | tst_psImageStats01.c)
@@ -40 +40 @@
 \**********************************************************************************/
 
-The sample mean was 15.500000
-
----> TESTPOINT PASSED (psImageStats functions{Calculate Sample Mean, no mask} | tst_psImageStats01.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psImageStats01.c                                       *
-*            TestPoint: psImageStats functions{Calculate Sample Mean with mask}    *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-The sample mean was 15.500000
+The sample mean was 15.50
+
+---> TESTPOINT PASSED (psImageStats functions{Calculate Sample Mean, no mask} | tst_psImageStats01.c)
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psImageStats01.c                                       *
+*            TestPoint: psImageStats functions{Calculate Sample Mean with mask}    *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+The sample mean was 15.50
 
 ---> TESTPOINT PASSED (psImageStats functions{Calculate Sample Mean with mask} | tst_psImageStats01.c)
@@ -72 +72 @@
 \**********************************************************************************/
 
-The sample mean was 15.500000
-
----> TESTPOINT PASSED (psImageStats functions{Calculate Sample Mean, no mask} | tst_psImageStats01.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psImageStats01.c                                       *
-*            TestPoint: psImageStats functions{Calculate Sample Mean with mask}    *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-The sample mean was 15.500000
+The sample mean was 15.50
+
+---> TESTPOINT PASSED (psImageStats functions{Calculate Sample Mean, no mask} | tst_psImageStats01.c)
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psImageStats01.c                                       *
+*            TestPoint: psImageStats functions{Calculate Sample Mean with mask}    *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+The sample mean was 15.50
 
 ---> TESTPOINT PASSED (psImageStats functions{Calculate Sample Mean with mask} | tst_psImageStats01.c)
@@ -104 +104 @@
 \**********************************************************************************/
 
-The sample mean was 31.000000
-
----> TESTPOINT PASSED (psImageStats functions{Calculate Sample Mean, no mask} | tst_psImageStats01.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psImageStats01.c                                       *
-*            TestPoint: psImageStats functions{Calculate Sample Mean with mask}    *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-The sample mean was 26.212767
+The sample mean was 31.00
+
+---> TESTPOINT PASSED (psImageStats functions{Calculate Sample Mean, no mask} | tst_psImageStats01.c)
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psImageStats01.c                                       *
+*            TestPoint: psImageStats functions{Calculate Sample Mean with mask}    *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+The sample mean was 26.21
 
 ---> TESTPOINT PASSED (psImageStats functions{Calculate Sample Mean with mask} | tst_psImageStats01.c)
@@ -136 +136 @@
 \**********************************************************************************/
 
-The sample mean was 47.000000
-
----> TESTPOINT PASSED (psImageStats functions{Calculate Sample Mean, no mask} | tst_psImageStats01.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psImageStats01.c                                       *
-*            TestPoint: psImageStats functions{Calculate Sample Mean with mask}    *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-The sample mean was 39.656349
+The sample mean was 47.00
+
+---> TESTPOINT PASSED (psImageStats functions{Calculate Sample Mean, no mask} | tst_psImageStats01.c)
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psImageStats01.c                                       *
+*            TestPoint: psImageStats functions{Calculate Sample Mean with mask}    *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+The sample mean was 39.66
 
 ---> TESTPOINT PASSED (psImageStats functions{Calculate Sample Mean with mask} | tst_psImageStats01.c)
@@ -168 +168 @@
 \**********************************************************************************/
 
-The sample mean was 47.000000
-
----> TESTPOINT PASSED (psImageStats functions{Calculate Sample Mean, no mask} | tst_psImageStats01.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psImageStats01.c                                       *
-*            TestPoint: psImageStats functions{Calculate Sample Mean with mask}    *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-The sample mean was 39.656349
+The sample mean was 47.00
+
+---> TESTPOINT PASSED (psImageStats functions{Calculate Sample Mean, no mask} | tst_psImageStats01.c)
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psImageStats01.c                                       *
+*            TestPoint: psImageStats functions{Calculate Sample Mean with mask}    *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+The sample mean was 39.66
 
 ---> TESTPOINT PASSED (psImageStats functions{Calculate Sample Mean with mask} | tst_psImageStats01.c)

trunk/psLib/test/image/verified/tst_psImageStats02.stdout

@@ -5 +5 @@
 \**********************************************************************************/
 
-Cheby Polynomial (0, 0) coefficient is 189.000000
-Cheby Polynomial (0, 1) coefficient is 25.935616
-Cheby Polynomial (0, 2) coefficient is 0.000005
-Cheby Polynomial (0, 3) coefficient is 2.879415
-Cheby Polynomial (0, 4) coefficient is 0.000004
-Cheby Polynomial (0, 5) coefficient is 1.034911
-Cheby Polynomial (0, 6) coefficient is 0.000019
-Cheby Polynomial (0, 7) coefficient is 0.526690
-Cheby Polynomial (1, 0) coefficient is 129.677979
-Cheby Polynomial (1, 1) coefficient is -0.000024
-Cheby Polynomial (1, 2) coefficient is 0.000002
-Cheby Polynomial (1, 3) coefficient is 0.000003
-Cheby Polynomial (1, 4) coefficient is 0.000003
-Cheby Polynomial (1, 5) coefficient is -0.000004
-Cheby Polynomial (1, 6) coefficient is 0.000016
-Cheby Polynomial (1, 7) coefficient is -0.000015
-Cheby Polynomial (2, 0) coefficient is -0.000034
-Cheby Polynomial (2, 1) coefficient is 0.000010
-Cheby Polynomial (2, 2) coefficient is -0.000002
-Cheby Polynomial (2, 3) coefficient is 0.000001
-Cheby Polynomial (2, 4) coefficient is 0.000002
-Cheby Polynomial (2, 5) coefficient is 0.000000
-Cheby Polynomial (2, 6) coefficient is -0.000000
-Cheby Polynomial (2, 7) coefficient is -0.000001
-Cheby Polynomial (3, 0) coefficient is 14.397046
-Cheby Polynomial (3, 1) coefficient is 0.000007
-Cheby Polynomial (3, 2) coefficient is -0.000000
-Cheby Polynomial (3, 3) coefficient is -0.000001
-Cheby Polynomial (3, 4) coefficient is 0.000001
-Cheby Polynomial (3, 5) coefficient is -0.000001
-Cheby Polynomial (3, 6) coefficient is 0.000002
-Cheby Polynomial (3, 7) coefficient is -0.000002
-Cheby Polynomial (4, 0) coefficient is 0.000023
-Cheby Polynomial (4, 1) coefficient is 0.000003
-Cheby Polynomial (4, 2) coefficient is -0.000003
-Cheby Polynomial (4, 3) coefficient is -0.000002
-Cheby Polynomial (4, 4) coefficient is 0.000000
-Cheby Polynomial (4, 5) coefficient is 0.000001
-Cheby Polynomial (4, 6) coefficient is -0.000000
-Cheby Polynomial (4, 7) coefficient is 0.000000
-Cheby Polynomial (5, 0) coefficient is 5.174568
-Cheby Polynomial (5, 1) coefficient is -0.000000
-Cheby Polynomial (5, 2) coefficient is 0.000000
-Cheby Polynomial (5, 3) coefficient is -0.000001
-Cheby Polynomial (5, 4) coefficient is -0.000001
-Cheby Polynomial (5, 5) coefficient is 0.000000
-Cheby Polynomial (5, 6) coefficient is 0.000001
-Cheby Polynomial (5, 7) coefficient is 0.000000
-Cheby Polynomial (6, 0) coefficient is 0.000014
-Cheby Polynomial (6, 1) coefficient is -0.000001
-Cheby Polynomial (6, 2) coefficient is 0.000001
-Cheby Polynomial (6, 3) coefficient is 0.000001
-Cheby Polynomial (6, 4) coefficient is -0.000001
-Cheby Polynomial (6, 5) coefficient is 0.000001
-Cheby Polynomial (6, 6) coefficient is 0.000000
-Cheby Polynomial (6, 7) coefficient is -0.000000
-Cheby Polynomial (7, 0) coefficient is 2.633517
-Cheby Polynomial (7, 1) coefficient is -0.000005
-Cheby Polynomial (7, 2) coefficient is -0.000001
-Cheby Polynomial (7, 3) coefficient is -0.000000
-Cheby Polynomial (7, 4) coefficient is 0.000001
-Cheby Polynomial (7, 5) coefficient is -0.000001
-Cheby Polynomial (7, 6) coefficient is 0.000001
-Cheby Polynomial (7, 7) coefficient is -0.000001
+Cheby Polynomial (0, 0) coefficient is 189.00
+Cheby Polynomial (0, 1) coefficient is 25.94
+Cheby Polynomial (0, 2) coefficient is 0.00
+Cheby Polynomial (0, 3) coefficient is 2.88
+Cheby Polynomial (0, 4) coefficient is 0.00
+Cheby Polynomial (0, 5) coefficient is 1.03
+Cheby Polynomial (0, 6) coefficient is 0.00
+Cheby Polynomial (0, 7) coefficient is 0.53
+Cheby Polynomial (1, 0) coefficient is 129.68
+Cheby Polynomial (1, 1) coefficient is -0.00
+Cheby Polynomial (1, 2) coefficient is 0.00
+Cheby Polynomial (1, 3) coefficient is 0.00
+Cheby Polynomial (1, 4) coefficient is 0.00
+Cheby Polynomial (1, 5) coefficient is 0.00
+Cheby Polynomial (1, 6) coefficient is 0.00
+Cheby Polynomial (1, 7) coefficient is 0.00
+Cheby Polynomial (2, 0) coefficient is -0.00
+Cheby Polynomial (2, 1) coefficient is 0.00
+Cheby Polynomial (2, 2) coefficient is -0.00
+Cheby Polynomial (2, 3) coefficient is 0.00
+Cheby Polynomial (2, 4) coefficient is 0.00
+Cheby Polynomial (2, 5) coefficient is 0.00
+Cheby Polynomial (2, 6) coefficient is -0.00
+Cheby Polynomial (2, 7) coefficient is -0.00
+Cheby Polynomial (3, 0) coefficient is 14.40
+Cheby Polynomial (3, 1) coefficient is 0.00
+Cheby Polynomial (3, 2) coefficient is 0.00
+Cheby Polynomial (3, 3) coefficient is 0.00
+Cheby Polynomial (3, 4) coefficient is 0.00
+Cheby Polynomial (3, 5) coefficient is -0.00
+Cheby Polynomial (3, 6) coefficient is 0.00
+Cheby Polynomial (3, 7) coefficient is 0.00
+Cheby Polynomial (4, 0) coefficient is 0.00
+Cheby Polynomial (4, 1) coefficient is 0.00
+Cheby Polynomial (4, 2) coefficient is -0.00
+Cheby Polynomial (4, 3) coefficient is -0.00
+Cheby Polynomial (4, 4) coefficient is 0.00
+Cheby Polynomial (4, 5) coefficient is 0.00
+Cheby Polynomial (4, 6) coefficient is -0.00
+Cheby Polynomial (4, 7) coefficient is 0.00
+Cheby Polynomial (5, 0) coefficient is 5.17
+Cheby Polynomial (5, 1) coefficient is 0.00
+Cheby Polynomial (5, 2) coefficient is -0.00
+Cheby Polynomial (5, 3) coefficient is 0.00
+Cheby Polynomial (5, 4) coefficient is -0.00
+Cheby Polynomial (5, 5) coefficient is 0.00
+Cheby Polynomial (5, 6) coefficient is 0.00
+Cheby Polynomial (5, 7) coefficient is 0.00
+Cheby Polynomial (6, 0) coefficient is 0.00
+Cheby Polynomial (6, 1) coefficient is -0.00
+Cheby Polynomial (6, 2) coefficient is -0.00
+Cheby Polynomial (6, 3) coefficient is 0.00
+Cheby Polynomial (6, 4) coefficient is -0.00
+Cheby Polynomial (6, 5) coefficient is -0.00
+Cheby Polynomial (6, 6) coefficient is -0.00
+Cheby Polynomial (6, 7) coefficient is -0.00
+Cheby Polynomial (7, 0) coefficient is 2.63
+Cheby Polynomial (7, 1) coefficient is -0.00
+Cheby Polynomial (7, 2) coefficient is -0.00
+Cheby Polynomial (7, 3) coefficient is 0.00
+Cheby Polynomial (7, 4) coefficient is 0.00
+Cheby Polynomial (7, 5) coefficient is 0.00
+Cheby Polynomial (7, 6) coefficient is -0.00
+Cheby Polynomial (7, 7) coefficient is 0.00
 
 ---> TESTPOINT PASSED (psImageStats functions{Calculate Chebyshev Polynomials, no mask} | tst_psImageStats02.c)
@@ -78 +78 @@
 \**********************************************************************************/
 
-Pixel (0, 0) is 6.927072, should be 0.000000
-Pixel (0, 1) is 7.173949, should be 1.000000
-Pixel (0, 2) is 7.655376, should be 2.000000
-Pixel (0, 3) is 8.347930, should be 3.000000
-Pixel (0, 4) is 9.218961, should be 4.000000
-Pixel (0, 5) is 10.229467, should be 5.000000
-Pixel (0, 6) is 11.337466, should be 6.000000
-Pixel (0, 7) is 12.501254, should be 7.000000
-Pixel (0, 8) is 13.682820, should be 8.000000
-Pixel (0, 9) is 14.850384, should be 9.000000
-Pixel (0, 10) is 15.980532, should be 10.000000
-Pixel (0, 11) is 17.059172, should be 11.000000
-Pixel (0, 12) is 18.081587, should be 12.000000
-Pixel (0, 13) is 19.051620, should be 13.000000
-Pixel (0, 14) is 19.980064, should be 14.000000
-Pixel (0, 15) is 20.882164, should be 15.000000
-Pixel (0, 16) is 21.775343, should be 16.000000
-Pixel (0, 17) is 22.676605, should be 17.000000
-Pixel (0, 18) is 23.600229, should be 18.000000
-Pixel (0, 19) is 24.556124, should be 19.000000
-Pixel (0, 20) is 25.548784, should be 20.000000
-Pixel (0, 21) is 26.577057, should be 21.000000
-Pixel (0, 22) is 27.634684, should be 22.000000
-Pixel (0, 23) is 28.711458, should be 23.000000
-Pixel (0, 24) is 29.794844, should be 24.000000
-Pixel (0, 25) is 30.871885, should be 25.000000
-Pixel (0, 26) is 31.931026, should be 26.000000
-Pixel (0, 27) is 32.963749, should be 27.000000
-Pixel (0, 28) is 33.965645, should be 28.000000
-Pixel (0, 29) is 34.937035, should be 29.000000
-Pixel (0, 30) is 35.882740, should be 30.000000
-Pixel (0, 31) is 36.811340, should be 31.000000
-Pixel (0, 32) is 37.733940, should be 32.000000
-Pixel (0, 33) is 38.662556, should be 33.000000
-Pixel (0, 34) is 39.608231, should be 34.000000
-Pixel (0, 35) is 40.579613, should be 35.000000
-Pixel (0, 36) is 41.581539, should be 36.000000
-Pixel (0, 37) is 42.614243, should be 37.000000
-Pixel (0, 38) is 43.673363, should be 38.000000
-Pixel (0, 39) is 44.750423, should be 39.000000
-Pixel (0, 40) is 45.833805, should be 40.000000
-Pixel (0, 41) is 46.910572, should be 41.000000
-Pixel (0, 42) is 47.968204, should be 42.000000
-Pixel (0, 43) is 48.996479, should be 43.000000
-Pixel (0, 44) is 49.989136, should be 44.000000
-Pixel (0, 45) is 50.945053, should be 45.000000
-Pixel (0, 46) is 51.868679, should be 46.000000
-Pixel (0, 47) is 52.769932, should be 47.000000
-Pixel (0, 48) is 53.663113, should be 48.000000
-Pixel (0, 49) is 54.565205, should be 49.000000
-Pixel (0, 50) is 55.493645, should be 50.000000
-Pixel (0, 51) is 56.463696, should be 51.000000
-Pixel (0, 52) is 57.486126, should be 52.000000
-Pixel (0, 53) is 58.564747, should be 53.000000
-Pixel (0, 54) is 59.694889, should be 54.000000
-Pixel (0, 55) is 60.862446, should be 55.000000
-Pixel (0, 56) is 62.044003, should be 56.000000
-Pixel (0, 57) is 63.207813, should be 57.000000
-Pixel (0, 58) is 64.315796, should be 58.000000
-Pixel (0, 59) is 65.326294, should be 59.000000
-Pixel (0, 60) is 66.197350, should be 60.000000
-Pixel (0, 61) is 66.889877, should be 61.000000
-Pixel (0, 62) is 67.371300, should be 62.000000
-Pixel (0, 63) is 67.618172, should be 63.000000
-Pixel (1, 0) is 8.161349, should be 5.000000
-Pixel (1, 1) is 8.408226, should be 6.000000
-Pixel (1, 2) is 8.889652, should be 7.000000
-Pixel (1, 3) is 9.582205, should be 8.000000
-Pixel (1, 4) is 10.453232, should be 9.000000
-Pixel (1, 5) is 11.463740, should be 10.000000
-Pixel (1, 6) is 12.571740, should be 11.000000
-Pixel (1, 7) is 13.735526, should be 12.000000
-Pixel (1, 8) is 14.917092, should be 13.000000
-Pixel (1, 9) is 16.084658, should be 14.000000
-Pixel (1, 10) is 17.214804, should be 15.000000
-Pixel (1, 11) is 18.293444, should be 16.000000
-Pixel (1, 12) is 19.315859, should be 17.000000
-Pixel (1, 13) is 20.285892, should be 18.000000
-Pixel (1, 14) is 21.214336, should be 19.000000
-Pixel (1, 15) is 22.116434, should be 20.000000
-Pixel (1, 16) is 23.009617, should be 21.000000
-Pixel (1, 17) is 23.910875, should be 22.000000
-Pixel (1, 18) is 24.834503, should be 23.000000
-Pixel (1, 19) is 25.790409, should be 24.000000
-Pixel (1, 20) is 26.783060, should be 25.000000
-Pixel (1, 21) is 27.811335, should be 26.000000
-Pixel (1, 22) is 28.868959, should be 27.000000
-Pixel (1, 23) is 29.945730, should be 28.000000
-Pixel (1, 24) is 31.029118, should be 29.000000
-Pixel (1, 25) is 32.106163, should be 30.000000
-Pixel (1, 26) is 33.165302, should be 31.000000
-Pixel (1, 27) is 34.198025, should be 32.000000
-Pixel (1, 28) is 35.199921, should be 33.000000
-Pixel (1, 29) is 36.171310, should be 34.000000
-Pixel (1, 30) is 37.117016, should be 35.000000
-Pixel (1, 31) is 38.045616, should be 36.000000
-Pixel (1, 32) is 38.968216, should be 37.000000
-Pixel (1, 33) is 39.896832, should be 38.000000
-Pixel (1, 34) is 40.842506, should be 39.000000
-Pixel (1, 35) is 41.813889, should be 40.000000
-Pixel (1, 36) is 42.815815, should be 41.000000
-Pixel (1, 37) is 43.848518, should be 42.000000
-Pixel (1, 38) is 44.907639, should be 43.000000
-Pixel (1, 39) is 45.984699, should be 44.000000
-Pixel (1, 40) is 47.068077, should be 45.000000
-Pixel (1, 41) is 48.144848, should be 46.000000
-Pixel (1, 42) is 49.202480, should be 47.000000
-Pixel (1, 43) is 50.230755, should be 48.000000
-Pixel (1, 44) is 51.223408, should be 49.000000
-Pixel (1, 45) is 52.179325, should be 50.000000
-Pixel (1, 46) is 53.102955, should be 51.000000
-Pixel (1, 47) is 54.004208, should be 52.000000
-Pixel (1, 48) is 54.897388, should be 53.000000
-Pixel (1, 49) is 55.799480, should be 54.000000
-Pixel (1, 50) is 56.727924, should be 55.000000
-Pixel (1, 51) is 57.697971, should be 56.000000
-Pixel (1, 52) is 58.720402, should be 57.000000
-Pixel (1, 53) is 59.799023, should be 58.000000
-Pixel (1, 54) is 60.929165, should be 59.000000
-Pixel (1, 55) is 62.096729, should be 60.000000
-Pixel (1, 56) is 63.278286, should be 61.000000
-Pixel (1, 57) is 64.442101, should be 62.000000
-Pixel (1, 58) is 65.550079, should be 63.000000
-Pixel (1, 59) is 66.560577, should be 64.000000
-Pixel (1, 60) is 67.431633, should be 65.000000
-Pixel (1, 61) is 68.124161, should be 66.000000
-Pixel (1, 62) is 68.605583, should be 67.000000
-Pixel (2, 3) is 11.989437, should be 13.000000
-Pixel (2, 4) is 12.860472, should be 14.000000
-Pixel (2, 5) is 13.870976, should be 15.000000
-Pixel (2, 6) is 14.978971, should be 16.000000
-Pixel (2, 63) is 71.259666, should be 73.000000
-Pixel (3, 1) is 14.278136, should be 16.000000
-Pixel (3, 2) is 14.759560, should be 17.000000
-Pixel (3, 3) is 15.452109, should be 18.000000
-Pixel (3, 4) is 16.323143, should be 19.000000
-Pixel (3, 5) is 17.333652, should be 20.000000
-Pixel (3, 6) is 18.441645, should be 21.000000
-Pixel (3, 7) is 19.605431, should be 22.000000
-Pixel (3, 8) is 20.786999, should be 23.000000
-Pixel (3, 9) is 21.954563, should be 24.000000
-Pixel (3, 10) is 23.084709, should be 25.000000
-Pixel (3, 11) is 24.163351, should be 26.000000
-Pixel (3, 12) is 25.185764, should be 27.000000
-Pixel (3, 13) is 26.155800, should be 28.000000
-Pixel (3, 14) is 27.084242, should be 29.000000
-Pixel (3, 15) is 27.986349, should be 30.000000
-Pixel (3, 16) is 28.879530, should be 31.000000
-Pixel (3, 17) is 29.780794, should be 32.000000
-Pixel (3, 18) is 30.704420, should be 33.000000
-Pixel (3, 19) is 31.660322, should be 34.000000
-Pixel (3, 20) is 32.652969, should be 35.000000
-Pixel (3, 21) is 33.681244, should be 36.000000
-Pixel (3, 22) is 34.738869, should be 37.000000
-Pixel (3, 23) is 35.815647, should be 38.000000
-Pixel (3, 24) is 36.899029, should be 39.000000
-Pixel (3, 25) is 37.976067, should be 40.000000
-Pixel (3, 26) is 39.035198, should be 41.000000
-Pixel (3, 27) is 40.067924, should be 42.000000
-Pixel (3, 28) is 41.069824, should be 43.000000
-Pixel (3, 29) is 42.041218, should be 44.000000
-Pixel (3, 30) is 42.986923, should be 45.000000
-Pixel (3, 31) is 43.915524, should be 46.000000
-Pixel (3, 32) is 44.838123, should be 47.000000
-Pixel (3, 33) is 45.766739, should be 48.000000
-Pixel (3, 34) is 46.712414, should be 49.000000
-Pixel (3, 35) is 47.683792, should be 50.000000
-Pixel (3, 36) is 48.685715, should be 51.000000
-Pixel (3, 37) is 49.718422, should be 52.000000
-Pixel (3, 38) is 50.777538, should be 53.000000
-Pixel (3, 39) is 51.854603, should be 54.000000
-Pixel (3, 40) is 52.937984, should be 55.000000
-Pixel (3, 41) is 54.014748, should be 56.000000
-Pixel (3, 42) is 55.072380, should be 57.000000
-Pixel (3, 43) is 56.100655, should be 58.000000
-Pixel (3, 44) is 57.093311, should be 59.000000
-Pixel (3, 45) is 58.049221, should be 60.000000
-Pixel (3, 46) is 58.972851, should be 61.000000
-Pixel (3, 47) is 59.874096, should be 62.000000
-Pixel (3, 48) is 60.767277, should be 63.000000
-Pixel (3, 49) is 61.669369, should be 64.000000
-Pixel (3, 50) is 62.597813, should be 65.000000
-Pixel (3, 51) is 63.567867, should be 66.000000
-Pixel (3, 52) is 64.590294, should be 67.000000
-Pixel (3, 53) is 65.668915, should be 68.000000
-Pixel (3, 54) is 66.799057, should be 69.000000
-Pixel (3, 55) is 67.966614, should be 70.000000
-Pixel (3, 56) is 69.148170, should be 71.000000
-Pixel (3, 57) is 70.311981, should be 72.000000
-Pixel (3, 58) is 71.419960, should be 73.000000
-Pixel (3, 59) is 72.430458, should be 74.000000
-Pixel (3, 60) is 73.301514, should be 75.000000
-Pixel (3, 61) is 73.994041, should be 76.000000
-Pixel (3, 62) is 74.475464, should be 77.000000
-Pixel (3, 63) is 74.722336, should be 78.000000
-Pixel (4, 0) is 18.386347, should be 20.000000
-Pixel (4, 1) is 18.633223, should be 21.000000
-Pixel (4, 2) is 19.114639, should be 22.000000
-Pixel (4, 3) is 19.807188, should be 23.000000
-Pixel (4, 4) is 20.678223, should be 24.000000
-Pixel (4, 5) is 21.688732, should be 25.000000
-Pixel (4, 6) is 22.796722, should be 26.000000
-Pixel (4, 7) is 23.960510, should be 27.000000
-Pixel (4, 8) is 25.142078, should be 28.000000
-Pixel (4, 9) is 26.309643, should be 29.000000
-Pixel (4, 10) is 27.439787, should be 30.000000
-Pixel (4, 11) is 28.518431, should be 31.000000
-Pixel (4, 12) is 29.540842, should be 32.000000
-Pixel (4, 13) is 30.510878, should be 33.000000
-Pixel (4, 14) is 31.439322, should be 34.000000
-Pixel (4, 15) is 32.341431, should be 35.000000
-Pixel (4, 16) is 33.234608, should be 36.000000
-Pixel (4, 17) is 34.135872, should be 37.000000
-Pixel (4, 18) is 35.059502, should be 38.000000
-Pixel (4, 19) is 36.015400, should be 39.000000
-Pixel (4, 20) is 37.008049, should be 40.000000
-Pixel (4, 21) is 38.036324, should be 41.000000
-Pixel (4, 22) is 39.093948, should be 42.000000
-Pixel (4, 23) is 40.170727, should be 43.000000
-Pixel (4, 24) is 41.254105, should be 44.000000
-Pixel (4, 25) is 42.331139, should be 45.000000
-Pixel (4, 26) is 43.390274, should be 46.000000
-Pixel (4, 27) is 44.423000, should be 47.000000
-Pixel (4, 28) is 45.424900, should be 48.000000
-Pixel (4, 29) is 46.396290, should be 49.000000
-Pixel (4, 30) is 47.341991, should be 50.000000
-Pixel (4, 31) is 48.270596, should be 51.000000
-Pixel (4, 32) is 49.193195, should be 52.000000
-Pixel (4, 33) is 50.121807, should be 53.000000
-Pixel (4, 34) is 51.067486, should be 54.000000
-Pixel (4, 35) is 52.038868, should be 55.000000
-Pixel (4, 36) is 53.040791, should be 56.000000
-Pixel (4, 37) is 54.073498, should be 57.000000
-Pixel (4, 38) is 55.132618, should be 58.000000
-Pixel (4, 39) is 56.209679, should be 59.000000
-Pixel (4, 40) is 57.293053, should be 60.000000
-Pixel (4, 41) is 58.369827, should be 61.000000
-Pixel (4, 42) is 59.427456, should be 62.000000
-Pixel (4, 43) is 60.455734, should be 63.000000
-Pixel (4, 44) is 61.448387, should be 64.000000
-Pixel (4, 45) is 62.404301, should be 65.000000
-Pixel (4, 46) is 63.327930, should be 66.000000
-Pixel (4, 47) is 64.229172, should be 67.000000
-Pixel (4, 48) is 65.122353, should be 68.000000
-Pixel (4, 49) is 66.024445, should be 69.000000
-Pixel (4, 50) is 66.952888, should be 70.000000
-Pixel (4, 51) is 67.922943, should be 71.000000
-Pixel (4, 52) is 68.945374, should be 72.000000
-Pixel (4, 53) is 70.023994, should be 73.000000
-Pixel (4, 54) is 71.154137, should be 74.000000
-Pixel (4, 55) is 72.321693, should be 75.000000
-Pixel (4, 56) is 73.503250, should be 76.000000
-Pixel (4, 57) is 74.667061, should be 77.000000
-Pixel (4, 58) is 75.775040, should be 78.000000
-Pixel (4, 59) is 76.785538, should be 79.000000
-Pixel (4, 60) is 77.656593, should be 80.000000
-Pixel (4, 61) is 78.349121, should be 81.000000
-Pixel (4, 62) is 78.830544, should be 82.000000
-Pixel (4, 63) is 79.077415, should be 83.000000
-Pixel (5, 0) is 23.438900, should be 25.000000
-Pixel (5, 1) is 23.685776, should be 26.000000
-Pixel (5, 2) is 24.167196, should be 27.000000
-Pixel (5, 3) is 24.859745, should be 28.000000
-Pixel (5, 4) is 25.730778, should be 29.000000
-Pixel (5, 5) is 26.741287, should be 30.000000
-Pixel (5, 6) is 27.849277, should be 31.000000
-Pixel (5, 7) is 29.013062, should be 32.000000
-Pixel (5, 8) is 30.194633, should be 33.000000
-Pixel (5, 9) is 31.362202, should be 34.000000
-Pixel (5, 10) is 32.492336, should be 35.000000
-Pixel (5, 11) is 33.570980, should be 36.000000
-Pixel (5, 12) is 34.593395, should be 37.000000
-Pixel (5, 13) is 35.563431, should be 38.000000
-Pixel (5, 14) is 36.491875, should be 39.000000
-Pixel (5, 15) is 37.393982, should be 40.000000
-Pixel (5, 16) is 38.287159, should be 41.000000
-Pixel (5, 17) is 39.188427, should be 42.000000
-Pixel (5, 18) is 40.112053, should be 43.000000
-Pixel (5, 19) is 41.067951, should be 44.000000
-Pixel (5, 20) is 42.060600, should be 45.000000
-Pixel (5, 21) is 43.088879, should be 46.000000
-Pixel (5, 22) is 44.146500, should be 47.000000
-Pixel (5, 23) is 45.223278, should be 48.000000
-Pixel (5, 24) is 46.306656, should be 49.000000
-Pixel (5, 25) is 47.383690, should be 50.000000
-Pixel (5, 26) is 48.442825, should be 51.000000
-Pixel (5, 27) is 49.475555, should be 52.000000
-Pixel (5, 28) is 50.477451, should be 53.000000
-Pixel (5, 29) is 51.448841, should be 54.000000
-Pixel (5, 30) is 52.394543, should be 55.000000
-Pixel (5, 31) is 53.323143, should be 56.000000
-Pixel (5, 32) is 54.245747, should be 57.000000
-Pixel (5, 33) is 55.174358, should be 58.000000
-Pixel (5, 34) is 56.120037, should be 59.000000
-Pixel (5, 35) is 57.091419, should be 60.000000
-Pixel (5, 36) is 58.093342, should be 61.000000
-Pixel (5, 37) is 59.126049, should be 62.000000
-Pixel (5, 38) is 60.185169, should be 63.000000
-Pixel (5, 39) is 61.262234, should be 64.000000
-Pixel (5, 40) is 62.345604, should be 65.000000
-Pixel (5, 41) is 63.422379, should be 66.000000
-Pixel (5, 42) is 64.480019, should be 67.000000
-Pixel (5, 43) is 65.508286, should be 68.000000
-Pixel (5, 44) is 66.500938, should be 69.000000
-Pixel (5, 45) is 67.456848, should be 70.000000
-Pixel (5, 46) is 68.380478, should be 71.000000
-Pixel (5, 47) is 69.281731, should be 72.000000
-Pixel (5, 48) is 70.174911, should be 73.000000
-Pixel (5, 49) is 71.076996, should be 74.000000
-Pixel (5, 50) is 72.005440, should be 75.000000
-Pixel (5, 51) is 72.975487, should be 76.000000
-Pixel (5, 52) is 73.997925, should be 77.000000
-Pixel (5, 53) is 75.076546, should be 78.000000
-Pixel (5, 54) is 76.206688, should be 79.000000
-Pixel (5, 55) is 77.374245, should be 80.000000
-Pixel (5, 56) is 78.555801, should be 81.000000
-Pixel (5, 57) is 79.719612, should be 82.000000
-Pixel (5, 58) is 80.827591, should be 83.000000
-Pixel (5, 59) is 81.838089, should be 84.000000
-Pixel (5, 60) is 82.709145, should be 85.000000
-Pixel (5, 61) is 83.401672, should be 86.000000
-Pixel (5, 62) is 83.883095, should be 87.000000
-Pixel (5, 63) is 84.129967, should be 88.000000
-Pixel (6, 0) is 28.978821, should be 30.000000
-Pixel (6, 1) is 29.225697, should be 31.000000
-Pixel (6, 2) is 29.707121, should be 32.000000
-Pixel (6, 3) is 30.399666, should be 33.000000
-Pixel (6, 4) is 31.270700, should be 34.000000
-Pixel (6, 5) is 32.281208, should be 35.000000
-Pixel (6, 6) is 33.389198, should be 36.000000
-Pixel (6, 7) is 34.552982, should be 37.000000
-Pixel (6, 8) is 35.734558, should be 38.000000
-Pixel (6, 9) is 36.902122, should be 39.000000
-Pixel (6, 10) is 38.032261, should be 40.000000
-Pixel (6, 11) is 39.110905, should be 41.000000
-Pixel (6, 12) is 40.133320, should be 42.000000
-Pixel (6, 13) is 41.103355, should be 43.000000
-Pixel (6, 14) is 42.031799, should be 44.000000
-Pixel (6, 15) is 42.933907, should be 45.000000
-Pixel (6, 16) is 43.827087, should be 46.000000
-Pixel (6, 17) is 44.728352, should be 47.000000
-Pixel (6, 18) is 45.651978, should be 48.000000
-Pixel (6, 19) is 46.607880, should be 49.000000
-Pixel (6, 20) is 47.600521, should be 50.000000
-Pixel (6, 21) is 48.628799, should be 51.000000
-Pixel (6, 22) is 49.686420, should be 52.000000
-Pixel (6, 23) is 50.763195, should be 53.000000
-Pixel (6, 24) is 51.846577, should be 54.000000
-Pixel (6, 25) is 52.923611, should be 55.000000
-Pixel (6, 26) is 53.982746, should be 56.000000
-Pixel (6, 27) is 55.015476, should be 57.000000
-Pixel (6, 28) is 56.017372, should be 58.000000
-Pixel (6, 29) is 56.988762, should be 59.000000
-Pixel (6, 30) is 57.934464, should be 60.000000
-Pixel (6, 31) is 58.863060, should be 61.000000
-Pixel (6, 32) is 59.785667, should be 62.000000
-Pixel (6, 33) is 60.714279, should be 63.000000
-Pixel (6, 34) is 61.659958, should be 64.000000
-Pixel (6, 35) is 62.631340, should be 65.000000
-Pixel (6, 36) is 63.633255, should be 66.000000
-Pixel (6, 37) is 64.665970, should be 67.000000
-Pixel (6, 38) is 65.725090, should be 68.000000
-Pixel (6, 39) is 66.802147, should be 69.000000
-Pixel (6, 40) is 67.885521, should be 70.000000
-Pixel (6, 41) is 68.962288, should be 71.000000
-Pixel (6, 42) is 70.019920, should be 72.000000
-Pixel (6, 43) is 71.048203, should be 73.000000
-Pixel (6, 44) is 72.040855, should be 74.000000
-Pixel (6, 45) is 72.996765, should be 75.000000
-Pixel (6, 46) is 73.920395, should be 76.000000
-Pixel (6, 47) is 74.821648, should be 77.000000
-Pixel (6, 48) is 75.714828, should be 78.000000
-Pixel (6, 49) is 76.616920, should be 79.000000
-Pixel (6, 50) is 77.545364, should be 80.000000
-Pixel (6, 51) is 78.515411, should be 81.000000
-Pixel (6, 52) is 79.537849, should be 82.000000
-Pixel (6, 53) is 80.616470, should be 83.000000
-Pixel (6, 54) is 81.746613, should be 84.000000
-Pixel (6, 55) is 82.914162, should be 85.000000
-Pixel (6, 56) is 84.095718, should be 86.000000
-Pixel (6, 57) is 85.259529, should be 87.000000
-Pixel (6, 58) is 86.367508, should be 88.000000
-Pixel (6, 59) is 87.378014, should be 89.000000
-Pixel (6, 60) is 88.249062, should be 90.000000
-Pixel (6, 61) is 88.941589, should be 91.000000
-Pixel (6, 62) is 89.423012, should be 92.000000
-Pixel (6, 63) is 89.669884, should be 93.000000
-Pixel (7, 2) is 35.526096, should be 37.000000
-Pixel (7, 3) is 36.218639, should be 38.000000
-Pixel (7, 4) is 37.089676, should be 39.000000
-Pixel (7, 5) is 38.100182, should be 40.000000
-Pixel (7, 6) is 39.208172, should be 41.000000
-Pixel (7, 7) is 40.371956, should be 42.000000
-Pixel (7, 8) is 41.553528, should be 43.000000
-Pixel (7, 9) is 42.721092, should be 44.000000
-Pixel (7, 10) is 43.851231, should be 45.000000
-Pixel (7, 11) is 44.929874, should be 46.000000
-Pixel (7, 12) is 45.952286, should be 47.000000
-Pixel (7, 13) is 46.922325, should be 48.000000
-Pixel (7, 14) is 47.850777, should be 49.000000
-Pixel (7, 15) is 48.752880, should be 50.000000
-Pixel (7, 16) is 49.646057, should be 51.000000
-Pixel (7, 17) is 50.547321, should be 52.000000
-Pixel (7, 18) is 51.470947, should be 53.000000
-Pixel (7, 19) is 52.426857, should be 54.000000
-Pixel (7, 20) is 53.419491, should be 55.000000
-Pixel (7, 21) is 54.447769, should be 56.000000
-Pixel (7, 22) is 55.505390, should be 57.000000
-Pixel (7, 23) is 56.582165, should be 58.000000
-Pixel (7, 24) is 57.665546, should be 59.000000
-Pixel (7, 25) is 58.742580, should be 60.000000
-Pixel (7, 26) is 59.801716, should be 61.000000
-Pixel (7, 27) is 60.834446, should be 62.000000
-Pixel (7, 28) is 61.836342, should be 63.000000
-Pixel (7, 29) is 62.807732, should be 64.000000
-Pixel (7, 30) is 63.753433, should be 65.000000
-Pixel (7, 31) is 64.682030, should be 66.000000
-Pixel (7, 32) is 65.604637, should be 67.000000
-Pixel (7, 33) is 66.533249, should be 68.000000
-Pixel (7, 34) is 67.478920, should be 69.000000
-Pixel (7, 35) is 68.450302, should be 70.000000
-Pixel (7, 36) is 69.452217, should be 71.000000
-Pixel (7, 37) is 70.484932, should be 72.000000
-Pixel (7, 38) is 71.544060, should be 73.000000
-Pixel (7, 39) is 72.621117, should be 74.000000
-Pixel (7, 40) is 73.704491, should be 75.000000
-Pixel (7, 41) is 74.781258, should be 76.000000
-Pixel (7, 42) is 75.838882, should be 77.000000
-Pixel (7, 43) is 76.867172, should be 78.000000
-Pixel (7, 44) is 77.859825, should be 79.000000
-Pixel (7, 45) is 78.815735, should be 80.000000
-Pixel (7, 46) is 79.739365, should be 81.000000
-Pixel (7, 47) is 80.640617, should be 82.000000
-Pixel (7, 48) is 81.533798, should be 83.000000
-Pixel (7, 49) is 82.435883, should be 84.000000
-Pixel (7, 50) is 83.364334, should be 85.000000
-Pixel (7, 51) is 84.334381, should be 86.000000
-Pixel (7, 52) is 85.356812, should be 87.000000
-Pixel (7, 53) is 86.435432, should be 88.000000
-Pixel (7, 54) is 87.565575, should be 89.000000
-Pixel (7, 55) is 88.733131, should be 90.000000
-Pixel (7, 56) is 89.914688, should be 91.000000
-Pixel (7, 61) is 94.760567, should be 96.000000
-Pixel (7, 62) is 95.241982, should be 97.000000
-Pixel (7, 63) is 95.488853, should be 98.000000
-Pixel (8, 4) is 42.997402, should be 44.000000
-Pixel (8, 63) is 101.396591, should be 103.000000
-Pixel (9, 0) is 46.543343, should be 45.000000
-Pixel (10, 0) is 52.194046, should be 50.000000
-Pixel (10, 1) is 52.440922, should be 51.000000
-Pixel (10, 9) is 60.117329, should be 59.000000
-Pixel (10, 10) is 61.247471, should be 60.000000
-Pixel (10, 11) is 62.326111, should be 61.000000
-Pixel (10, 12) is 63.348526, should be 62.000000
-Pixel (10, 13) is 64.318565, should be 63.000000
-Pixel (10, 14) is 65.247009, should be 64.000000
-Pixel (10, 15) is 66.149117, should be 65.000000
-Pixel (10, 16) is 67.042290, should be 66.000000
-Pixel (10, 24) is 75.061806, should be 74.000000
-Pixel (10, 25) is 76.138832, should be 75.000000
-Pixel (10, 26) is 77.197975, should be 76.000000
-Pixel (10, 27) is 78.230690, should be 77.000000
-Pixel (10, 28) is 79.232597, should be 78.000000
-Pixel (10, 29) is 80.203979, should be 79.000000
-Pixel (10, 30) is 81.149681, should be 80.000000
-Pixel (10, 31) is 82.078278, should be 81.000000
-Pixel (10, 32) is 83.000885, should be 82.000000
-Pixel (10, 39) is 90.017372, should be 89.000000
-Pixel (10, 40) is 91.100746, should be 90.000000
-Pixel (10, 41) is 92.177513, should be 91.000000
-Pixel (10, 42) is 93.235138, should be 92.000000
-Pixel (10, 43) is 94.263412, should be 93.000000
-Pixel (10, 44) is 95.256073, should be 94.000000
-Pixel (10, 45) is 96.211983, should be 95.000000
-Pixel (10, 46) is 97.135612, should be 96.000000
-Pixel (10, 47) is 98.036858, should be 97.000000
-Pixel (10, 55) is 106.129387, should be 105.000000
-Pixel (10, 56) is 107.310951, should be 106.000000
-Pixel (10, 57) is 108.474754, should be 107.000000
-Pixel (10, 58) is 109.582733, should be 108.000000
-Pixel (10, 59) is 110.593239, should be 109.000000
-Pixel (10, 60) is 111.464287, should be 110.000000
-Pixel (10, 61) is 112.156822, should be 111.000000
-Pixel (11, 0) is 57.587215, should be 55.000000
-Pixel (11, 1) is 57.834091, should be 56.000000
-Pixel (11, 2) is 58.315510, should be 57.000000
-Pixel (11, 3) is 59.008057, should be 58.000000
-Pixel (11, 7) is 63.161362, should be 62.000000
-Pixel (11, 8) is 64.342926, should be 63.000000
-Pixel (11, 9) is 65.510483, should be 64.000000
-Pixel (11, 10) is 66.640625, should be 65.000000
-Pixel (11, 11) is 67.719269, should be 66.000000
-Pixel (11, 12) is 68.741676, should be 67.000000
-Pixel (11, 13) is 69.711723, should be 68.000000
-Pixel (11, 14) is 70.640167, should be 69.000000
-Pixel (11, 15) is 71.542274, should be 70.000000
-Pixel (11, 16) is 72.435448, should be 71.000000
-Pixel (11, 17) is 73.336716, should be 72.000000
-Pixel (11, 18) is 74.260345, should be 73.000000
-Pixel (11, 19) is 75.216240, should be 74.000000
-Pixel (11, 20) is 76.208900, should be 75.000000
-Pixel (11, 21) is 77.237175, should be 76.000000
-Pixel (11, 22) is 78.294800, should be 77.000000
-Pixel (11, 23) is 79.371574, should be 78.000000
-Pixel (11, 24) is 80.454956, should be 79.000000
-Pixel (11, 25) is 81.531982, should be 80.000000
-Pixel (11, 26) is 82.591125, should be 81.000000
-Pixel (11, 27) is 83.623840, should be 82.000000
-Pixel (11, 28) is 84.625748, should be 83.000000
-Pixel (11, 29) is 85.597130, should be 84.000000
-Pixel (11, 30) is 86.542831, should be 85.000000
-Pixel (11, 31) is 87.471428, should be 86.000000
-Pixel (11, 32) is 88.394035, should be 87.000000
-Pixel (11, 33) is 89.322647, should be 88.000000
-Pixel (11, 34) is 90.268318, should be 89.000000
-Pixel (11, 35) is 91.239700, should be 90.000000
-Pixel (11, 36) is 92.241623, should be 91.000000
-Pixel (11, 37) is 93.274338, should be 92.000000
-Pixel (11, 38) is 94.333466, should be 93.000000
-Pixel (11, 39) is 95.410522, should be 94.000000
-Pixel (11, 40) is 96.493904, should be 95.000000
-Pixel (11, 41) is 97.570663, should be 96.000000
-Pixel (11, 42) is 98.628288, should be 97.000000
-Pixel (11, 43) is 99.656563, should be 98.000000
-Pixel (11, 44) is 100.649223, should be 99.000000
-Pixel (11, 45) is 101.605133, should be 100.000000
-Pixel (11, 46) is 102.528763, should be 101.000000
-Pixel (11, 47) is 103.430008, should be 102.000000
-Pixel (11, 48) is 104.323196, should be 103.000000
-Pixel (11, 49) is 105.225281, should be 104.000000
-Pixel (11, 50) is 106.153732, should be 105.000000
-Pixel (11, 51) is 107.123779, should be 106.000000
-Pixel (11, 52) is 108.146210, should be 107.000000
-Pixel (11, 53) is 109.224831, should be 108.000000
-Pixel (11, 54) is 110.354980, should be 109.000000
-Pixel (11, 55) is 111.522530, should be 110.000000
-Pixel (11, 56) is 112.704102, should be 111.000000
-Pixel (11, 57) is 113.867912, should be 112.000000
-Pixel (11, 58) is 114.975891, should be 113.000000
-Pixel (11, 59) is 115.986397, should be 114.000000
-Pixel (11, 60) is 116.857445, should be 115.000000
-Pixel (11, 61) is 117.549980, should be 116.000000
-Pixel (11, 62) is 118.031387, should be 117.000000
-Pixel (12, 0) is 62.699329, should be 60.000000
-Pixel (12, 1) is 62.946201, should be 61.000000
-Pixel (12, 2) is 63.427620, should be 62.000000
-Pixel (12, 3) is 64.120163, should be 63.000000
-Pixel (12, 5) is 66.001686, should be 65.000000
-Pixel (12, 6) is 67.109680, should be 66.000000
-Pixel (12, 7) is 68.273460, should be 67.000000
-Pixel (12, 8) is 69.455032, should be 68.000000
-Pixel (12, 9) is 70.622589, should be 69.000000
-Pixel (12, 10) is 71.752739, should be 70.000000
-Pixel (12, 11) is 72.831375, should be 71.000000
-Pixel (12, 12) is 73.853783, should be 72.000000
-Pixel (12, 13) is 74.823830, should be 73.000000
-Pixel (12, 14) is 75.752281, should be 74.000000
-Pixel (12, 15) is 76.654381, should be 75.000000
-Pixel (12, 16) is 77.547569, should be 76.000000
-Pixel (12, 17) is 78.448830, should be 77.000000
-Pixel (12, 18) is 79.372459, should be 78.000000
-Pixel (12, 19) is 80.328369, should be 79.000000
-Pixel (12, 20) is 81.321014, should be 80.000000
-Pixel (12, 21) is 82.349289, should be 81.000000
-Pixel (12, 22) is 83.406914, should be 82.000000
-Pixel (12, 23) is 84.483688, should be 83.000000
-Pixel (12, 24) is 85.567070, should be 84.000000
-Pixel (12, 25) is 86.644096, should be 85.000000
-Pixel (12, 26) is 87.703239, should be 86.000000
-Pixel (12, 27) is 88.735954, should be 87.000000
-Pixel (12, 28) is 89.737862, should be 88.000000
-Pixel (12, 29) is 90.709244, should be 89.000000
-Pixel (12, 30) is 91.654945, should be 90.000000
-Pixel (12, 31) is 92.583542, should be 91.000000
-Pixel (12, 32) is 93.506149, should be 92.000000
-Pixel (12, 33) is 94.434761, should be 93.000000
-Pixel (12, 34) is 95.380432, should be 94.000000
-Pixel (12, 35) is 96.351814, should be 95.000000
-Pixel (12, 36) is 97.353737, should be 96.000000
-Pixel (12, 37) is 98.386452, should be 97.000000
-Pixel (12, 38) is 99.445580, should be 98.000000
-Pixel (12, 39) is 100.522636, should be 99.000000
-Pixel (12, 40) is 101.606018, should be 100.000000
-Pixel (12, 41) is 102.682777, should be 101.000000
-Pixel (12, 42) is 103.740402, should be 102.000000
-Pixel (12, 43) is 104.768677, should be 103.000000
-Pixel (12, 44) is 105.761322, should be 104.000000
-Pixel (12, 45) is 106.717247, should be 105.000000
-Pixel (12, 46) is 107.640877, should be 106.000000
-Pixel (12, 47) is 108.542122, should be 107.000000
-Pixel (12, 48) is 109.435310, should be 108.000000
-Pixel (12, 49) is 110.337395, should be 109.000000
-Pixel (12, 50) is 111.265846, should be 110.000000
-Pixel (12, 51) is 112.235893, should be 111.000000
-Pixel (12, 52) is 113.258324, should be 112.000000
-Pixel (12, 53) is 114.336952, should be 113.000000
-Pixel (12, 54) is 115.467087, should be 114.000000
-Pixel (12, 55) is 116.634636, should be 115.000000
-Pixel (12, 56) is 117.816208, should be 116.000000
-Pixel (12, 57) is 118.980011, should be 117.000000
-Pixel (12, 58) is 120.087990, should be 118.000000
-Pixel (12, 59) is 121.098503, should be 119.000000
-Pixel (12, 60) is 121.969551, should be 120.000000
-Pixel (12, 61) is 122.662086, should be 121.000000
-Pixel (12, 62) is 123.143494, should be 122.000000
-Pixel (13, 0) is 67.549660, should be 65.000000
-Pixel (13, 1) is 67.796532, should be 66.000000
-Pixel (13, 2) is 68.277954, should be 67.000000
-Pixel (13, 7) is 73.123795, should be 72.000000
-Pixel (13, 8) is 74.305367, should be 73.000000
-Pixel (13, 9) is 75.472939, should be 74.000000
-Pixel (13, 10) is 76.603073, should be 75.000000
-Pixel (13, 11) is 77.681717, should be 76.000000
-Pixel (13, 12) is 78.704124, should be 77.000000
-Pixel (13, 13) is 79.674164, should be 78.000000
-Pixel (13, 14) is 80.602615, should be 79.000000
-Pixel (13, 15) is 81.504715, should be 80.000000
-Pixel (13, 16) is 82.397903, should be 81.000000
-Pixel (13, 17) is 83.299164, should be 82.000000
-Pixel (13, 18) is 84.222794, should be 83.000000
-Pixel (13, 19) is 85.178711, should be 84.000000
-Pixel (13, 20) is 86.171349, should be 85.000000
-Pixel (13, 21) is 87.199623, should be 86.000000
-Pixel (13, 22) is 88.257248, should be 87.000000
-Pixel (13, 23) is 89.334023, should be 88.000000
-Pixel (13, 24) is 90.417404, should be 89.000000
-Pixel (13, 25) is 91.494431, should be 90.000000
-Pixel (13, 26) is 92.553566, should be 91.000000
-Pixel (13, 27) is 93.586288, should be 92.000000
-Pixel (13, 28) is 94.588188, should be 93.000000
-Pixel (13, 29) is 95.559578, should be 94.000000
-Pixel (13, 30) is 96.505280, should be 95.000000
-Pixel (13, 31) is 97.433876, should be 96.000000
-Pixel (13, 32) is 98.356483, should be 97.000000
-Pixel (13, 33) is 99.285095, should be 98.000000
-Pixel (13, 34) is 100.230766, should be 99.000000
-Pixel (13, 35) is 101.202156, should be 100.000000
-Pixel (13, 36) is 102.204071, should be 101.000000
-Pixel (13, 37) is 103.236794, should be 102.000000
-Pixel (13, 38) is 104.295914, should be 103.000000
-Pixel (13, 39) is 105.372971, should be 104.000000
-Pixel (13, 40) is 106.456352, should be 105.000000
-Pixel (13, 41) is 107.533112, should be 106.000000
-Pixel (13, 42) is 108.590736, should be 107.000000
-Pixel (13, 43) is 109.619011, should be 108.000000
-Pixel (13, 44) is 110.611664, should be 109.000000
-Pixel (13, 45) is 111.567581, should be 110.000000
-Pixel (13, 46) is 112.491211, should be 111.000000
-Pixel (13, 47) is 113.392456, should be 112.000000
-Pixel (13, 48) is 114.285645, should be 113.000000
-Pixel (13, 49) is 115.187729, should be 114.000000
-Pixel (13, 50) is 116.116180, should be 115.000000
-Pixel (13, 51) is 117.086220, should be 116.000000
-Pixel (13, 52) is 118.108658, should be 117.000000
-Pixel (13, 53) is 119.187286, should be 118.000000
-Pixel (13, 54) is 120.317421, should be 119.000000
-Pixel (13, 55) is 121.484970, should be 120.000000
-Pixel (13, 56) is 122.666542, should be 121.000000
-Pixel (13, 57) is 123.830345, should be 122.000000
-Pixel (13, 58) is 124.938332, should be 123.000000
-Pixel (13, 59) is 125.948830, should be 124.000000
-Pixel (13, 60) is 126.819878, should be 125.000000
-Pixel (13, 61) is 127.512413, should be 126.000000
-Pixel (14, 0) is 72.191757, should be 70.000000
-Pixel (14, 1) is 72.438629, should be 71.000000
-Pixel (14, 9) is 80.115044, should be 79.000000
-Pixel (14, 10) is 81.245178, should be 80.000000
-Pixel (14, 11) is 82.323822, should be 81.000000
-Pixel (14, 12) is 83.346230, should be 82.000000
-Pixel (14, 13) is 84.316269, should be 83.000000
-Pixel (14, 14) is 85.244720, should be 84.000000
-Pixel (14, 15) is 86.146820, should be 85.000000
-Pixel (14, 16) is 87.040009, should be 86.000000
-Pixel (14, 24) is 95.059509, should be 94.000000
-Pixel (14, 25) is 96.136536, should be 95.000000
-Pixel (14, 26) is 97.195671, should be 96.000000
-Pixel (14, 27) is 98.228394, should be 97.000000
-Pixel (14, 28) is 99.230293, should be 98.000000
-Pixel (14, 29) is 100.201683, should be 99.000000
-Pixel (14, 30) is 101.147377, should be 100.000000
-Pixel (14, 31) is 102.075981, should be 101.000000
-Pixel (14, 39) is 110.015076, should be 109.000000
-Pixel (14, 40) is 111.098457, should be 110.000000
-Pixel (14, 41) is 112.175217, should be 111.000000
-Pixel (14, 42) is 113.232841, should be 112.000000
-Pixel (14, 43) is 114.261116, should be 113.000000
-Pixel (14, 44) is 115.253769, should be 114.000000
-Pixel (14, 45) is 116.209679, should be 115.000000
-Pixel (14, 46) is 117.133308, should be 116.000000
-Pixel (14, 47) is 118.034561, should be 117.000000
-Pixel (14, 55) is 126.127083, should be 125.000000
-Pixel (14, 56) is 127.308655, should be 126.000000
-Pixel (14, 57) is 128.472458, should be 127.000000
-Pixel (14, 58) is 129.580444, should be 128.000000
-Pixel (14, 59) is 130.590958, should be 129.000000
-Pixel (14, 60) is 131.462006, should be 130.000000
-Pixel (14, 61) is 132.154541, should be 131.000000
-Pixel (15, 0) is 76.702263, should be 75.000000
-Pixel (15, 58) is 134.090927, should be 133.000000
-Pixel (15, 59) is 135.101425, should be 134.000000
-Pixel (16, 0) is 81.168243, should be 80.000000
-Pixel (16, 63) is 141.859314, should be 143.000000
-Pixel (17, 4) is 87.966415, should be 89.000000
-Pixel (17, 5) is 88.976913, should be 90.000000
-Pixel (17, 63) is 146.365601, should be 148.000000
-Pixel (18, 3) is 91.713509, should be 93.000000
-Pixel (18, 4) is 92.584534, should be 94.000000
-Pixel (18, 5) is 93.595032, should be 95.000000
-Pixel (18, 6) is 94.703026, should be 96.000000
-Pixel (18, 7) is 95.866806, should be 97.000000
-Pixel (18, 18) is 106.965820, should be 108.000000
-Pixel (18, 19) is 107.921722, should be 109.000000
-Pixel (18, 20) is 108.914375, should be 110.000000
-Pixel (18, 21) is 109.942650, should be 111.000000
-Pixel (18, 34) is 122.973785, should be 124.000000
-Pixel (18, 35) is 123.945175, should be 125.000000
-Pixel (18, 36) is 124.947090, should be 126.000000
-Pixel (18, 37) is 125.979820, should be 127.000000
-Pixel (18, 49) is 137.930756, should be 139.000000
-Pixel (18, 50) is 138.859222, should be 140.000000
-Pixel (18, 51) is 139.829285, should be 141.000000
-Pixel (18, 52) is 140.851715, should be 142.000000
-Pixel (18, 53) is 141.930328, should be 143.000000
-Pixel (18, 62) is 150.736877, should be 152.000000
-Pixel (18, 63) is 150.983749, should be 153.000000
-Pixel (19, 2) is 95.800407, should be 97.000000
-Pixel (19, 3) is 96.492950, should be 98.000000
-Pixel (19, 4) is 97.363976, should be 99.000000
-Pixel (19, 5) is 98.374474, should be 100.000000
-Pixel (19, 6) is 99.482468, should be 101.000000
-Pixel (19, 7) is 100.646248, should be 102.000000
-Pixel (19, 8) is 101.827812, should be 103.000000
-Pixel (19, 9) is 102.995369, should be 104.000000
-Pixel (19, 16) is 109.920364, should be 111.000000
-Pixel (19, 17) is 110.821632, should be 112.000000
-Pixel (19, 18) is 111.745262, should be 113.000000
-Pixel (19, 19) is 112.701164, should be 114.000000
-Pixel (19, 20) is 113.693817, should be 115.000000
-Pixel (19, 21) is 114.722092, should be 116.000000
-Pixel (19, 22) is 115.779716, should be 117.000000
-Pixel (19, 23) is 116.856483, should be 118.000000
-Pixel (19, 24) is 117.939865, should be 119.000000
-Pixel (19, 31) is 124.956329, should be 126.000000
-Pixel (19, 32) is 125.878944, should be 127.000000
-Pixel (19, 33) is 126.807564, should be 128.000000
-Pixel (19, 34) is 127.753242, should be 129.000000
-Pixel (19, 35) is 128.724625, should be 130.000000
-Pixel (19, 36) is 129.726532, should be 131.000000
-Pixel (19, 37) is 130.759247, should be 132.000000
-Pixel (19, 38) is 131.818390, should be 133.000000
-Pixel (19, 39) is 132.895432, should be 134.000000
-Pixel (19, 40) is 133.978821, should be 135.000000
-Pixel (19, 47) is 140.914932, should be 142.000000
-Pixel (19, 48) is 141.808121, should be 143.000000
-Pixel (19, 49) is 142.710205, should be 144.000000
-Pixel (19, 50) is 143.638657, should be 145.000000
-Pixel (19, 51) is 144.608719, should be 146.000000
-Pixel (19, 52) is 145.631149, should be 147.000000
-Pixel (19, 53) is 146.709763, should be 148.000000
-Pixel (19, 54) is 147.839905, should be 149.000000
-Pixel (19, 62) is 155.516312, should be 157.000000
-Pixel (19, 63) is 155.763184, should be 158.000000
-Pixel (20, 2) is 100.763664, should be 102.000000
-Pixel (20, 3) is 101.456207, should be 103.000000
-Pixel (20, 4) is 102.327232, should be 104.000000
-Pixel (20, 5) is 103.337730, should be 105.000000
-Pixel (20, 6) is 104.445724, should be 106.000000
-Pixel (20, 7) is 105.609505, should be 107.000000
-Pixel (20, 8) is 106.791069, should be 108.000000
-Pixel (20, 9) is 107.958626, should be 109.000000
-Pixel (20, 15) is 113.990417, should be 115.000000
-Pixel (20, 16) is 114.883606, should be 116.000000
-Pixel (20, 17) is 115.784882, should be 117.000000
-Pixel (20, 18) is 116.708504, should be 118.000000
-Pixel (20, 19) is 117.664406, should be 119.000000
-Pixel (20, 20) is 118.657051, should be 120.000000
-Pixel (20, 21) is 119.685341, should be 121.000000
-Pixel (20, 22) is 120.742958, should be 122.000000
-Pixel (20, 23) is 121.819725, should be 123.000000
-Pixel (20, 24) is 122.903107, should be 124.000000
-Pixel (20, 25) is 123.980141, should be 125.000000
-Pixel (20, 30) is 128.990982, should be 130.000000
-Pixel (20, 31) is 129.919571, should be 131.000000
-Pixel (20, 32) is 130.842178, should be 132.000000
-Pixel (20, 33) is 131.770798, should be 133.000000
-Pixel (20, 34) is 132.716476, should be 134.000000
-Pixel (20, 35) is 133.687866, should be 135.000000
-Pixel (20, 36) is 134.689774, should be 136.000000
-Pixel (20, 37) is 135.722488, should be 137.000000
-Pixel (20, 38) is 136.781631, should be 138.000000
-Pixel (20, 39) is 137.858673, should be 139.000000
-Pixel (20, 40) is 138.942047, should be 140.000000
-Pixel (20, 46) is 144.976913, should be 146.000000
-Pixel (20, 47) is 145.878143, should be 147.000000
-Pixel (20, 48) is 146.771332, should be 148.000000
-Pixel (20, 49) is 147.673416, should be 149.000000
-Pixel (20, 50) is 148.601868, should be 150.000000
-Pixel (20, 51) is 149.571915, should be 151.000000
-Pixel (20, 52) is 150.594360, should be 152.000000
-Pixel (20, 53) is 151.672989, should be 153.000000
-Pixel (20, 54) is 152.803116, should be 154.000000
-Pixel (20, 55) is 153.970657, should be 155.000000
-Pixel (20, 61) is 159.998108, should be 161.000000
-Pixel (20, 62) is 160.479507, should be 162.000000
-Pixel (20, 63) is 160.726395, should be 163.000000
-Pixel (21, 2) is 105.905037, should be 107.000000
-Pixel (21, 3) is 106.597580, should be 108.000000
-Pixel (21, 4) is 107.468605, should be 109.000000
-Pixel (21, 5) is 108.479103, should be 110.000000
-Pixel (21, 6) is 109.587105, should be 111.000000
-Pixel (21, 7) is 110.750885, should be 112.000000
-Pixel (21, 8) is 111.932449, should be 113.000000
-Pixel (21, 17) is 120.926254, should be 122.000000
-Pixel (21, 18) is 121.849876, should be 123.000000
-Pixel (21, 19) is 122.805779, should be 124.000000
-Pixel (21, 20) is 123.798424, should be 125.000000
-Pixel (21, 21) is 124.826706, should be 126.000000
-Pixel (21, 22) is 125.884323, should be 127.000000
-Pixel (21, 23) is 126.961082, should be 128.000000
-Pixel (21, 32) is 135.983551, should be 137.000000
-Pixel (21, 33) is 136.912170, should be 138.000000
-Pixel (21, 34) is 137.857834, should be 139.000000
-Pixel (21, 35) is 138.829224, should be 140.000000
-Pixel (21, 36) is 139.831146, should be 141.000000
-Pixel (21, 37) is 140.863861, should be 142.000000
-Pixel (21, 38) is 141.922989, should be 143.000000
-Pixel (21, 48) is 151.912704, should be 153.000000
-Pixel (21, 49) is 152.814789, should be 154.000000
-Pixel (21, 50) is 153.743240, should be 155.000000
-Pixel (21, 51) is 154.713287, should be 156.000000
-Pixel (21, 52) is 155.735733, should be 157.000000
-Pixel (21, 53) is 156.814362, should be 158.000000
-Pixel (21, 54) is 157.944504, should be 159.000000
-Pixel (21, 62) is 165.620895, should be 167.000000
-Pixel (21, 63) is 165.867752, should be 168.000000
-Pixel (22, 3) is 111.885727, should be 113.000000
-Pixel (22, 4) is 112.756744, should be 114.000000
-Pixel (22, 5) is 113.767242, should be 115.000000
-Pixel (22, 6) is 114.875237, should be 116.000000
-Pixel (22, 62) is 170.909042, should be 172.000000
-Pixel (22, 63) is 171.155914, should be 173.000000
-Pixel (23, 63) is 176.539764, should be 178.000000
-Pixel (24, 0) is 121.265671, should be 120.000000
-Pixel (24, 63) is 181.956696, should be 183.000000
-Pixel (25, 0) is 126.650871, should be 125.000000
-Pixel (25, 58) is 184.039474, should be 183.000000
-Pixel (25, 59) is 185.049973, should be 184.000000
-Pixel (26, 0) is 131.946564, should be 130.000000
-Pixel (26, 1) is 132.193436, should be 131.000000
-Pixel (26, 11) is 142.078583, should be 141.000000
-Pixel (26, 12) is 143.100998, should be 142.000000
-Pixel (26, 13) is 144.071045, should be 143.000000
-Pixel (26, 43) is 174.015884, should be 173.000000
-Pixel (26, 44) is 175.008530, should be 174.000000
-Pixel (26, 56) is 187.063385, should be 186.000000
-Pixel (26, 57) is 188.227188, should be 187.000000
-Pixel (26, 58) is 189.335175, should be 188.000000
-Pixel (26, 59) is 190.345673, should be 189.000000
-Pixel (26, 60) is 191.216721, should be 190.000000
-Pixel (27, 0) is 137.110168, should be 135.000000
-Pixel (27, 1) is 137.357040, should be 136.000000
-Pixel (27, 9) is 145.033386, should be 144.000000
-Pixel (27, 10) is 146.163528, should be 145.000000
-Pixel (27, 11) is 147.242172, should be 146.000000
-Pixel (27, 12) is 148.264572, should be 147.000000
-Pixel (27, 13) is 149.234619, should be 148.000000
-Pixel (27, 14) is 150.163071, should be 149.000000
-Pixel (27, 15) is 151.065186, should be 150.000000
-Pixel (27, 25) is 161.054886, should be 160.000000
-Pixel (27, 26) is 162.114014, should be 161.000000
-Pixel (27, 27) is 163.146729, should be 162.000000
-Pixel (27, 28) is 164.148621, should be 163.000000
-Pixel (27, 29) is 165.120010, should be 164.000000
-Pixel (27, 30) is 166.065704, should be 165.000000
-Pixel (27, 40) is 176.016800, should be 175.000000
-Pixel (27, 41) is 177.093567, should be 176.000000
-Pixel (27, 42) is 178.151184, should be 177.000000
-Pixel (27, 43) is 179.179459, should be 178.000000
-Pixel (27, 44) is 180.172104, should be 179.000000
-Pixel (27, 45) is 181.128006, should be 180.000000
-Pixel (27, 46) is 182.051636, should be 181.000000
-Pixel (27, 55) is 191.045395, should be 190.000000
-Pixel (27, 56) is 192.226959, should be 191.000000
-Pixel (27, 57) is 193.390762, should be 192.000000
-Pixel (27, 58) is 194.498749, should be 193.000000
-Pixel (27, 59) is 195.509247, should be 194.000000
-Pixel (27, 60) is 196.380295, should be 195.000000
-Pixel (27, 61) is 197.072830, should be 196.000000
-Pixel (28, 0) is 142.119690, should be 140.000000
-Pixel (28, 1) is 142.366562, should be 141.000000
-Pixel (28, 9) is 150.042908, should be 149.000000
-Pixel (28, 10) is 151.173050, should be 150.000000
-Pixel (28, 11) is 152.251694, should be 151.000000
-Pixel (28, 12) is 153.274109, should be 152.000000
-Pixel (28, 13) is 154.244141, should be 153.000000
-Pixel (28, 14) is 155.172592, should be 154.000000
-Pixel (28, 15) is 156.074707, should be 155.000000
-Pixel (28, 25) is 166.064407, should be 165.000000
-Pixel (28, 26) is 167.123535, should be 166.000000
-Pixel (28, 27) is 168.156250, should be 167.000000
-Pixel (28, 28) is 169.158142, should be 168.000000
-Pixel (28, 29) is 170.129532, should be 169.000000
-Pixel (28, 30) is 171.075226, should be 170.000000
-Pixel (28, 31) is 172.003830, should be 171.000000
-Pixel (28, 40) is 181.026321, should be 180.000000
-Pixel (28, 41) is 182.103088, should be 181.000000
-Pixel (28, 42) is 183.160706, should be 182.000000
-Pixel (28, 43) is 184.188980, should be 183.000000
-Pixel (28, 44) is 185.181625, should be 184.000000
-Pixel (28, 45) is 186.137527, should be 185.000000
-Pixel (28, 46) is 187.061157, should be 186.000000
-Pixel (28, 55) is 196.054916, should be 195.000000
-Pixel (28, 56) is 197.236481, should be 196.000000
-Pixel (28, 57) is 198.400284, should be 197.000000
-Pixel (28, 58) is 199.508270, should be 198.000000
-Pixel (28, 59) is 200.518768, should be 199.000000
-Pixel (28, 60) is 201.389816, should be 200.000000
-Pixel (28, 61) is 202.082352, should be 201.000000
-Pixel (29, 0) is 146.976593, should be 145.000000
-Pixel (29, 1) is 147.223465, should be 146.000000
-Pixel (29, 10) is 156.029953, should be 155.000000
-Pixel (29, 11) is 157.108597, should be 156.000000
-Pixel (29, 12) is 158.131012, should be 157.000000
-Pixel (29, 13) is 159.101059, should be 158.000000
-Pixel (29, 14) is 160.029495, should be 159.000000
-Pixel (29, 27) is 173.013153, should be 172.000000
-Pixel (29, 28) is 174.015045, should be 173.000000
-Pixel (29, 42) is 188.017609, should be 187.000000
-Pixel (29, 43) is 189.045883, should be 188.000000
-Pixel (29, 44) is 190.038528, should be 189.000000
-Pixel (29, 56) is 202.093384, should be 201.000000
-Pixel (29, 57) is 203.257187, should be 202.000000
-Pixel (29, 58) is 204.365173, should be 203.000000
-Pixel (29, 59) is 205.375671, should be 204.000000
-Pixel (29, 60) is 206.246719, should be 205.000000
-Pixel (30, 0) is 151.705017, should be 150.000000
-Pixel (30, 58) is 209.093597, should be 208.000000
-Pixel (30, 59) is 210.104095, should be 209.000000
-Pixel (31, 0) is 156.348038, should be 155.000000
-Pixel (32, 63) is 221.652069, should be 223.000000
-Pixel (33, 4) is 167.895950, should be 169.000000
-Pixel (33, 5) is 168.906448, should be 170.000000
-Pixel (33, 63) is 226.295059, should be 228.000000
-Pixel (34, 3) is 171.753357, should be 173.000000
-Pixel (34, 4) is 172.624374, should be 174.000000
-Pixel (34, 5) is 173.634872, should be 175.000000
-Pixel (34, 6) is 174.742859, should be 176.000000
-Pixel (34, 7) is 175.906631, should be 177.000000
-Pixel (34, 19) is 187.961548, should be 189.000000
-Pixel (34, 20) is 188.954193, should be 190.000000
-Pixel (34, 21) is 189.982468, should be 191.000000
-Pixel (34, 35) is 203.984970, should be 205.000000
-Pixel (34, 36) is 204.986893, should be 206.000000
-Pixel (34, 49) is 217.970520, should be 219.000000
-Pixel (34, 50) is 218.898956, should be 220.000000
-Pixel (34, 51) is 219.869003, should be 221.000000
-Pixel (34, 52) is 220.891434, should be 222.000000
-Pixel (34, 53) is 221.970062, should be 223.000000
-Pixel (34, 62) is 230.776611, should be 232.000000
-Pixel (34, 63) is 231.023483, should be 233.000000
-Pixel (35, 2) is 175.917755, should be 177.000000
-Pixel (35, 3) is 176.610291, should be 178.000000
-Pixel (35, 4) is 177.481308, should be 179.000000
-Pixel (35, 5) is 178.491806, should be 180.000000
-Pixel (35, 6) is 179.599792, should be 181.000000
-Pixel (35, 7) is 180.763565, should be 182.000000
-Pixel (35, 8) is 181.945129, should be 183.000000
-Pixel (35, 17) is 190.938950, should be 192.000000
-Pixel (35, 18) is 191.862579, should be 193.000000
-Pixel (35, 19) is 192.818481, should be 194.000000
-Pixel (35, 20) is 193.811127, should be 195.000000
-Pixel (35, 21) is 194.839401, should be 196.000000
-Pixel (35, 22) is 195.897018, should be 197.000000
-Pixel (35, 23) is 196.973785, should be 198.000000
-Pixel (35, 32) is 205.996216, should be 207.000000
-Pixel (35, 33) is 206.924835, should be 208.000000
-Pixel (35, 34) is 207.870514, should be 209.000000
-Pixel (35, 35) is 208.841904, should be 210.000000
-Pixel (35, 36) is 209.843826, should be 211.000000
-Pixel (35, 37) is 210.876541, should be 212.000000
-Pixel (35, 38) is 211.935669, should be 213.000000
-Pixel (35, 48) is 221.925369, should be 223.000000
-Pixel (35, 49) is 222.827454, should be 224.000000
-Pixel (35, 50) is 223.755905, should be 225.000000
-Pixel (35, 51) is 224.725937, should be 226.000000
-Pixel (35, 52) is 225.748367, should be 227.000000
-Pixel (35, 53) is 226.826996, should be 228.000000
-Pixel (35, 54) is 227.957138, should be 229.000000
-Pixel (35, 62) is 235.633545, should be 237.000000
-Pixel (35, 63) is 235.880417, should be 238.000000
-Pixel (36, 2) is 180.927292, should be 182.000000
-Pixel (36, 3) is 181.619827, should be 183.000000
-Pixel (36, 4) is 182.490845, should be 184.000000
-Pixel (36, 5) is 183.501343, should be 185.000000
-Pixel (36, 6) is 184.609329, should be 186.000000
-Pixel (36, 7) is 185.773102, should be 187.000000
-Pixel (36, 8) is 186.954666, should be 188.000000
-Pixel (36, 17) is 195.948486, should be 197.000000
-Pixel (36, 18) is 196.872116, should be 198.000000
-Pixel (36, 19) is 197.828018, should be 199.000000
-Pixel (36, 20) is 198.820663, should be 200.000000
-Pixel (36, 21) is 199.848938, should be 201.000000
-Pixel (36, 22) is 200.906555, should be 202.000000
-Pixel (36, 23) is 201.983322, should be 203.000000
-Pixel (36, 33) is 211.934372, should be 213.000000
-Pixel (36, 34) is 212.880051, should be 214.000000
-Pixel (36, 35) is 213.851440, should be 215.000000
-Pixel (36, 36) is 214.853363, should be 216.000000
-Pixel (36, 37) is 215.886078, should be 217.000000
-Pixel (36, 38) is 216.945206, should be 218.000000
-Pixel (36, 48) is 226.934906, should be 228.000000
-Pixel (36, 49) is 227.836990, should be 229.000000
-Pixel (36, 50) is 228.765442, should be 230.000000
-Pixel (36, 51) is 229.735489, should be 231.000000
-Pixel (36, 52) is 230.757904, should be 232.000000
-Pixel (36, 53) is 231.836533, should be 233.000000
-Pixel (36, 54) is 232.966675, should be 234.000000
-Pixel (36, 62) is 240.643082, should be 242.000000
-Pixel (36, 63) is 240.889954, should be 243.000000
-Pixel (37, 3) is 186.783417, should be 188.000000
-Pixel (37, 4) is 187.654434, should be 189.000000
-Pixel (37, 5) is 188.664932, should be 190.000000
-Pixel (37, 6) is 189.772919, should be 191.000000
-Pixel (37, 7) is 190.936691, should be 192.000000
-Pixel (37, 19) is 202.991608, should be 204.000000
-Pixel (37, 20) is 203.984253, should be 205.000000
-Pixel (37, 50) is 233.929031, should be 235.000000
-Pixel (37, 51) is 234.899078, should be 236.000000
-Pixel (37, 52) is 235.921509, should be 237.000000
-Pixel (37, 62) is 245.806671, should be 247.000000
-Pixel (37, 63) is 246.053543, should be 248.000000
-Pixel (38, 4) is 192.950089, should be 194.000000
-Pixel (38, 5) is 193.960587, should be 195.000000
-Pixel (38, 63) is 251.349228, should be 253.000000
-Pixel (39, 0) is 196.043472, should be 195.000000
-Pixel (39, 63) is 256.734406, should be 258.000000
-Pixel (40, 0) is 201.460358, should be 200.000000
-Pixel (41, 0) is 206.844208, should be 205.000000
-Pixel (41, 1) is 207.091080, should be 206.000000
-Pixel (41, 57) is 263.124786, should be 262.000000
-Pixel (41, 58) is 264.232758, should be 263.000000
-Pixel (41, 59) is 265.243256, should be 264.000000
-Pixel (41, 60) is 266.114319, should be 265.000000
-Pixel (42, 0) is 212.132355, should be 210.000000
-Pixel (42, 1) is 212.379211, should be 211.000000
-Pixel (42, 9) is 220.055542, should be 219.000000
-Pixel (42, 10) is 221.185684, should be 220.000000
-Pixel (42, 11) is 222.264328, should be 221.000000
-Pixel (42, 12) is 223.286758, should be 222.000000
-Pixel (42, 13) is 224.256805, should be 223.000000
-Pixel (42, 14) is 225.185257, should be 224.000000
-Pixel (42, 15) is 226.087372, should be 225.000000
-Pixel (42, 24) is 235.000031, should be 234.000000
-Pixel (42, 25) is 236.077057, should be 235.000000
-Pixel (42, 26) is 237.136185, should be 236.000000
-Pixel (42, 27) is 238.168900, should be 237.000000
-Pixel (42, 28) is 239.170792, should be 238.000000
-Pixel (42, 29) is 240.142181, should be 239.000000
-Pixel (42, 30) is 241.087875, should be 240.000000
-Pixel (42, 31) is 242.016464, should be 241.000000
-Pixel (42, 40) is 251.038986, should be 250.000000
-Pixel (42, 41) is 252.115738, should be 251.000000
-Pixel (42, 42) is 253.173355, should be 252.000000
-Pixel (42, 43) is 254.201645, should be 253.000000
-Pixel (42, 44) is 255.194290, should be 254.000000
-Pixel (42, 45) is 256.150177, should be 255.000000
-Pixel (42, 46) is 257.073792, should be 256.000000
-Pixel (42, 55) is 266.067566, should be 265.000000
-Pixel (42, 56) is 267.249146, should be 266.000000
-Pixel (42, 57) is 268.412933, should be 267.000000
-Pixel (42, 58) is 269.520935, should be 268.000000
-Pixel (42, 59) is 270.531433, should be 269.000000
-Pixel (42, 60) is 271.402466, should be 270.000000
-Pixel (42, 61) is 272.095001, should be 271.000000
-Pixel (43, 0) is 217.273712, should be 215.000000
-Pixel (43, 1) is 217.520569, should be 216.000000
-Pixel (43, 2) is 218.001968, should be 217.000000
-Pixel (43, 8) is 224.029327, should be 223.000000
-Pixel (43, 9) is 225.196869, should be 224.000000
-Pixel (43, 10) is 226.327026, should be 225.000000
-Pixel (43, 11) is 227.405670, should be 226.000000
-Pixel (43, 12) is 228.428101, should be 227.000000
-Pixel (43, 13) is 229.398148, should be 228.000000
-Pixel (43, 14) is 230.326599, should be 229.000000
-Pixel (43, 15) is 231.228714, should be 230.000000
-Pixel (43, 16) is 232.121902, should be 231.000000
-Pixel (43, 17) is 233.023193, should be 232.000000
-Pixel (43, 23) is 239.057999, should be 238.000000
-Pixel (43, 24) is 240.141373, should be 239.000000
-Pixel (43, 25) is 241.218399, should be 240.000000
-Pixel (43, 26) is 242.277512, should be 241.000000
-Pixel (43, 27) is 243.310226, should be 242.000000
-Pixel (43, 28) is 244.312134, should be 243.000000
-Pixel (43, 29) is 245.283524, should be 244.000000
-Pixel (43, 30) is 246.229202, should be 245.000000
-Pixel (43, 31) is 247.157822, should be 246.000000
-Pixel (43, 32) is 248.080429, should be 247.000000
-Pixel (43, 33) is 249.009048, should be 248.000000
-Pixel (43, 38) is 254.019882, should be 253.000000
-Pixel (43, 39) is 255.096939, should be 254.000000
-Pixel (43, 40) is 256.180328, should be 255.000000
-Pixel (43, 41) is 257.257080, should be 256.000000
-Pixel (43, 42) is 258.314667, should be 257.000000
-Pixel (43, 43) is 259.342957, should be 258.000000
-Pixel (43, 44) is 260.335632, should be 259.000000
-Pixel (43, 45) is 261.291534, should be 260.000000
-Pixel (43, 46) is 262.215149, should be 261.000000
-Pixel (43, 47) is 263.116394, should be 262.000000
-Pixel (43, 48) is 264.009583, should be 263.000000
-Pixel (43, 54) is 270.041382, should be 269.000000
-Pixel (43, 55) is 271.208923, should be 270.000000
-Pixel (43, 56) is 272.390503, should be 271.000000
-Pixel (43, 57) is 273.554291, should be 272.000000
-Pixel (43, 58) is 274.662292, should be 273.000000
-Pixel (43, 59) is 275.672791, should be 274.000000
-Pixel (43, 60) is 276.543823, should be 275.000000
-Pixel (43, 61) is 277.236359, should be 276.000000
-Pixel (44, 0) is 222.236954, should be 220.000000
-Pixel (44, 1) is 222.483826, should be 221.000000
-Pixel (44, 9) is 230.160110, should be 229.000000
-Pixel (44, 10) is 231.290253, should be 230.000000
-Pixel (44, 11) is 232.368912, should be 231.000000
-Pixel (44, 12) is 233.391327, should be 232.000000
-Pixel (44, 13) is 234.361389, should be 233.000000
-Pixel (44, 14) is 235.289841, should be 234.000000
-Pixel (44, 15) is 236.191956, should be 235.000000
-Pixel (44, 16) is 237.085144, should be 236.000000
-Pixel (44, 23) is 244.021240, should be 243.000000
-Pixel (44, 24) is 245.104584, should be 244.000000
-Pixel (44, 25) is 246.181610, should be 245.000000
-Pixel (44, 26) is 247.240753, should be 246.000000
-Pixel (44, 27) is 248.273468, should be 247.000000
-Pixel (44, 28) is 249.275360, should be 248.000000
-Pixel (44, 29) is 250.246735, should be 249.000000
-Pixel (44, 30) is 251.192444, should be 250.000000
-Pixel (44, 31) is 252.121033, should be 251.000000
-Pixel (44, 32) is 253.043640, should be 252.000000
-Pixel (44, 39) is 260.060150, should be 259.000000
-Pixel (44, 40) is 261.143524, should be 260.000000
-Pixel (44, 41) is 262.220306, should be 261.000000
-Pixel (44, 42) is 263.277924, should be 262.000000
-Pixel (44, 43) is 264.306183, should be 263.000000
-Pixel (44, 44) is 265.298828, should be 264.000000
-Pixel (44, 45) is 266.254730, should be 265.000000
-Pixel (44, 46) is 267.178375, should be 266.000000
-Pixel (44, 47) is 268.079620, should be 267.000000
-Pixel (44, 54) is 275.004578, should be 274.000000
-Pixel (44, 55) is 276.172150, should be 275.000000
-Pixel (44, 56) is 277.353699, should be 276.000000
-Pixel (44, 57) is 278.517517, should be 277.000000
-Pixel (44, 58) is 279.625488, should be 278.000000
-Pixel (44, 59) is 280.635986, should be 279.000000
-Pixel (44, 60) is 281.507050, should be 280.000000
-Pixel (44, 61) is 282.199585, should be 281.000000
-Pixel (45, 0) is 227.016373, should be 225.000000
-Pixel (45, 1) is 227.263245, should be 226.000000
-Pixel (45, 10) is 236.069672, should be 235.000000
-Pixel (45, 11) is 237.148331, should be 236.000000
-Pixel (45, 12) is 238.170746, should be 237.000000
-Pixel (45, 13) is 239.140808, should be 238.000000
-Pixel (45, 14) is 240.069260, should be 239.000000
-Pixel (45, 26) is 252.020172, should be 251.000000
-Pixel (45, 27) is 253.052887, should be 252.000000
-Pixel (45, 28) is 254.054779, should be 253.000000
-Pixel (45, 29) is 255.026184, should be 254.000000
-Pixel (45, 42) is 268.057312, should be 267.000000
-Pixel (45, 43) is 269.085602, should be 268.000000
-Pixel (45, 44) is 270.078247, should be 269.000000
-Pixel (45, 45) is 271.034149, should be 270.000000
-Pixel (45, 56) is 282.133118, should be 281.000000
-Pixel (45, 57) is 283.296906, should be 282.000000
-Pixel (45, 58) is 284.404907, should be 283.000000
-Pixel (45, 59) is 285.415405, should be 284.000000
-Pixel (45, 60) is 286.286438, should be 285.000000
-Pixel (46, 0) is 231.634460, should be 230.000000
-Pixel (46, 58) is 289.023010, should be 288.000000
-Pixel (46, 59) is 290.033478, should be 289.000000
-Pixel (47, 0) is 236.140778, should be 235.000000
-Pixel (47, 63) is 296.831665, should be 298.000000
-Pixel (48, 4) is 242.898560, should be 244.000000
-Pixel (48, 5) is 243.909058, should be 245.000000
-Pixel (48, 63) is 301.297638, should be 303.000000
-Pixel (49, 2) is 245.845490, should be 247.000000
-Pixel (49, 3) is 246.538025, should be 248.000000
-Pixel (49, 4) is 247.409058, should be 249.000000
-Pixel (49, 5) is 248.419556, should be 250.000000
-Pixel (49, 6) is 249.527527, should be 251.000000
-Pixel (49, 7) is 250.691315, should be 252.000000
-Pixel (49, 8) is 251.872864, should be 253.000000
-Pixel (49, 16) is 259.965363, should be 261.000000
-Pixel (49, 17) is 260.866638, should be 262.000000
-Pixel (49, 18) is 261.790283, should be 263.000000
-Pixel (49, 19) is 262.746185, should be 264.000000
-Pixel (49, 20) is 263.738831, should be 265.000000
-Pixel (49, 21) is 264.767090, should be 266.000000
-Pixel (49, 22) is 265.824707, should be 267.000000
-Pixel (49, 23) is 266.901489, should be 268.000000
-Pixel (49, 24) is 267.984863, should be 269.000000
-Pixel (49, 32) is 275.923920, should be 277.000000
-Pixel (49, 33) is 276.852539, should be 278.000000
-Pixel (49, 34) is 277.798218, should be 279.000000
-Pixel (49, 35) is 278.769592, should be 280.000000
-Pixel (49, 36) is 279.771515, should be 281.000000
-Pixel (49, 37) is 280.804230, should be 282.000000
-Pixel (49, 38) is 281.863373, should be 283.000000
-Pixel (49, 39) is 282.940430, should be 284.000000
-Pixel (49, 47) is 290.959869, should be 292.000000
-Pixel (49, 48) is 291.853058, should be 293.000000
-Pixel (49, 49) is 292.755157, should be 294.000000
-Pixel (49, 50) is 293.683594, should be 295.000000
-Pixel (49, 51) is 294.653656, should be 296.000000
-Pixel (49, 52) is 295.676056, should be 297.000000
-Pixel (49, 53) is 296.754669, should be 298.000000
-Pixel (49, 54) is 297.884827, should be 299.000000
-Pixel (49, 62) is 305.561218, should be 307.000000
-Pixel (49, 63) is 305.808105, should be 308.000000
-Pixel (50, 2) is 250.487579, should be 252.000000
-Pixel (50, 3) is 251.180115, should be 253.000000
-Pixel (50, 4) is 252.051147, should be 254.000000
-Pixel (50, 5) is 253.061646, should be 255.000000
-Pixel (50, 6) is 254.169617, should be 256.000000
-Pixel (50, 7) is 255.333405, should be 257.000000
-Pixel (50, 8) is 256.514984, should be 258.000000
-Pixel (50, 9) is 257.682556, should be 259.000000
-Pixel (50, 10) is 258.812683, should be 260.000000
-Pixel (50, 11) is 259.891327, should be 261.000000
-Pixel (50, 12) is 260.913757, should be 262.000000
-Pixel (50, 13) is 261.883759, should be 263.000000
-Pixel (50, 14) is 262.812225, should be 264.000000
-Pixel (50, 15) is 263.714325, should be 265.000000
-Pixel (50, 16) is 264.607513, should be 266.000000
-Pixel (50, 17) is 265.508789, should be 267.000000
-Pixel (50, 18) is 266.432434, should be 268.000000
-Pixel (50, 19) is 267.388336, should be 269.000000
-Pixel (50, 20) is 268.380981, should be 270.000000
-Pixel (50, 21) is 269.409241, should be 271.000000
-Pixel (50, 22) is 270.466858, should be 272.000000
-Pixel (50, 23) is 271.543640, should be 273.000000
-Pixel (50, 24) is 272.627014, should be 274.000000
-Pixel (50, 25) is 273.704041, should be 275.000000
-Pixel (50, 26) is 274.763153, should be 276.000000
-Pixel (50, 27) is 275.795868, should be 277.000000
-Pixel (50, 28) is 276.797760, should be 278.000000
-Pixel (50, 29) is 277.769165, should be 279.000000
-Pixel (50, 30) is 278.714844, should be 280.000000
-Pixel (50, 31) is 279.643463, should be 281.000000
-Pixel (50, 32) is 280.566071, should be 282.000000
-Pixel (50, 33) is 281.494690, should be 283.000000
-Pixel (50, 34) is 282.440369, should be 284.000000
-Pixel (50, 35) is 283.411743, should be 285.000000
-Pixel (50, 36) is 284.413666, should be 286.000000
-Pixel (50, 37) is 285.446381, should be 287.000000
-Pixel (50, 38) is 286.505524, should be 288.000000
-Pixel (50, 39) is 287.582581, should be 289.000000
-Pixel (50, 40) is 288.665955, should be 290.000000
-Pixel (50, 41) is 289.742706, should be 291.000000
-Pixel (50, 42) is 290.800323, should be 292.000000
-Pixel (50, 43) is 291.828613, should be 293.000000
-Pixel (50, 44) is 292.821259, should be 294.000000
-Pixel (50, 45) is 293.777161, should be 295.000000
-Pixel (50, 46) is 294.700775, should be 296.000000
-Pixel (50, 47) is 295.602020, should be 297.000000
-Pixel (50, 48) is 296.495209, should be 298.000000
-Pixel (50, 49) is 297.397308, should be 299.000000
-Pixel (50, 50) is 298.325745, should be 300.000000
-Pixel (50, 51) is 299.295776, should be 301.000000
-Pixel (50, 52) is 300.318207, should be 302.000000
-Pixel (50, 53) is 301.396820, should be 303.000000
-Pixel (50, 54) is 302.526978, should be 304.000000
-Pixel (50, 55) is 303.694519, should be 305.000000
-Pixel (50, 56) is 304.876099, should be 306.000000
-Pixel (50, 61) is 309.721954, should be 311.000000
-Pixel (50, 62) is 310.203369, should be 312.000000
-Pixel (50, 63) is 310.450256, should be 313.000000
-Pixel (51, 1) is 254.856476, should be 256.000000
-Pixel (51, 2) is 255.337906, should be 257.000000
-Pixel (51, 3) is 256.030457, should be 258.000000
-Pixel (51, 4) is 256.901489, should be 259.000000
-Pixel (51, 5) is 257.911987, should be 260.000000
-Pixel (51, 6) is 259.019958, should be 261.000000
-Pixel (51, 7) is 260.183746, should be 262.000000
-Pixel (51, 8) is 261.365295, should be 263.000000
-Pixel (51, 9) is 262.532867, should be 264.000000
-Pixel (51, 10) is 263.662994, should be 265.000000
-Pixel (51, 11) is 264.741638, should be 266.000000
-Pixel (51, 12) is 265.764069, should be 267.000000
-Pixel (51, 13) is 266.734100, should be 268.000000
-Pixel (51, 14) is 267.662537, should be 269.000000
-Pixel (51, 15) is 268.564636, should be 270.000000
-Pixel (51, 16) is 269.457825, should be 271.000000
-Pixel (51, 17) is 270.359100, should be 272.000000
-Pixel (51, 18) is 271.282745, should be 273.000000
-Pixel (51, 19) is 272.238647, should be 274.000000
-Pixel (51, 20) is 273.231293, should be 275.000000
-Pixel (51, 21) is 274.259552, should be 276.000000
-Pixel (51, 22) is 275.317169, should be 277.000000
-Pixel (51, 23) is 276.393951, should be 278.000000
-Pixel (51, 24) is 277.477325, should be 279.000000
-Pixel (51, 25) is 278.554352, should be 280.000000
-Pixel (51, 26) is 279.613464, should be 281.000000
-Pixel (51, 27) is 280.646179, should be 282.000000
-Pixel (51, 28) is 281.648071, should be 283.000000
-Pixel (51, 29) is 282.619476, should be 284.000000
-Pixel (51, 30) is 283.565155, should be 285.000000
-Pixel (51, 31) is 284.493774, should be 286.000000
-Pixel (51, 32) is 285.416382, should be 287.000000
-Pixel (51, 33) is 286.345001, should be 288.000000
-Pixel (51, 34) is 287.290680, should be 289.000000
-Pixel (51, 35) is 288.262054, should be 290.000000
-Pixel (51, 36) is 289.263977, should be 291.000000
-Pixel (51, 37) is 290.296692, should be 292.000000
-Pixel (51, 38) is 291.355835, should be 293.000000
-Pixel (51, 39) is 292.432892, should be 294.000000
-Pixel (51, 40) is 293.516266, should be 295.000000
-Pixel (51, 41) is 294.593018, should be 296.000000
-Pixel (51, 42) is 295.650635, should be 297.000000
-Pixel (51, 43) is 296.678925, should be 298.000000
-Pixel (51, 44) is 297.671570, should be 299.000000
-Pixel (51, 45) is 298.627472, should be 300.000000
-Pixel (51, 46) is 299.551086, should be 301.000000
-Pixel (51, 47) is 300.452332, should be 302.000000
-Pixel (51, 48) is 301.345520, should be 303.000000
-Pixel (51, 49) is 302.247620, should be 304.000000
-Pixel (51, 50) is 303.176025, should be 305.000000
-Pixel (51, 51) is 304.146088, should be 306.000000
-Pixel (51, 52) is 305.168518, should be 307.000000
-Pixel (51, 53) is 306.247131, should be 308.000000
-Pixel (51, 54) is 307.377289, should be 309.000000
-Pixel (51, 55) is 308.544830, should be 310.000000
-Pixel (51, 56) is 309.726410, should be 311.000000
-Pixel (51, 57) is 310.890198, should be 312.000000
-Pixel (51, 58) is 311.998199, should be 313.000000
-Pixel (51, 60) is 313.879730, should be 315.000000
-Pixel (51, 61) is 314.572266, should be 316.000000
-Pixel (51, 62) is 315.053680, should be 317.000000
-Pixel (51, 63) is 315.300568, should be 318.000000
-Pixel (52, 1) is 259.968658, should be 261.000000
-Pixel (52, 2) is 260.450073, should be 262.000000
-Pixel (52, 3) is 261.142609, should be 263.000000
-Pixel (52, 4) is 262.013641, should be 264.000000
-Pixel (52, 5) is 263.024139, should be 265.000000
-Pixel (52, 6) is 264.132111, should be 266.000000
-Pixel (52, 7) is 265.295898, should be 267.000000
-Pixel (52, 8) is 266.477448, should be 268.000000
-Pixel (52, 9) is 267.645020, should be 269.000000
-Pixel (52, 10) is 268.775146, should be 270.000000
-Pixel (52, 11) is 269.853790, should be 271.000000
-Pixel (52, 12) is 270.876221, should be 272.000000
-Pixel (52, 13) is 271.846252, should be 273.000000
-Pixel (52, 14) is 272.774719, should be 274.000000
-Pixel (52, 15) is 273.676788, should be 275.000000
-Pixel (52, 16) is 274.569977, should be 276.000000
-Pixel (52, 17) is 275.471252, should be 277.000000
-Pixel (52, 18) is 276.394897, should be 278.000000
-Pixel (52, 19) is 277.350800, should be 279.000000
-Pixel (52, 20) is 278.343445, should be 280.000000
-Pixel (52, 21) is 279.371704, should be 281.000000
-Pixel (52, 22) is 280.429321, should be 282.000000
-Pixel (52, 23) is 281.506104, should be 283.000000
-Pixel (52, 24) is 282.589478, should be 284.000000
-Pixel (52, 25) is 283.666504, should be 285.000000
-Pixel (52, 26) is 284.725616, should be 286.000000
-Pixel (52, 27) is 285.758331, should be 287.000000
-Pixel (52, 28) is 286.760223, should be 288.000000
-Pixel (52, 29) is 287.731628, should be 289.000000
-Pixel (52, 30) is 288.677307, should be 290.000000
-Pixel (52, 31) is 289.605927, should be 291.000000
-Pixel (52, 32) is 290.528534, should be 292.000000
-Pixel (52, 33) is 291.457153, should be 293.000000
-Pixel (52, 34) is 292.402832, should be 294.000000
-Pixel (52, 35) is 293.374207, should be 295.000000
-Pixel (52, 36) is 294.376129, should be 296.000000
-Pixel (52, 37) is 295.408844, should be 297.000000
-Pixel (52, 38) is 296.467987, should be 298.000000
-Pixel (52, 39) is 297.545044, should be 299.000000
-Pixel (52, 40) is 298.628418, should be 300.000000
-Pixel (52, 41) is 299.705170, should be 301.000000
-Pixel (52, 42) is 300.762787, should be 302.000000
-Pixel (52, 43) is 301.791077, should be 303.000000
-Pixel (52, 44) is 302.783722, should be 304.000000
-Pixel (52, 45) is 303.739624, should be 305.000000
-Pixel (52, 46) is 304.663239, should be 306.000000
-Pixel (52, 47) is 305.564484, should be 307.000000
-Pixel (52, 48) is 306.457672, should be 308.000000
-Pixel (52, 49) is 307.359741, should be 309.000000
-Pixel (52, 50) is 308.288177, should be 310.000000
-Pixel (52, 51) is 309.258240, should be 311.000000
-Pixel (52, 52) is 310.280670, should be 312.000000
-Pixel (52, 53) is 311.359283, should be 313.000000
-Pixel (52, 54) is 312.489441, should be 314.000000
-Pixel (52, 55) is 313.656982, should be 315.000000
-Pixel (52, 56) is 314.838562, should be 316.000000
-Pixel (52, 60) is 318.991882, should be 320.000000
-Pixel (52, 61) is 319.684418, should be 321.000000
-Pixel (52, 62) is 320.165833, should be 322.000000
-Pixel (52, 63) is 320.412720, should be 323.000000
-Pixel (53, 2) is 265.843201, should be 267.000000
-Pixel (53, 3) is 266.535736, should be 268.000000
-Pixel (53, 4) is 267.406769, should be 269.000000
-Pixel (53, 5) is 268.417267, should be 270.000000
-Pixel (53, 6) is 269.525238, should be 271.000000
-Pixel (53, 7) is 270.689026, should be 272.000000
-Pixel (53, 8) is 271.870575, should be 273.000000
-Pixel (53, 16) is 279.963104, should be 281.000000
-Pixel (53, 17) is 280.864380, should be 282.000000
-Pixel (53, 18) is 281.788025, should be 283.000000
-Pixel (53, 19) is 282.743927, should be 284.000000
-Pixel (53, 20) is 283.736572, should be 285.000000
-Pixel (53, 21) is 284.764832, should be 286.000000
-Pixel (53, 22) is 285.822449, should be 287.000000
-Pixel (53, 23) is 286.899231, should be 288.000000
-Pixel (53, 24) is 287.982605, should be 289.000000
-Pixel (53, 31) is 294.999054, should be 296.000000
-Pixel (53, 32) is 295.921661, should be 297.000000
-Pixel (53, 33) is 296.850281, should be 298.000000
-Pixel (53, 34) is 297.795959, should be 299.000000
-Pixel (53, 35) is 298.767334, should be 300.000000
-Pixel (53, 36) is 299.769257, should be 301.000000
-Pixel (53, 37) is 300.801971, should be 302.000000
-Pixel (53, 38) is 301.861115, should be 303.000000
-Pixel (53, 39) is 302.938171, should be 304.000000
-Pixel (53, 47) is 310.957611, should be 312.000000
-Pixel (53, 48) is 311.850800, should be 313.000000
-Pixel (53, 49) is 312.752869, should be 314.000000
-Pixel (53, 50) is 313.681305, should be 315.000000
-Pixel (53, 51) is 314.651367, should be 316.000000
-Pixel (53, 52) is 315.673798, should be 317.000000
-Pixel (53, 53) is 316.752411, should be 318.000000
-Pixel (53, 54) is 317.882568, should be 319.000000
-Pixel (53, 62) is 325.558960, should be 327.000000
-Pixel (53, 63) is 325.805847, should be 328.000000
-Pixel (54, 63) is 331.456512, should be 333.000000
-Pixel (55, 0) is 276.603424, should be 275.000000
-Pixel (55, 59) is 335.002472, should be 334.000000
-Pixel (56, 0) is 282.511169, should be 280.000000
-Pixel (56, 1) is 282.758026, should be 281.000000
-Pixel (56, 2) is 283.239441, should be 282.000000
-Pixel (56, 7) is 288.085266, should be 287.000000
-Pixel (56, 8) is 289.266815, should be 288.000000
-Pixel (56, 9) is 290.434387, should be 289.000000
-Pixel (56, 10) is 291.564484, should be 290.000000
-Pixel (56, 11) is 292.643158, should be 291.000000
-Pixel (56, 12) is 293.665588, should be 292.000000
-Pixel (56, 13) is 294.635620, should be 293.000000
-Pixel (56, 14) is 295.564087, should be 294.000000
-Pixel (56, 15) is 296.466187, should be 295.000000
-Pixel (56, 16) is 297.359375, should be 296.000000
-Pixel (56, 17) is 298.260620, should be 297.000000
-Pixel (56, 18) is 299.184265, should be 298.000000
-Pixel (56, 19) is 300.140167, should be 299.000000
-Pixel (56, 20) is 301.132812, should be 300.000000
-Pixel (56, 21) is 302.161102, should be 301.000000
-Pixel (56, 22) is 303.218689, should be 302.000000
-Pixel (56, 23) is 304.295471, should be 303.000000
-Pixel (56, 24) is 305.378845, should be 304.000000
-Pixel (56, 25) is 306.455872, should be 305.000000
-Pixel (56, 26) is 307.514984, should be 306.000000
-Pixel (56, 27) is 308.547699, should be 307.000000
-Pixel (56, 28) is 309.549591, should be 308.000000
-Pixel (56, 29) is 310.520996, should be 309.000000
-Pixel (56, 30) is 311.466675, should be 310.000000
-Pixel (56, 31) is 312.395294, should be 311.000000
-Pixel (56, 32) is 313.317902, should be 312.000000
-Pixel (56, 33) is 314.246521, should be 313.000000
-Pixel (56, 34) is 315.192200, should be 314.000000
-Pixel (56, 35) is 316.163574, should be 315.000000
-Pixel (56, 36) is 317.165497, should be 316.000000
-Pixel (56, 37) is 318.198212, should be 317.000000
-Pixel (56, 38) is 319.257355, should be 318.000000
-Pixel (56, 39) is 320.334412, should be 319.000000
-Pixel (56, 40) is 321.417786, should be 320.000000
-Pixel (56, 41) is 322.494537, should be 321.000000
-Pixel (56, 42) is 323.552185, should be 322.000000
-Pixel (56, 43) is 324.580444, should be 323.000000
-Pixel (56, 44) is 325.573090, should be 324.000000
-Pixel (56, 45) is 326.528992, should be 325.000000
-Pixel (56, 46) is 327.452606, should be 326.000000
-Pixel (56, 47) is 328.353821, should be 327.000000
-Pixel (56, 48) is 329.247009, should be 328.000000
-Pixel (56, 49) is 330.149109, should be 329.000000
-Pixel (56, 50) is 331.077545, should be 330.000000
-Pixel (56, 51) is 332.047607, should be 331.000000
-Pixel (56, 52) is 333.070038, should be 332.000000
-Pixel (56, 53) is 334.148621, should be 333.000000
-Pixel (56, 54) is 335.278809, should be 334.000000
-Pixel (56, 55) is 336.446350, should be 335.000000
-Pixel (56, 56) is 337.627930, should be 336.000000
-Pixel (56, 57) is 338.791718, should be 337.000000
-Pixel (56, 58) is 339.899719, should be 338.000000
-Pixel (56, 59) is 340.910217, should be 339.000000
-Pixel (56, 60) is 341.781250, should be 340.000000
-Pixel (56, 61) is 342.473785, should be 341.000000
-Pixel (57, 0) is 288.330200, should be 285.000000
-Pixel (57, 1) is 288.577057, should be 286.000000
-Pixel (57, 2) is 289.058472, should be 287.000000
-Pixel (57, 3) is 289.751007, should be 288.000000
-Pixel (57, 4) is 290.622009, should be 289.000000
-Pixel (57, 5) is 291.632507, should be 290.000000
-Pixel (57, 6) is 292.740509, should be 291.000000
-Pixel (57, 7) is 293.904266, should be 292.000000
-Pixel (57, 8) is 295.085846, should be 293.000000
-Pixel (57, 9) is 296.253387, should be 294.000000
-Pixel (57, 10) is 297.383514, should be 295.000000
-Pixel (57, 11) is 298.462189, should be 296.000000
-Pixel (57, 12) is 299.484589, should be 297.000000
-Pixel (57, 13) is 300.454651, should be 298.000000
-Pixel (57, 14) is 301.383087, should be 299.000000
-Pixel (57, 15) is 302.285217, should be 300.000000
-Pixel (57, 16) is 303.178406, should be 301.000000
-Pixel (57, 17) is 304.079651, should be 302.000000
-Pixel (57, 18) is 305.003265, should be 303.000000
-Pixel (57, 19) is 305.959167, should be 304.000000
-Pixel (57, 20) is 306.951813, should be 305.000000
-Pixel (57, 21) is 307.980133, should be 306.000000
-Pixel (57, 22) is 309.037720, should be 307.000000
-Pixel (57, 23) is 310.114471, should be 308.000000
-Pixel (57, 24) is 311.197845, should be 309.000000
-Pixel (57, 25) is 312.274872, should be 310.000000
-Pixel (57, 26) is 313.334015, should be 311.000000
-Pixel (57, 27) is 314.366730, should be 312.000000
-Pixel (57, 28) is 315.368622, should be 313.000000
-Pixel (57, 29) is 316.339996, should be 314.000000
-Pixel (57, 30) is 317.285706, should be 315.000000
-Pixel (57, 31) is 318.214264, should be 316.000000
-Pixel (57, 32) is 319.136871, should be 317.000000
-Pixel (57, 33) is 320.065521, should be 318.000000
-Pixel (57, 34) is 321.011200, should be 319.000000
-Pixel (57, 35) is 321.982605, should be 320.000000
-Pixel (57, 36) is 322.984528, should be 321.000000
-Pixel (57, 37) is 324.017242, should be 322.000000
-Pixel (57, 38) is 325.076355, should be 323.000000
-Pixel (57, 39) is 326.153412, should be 324.000000
-Pixel (57, 40) is 327.236786, should be 325.000000
-Pixel (57, 41) is 328.313568, should be 326.000000
-Pixel (57, 42) is 329.371216, should be 327.000000
-Pixel (57, 43) is 330.399445, should be 328.000000
-Pixel (57, 44) is 331.392090, should be 329.000000
-Pixel (57, 45) is 332.347992, should be 330.000000
-Pixel (57, 46) is 333.271637, should be 331.000000
-Pixel (57, 47) is 334.172852, should be 332.000000
-Pixel (57, 48) is 335.066040, should be 333.000000
-Pixel (57, 49) is 335.968109, should be 334.000000
-Pixel (57, 50) is 336.896576, should be 335.000000
-Pixel (57, 51) is 337.866608, should be 336.000000
-Pixel (57, 52) is 338.889038, should be 337.000000
-Pixel (57, 53) is 339.967651, should be 338.000000
-Pixel (57, 54) is 341.097809, should be 339.000000
-Pixel (57, 55) is 342.265381, should be 340.000000
-Pixel (57, 56) is 343.446930, should be 341.000000
-Pixel (57, 57) is 344.610748, should be 342.000000
-Pixel (57, 58) is 345.718719, should be 343.000000
-Pixel (57, 59) is 346.729218, should be 344.000000
-Pixel (57, 60) is 347.600281, should be 345.000000
-Pixel (57, 61) is 348.292816, should be 346.000000
-Pixel (57, 62) is 348.774231, should be 347.000000
-Pixel (57, 63) is 349.021118, should be 348.000000
-Pixel (58, 0) is 293.870117, should be 290.000000
-Pixel (58, 1) is 294.116943, should be 291.000000
-Pixel (58, 2) is 294.598358, should be 292.000000
-Pixel (58, 3) is 295.290894, should be 293.000000
-Pixel (58, 4) is 296.161926, should be 294.000000
-Pixel (58, 5) is 297.172424, should be 295.000000
-Pixel (58, 6) is 298.280396, should be 296.000000
-Pixel (58, 7) is 299.444183, should be 297.000000
-Pixel (58, 8) is 300.625732, should be 298.000000
-Pixel (58, 9) is 301.793304, should be 299.000000
-Pixel (58, 10) is 302.923401, should be 300.000000
-Pixel (58, 11) is 304.002045, should be 301.000000
-Pixel (58, 12) is 305.024506, should be 302.000000
-Pixel (58, 13) is 305.994537, should be 303.000000
-Pixel (58, 14) is 306.923004, should be 304.000000
-Pixel (58, 15) is 307.825104, should be 305.000000
-Pixel (58, 16) is 308.718292, should be 306.000000
-Pixel (58, 17) is 309.619537, should be 307.000000
-Pixel (58, 18) is 310.543182, should be 308.000000
-Pixel (58, 19) is 311.499084, should be 309.000000
-Pixel (58, 20) is 312.491760, should be 310.000000
-Pixel (58, 21) is 313.520020, should be 311.000000
-Pixel (58, 22) is 314.577606, should be 312.000000
-Pixel (58, 23) is 315.654388, should be 313.000000
-Pixel (58, 24) is 316.737762, should be 314.000000
-Pixel (58, 25) is 317.814789, should be 315.000000
-Pixel (58, 26) is 318.873901, should be 316.000000
-Pixel (58, 27) is 319.906616, should be 317.000000
-Pixel (58, 28) is 320.908508, should be 318.000000
-Pixel (58, 29) is 321.879913, should be 319.000000
-Pixel (58, 30) is 322.825592, should be 320.000000
-Pixel (58, 31) is 323.754181, should be 321.000000
-Pixel (58, 32) is 324.676788, should be 322.000000
-Pixel (58, 33) is 325.605438, should be 323.000000
-Pixel (58, 34) is 326.551117, should be 324.000000
-Pixel (58, 35) is 327.522491, should be 325.000000
-Pixel (58, 36) is 328.524414, should be 326.000000
-Pixel (58, 37) is 329.557129, should be 327.000000
-Pixel (58, 38) is 330.616272, should be 328.000000
-Pixel (58, 39) is 331.693329, should be 329.000000
-Pixel (58, 40) is 332.776703, should be 330.000000
-Pixel (58, 41) is 333.853455, should be 331.000000
-Pixel (58, 42) is 334.911102, should be 332.000000
-Pixel (58, 43) is 335.939392, should be 333.000000
-Pixel (58, 44) is 336.932007, should be 334.000000
-Pixel (58, 45) is 337.887909, should be 335.000000
-Pixel (58, 46) is 338.811523, should be 336.000000
-Pixel (58, 47) is 339.712738, should be 337.000000
-Pixel (58, 48) is 340.605927, should be 338.000000
-Pixel (58, 49) is 341.508026, should be 339.000000
-Pixel (58, 50) is 342.436462, should be 340.000000
-Pixel (58, 51) is 343.406525, should be 341.000000
-Pixel (58, 52) is 344.428925, should be 342.000000
-Pixel (58, 53) is 345.507538, should be 343.000000
-Pixel (58, 54) is 346.637726, should be 344.000000
-Pixel (58, 55) is 347.805267, should be 345.000000
-Pixel (58, 56) is 348.986847, should be 346.000000
-Pixel (58, 57) is 350.150635, should be 347.000000
-Pixel (58, 58) is 351.258636, should be 348.000000
-Pixel (58, 59) is 352.269135, should be 349.000000
-Pixel (58, 60) is 353.140167, should be 350.000000
-Pixel (58, 61) is 353.832703, should be 351.000000
-Pixel (58, 62) is 354.314117, should be 352.000000
-Pixel (58, 63) is 354.561035, should be 353.000000
-Pixel (59, 0) is 298.922668, should be 295.000000
-Pixel (59, 1) is 299.169495, should be 296.000000
-Pixel (59, 2) is 299.650909, should be 297.000000
-Pixel (59, 3) is 300.343445, should be 298.000000
-Pixel (59, 4) is 301.214478, should be 299.000000
-Pixel (59, 5) is 302.224976, should be 300.000000
-Pixel (59, 6) is 303.332947, should be 301.000000
-Pixel (59, 7) is 304.496735, should be 302.000000
-Pixel (59, 8) is 305.678284, should be 303.000000
-Pixel (59, 9) is 306.845856, should be 304.000000
-Pixel (59, 10) is 307.975952, should be 305.000000
-Pixel (59, 11) is 309.054596, should be 306.000000
-Pixel (59, 12) is 310.077057, should be 307.000000
-Pixel (59, 13) is 311.047089, should be 308.000000
-Pixel (59, 14) is 311.975555, should be 309.000000
-Pixel (59, 15) is 312.877655, should be 310.000000
-Pixel (59, 16) is 313.770844, should be 311.000000
-Pixel (59, 17) is 314.672119, should be 312.000000
-Pixel (59, 18) is 315.595734, should be 313.000000
-Pixel (59, 19) is 316.551636, should be 314.000000
-Pixel (59, 20) is 317.544312, should be 315.000000
-Pixel (59, 21) is 318.572571, should be 316.000000
-Pixel (59, 22) is 319.630157, should be 317.000000
-Pixel (59, 23) is 320.706940, should be 318.000000
-Pixel (59, 24) is 321.790314, should be 319.000000
-Pixel (59, 25) is 322.867340, should be 320.000000
-Pixel (59, 26) is 323.926453, should be 321.000000
-Pixel (59, 27) is 324.959167, should be 322.000000
-Pixel (59, 28) is 325.961060, should be 323.000000
-Pixel (59, 29) is 326.932465, should be 324.000000
-Pixel (59, 30) is 327.878143, should be 325.000000
-Pixel (59, 31) is 328.806732, should be 326.000000
-Pixel (59, 32) is 329.729340, should be 327.000000
-Pixel (59, 33) is 330.657990, should be 328.000000
-Pixel (59, 34) is 331.603668, should be 329.000000
-Pixel (59, 35) is 332.575043, should be 330.000000
-Pixel (59, 36) is 333.576965, should be 331.000000
-Pixel (59, 37) is 334.609680, should be 332.000000
-Pixel (59, 38) is 335.668823, should be 333.000000
-Pixel (59, 39) is 336.745880, should be 334.000000
-Pixel (59, 40) is 337.829254, should be 335.000000
-Pixel (59, 41) is 338.906006, should be 336.000000
-Pixel (59, 42) is 339.963654, should be 337.000000
-Pixel (59, 43) is 340.991943, should be 338.000000
-Pixel (59, 44) is 341.984558, should be 339.000000
-Pixel (59, 45) is 342.940460, should be 340.000000
-Pixel (59, 46) is 343.864044, should be 341.000000
-Pixel (59, 47) is 344.765289, should be 342.000000
-Pixel (59, 48) is 345.658478, should be 343.000000
-Pixel (59, 49) is 346.560577, should be 344.000000
-Pixel (59, 50) is 347.489014, should be 345.000000
-Pixel (59, 51) is 348.459076, should be 346.000000
-Pixel (59, 52) is 349.481476, should be 347.000000
-Pixel (59, 53) is 350.560089, should be 348.000000
-Pixel (59, 54) is 351.690277, should be 349.000000
-Pixel (59, 55) is 352.857819, should be 350.000000
-Pixel (59, 56) is 354.039398, should be 351.000000
-Pixel (59, 57) is 355.203186, should be 352.000000
-Pixel (59, 58) is 356.311188, should be 353.000000
-Pixel (59, 59) is 357.321686, should be 354.000000
-Pixel (59, 60) is 358.192719, should be 355.000000
-Pixel (59, 61) is 358.885254, should be 356.000000
-Pixel (59, 62) is 359.366669, should be 357.000000
-Pixel (59, 63) is 359.613586, should be 358.000000
-Pixel (60, 0) is 303.277740, should be 300.000000
-Pixel (60, 1) is 303.524597, should be 301.000000
-Pixel (60, 2) is 304.006012, should be 302.000000
-Pixel (60, 3) is 304.698547, should be 303.000000
-Pixel (60, 4) is 305.569550, should be 304.000000
-Pixel (60, 5) is 306.580048, should be 305.000000
-Pixel (60, 6) is 307.688049, should be 306.000000
-Pixel (60, 7) is 308.851807, should be 307.000000
-Pixel (60, 8) is 310.033386, should be 308.000000
-Pixel (60, 9) is 311.200897, should be 309.000000
-Pixel (60, 10) is 312.331055, should be 310.000000
-Pixel (60, 11) is 313.409698, should be 311.000000
-Pixel (60, 12) is 314.432129, should be 312.000000
-Pixel (60, 13) is 315.402191, should be 313.000000
-Pixel (60, 14) is 316.330627, should be 314.000000
-Pixel (60, 15) is 317.232758, should be 315.000000
-Pixel (60, 16) is 318.125946, should be 316.000000
-Pixel (60, 17) is 319.027222, should be 317.000000
-Pixel (60, 18) is 319.950806, should be 318.000000
-Pixel (60, 19) is 320.906708, should be 319.000000
-Pixel (60, 20) is 321.899384, should be 320.000000
-Pixel (60, 21) is 322.927673, should be 321.000000
-Pixel (60, 22) is 323.985291, should be 322.000000
-Pixel (60, 23) is 325.062012, should be 323.000000
-Pixel (60, 24) is 326.145386, should be 324.000000
-Pixel (60, 25) is 327.222412, should be 325.000000
-Pixel (60, 26) is 328.281555, should be 326.000000
-Pixel (60, 27) is 329.314270, should be 327.000000
-Pixel (60, 28) is 330.316162, should be 328.000000
-Pixel (60, 29) is 331.287537, should be 329.000000
-Pixel (60, 30) is 332.233246, should be 330.000000
-Pixel (60, 31) is 333.161804, should be 331.000000
-Pixel (60, 32) is 334.084412, should be 332.000000
-Pixel (60, 33) is 335.013062, should be 333.000000
-Pixel (60, 34) is 335.958740, should be 334.000000
-Pixel (60, 35) is 336.930145, should be 335.000000
-Pixel (60, 36) is 337.932068, should be 336.000000
-Pixel (60, 37) is 338.964783, should be 337.000000
-Pixel (60, 38) is 340.023895, should be 338.000000
-Pixel (60, 39) is 341.100952, should be 339.000000
-Pixel (60, 40) is 342.184326, should be 340.000000
-Pixel (60, 41) is 343.261139, should be 341.000000
-Pixel (60, 42) is 344.318756, should be 342.000000
-Pixel (60, 43) is 345.347015, should be 343.000000
-Pixel (60, 44) is 346.339630, should be 344.000000
-Pixel (60, 45) is 347.295532, should be 345.000000
-Pixel (60, 46) is 348.219147, should be 346.000000
-Pixel (60, 47) is 349.120392, should be 347.000000
-Pixel (60, 48) is 350.013580, should be 348.000000
-Pixel (60, 49) is 350.915649, should be 349.000000
-Pixel (60, 50) is 351.844116, should be 350.000000
-Pixel (60, 51) is 352.814148, should be 351.000000
-Pixel (60, 52) is 353.836548, should be 352.000000
-Pixel (60, 53) is 354.915192, should be 353.000000
-Pixel (60, 54) is 356.045319, should be 354.000000
-Pixel (60, 55) is 357.212921, should be 355.000000
-Pixel (60, 56) is 358.394470, should be 356.000000
-Pixel (60, 57) is 359.558289, should be 357.000000
-Pixel (60, 58) is 360.666260, should be 358.000000
-Pixel (60, 59) is 361.676758, should be 359.000000
-Pixel (60, 60) is 362.547821, should be 360.000000
-Pixel (60, 61) is 363.240356, should be 361.000000
-Pixel (60, 62) is 363.721771, should be 362.000000
-Pixel (61, 0) is 306.740479, should be 305.000000
-Pixel (61, 57) is 363.020996, should be 362.000000
-Pixel (61, 58) is 364.128998, should be 363.000000
-Pixel (61, 59) is 365.139496, should be 364.000000
-Pixel (61, 60) is 366.010529, should be 365.000000
-Pixel (62, 1) is 309.394470, should be 311.000000
-Pixel (62, 2) is 309.875885, should be 312.000000
-Pixel (62, 3) is 310.568420, should be 313.000000
-Pixel (62, 4) is 311.439453, should be 314.000000
-Pixel (62, 5) is 312.449951, should be 315.000000
-Pixel (62, 6) is 313.557922, should be 316.000000
-Pixel (62, 7) is 314.721710, should be 317.000000
-Pixel (62, 8) is 315.903259, should be 318.000000
-Pixel (62, 9) is 317.070801, should be 319.000000
-Pixel (62, 10) is 318.200928, should be 320.000000
-Pixel (62, 11) is 319.279572, should be 321.000000
-Pixel (62, 12) is 320.302032, should be 322.000000
-Pixel (62, 13) is 321.272064, should be 323.000000
-Pixel (62, 14) is 322.200531, should be 324.000000
-Pixel (62, 15) is 323.102631, should be 325.000000
-Pixel (62, 16) is 323.995819, should be 326.000000
-Pixel (62, 17) is 324.897095, should be 327.000000
-Pixel (62, 18) is 325.820709, should be 328.000000
-Pixel (62, 19) is 326.776611, should be 329.000000
-Pixel (62, 20) is 327.769287, should be 330.000000
-Pixel (62, 21) is 328.797546, should be 331.000000
-Pixel (62, 22) is 329.855164, should be 332.000000
-Pixel (62, 23) is 330.931915, should be 333.000000
-Pixel (62, 24) is 332.015289, should be 334.000000
-Pixel (62, 25) is 333.092316, should be 335.000000
-Pixel (62, 26) is 334.151428, should be 336.000000
-Pixel (62, 27) is 335.184143, should be 337.000000
-Pixel (62, 28) is 336.186035, should be 338.000000
-Pixel (62, 29) is 337.157440, should be 339.000000
-Pixel (62, 30) is 338.103119, should be 340.000000
-Pixel (62, 31) is 339.031708, should be 341.000000
-Pixel (62, 32) is 339.954315, should be 342.000000
-Pixel (62, 33) is 340.882965, should be 343.000000
-Pixel (62, 34) is 341.828644, should be 344.000000
-Pixel (62, 35) is 342.800018, should be 345.000000
-Pixel (62, 36) is 343.801941, should be 346.000000
-Pixel (62, 37) is 344.834656, should be 347.000000
-Pixel (62, 38) is 345.893799, should be 348.000000
-Pixel (62, 39) is 346.970856, should be 349.000000
-Pixel (62, 40) is 348.054230, should be 350.000000
-Pixel (62, 41) is 349.131012, should be 351.000000
-Pixel (62, 42) is 350.188629, should be 352.000000
-Pixel (62, 43) is 351.216919, should be 353.000000
-Pixel (62, 44) is 352.209534, should be 354.000000
-Pixel (62, 45) is 353.165436, should be 355.000000
-Pixel (62, 46) is 354.089020, should be 356.000000
-Pixel (62, 47) is 354.990265, should be 357.000000
-Pixel (62, 48) is 355.883453, should be 358.000000
-Pixel (62, 49) is 356.785553, should be 359.000000
-Pixel (62, 50) is 357.713989, should be 360.000000
-Pixel (62, 51) is 358.684052, should be 361.000000
-Pixel (62, 52) is 359.706451, should be 362.000000
-Pixel (62, 53) is 360.785065, should be 363.000000
-Pixel (62, 54) is 361.915222, should be 364.000000
-Pixel (62, 55) is 363.082794, should be 365.000000
-Pixel (62, 56) is 364.264374, should be 366.000000
-Pixel (62, 57) is 365.428162, should be 367.000000
-Pixel (62, 58) is 366.536163, should be 368.000000
-Pixel (62, 59) is 367.546661, should be 369.000000
-Pixel (62, 60) is 368.417694, should be 370.000000
-Pixel (62, 61) is 369.110229, should be 371.000000
-Pixel (62, 62) is 369.591644, should be 372.000000
-Pixel (62, 63) is 369.838562, should be 373.000000
-Pixel (63, 0) is 310.381958, should be 315.000000
-Pixel (63, 1) is 310.628784, should be 316.000000
-Pixel (63, 2) is 311.110199, should be 317.000000
-Pixel (63, 3) is 311.802734, should be 318.000000
-Pixel (63, 4) is 312.673767, should be 319.000000
-Pixel (63, 5) is 313.684265, should be 320.000000
-Pixel (63, 6) is 314.792236, should be 321.000000
-Pixel (63, 7) is 315.956024, should be 322.000000
-Pixel (63, 8) is 317.137573, should be 323.000000
-Pixel (63, 9) is 318.305115, should be 324.000000
-Pixel (63, 10) is 319.435242, should be 325.000000
-Pixel (63, 11) is 320.513885, should be 326.000000
-Pixel (63, 12) is 321.536346, should be 327.000000
-Pixel (63, 13) is 322.506378, should be 328.000000
-Pixel (63, 14) is 323.434845, should be 329.000000
-Pixel (63, 15) is 324.336945, should be 330.000000
-Pixel (63, 16) is 325.230133, should be 331.000000
-Pixel (63, 17) is 326.131409, should be 332.000000
-Pixel (63, 18) is 327.055023, should be 333.000000
-Pixel (63, 19) is 328.010925, should be 334.000000
-Pixel (63, 20) is 329.003601, should be 335.000000
-Pixel (63, 21) is 330.031860, should be 336.000000
-Pixel (63, 22) is 331.089478, should be 337.000000
-Pixel (63, 23) is 332.166229, should be 338.000000
-Pixel (63, 24) is 333.249603, should be 339.000000
-Pixel (63, 25) is 334.326630, should be 340.000000
-Pixel (63, 26) is 335.385742, should be 341.000000
-Pixel (63, 27) is 336.418457, should be 342.000000
-Pixel (63, 28) is 337.420349, should be 343.000000
-Pixel (63, 29) is 338.391754, should be 344.000000
-Pixel (63, 30) is 339.337433, should be 345.000000
-Pixel (63, 31) is 340.266022, should be 346.000000
-Pixel (63, 32) is 341.188629, should be 347.000000
-Pixel (63, 33) is 342.117279, should be 348.000000
-Pixel (63, 34) is 343.062958, should be 349.000000
-Pixel (63, 35) is 344.034332, should be 350.000000
-Pixel (63, 36) is 345.036255, should be 351.000000
-Pixel (63, 37) is 346.068970, should be 352.000000
-Pixel (63, 38) is 347.128113, should be 353.000000
-Pixel (63, 39) is 348.205170, should be 354.000000
-Pixel (63, 40) is 349.288544, should be 355.000000
-Pixel (63, 41) is 350.365326, should be 356.000000
-Pixel (63, 42) is 351.422943, should be 357.000000
-Pixel (63, 43) is 352.451233, should be 358.000000
-Pixel (63, 44) is 353.443848, should be 359.000000
-Pixel (63, 45) is 354.399750, should be 360.000000
-Pixel (63, 46) is 355.323334, should be 361.000000
-Pixel (63, 47) is 356.224579, should be 362.000000
-Pixel (63, 48) is 357.117767, should be 363.000000
-Pixel (63, 49) is 358.019867, should be 364.000000
-Pixel (63, 50) is 358.948303, should be 365.000000
-Pixel (63, 51) is 359.918365, should be 366.000000
-Pixel (63, 52) is 360.940765, should be 367.000000
-Pixel (63, 53) is 362.019379, should be 368.000000
-Pixel (63, 54) is 363.149536, should be 369.000000
-Pixel (63, 55) is 364.317108, should be 370.000000
-Pixel (63, 56) is 365.498688, should be 371.000000
-Pixel (63, 57) is 366.662476, should be 372.000000
-Pixel (63, 58) is 367.770477, should be 373.000000
-Pixel (63, 59) is 368.780975, should be 374.000000
-Pixel (63, 60) is 369.652008, should be 375.000000
-Pixel (63, 61) is 370.344543, should be 376.000000
-Pixel (63, 62) is 370.825958, should be 377.000000
-Pixel (63, 63) is 371.072876, should be 378.000000
 
 ---> TESTPOINT PASSED (psImageStats functions{Calculate Chebyshev Polynomials, no mask} | tst_psImageStats02.c)

trunk/psLib/test/sysUtils/tst_psMemory.c

@@ -1 +1 @@
 /** @file  tst_psMemory.c
- *
- *  @brief Contains the tests for psMemory.[ch]
- *
- *
- *  @author Robert DeSonia, MHPCC
- *
- *  @version $Revision: 1.20 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-07-19 22:38:36 $
- *
- *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
- */
+*
+*  @brief Contains the tests for psMemory.[ch]
+*
+*
+*  @author Robert DeSonia, MHPCC
+*
+*  @version $Revision: 1.21 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2004-08-02 19:43:23 $
+*
+*  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
+*/
 
 // need to allow malloc for callback use
@@ -26 +26 @@
 #include "pslib.h"
 
-static int TPFreeReferencedMemory(void);
-static int TPOutOfMemory(void);
-static int TPReallocOutOfMemory(void);
-static void* TPOutOfMemoryExhaustedCallback(size_t size);
-static int TPCheckBufferPositive(void);
-static int TPrealloc(void);
-static int TPallocCallback(void);
-static psMemoryId memAllocateCallback(const psMemBlock *ptr);
-static psMemoryId memFreeCallback(const psMemBlock *ptr);
-static int TPcheckLeaks(void);
-static int TPmemCorruption(void);
-static int TPmultipleFree(void);
-void memProblemCallback(const psMemBlock *ptr, const char *file, int lineno);
+static int TPFreeReferencedMemory( void );
+static int TPOutOfMemory( void );
+static int TPReallocOutOfMemory( void );
+static void* TPOutOfMemoryExhaustedCallback( size_t size );
+static int TPCheckBufferPositive( void );
+static int TPrealloc( void );
+static int TPallocCallback( void );
+static psMemoryId memAllocateCallback( const psMemBlock *ptr );
+static psMemoryId memFreeCallback( const psMemBlock *ptr );
+static int TPcheckLeaks( void );
+static int TPmemCorruption( void );
+static int TPmultipleFree( void );
+void memProblemCallback( const psMemBlock *ptr, const char *file, int lineno );
 
 static int problemCallbackCalled = 0;
@@ -46 +46 @@
 
 testDescription tests[] = {
-                              {TPCheckBufferPositive,449,"checkBufferPositive",0,false},
-                              {TPOutOfMemory,450,"outOfMemory",-6,false},
-                              {TPReallocOutOfMemory,562,"reallocOutOfMemory",-6,false},
-                              {TPrealloc,451,"psRealloc",0,false},
-                              {TPallocCallback,452,"allocCallback",0,false},
-                              {TPallocCallback,453,"allocCallback2",0,true},
-                              {TPcheckLeaks,454,"checkLeaks",0,false},
-                              {TPmemCorruption,455,"psMemCorruption",0,false},
-                              {TPFreeReferencedMemory,456,"freeReferencedMemory",0,false},
-                              {TPmultipleFree,699,"multipleFree",-6,false},
-                              {NULL}
+                              {
+                                  TPCheckBufferPositive, 449, "checkBufferPositive", 0, false
+                              },
+                              {
+                                  TPOutOfMemory, 450, "outOfMemory", -6, false
+                              },
+                              {
+                                  TPReallocOutOfMemory, 562, "reallocOutOfMemory", -6, false
+                              },
+                              {
+                                  TPrealloc, 451, "psRealloc", 0, false
+                              },
+                              {
+                                  TPallocCallback, 452, "allocCallback", 0, false
+                              },
+                              {
+                                  TPallocCallback, 453, "allocCallback2", 0, true
+                              },
+                              {
+                                  TPcheckLeaks, 454, "checkLeaks", 0, false
+                              },
+                              {
+                                  TPmemCorruption, 455, "psMemCorruption", 0, false
+                              },
+                              {
+                                  TPFreeReferencedMemory, 456, "freeReferencedMemory", 0, false
+                              },
+                              {
+                                  TPmultipleFree, 699, "multipleFree", -6, false
+                              },
+                              {
+                                  NULL
+                              }
                           };
-
-int main(int argc, char* argv[])
-{
-    psLogSetLevel(PS_LOG_INFO);
-
-    if (! runTestSuite(stderr,"psMemory",tests,argc,argv) ) {
-        psError(__FILE__,"One or more tests failed");
-        return 1;
-    }
-    return 0;
+                          
+int main( int argc, char* argv[] )
+{
+    psLogSetLevel( PS_LOG_INFO );
+    
+    return ( ! runTestSuite( stderr, "psMemory", tests, argc, argv ) );
 }
 
 // Testpoint #449, psAlloc shall allocate memory blocks writeable by caller.
-int TPCheckBufferPositive(void)
-{
-    int* mem;
+int TPCheckBufferPositive( void )
+{
+    int * mem;
     const int size = 100;
     int failed = 0;
-
-    psLogMsg(__func__,PS_LOG_INFO,"psAlloc shall allocate memory blocks writeable by caller.\n");
-
-    mem = (int*) psAlloc(size*sizeof(int));
-    if (mem == NULL) {
-        psError(__FILE__,"psAlloc returned a NULL value in %s!",__func__);
-        return 1;
-    }
-
-    for (int index=0;index<size;index++) {
-        mem[index]=index;
-    }
-
-    for (int index=0;index<size;index++) {
-        if (mem[index] != index) {
-            failed++;
-        }
-    }
-
-    psFree(mem);
-
+    
+    psLogMsg( __func__, PS_LOG_INFO, "psAlloc shall allocate memory blocks writeable by caller.\n" );
+    
+    mem = ( int* ) psAlloc( size * sizeof( int ) );
+    if ( mem == NULL ) {
+            psError( __FILE__, "psAlloc returned a NULL value in %s!", __func__ );
+            return 1;
+        }
+        
+    for ( int index = 0;index < size;index++ ) {
+            mem[ index ] = index;
+        }
+        
+    for ( int index = 0;index < size;index++ ) {
+            if ( mem[ index ] != index ) {
+                    failed++;
+                }
+        }
+        
+    psFree( mem );
+    
     return failed;
 }
 
-int TPFreeReferencedMemory(void)
+int TPFreeReferencedMemory( void )
 {
     // create memory
-    int* mem;
+    int * mem;
     int ref = 0;
-
-    psLogMsg(__func__,PS_LOG_INFO,"memory reference count shall be incrementable/decrementable");
-
-    mem = (int*) psAlloc(100*sizeof(int));
-
-    ref = psMemGetRefCounter(mem);
-    if (ref != 1) {
-        psError(__func__,"Expected to buffer reference count to be initially 1, but it was %d.",ref);
-        return 1;
-    }
-
-    psMemIncrRefCounter(mem);
-    psMemIncrRefCounter(mem);
-    psMemIncrRefCounter(mem);
-
-    ref = psMemGetRefCounter(mem);
-    if (ref != 4) {
-        psError(__func__,"Expected to find buffer reference count to be 4, but it was %d.",ref);
-        return 1;
-    }
-
-    psMemDecrRefCounter(mem);
-    psMemDecrRefCounter(mem);
-
-    ref = psMemGetRefCounter(mem);
-    if (ref != 2) {
-        psError(__func__,"Expected to find buffer reference count to be 2, but it was %d.",ref);
-        return 1;
-    }
-
-    psLogMsg(__func__,PS_LOG_INFO,"psFree shall be just decrement a multiple refererenced pointer.");
-
-    psFree(mem);
-
-    ref = psMemGetRefCounter(mem);
-    if (ref != 1) {
-        psError(__func__,"Expected to find buffer reference count to be 1, but it was %d.",ref);
-        return 1;
-    }
-
-    psFree(mem);
-
+    
+    psLogMsg( __func__, PS_LOG_INFO, "memory reference count shall be incrementable/decrementable" );
+    
+    mem = ( int* ) psAlloc( 100 * sizeof( int ) );
+    
+    ref = psMemGetRefCounter( mem );
+    if ( ref != 1 ) {
+            psError( __func__, "Expected to buffer reference count to be initially 1, but it was %d.", ref );
+            return 1;
+        }
+        
+    psMemIncrRefCounter( mem );
+    psMemIncrRefCounter( mem );
+    psMemIncrRefCounter( mem );
+    
+    ref = psMemGetRefCounter( mem );
+    if ( ref != 4 ) {
+            psError( __func__, "Expected to find buffer reference count to be 4, but it was %d.", ref );
+            return 1;
+        }
+        
+    psMemDecrRefCounter( mem );
+    psMemDecrRefCounter( mem );
+    
+    ref = psMemGetRefCounter( mem );
+    if ( ref != 2 ) {
+            psError( __func__, "Expected to find buffer reference count to be 2, but it was %d.", ref );
+            return 1;
+        }
+        
+    psLogMsg( __func__, PS_LOG_INFO, "psFree shall be just decrement a multiple refererenced pointer." );
+    
+    psFree( mem );
+    
+    ref = psMemGetRefCounter( mem );
+    if ( ref != 1 ) {
+            psError( __func__, "Expected to find buffer reference count to be 1, but it was %d.", ref );
+            return 1;
+        }
+        
+    psFree( mem );
+    
     return 0;
 }
@@ -152 +170 @@
 // Bug/Task #562 regression test.  Upon requesting more memory than is available, psRealloc shall call
 // the psMemExhaustedCallback.
-int TPReallocOutOfMemory(void)
-{
-    int* mem[100];
+int TPReallocOutOfMemory( void )
+{
+    int * mem[ 100 ];
     psMemExhaustedCallback cb;
-
-    for (int lcv = 0; lcv<100; lcv++) {
-        mem[lcv] = NULL;
-    }
-
-    psLogMsg(__func__,PS_LOG_INFO,"Upon requesting more memory than is available, psRealloc shall call "
-             "the psMemExhaustedCallback.\n");
-
+    
+    for ( int lcv = 0; lcv < 100; lcv++ ) {
+            mem[ lcv ] = NULL;
+        }
+        
+    psLogMsg( __func__, PS_LOG_INFO, "Upon requesting more memory than is available, psRealloc shall call "
+              "the psMemExhaustedCallback.\n" );
+              
     exhaustedCallbackCalled = 0;
-
-    cb = psMemExhaustedCallbackSet(TPOutOfMemoryExhaustedCallback);
-
-    for (int lcv = 0; lcv<100; lcv++) {
-        mem[lcv] = (int*) psAlloc(10);
-    }
-
-    for (int lcv = 0; lcv<100; lcv++) {
-        mem[lcv] = (int*) psRealloc(mem[lcv],SIZE_MAX-1000);
-    }
-
-    psMemExhaustedCallbackSet(cb);
-
-    if (exhaustedCallbackCalled == 0) {
-        psError(__FILE__,"Called psRealloc with HUGE memory requirement and survived in %s!",__func__);
-        return 1;
-    }
-
-    for (int lcv = 0; lcv<100; lcv++) {
-        psFree(mem[lcv]);
-    }
-
+    
+    cb = psMemExhaustedCallbackSet( TPOutOfMemoryExhaustedCallback );
+    
+    for ( int lcv = 0; lcv < 100; lcv++ ) {
+            mem[ lcv ] = ( int* ) psAlloc( 10 );
+        }
+        
+    for ( int lcv = 0; lcv < 100; lcv++ ) {
+            mem[ lcv ] = ( int* ) psRealloc( mem[ lcv ], SIZE_MAX - 1000 );
+        }
+        
+    psMemExhaustedCallbackSet( cb );
+    
+    if ( exhaustedCallbackCalled == 0 ) {
+            psError( __FILE__, "Called psRealloc with HUGE memory requirement and survived in %s!", __func__ );
+            return 1;
+        }
+        
+    for ( int lcv = 0; lcv < 100; lcv++ ) {
+            psFree( mem[ lcv ] );
+        }
+        
     return 0;
 }
 // Testpoint #450,  Upon requesting more memory than is available, psalloc shall call
 // the psMemExhaustedCallback.
-int TPOutOfMemory(void)
-{
-    int* mem[100];
+int TPOutOfMemory( void )
+{
+    int * mem[ 100 ];
     psMemExhaustedCallback cb;
-
-    for (int lcv = 0; lcv<100; lcv++) {
-        mem[lcv] = NULL;
-    }
-
-    psLogMsg(__func__,PS_LOG_INFO,"Upon requesting more memory than is available, psalloc shall call "
-             "the psMemExhaustedCallback.\n");
-
+    
+    for ( int lcv = 0; lcv < 100; lcv++ ) {
+            mem[ lcv ] = NULL;
+        }
+        
+    psLogMsg( __func__, PS_LOG_INFO, "Upon requesting more memory than is available, psalloc shall call "
+              "the psMemExhaustedCallback.\n" );
+              
     exhaustedCallbackCalled = 0;
-
-    cb = psMemExhaustedCallbackSet(TPOutOfMemoryExhaustedCallback);
-
-    for (int lcv = 0; lcv<100; lcv++) {
-        mem[lcv] = (int*) psAlloc(SIZE_MAX-1000);
-    }
-
-    psMemExhaustedCallbackSet(cb);
-
-    if (exhaustedCallbackCalled == 0) {
-        psError(__FILE__,"Called psAlloc with HUGE memory requirement and survived in %s!",__func__);
-        return 1;
-    }
-
-    for (int lcv = 0; lcv<100; lcv++) {
-        psFree(mem[lcv]);
-    }
-
+    
+    cb = psMemExhaustedCallbackSet( TPOutOfMemoryExhaustedCallback );
+    
+    for ( int lcv = 0; lcv < 100; lcv++ ) {
+            mem[ lcv ] = ( int* ) psAlloc( SIZE_MAX - 1000 );
+        }
+        
+    psMemExhaustedCallbackSet( cb );
+    
+    if ( exhaustedCallbackCalled == 0 ) {
+            psError( __FILE__, "Called psAlloc with HUGE memory requirement and survived in %s!", __func__ );
+            return 1;
+        }
+        
+    for ( int lcv = 0; lcv < 100; lcv++ ) {
+            psFree( mem[ lcv ] );
+        }
+        
     return 0;
 }
 
 // Testpoint #451,  psRealloc shall increase/decrease memory buffer while preserving contents
-int TPrealloc(void)
-{
-    int* mem1;
+int TPrealloc( void )
+{
+    int * mem1;
     int* mem2;
     int* mem3;
     const int initialSize = 100;
-
-    psLogMsg(__func__,PS_LOG_INFO,"psRealloc shall increase/decrease memory buffer while "
-             "preserving contents");
-
+    
+    psLogMsg( __func__, PS_LOG_INFO, "psRealloc shall increase/decrease memory buffer while "
+              "preserving contents" );
+              
     // allocate buffer with known values.
-    mem1 = (int*) psAlloc(initialSize*sizeof(int));
-    mem2 = (int*) psAlloc(initialSize*sizeof(int));
-    mem3 = (int*) psAlloc(initialSize*sizeof(int));
-    for (int lcv=0;lcv<initialSize;lcv++) {
-        mem1[lcv] = mem2[lcv] = mem3[lcv] = lcv;
-    }
-
-    psMemCheckCorruption(1);
-    psLogMsg(__func__,PS_LOG_INFO,"Expanding memory buffer.");
-
+    mem1 = ( int* ) psAlloc( initialSize * sizeof( int ) );
+    mem2 = ( int* ) psAlloc( initialSize * sizeof( int ) );
+    mem3 = ( int* ) psAlloc( initialSize * sizeof( int ) );
+    for ( int lcv = 0;lcv < initialSize;lcv++ ) {
+            mem1[ lcv ] = mem2[ lcv ] = mem3[ lcv ] = lcv;
+        }
+        
+    psMemCheckCorruption( 1 );
+    psLogMsg( __func__, PS_LOG_INFO, "Expanding memory buffer." );
+    
     // realloc to 2x
-    mem1 = (int*) psRealloc(mem1, 2*initialSize*sizeof(int));
-    mem2 = (int*) psRealloc(mem2, 2*initialSize*sizeof(int));
-    mem3 = (int*) psRealloc(mem3, 2*initialSize*sizeof(int));
-
+    mem1 = ( int* ) psRealloc( mem1, 2 * initialSize * sizeof( int ) );
+    mem2 = ( int* ) psRealloc( mem2, 2 * initialSize * sizeof( int ) );
+    mem3 = ( int* ) psRealloc( mem3, 2 * initialSize * sizeof( int ) );
+    
     // check values of initial block
-    for (int i=0;i<initialSize;i++) {
-        if (mem1[i] != i || mem2[i] != i || mem3[i] != i) {
-            psError(__FILE__,"Realloc didn't preserve the contents with expanding buffer in %s.",
-                    __func__);
-            break;
-        }
-    }
-
-    psMemCheckCorruption(1);
-    psLogMsg(__func__,PS_LOG_INFO,"Shrinking memory buffer.");
-
+    for ( int i = 0;i < initialSize;i++ ) {
+            if ( mem1[ i ] != i || mem2[ i ] != i || mem3[ i ] != i ) {
+                    psError( __FILE__, "Realloc didn't preserve the contents with expanding buffer in %s.",
+                             __func__ );
+                    break;
+                }
+        }
+        
+    psMemCheckCorruption( 1 );
+    psLogMsg( __func__, PS_LOG_INFO, "Shrinking memory buffer." );
+    
     // realloc to 1/2 initial value.
-    mem1 = (int*) psRealloc(mem1, (initialSize/2)*sizeof(int));
-    mem2 = (int*) psRealloc(mem2, (initialSize/2)*sizeof(int));
-    mem3 = (int*) psRealloc(mem3, (initialSize/2)*sizeof(int));
-
+    mem1 = ( int* ) psRealloc( mem1, ( initialSize / 2 ) * sizeof( int ) );
+    mem2 = ( int* ) psRealloc( mem2, ( initialSize / 2 ) * sizeof( int ) );
+    mem3 = ( int* ) psRealloc( mem3, ( initialSize / 2 ) * sizeof( int ) );
+    
     // check values of initial block
-    for (int i=0;i<initialSize/2;i++) {
-        if (mem1[i] != i || mem2[i] != i || mem3[i] != i) {
-            psError(__FILE__,"Realloc didn't preserve the contents with shrinking buffer in %s.",
-                    __func__);
-            break;
-        }
-    }
-
-    psFree(mem1);
-    psFree(mem2);
-    psFree(mem3);
-
-    return 0;
-}
-
-int TPallocCallback(void)
-{
-    int* mem1;
+    for ( int i = 0;i < initialSize / 2;i++ ) {
+            if ( mem1[ i ] != i || mem2[ i ] != i || mem3[ i ] != i ) {
+                    psError( __FILE__, "Realloc didn't preserve the contents with shrinking buffer in %s.",
+                             __func__ );
+                    break;
+                }
+        }
+        
+    psFree( mem1 );
+    psFree( mem2 );
+    psFree( mem3 );
+    
+    return 0;
+}
+
+int TPallocCallback( void )
+{
+    int * mem1;
     int* mem2;
     int* mem3;
@@ -293 +311 @@
     const int initialSize = 100;
     int mark;
-
+    
     allocCallbackCalled = 0;
     freeCallbackCalled = 0;
-    psMemAllocateCallbackSet(memAllocateCallback);
-    psMemFreeCallbackSet(memFreeCallback);
-
-    psMemAllocateCallbackSetID(currentId+1);
-    psMemFreeCallbackSetID(currentId+1);
-
-    psLogMsg(__func__,PS_LOG_INFO,"call to psAlloc/psRealloc shall generate a callback if specified "
-             "memory ID is allocated.");
-
+    psMemAllocateCallbackSet( memAllocateCallback );
+    psMemFreeCallbackSet( memFreeCallback );
+    
+    psMemAllocateCallbackSetID( currentId + 1 );
+    psMemFreeCallbackSetID( currentId + 1 );
+    
+    psLogMsg( __func__, PS_LOG_INFO, "call to psAlloc/psRealloc shall generate a callback if specified "
+              "memory ID is allocated." );
+              
     // allocate buffer with known values.
-    mem1 = (int*) psAlloc(initialSize*sizeof(int));
-    mem2 = (int*) psAlloc(initialSize*sizeof(int));
-    mem3 = (int*) psAlloc(initialSize*sizeof(int));
-
-    psFree(mem1);
-    psFree(mem2);
-    psFree(mem3);
-
-    if (allocCallbackCalled != 2 || freeCallbackCalled != 2) {
-        psError(__FILE__,"alloc/free callbacks were not called the proper number of times in %s",
-                __func__);
-        return 1;
-    }
-
+    mem1 = ( int* ) psAlloc( initialSize * sizeof( int ) );
+    mem2 = ( int* ) psAlloc( initialSize * sizeof( int ) );
+    mem3 = ( int* ) psAlloc( initialSize * sizeof( int ) );
+    
+    psFree( mem1 );
+    psFree( mem2 );
+    psFree( mem3 );
+    
+    if ( allocCallbackCalled != 2 || freeCallbackCalled != 2 ) {
+            psError( __FILE__, "alloc/free callbacks were not called the proper number of times in %s",
+                     __func__ );
+            return 1;
+        }
+        
     allocCallbackCalled = 0;
     freeCallbackCalled = 0;
-
+    
     mark = psMemGetId();
-
-    mem1 = (int*) psAlloc(initialSize*sizeof(int));
-
-    psMemAllocateCallbackSetID(mark);
-
-    mem1 = (int*) psRealloc(mem1,initialSize*2*sizeof(int));
-
-    psFree(mem1);
-
-    if (allocCallbackCalled != 2) {
-        psError(__FILE__,"realloc callbacks were not called the proper number of times in %s",
-                __func__);
-        return 1;
-    }
-
-    return 0;
-
-}
-
-int TPcheckLeaks(void)
+    
+    mem1 = ( int* ) psAlloc( initialSize * sizeof( int ) );
+    
+    psMemAllocateCallbackSetID( mark );
+    
+    mem1 = ( int* ) psRealloc( mem1, initialSize * 2 * sizeof( int ) );
+    
+    psFree( mem1 );
+    
+    if ( allocCallbackCalled != 2 ) {
+            psError( __FILE__, "realloc callbacks were not called the proper number of times in %s",
+                     __func__ );
+            return 1;
+        }
+        
+    return 0;
+    
+}
+
+int TPcheckLeaks( void )
 {
     const int numBuffers = 5;
-    int* buffers[5];
+    int* buffers[ 5 ];
     int lcv;
     int currentId = psMemGetId();
@@ -352 +370 @@
     int nLeaks = 0;
     int lineMark = 0;
-
-    psLogMsg(__func__,PS_LOG_INFO,"psMemCheckLeaks shall return the number of blocks above an ID "
-             "that are still allocated");
-
-    for (lcv=0;lcv<numBuffers;lcv++) {
-        lineMark = __LINE__+1;
-        buffers[lcv] = psAlloc(sizeof(int));
-    }
-
-    for (lcv=1;lcv<numBuffers;lcv++) {
-        psFree(buffers[lcv]);
-    }
-
-    psLogMsg(__func__,PS_LOG_INFO,"following psMemCheckLeaks call should produce one instance.");
-
-    nLeaks = psMemCheckLeaks(currentId, &blks, stderr);
-
-    if (nLeaks != 1) {
-        psError(__FILE__,"psMemCheckLeaks should have found 1 leak, but found %d in %s.",nLeaks,__func__);
-        return 1;
-    }
-
-    if (blks[0]->lineno != lineMark) {
-        psError(__FILE__,"psMemCheckLeaks found a leak other than the expected one (line %d vs %d) in %s.",
-                lineMark, blks[0]->lineno, __func__);
-        return 1;
-    }
-
-    psFree(buffers[0]);
-    psFree(blks);
-
-    psLogMsg(__func__,PS_LOG_INFO,"Testing psMemCheckLeaks again with a different leak location");
-    psMemCheckLeaks(currentId,NULL,stderr);
-
-    for (lcv=0;lcv<numBuffers;lcv++) {
-        lineMark = __LINE__+1;
-        buffers[lcv] = psAlloc(sizeof(int));
-    }
-
-    for (lcv=0;lcv<numBuffers-1;lcv++) {
-        psFree(buffers[lcv]);
-    }
-
-    psLogMsg(__func__,PS_LOG_INFO,"following psMemCheckLeaks call should produce one error.");
-
-    nLeaks = psMemCheckLeaks(currentId, &blks, stderr);
-
-    if (nLeaks != 1) {
-        psError(__FILE__,"psMemCheckLeaks should have found 1 leak, but found %d in %s.",nLeaks,__func__);
-        return 1;
-    }
-
-    if (blks[0]->lineno != lineMark) {
-        psError(__FILE__,"psMemCheckLeaks found a leak other than the expected one in %s.",__func__);
-        return 1;
-    }
-
-    psFree(buffers[4]);
-    psFree(blks);
-
-    psLogMsg(__func__,PS_LOG_INFO,"Testing psMemCheckLeaks again with multiple leak locations.");
-
-    for (lcv=0;lcv<numBuffers;lcv++) {
-        lineMark = __LINE__+1;
-        buffers[lcv] = psAlloc(sizeof(int));
-    }
-
-    for (lcv=0;lcv<numBuffers;lcv++) {
-        if (lcv%2 == 0) {
-            psFree(buffers[lcv]);
-        }
-    }
-
-    psLogMsg(__func__,PS_LOG_INFO,"following psMemCheckLeaks call should produce two errors.");
-
-    nLeaks = psMemCheckLeaks(currentId, &blks, stderr);
-
-    if (nLeaks != 2) {
-        psError(__FILE__,"psMemCheckLeaks should have found 1 leak, but found %d in %s.",nLeaks,__func__);
-        return 1;
-    }
-
-    if (blks[0]->lineno != lineMark) {
-        psError(__FILE__,"psMemCheckLeaks found a leak other than the expected one in %s.",__func__);
-        return 1;
-    }
-
-    psFree(blks);
-    psFree(buffers[1]);
-    psFree(buffers[3]);
-
-    return 0;
-}
-
-int TPmemCorruption(void)
-{
-    int* buffer = NULL;
+    
+    psLogMsg( __func__, PS_LOG_INFO, "psMemCheckLeaks shall return the number of blocks above an ID "
+              "that are still allocated" );
+              
+    for ( lcv = 0;lcv < numBuffers;lcv++ ) {
+            lineMark = __LINE__ + 1;
+            buffers[ lcv ] = psAlloc( sizeof( int ) );
+        }
+        
+    for ( lcv = 1;lcv < numBuffers;lcv++ ) {
+            psFree( buffers[ lcv ] );
+        }
+        
+    psLogMsg( __func__, PS_LOG_INFO, "following psMemCheckLeaks call should produce one instance." );
+    
+    nLeaks = psMemCheckLeaks( currentId, &blks, stderr );
+    
+    if ( nLeaks != 1 ) {
+            psError( __FILE__, "psMemCheckLeaks should have found 1 leak, but found %d in %s.", nLeaks, __func__ );
+            return 1;
+        }
+        
+    if ( blks[ 0 ] ->lineno != lineMark ) {
+            psError( __FILE__, "psMemCheckLeaks found a leak other than the expected one (line %d vs %d) in %s.",
+                     lineMark, blks[ 0 ] ->lineno, __func__ );
+            return 1;
+        }
+        
+    psFree( buffers[ 0 ] );
+    psFree( blks );
+    
+    psLogMsg( __func__, PS_LOG_INFO, "Testing psMemCheckLeaks again with a different leak location" );
+    psMemCheckLeaks( currentId, NULL, stderr );
+    
+    for ( lcv = 0;lcv < numBuffers;lcv++ ) {
+            lineMark = __LINE__ + 1;
+            buffers[ lcv ] = psAlloc( sizeof( int ) );
+        }
+        
+    for ( lcv = 0;lcv < numBuffers - 1;lcv++ ) {
+            psFree( buffers[ lcv ] );
+        }
+        
+    psLogMsg( __func__, PS_LOG_INFO, "following psMemCheckLeaks call should produce one error." );
+    
+    nLeaks = psMemCheckLeaks( currentId, &blks, stderr );
+    
+    if ( nLeaks != 1 ) {
+            psError( __FILE__, "psMemCheckLeaks should have found 1 leak, but found %d in %s.", nLeaks, __func__ );
+            return 1;
+        }
+        
+    if ( blks[ 0 ] ->lineno != lineMark ) {
+            psError( __FILE__, "psMemCheckLeaks found a leak other than the expected one in %s.", __func__ );
+            return 1;
+        }
+        
+    psFree( buffers[ 4 ] );
+    psFree( blks );
+    
+    psLogMsg( __func__, PS_LOG_INFO, "Testing psMemCheckLeaks again with multiple leak locations." );
+    
+    for ( lcv = 0;lcv < numBuffers;lcv++ ) {
+            lineMark = __LINE__ + 1;
+            buffers[ lcv ] = psAlloc( sizeof( int ) );
+        }
+        
+    for ( lcv = 0;lcv < numBuffers;lcv++ ) {
+            if ( lcv % 2 == 0 ) {
+                    psFree( buffers[ lcv ] );
+                }
+        }
+        
+    psLogMsg( __func__, PS_LOG_INFO, "following psMemCheckLeaks call should produce two errors." );
+    
+    nLeaks = psMemCheckLeaks( currentId, &blks, stderr );
+    
+    if ( nLeaks != 2 ) {
+            psError( __FILE__, "psMemCheckLeaks should have found 1 leak, but found %d in %s.", nLeaks, __func__ );
+            return 1;
+        }
+        
+    if ( blks[ 0 ] ->lineno != lineMark ) {
+            psError( __FILE__, "psMemCheckLeaks found a leak other than the expected one in %s.", __func__ );
+            return 1;
+        }
+        
+    psFree( blks );
+    psFree( buffers[ 1 ] );
+    psFree( buffers[ 3 ] );
+    
+    return 0;
+}
+
+int TPmemCorruption( void )
+{
+    int * buffer = NULL;
     int oldValue = 0;
     int corruptions = 0;
     psMemProblemCallback cb;
-
-    psLogMsg(__func__,PS_LOG_INFO,"psMemCheckCorruption shall detect memory corruptions");
-
-    buffer = psAlloc(sizeof(int));
-
+    
+    psLogMsg( __func__, PS_LOG_INFO, "psMemCheckCorruption shall detect memory corruptions" );
+    
+    buffer = psAlloc( sizeof( int ) );
+    
     // cause memory corruption via buffer underflow
     *buffer = 1;
@@ -462 +480 @@
     oldValue = *buffer;
     *buffer = 2;
-
+    
     problemCallbackCalled = 0;
-    cb = psMemProblemCallbackSet(memProblemCallback);
-
-    psLogMsg(__func__,PS_LOG_INFO,"psMemCheckCorruption should output an error message and "
-             "memProblemCallback callback should be called.");
-
-    corruptions = psMemCheckCorruption(0);
-
+    cb = psMemProblemCallbackSet( memProblemCallback );
+    
+    psLogMsg( __func__, PS_LOG_INFO, "psMemCheckCorruption should output an error message and "
+              "memProblemCallback callback should be called." );
+              
+    corruptions = psMemCheckCorruption( 0 );
+    
     // restore the memory problem callback
-    psMemProblemCallbackSet(cb);
-
+    psMemProblemCallbackSet( cb );
+    
     // restore the value, 'uncorrupting' the buffer
     *buffer = oldValue;
     buffer++;
-
-    psFree(buffer);
-
-    if (corruptions != 1) {
-        psError(__FILE__,"Expected one memory corruption but found %d in %s.",
-                corruptions, __func__);
-        return 1;
-    }
-
-    if (problemCallbackCalled != 1) {
-        psError(__FILE__,"The memProblemCallback was not invoked but should have been in %s",
-                __func__);
-        return 1;
-    }
-
-    return 0;
-
-}
-
-void memProblemCallback(const psMemBlock *ptr, const char *file, int lineno)
-{
-    psLogMsg(__func__,PS_LOG_INFO,"memory callback called for id %d (%s:%d).",
-             ptr->id, file, lineno);
+    
+    psFree( buffer );
+    
+    if ( corruptions != 1 ) {
+            psError( __FILE__, "Expected one memory corruption but found %d in %s.",
+                     corruptions, __func__ );
+            return 1;
+        }
+        
+    if ( problemCallbackCalled != 1 ) {
+            psError( __FILE__, "The memProblemCallback was not invoked but should have been in %s",
+                     __func__ );
+            return 1;
+        }
+        
+    return 0;
+    
+}
+
+void memProblemCallback( const psMemBlock *ptr, const char *file, int lineno )
+{
+    psLogMsg( __func__, PS_LOG_INFO, "memory callback called for id %d (%s:%d).",
+              ptr->id, file, lineno );
     problemCallbackCalled++;
-    return;
-}
-
-psMemoryId memAllocateCallback(const psMemBlock *ptr)
-{
-    psLogMsg(__func__,PS_LOG_INFO,"block %d was (re)allocated",ptr->id);
+    return ;
+}
+
+psMemoryId memAllocateCallback( const psMemBlock *ptr )
+{
+    psLogMsg( __func__, PS_LOG_INFO, "block %d was (re)allocated", ptr->id );
     allocCallbackCalled++;
     return 1;
 }
 
-psMemoryId memFreeCallback(const psMemBlock *ptr)
-{
-    psLogMsg(__func__,PS_LOG_INFO,"block %d was freed",ptr->id);
+psMemoryId memFreeCallback( const psMemBlock *ptr )
+{
+    psLogMsg( __func__, PS_LOG_INFO, "block %d was freed", ptr->id );
     freeCallbackCalled++;
     return 1;
 }
 
-void* TPOutOfMemoryExhaustedCallback(size_t size)
-{
-    psLogMsg(__func__,PS_LOG_INFO,"Custom MemExhaustedCallback was invoked.");
+void* TPOutOfMemoryExhaustedCallback( size_t size )
+{
+    psLogMsg( __func__, PS_LOG_INFO, "Custom MemExhaustedCallback was invoked." );
     exhaustedCallbackCalled++;
     return NULL;
 }
 
-int TPmultipleFree(void)
-{
-
-    void* buffer = psAlloc(1024);
-
-    psFree(buffer);
-
-    psLogMsg(__func__,PS_LOG_INFO,"Next should be an error about multiple freeing.");
-    psFree(buffer);
-
-    return 0;
-}
+int TPmultipleFree( void )
+{
+
+    void * buffer = psAlloc( 1024 );
+    
+    psFree( buffer );
+    
+    psLogMsg( __func__, PS_LOG_INFO, "Next should be an error about multiple freeing." );
+    psFree( buffer );
+    
+    return 0;
+}

trunk/psLib/test/sysUtils/verified/tst_psMemory.stderr

@@ -17 +17 @@
  <DATE> <TIME> |<HOST>|I|  TPOutOfMemory|Upon requesting more memory than is available, psalloc shall call the psMemExhaustedCallback.
  <DATE> <TIME> |<HOST>|I|TPOutOfMemoryEx|Custom MemExhaustedCallback was invoked.
- <DATE> <TIME> |<HOST>|A|      p_psAlloc|Failed to allocate 4294966295 bytes at tst_psMemory.c:210
+ <DATE> <TIME> |<HOST>|A|      p_psAlloc|Failed to allocate 4294966295 bytes at tst_psMemory.c:206
 
 ---> TESTPOINT PASSED (psMemory{outOfMemory} | tst_psMemory.c)
@@ -28 +28 @@
 
  <DATE> <TIME> |<HOST>|I|TPReallocOutOfM|Upon requesting more memory than is available, psRealloc shall call the psMemExhaustedCallback.
- <DATE> <TIME> |<HOST>|A|    p_psRealloc|Failed to reallocate -1001 bytes at tst_psMemory.c:175
+ <DATE> <TIME> |<HOST>|A|    p_psRealloc|Failed to reallocate -1001 bytes at tst_psMemory.c:171
 
 ---> TESTPOINT PASSED (psMemory{reallocOutOfMemory} | tst_psMemory.c)
@@ -70 +70 @@
  <DATE> <TIME> |<HOST>|I|   TPcheckLeaks|following psMemCheckLeaks call should produce one instance.
                    file:line ID
-         tst_psMemory.c:360  1
+         tst_psMemory.c:356  1
  <DATE> <TIME> |<HOST>|I|   TPcheckLeaks|Testing psMemCheckLeaks again with a different leak location
  <DATE> <TIME> |<HOST>|I|   TPcheckLeaks|following psMemCheckLeaks call should produce one error.
                    file:line ID
-         tst_psMemory.c:390  11
+         tst_psMemory.c:386  11
  <DATE> <TIME> |<HOST>|I|   TPcheckLeaks|Testing psMemCheckLeaks again with multiple leak locations.
  <DATE> <TIME> |<HOST>|I|   TPcheckLeaks|following psMemCheckLeaks call should produce two errors.
                    file:line ID
-         tst_psMemory.c:418  16
-         tst_psMemory.c:418  14
+         tst_psMemory.c:414  16
+         tst_psMemory.c:414  14
 
 ---> TESTPOINT PASSED (psMemory{checkLeaks} | tst_psMemory.c)
@@ -92 +92 @@
  <DATE> <TIME> |<HOST>|I|TPmemCorruption|psMemCheckCorruption should output an error message and memProblemCallback callback should be called.
  <DATE> <TIME> |<HOST>|E|psMemCheckCorru|Memory Corruption: memory block 1 is corrupted (buffer underflow)
- <DATE> <TIME> |<HOST>|I|memProblemCallb|memory callback called for id 1 (psMemCheckCorruption:254).
+ <DATE> <TIME> |<HOST>|I|memProblemCallb|memory callback called for id 1 (psMemCheckCorruption:260).
 
 ---> TESTPOINT PASSED (psMemory{psMemCorruption} | tst_psMemory.c)
@@ -115 +115 @@
  <DATE> <TIME> |<HOST>|I| TPmultipleFree|Next should be an error about multiple freeing.
  <DATE> <TIME> |<HOST>|E|  checkMemBlock|Memory Corruption: memory block 1 was freed but still used.
- <DATE> <TIME> |<HOST>|E|memProblemCallb|Block 1 allocated at tst_psMemory.c:530 freed more than once at tst_psMemory.c:535
- <DATE> <TIME> |<HOST>|A|memProblemCallb|Detected a problem in the memory system at tst_psMemory.c:535
+ <DATE> <TIME> |<HOST>|E|memProblemCallb|Block 1 allocated at tst_psMemory.c:526 freed more than once at tst_psMemory.c:531
+ <DATE> <TIME> |<HOST>|A|memProblemCallb|Detected a problem in the memory system at tst_psMemory.c:531
 
 ---> TESTPOINT PASSED (psMemory{multipleFree} | tst_psMemory.c)