Changeset 1365 for trunk/psLib/test/dataManip

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/dataManip

Files:

• tst_psHist02.c (modified) (3 diffs)
• tst_psMatrixVectorArithmetic02.c (modified) (8 diffs)
• tst_psStats07.c (modified) (3 diffs)
• tst_psVectorFFT.c (modified) (8 diffs)
• verified/tst_psHist02.stdout (modified) (4 diffs)
• verified/tst_psMatrixVectorArithmetic02.stdout (modified) (106 diffs)
• verified/tst_psStats07.stdout (modified) (8 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)