Changeset 1406 for trunk/psLib/test/dataManip/tst_psStats07.c

Timestamp:

Aug 6, 2004, 12:34:06 PM (22 years ago)

Author:

desonia

Message:

astyle fixed?

File:

• trunk/psLib/test/dataManip/tst_psStats07.c (modified) (7 diffs)

trunk/psLib/test/dataManip/tst_psStats07.c

@@ -45 +45 @@
     float realN50WithMask = ( float ) N / 4;
     float realNfitWithMask = ( float ) N / 4;
-    
-    
+
+
     /*************************************************************************/
     /*  Allocate and initialize data structures                              */
@@ -55 +55 @@
                             PS_STAT_ROBUST_STDEV |
                             PS_STAT_ROBUST_QUARTILE );
-                            
+
     maskVector = psVectorAlloc( N, PS_TYPE_U8 );
     maskVector->n = N;
@@ -61 +61 @@
     // 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;
-                }
+        if ( i < ( N / 2 ) ) {
+            maskVector->data.U8[ i ] = 0;
+            count++;
+        } else {
+            maskVector->data.U8[ i ] = 1;
         }
+    }
     /*************************************************************************/
     /*  Call psVectorStats() with no vector mask.                            */
@@ -74 +74 @@
                              "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;
-        }
+        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;
-        }
+        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;
-        }
+        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;
-        }
+        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;
-        }
+        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;
-        }
+        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 %.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;
-        }
+        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 %.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;
-        }
+        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.                               */
@@ -238 +238 @@
                              "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 );
@@ -245 +245 @@
             realMeanWithMask, myStats->robustMean );
     if ( fabs( myStats->robustMean - realMeanWithMask ) < ( ERROR_TOLERANCE * realMeanWithMask ) ) {
-            testStatus = true;
-        } else {
-            testStatus = false;
-            globalTestStatus = false;
-        }
+        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;
-        }
+        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;
-        }
+        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;
-        }
+        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;
-        }
+        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;
-        }
+        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;
-        }
+        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;
-        }
+        testStatus = true;
+    } else {
+        testStatus = false;
+        globalTestStatus = false;
+    }
     printFooter( stdout,
                  "psVector functions",
                  "PS_STAT_ROBUST_STATS: robust Nfit: with vector mask",
                  testStatus );
-                 
-                 
-                 
+
+
+
     /*************************************************************************/
     /*  Deallocate data structures                                           */
@@ -396 +396 @@
                              "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 );
-        }
-        
+        psAbort( __func__, "Memory Leaks! (%d leaks)", memLeaks );
+    }
+
     printFooter( stdout,
                  "psVector functions",
                  "psStats(): deallocating memory",
                  testStatus );
-                 
+
     return ( !globalTestStatus );
 }