Index: /trunk/psLib/src/dataManip/psFunctions.c =================================================================== --- /trunk/psLib/src/dataManip/psFunctions.c (revision 1280) +++ /trunk/psLib/src/dataManip/psFunctions.c (revision 1281) @@ -7,6 +7,6 @@ * polynomials. It also contains a Gaussian functions. * - * @version $Revision: 1.15 $ $Name: not supported by cvs2svn $ - * @date $Date: 2004-07-15 23:52:34 $ + * @version $Revision: 1.16 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-07-22 23:45:16 $ * * Copyright 2004 Maui High Performance Computing Center, University of Hawaii @@ -29,9 +29,15 @@ #include "psFunctions.h" -#include "float.h" -#include #include #include - +/*****************************************************************************/ +/* DEFINE STATEMENTS */ +/*****************************************************************************/ + +// None + +/*****************************************************************************/ +/* TYPE DEFINITIONS */ +/*****************************************************************************/ static void polynomial1DFree(psPolynomial1D *myPoly); static void polynomial2DFree(psPolynomial2D *myPoly); @@ -44,4 +50,22 @@ /*****************************************************************************/ +/* GLOBAL VARIABLES */ +/*****************************************************************************/ + +// None + +/*****************************************************************************/ +/* FILE STATIC VARIABLES */ +/*****************************************************************************/ + +// None + +/*****************************************************************************/ +/* FUNCTION IMPLEMENTATION - LOCAL */ +/*****************************************************************************/ + +// None + +/*****************************************************************************/ /* FUNCTION IMPLEMENTATION - PUBLIC */ /*****************************************************************************/ @@ -55,21 +79,20 @@ psGaussian(float x, float mean, - float stddev, + float sigma, int normal) { - float tmp = 0.0; + float tmp = 1.0; if (normal == 1) { #ifdef DARWIN - tmp = 1.0 / (float)sqrt(2.0 * M_PI * (stddev * stddev)); + tmp = 1.0 / (float)sqrt(2.0 * M_PI * (sigma * sigma)); #else - tmp = 1.0 / sqrtf(2.0 * M_PI * (stddev * stddev)); + tmp = 1.0 / sqrtf(2.0 * M_PI * (sigma * sigma)); #endif - return(tmp * exp(-((x-mean) * (x-mean)) / (2.0 * stddev * stddev))); - } else { - return(exp(-((x-mean) * (x-mean)) / (2.0 * stddev * stddev))); - } + } + + return(tmp * exp(-((x-mean) * (x-mean)) / (2.0 * sigma * sigma))); } @@ -328,7 +351,16 @@ float xSum = 1.0; + if (NULL == myPoly) { + psAbort(__func__, "psEvalPolynomial1D(): myPoly is NULL\n"); + } + + // NOTE: Do we want to flag this case? if (myPoly->n == 0) { return(1.0); + } + + if (NULL == myPoly->coeff) { + psAbort(__func__, "psEvalPolynomial1D(): myPoly->coeff is NULL\n"); } Index: /trunk/psLib/src/dataManip/psMinimize.h =================================================================== --- /trunk/psLib/src/dataManip/psMinimize.h (revision 1280) +++ /trunk/psLib/src/dataManip/psMinimize.h (revision 1281) @@ -2,4 +2,5 @@ #define PS_MINIMIZE_H +#include "psFunctions.h" /** \file psMinimize.h * \brief minimization operations Index: /trunk/psLib/src/dataManip/psStats.h =================================================================== --- /trunk/psLib/src/dataManip/psStats.h (revision 1280) +++ /trunk/psLib/src/dataManip/psStats.h (revision 1281) @@ -9,6 +9,6 @@ * @author George Gusciora, MHPCC * - * @version $Revision: 1.13 $ $Name: not supported by cvs2svn $ - * @date $Date: 2004-06-23 23:00:15 $ + * @version $Revision: 1.14 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-07-22 23:44:49 $ * * Copyright 2004 Maui High Performance Computing Center, University of Hawaii @@ -57,5 +57,4 @@ double sampleLimit; ///< double robustMean; ///< robust mean of array - int robustMeanNvalues; ///< number of measurements used for robust mean double robustMedian; ///< robust median of array double robustMode; ///< Robust mode of array Index: /trunk/psLib/src/math/psMinimize.h =================================================================== --- /trunk/psLib/src/math/psMinimize.h (revision 1280) +++ /trunk/psLib/src/math/psMinimize.h (revision 1281) @@ -2,4 +2,5 @@ #define PS_MINIMIZE_H +#include "psFunctions.h" /** \file psMinimize.h * \brief minimization operations Index: /trunk/psLib/src/math/psPolynomial.c =================================================================== --- /trunk/psLib/src/math/psPolynomial.c (revision 1280) +++ /trunk/psLib/src/math/psPolynomial.c (revision 1281) @@ -7,6 +7,6 @@ * polynomials. It also contains a Gaussian functions. * - * @version $Revision: 1.15 $ $Name: not supported by cvs2svn $ - * @date $Date: 2004-07-15 23:52:34 $ + * @version $Revision: 1.16 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-07-22 23:45:16 $ * * Copyright 2004 Maui High Performance Computing Center, University of Hawaii @@ -29,9 +29,15 @@ #include "psFunctions.h" -#include "float.h" -#include #include #include - +/*****************************************************************************/ +/* DEFINE STATEMENTS */ +/*****************************************************************************/ + +// None + +/*****************************************************************************/ +/* TYPE DEFINITIONS */ +/*****************************************************************************/ static void polynomial1DFree(psPolynomial1D *myPoly); static void polynomial2DFree(psPolynomial2D *myPoly); @@ -44,4 +50,22 @@ /*****************************************************************************/ +/* GLOBAL VARIABLES */ +/*****************************************************************************/ + +// None + +/*****************************************************************************/ +/* FILE STATIC VARIABLES */ +/*****************************************************************************/ + +// None + +/*****************************************************************************/ +/* FUNCTION IMPLEMENTATION - LOCAL */ +/*****************************************************************************/ + +// None + +/*****************************************************************************/ /* FUNCTION IMPLEMENTATION - PUBLIC */ /*****************************************************************************/ @@ -55,21 +79,20 @@ psGaussian(float x, float mean, - float stddev, + float sigma, int normal) { - float tmp = 0.0; + float tmp = 1.0; if (normal == 1) { #ifdef DARWIN - tmp = 1.0 / (float)sqrt(2.0 * M_PI * (stddev * stddev)); + tmp = 1.0 / (float)sqrt(2.0 * M_PI * (sigma * sigma)); #else - tmp = 1.0 / sqrtf(2.0 * M_PI * (stddev * stddev)); + tmp = 1.0 / sqrtf(2.0 * M_PI * (sigma * sigma)); #endif - return(tmp * exp(-((x-mean) * (x-mean)) / (2.0 * stddev * stddev))); - } else { - return(exp(-((x-mean) * (x-mean)) / (2.0 * stddev * stddev))); - } + } + + return(tmp * exp(-((x-mean) * (x-mean)) / (2.0 * sigma * sigma))); } @@ -328,7 +351,16 @@ float xSum = 1.0; + if (NULL == myPoly) { + psAbort(__func__, "psEvalPolynomial1D(): myPoly is NULL\n"); + } + + // NOTE: Do we want to flag this case? if (myPoly->n == 0) { return(1.0); + } + + if (NULL == myPoly->coeff) { + psAbort(__func__, "psEvalPolynomial1D(): myPoly->coeff is NULL\n"); } Index: /trunk/psLib/src/math/psSpline.c =================================================================== --- /trunk/psLib/src/math/psSpline.c (revision 1280) +++ /trunk/psLib/src/math/psSpline.c (revision 1281) @@ -7,6 +7,6 @@ * polynomials. It also contains a Gaussian functions. * - * @version $Revision: 1.15 $ $Name: not supported by cvs2svn $ - * @date $Date: 2004-07-15 23:52:34 $ + * @version $Revision: 1.16 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-07-22 23:45:16 $ * * Copyright 2004 Maui High Performance Computing Center, University of Hawaii @@ -29,9 +29,15 @@ #include "psFunctions.h" -#include "float.h" -#include #include #include - +/*****************************************************************************/ +/* DEFINE STATEMENTS */ +/*****************************************************************************/ + +// None + +/*****************************************************************************/ +/* TYPE DEFINITIONS */ +/*****************************************************************************/ static void polynomial1DFree(psPolynomial1D *myPoly); static void polynomial2DFree(psPolynomial2D *myPoly); @@ -44,4 +50,22 @@ /*****************************************************************************/ +/* GLOBAL VARIABLES */ +/*****************************************************************************/ + +// None + +/*****************************************************************************/ +/* FILE STATIC VARIABLES */ +/*****************************************************************************/ + +// None + +/*****************************************************************************/ +/* FUNCTION IMPLEMENTATION - LOCAL */ +/*****************************************************************************/ + +// None + +/*****************************************************************************/ /* FUNCTION IMPLEMENTATION - PUBLIC */ /*****************************************************************************/ @@ -55,21 +79,20 @@ psGaussian(float x, float mean, - float stddev, + float sigma, int normal) { - float tmp = 0.0; + float tmp = 1.0; if (normal == 1) { #ifdef DARWIN - tmp = 1.0 / (float)sqrt(2.0 * M_PI * (stddev * stddev)); + tmp = 1.0 / (float)sqrt(2.0 * M_PI * (sigma * sigma)); #else - tmp = 1.0 / sqrtf(2.0 * M_PI * (stddev * stddev)); + tmp = 1.0 / sqrtf(2.0 * M_PI * (sigma * sigma)); #endif - return(tmp * exp(-((x-mean) * (x-mean)) / (2.0 * stddev * stddev))); - } else { - return(exp(-((x-mean) * (x-mean)) / (2.0 * stddev * stddev))); - } + } + + return(tmp * exp(-((x-mean) * (x-mean)) / (2.0 * sigma * sigma))); } @@ -328,7 +351,16 @@ float xSum = 1.0; + if (NULL == myPoly) { + psAbort(__func__, "psEvalPolynomial1D(): myPoly is NULL\n"); + } + + // NOTE: Do we want to flag this case? if (myPoly->n == 0) { return(1.0); + } + + if (NULL == myPoly->coeff) { + psAbort(__func__, "psEvalPolynomial1D(): myPoly->coeff is NULL\n"); } Index: /trunk/psLib/src/math/psStats.h =================================================================== --- /trunk/psLib/src/math/psStats.h (revision 1280) +++ /trunk/psLib/src/math/psStats.h (revision 1281) @@ -9,6 +9,6 @@ * @author George Gusciora, MHPCC * - * @version $Revision: 1.13 $ $Name: not supported by cvs2svn $ - * @date $Date: 2004-06-23 23:00:15 $ + * @version $Revision: 1.14 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-07-22 23:44:49 $ * * Copyright 2004 Maui High Performance Computing Center, University of Hawaii @@ -57,5 +57,4 @@ double sampleLimit; ///< double robustMean; ///< robust mean of array - int robustMeanNvalues; ///< number of measurements used for robust mean double robustMedian; ///< robust median of array double robustMode; ///< Robust mode of array Index: /trunk/psLib/test/dataManip/tst_psStats07.c =================================================================== --- /trunk/psLib/test/dataManip/tst_psStats07.c (revision 1280) +++ /trunk/psLib/test/dataManip/tst_psStats07.c (revision 1281) @@ -10,5 +10,8 @@ #include -#define N 15 +#define N 200 +#define MEAN 32.0 +#define STDEV 2.0 +#define ERROR_TOLERANCE 0.10 int main() @@ -23,26 +26,27 @@ // A: They must be changed if we adjust the number of data points. // B: We don't really know that they are correct. - float realMeanNoMask = 0.0; - float realMedianNoMask = 0.0; - float realModeNoMask = -1.0; - float realStdevNoMask = 0.0; - float realLQNoMask = 0.0; - float realUQNoMask = 0.0; - float realN50NoMask = 0.0; - float realNfitNoMask = 0.0; - float realMeanWithMask = 0.0; - float realMedianWithMask = 0.0; - float realModeWithMask = 40.0; - float realStdevWithMask = 0.0; - float realLQWithMask = 0.0; - float realUQWithMask = 0.0; - float realN50WithMask = 0.0; - float realNfitWithMask = 0.0; int count = 0; int currentId = psMemGetId(); int memLeaks = 0; - - /*************************************************************************/ - /* Allocate and initialize data structures */ + 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 realMeanWithMask = MEAN; + float realMedianWithMask = MEAN; + float realModeWithMask = MEAN; + float realStdevWithMask = STDEV; + float realLQWithMask = MEAN; + float realUQWithMask = MEAN; + float realN50WithMask = (float) N/4; + float realNfitWithMask = (float) N/4; + + + /*************************************************************************/ + /* Allocate and initialize data structures */ /*************************************************************************/ myStats = psStatsAlloc(PS_STAT_ROBUST_MEAN | @@ -52,14 +56,7 @@ PS_STAT_ROBUST_QUARTILE); - myVector = psVectorAlloc(N, PS_TYPE_F32); - myVector->n = N; maskVector = psVectorAlloc(N, PS_TYPE_U8); maskVector->n = N; - - // Set the appropriate values for the vector data. - for (i=0;idata.F32[i] = (float) i; - } - + myVector = psGaussianDev(MEAN, STDEV, N); // Set the mask vector and calculate the expected maximum. for (i=0;irobustMean); - if (fabs(myStats->robustMean - realMeanNoMask) <= 2.0 * FLT_EPSILON) { + + if (fabs(myStats->robustMean - realMeanNoMask) < (ERROR_TOLERANCE * realMeanNoMask)) { testStatus = true; } else { @@ -95,5 +90,4 @@ "PS_STAT_ROBUST_STATS: robust mean: no vector mask", testStatus); - @@ -104,5 +98,5 @@ printf("The expected Median was %f; the calculated Median was %f\n", realMedianNoMask, myStats->robustMedian); - if (fabs(myStats->robustMedian - realMedianNoMask) <= 2.0 * FLT_EPSILON) { + if (fabs(myStats->robustMedian - realMedianNoMask) < (ERROR_TOLERANCE * realMedianNoMask)) { testStatus = true; } else { @@ -115,13 +109,12 @@ 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) <= 2.0 * FLT_EPSILON) { + if (fabs(myStats->robustMode - realModeNoMask) < (ERROR_TOLERANCE * realModeNoMask)) { testStatus = true; } else { @@ -142,5 +135,5 @@ printf("The expected Stdev was %f; the calculated Stdev was %f\n", realStdevNoMask, myStats->robustStdev); - if (fabs(myStats->robustStdev - realStdevNoMask) <= 2.0 * FLT_EPSILON) { + if (fabs(myStats->robustStdev - realStdevNoMask) < (ERROR_TOLERANCE * realStdevNoMask)) { testStatus = true; } else { @@ -161,5 +154,6 @@ printf("The expected LQ was %f; the calculated LQ was %f\n", realLQNoMask, myStats->robustLQ); - if (fabs(myStats->robustLQ - realLQNoMask) <= 2.0 * FLT_EPSILON) { + + if (fabs(myStats->robustLQ - realLQNoMask) < (ERROR_TOLERANCE * realLQNoMask)) { testStatus = true; } else { @@ -180,5 +174,5 @@ printf("The expected UQ was %f; the calculated UQ was %f\n", realUQNoMask, myStats->robustUQ); - if (fabs(myStats->robustUQ - realUQNoMask) <= 2.0 * FLT_EPSILON) { + if (fabs(myStats->robustUQ - realUQNoMask) < (ERROR_TOLERANCE * realUQNoMask)) { testStatus = true; } else { @@ -196,8 +190,11 @@ "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) <= 2.0 * FLT_EPSILON) { + if (fabs(myStats->robustN50 - realN50NoMask) < (ERROR_TOLERANCE * realN50NoMask)) { testStatus = true; } else { @@ -215,8 +212,11 @@ "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) <= 2.0 * FLT_EPSILON) { + if (fabs(myStats->robustNfit - realNfitNoMask) < (ERROR_TOLERANCE * realNfitNoMask)) { testStatus = true; } else { @@ -230,6 +230,8 @@ - /*************************************************************************/ - /* Call psVectorStats() with vector mask. */ + return(0); + + /*************************************************************************/ + /* Call psVectorStats() with vector mask. */ /*************************************************************************/ printPositiveTestHeader(stdout, @@ -242,5 +244,5 @@ printf("The expected Mean was %f; the calculated Mean was %f\n", realMeanWithMask, myStats->robustMean); - if (fabs(myStats->robustMean - realMeanWithMask) <= 2.0 * FLT_EPSILON) { + if (fabs(myStats->robustMean - realMeanWithMask) < (ERROR_TOLERANCE * realMeanWithMask)) { testStatus = true; } else { @@ -261,5 +263,5 @@ printf("The expected Median was %f; the calculated Median was %f\n", realMedianWithMask, myStats->robustMedian); - if (fabs(myStats->robustMedian - realMedianWithMask) <= 2.0 * FLT_EPSILON) { + if (fabs(myStats->robustMedian - realMedianWithMask) < (ERROR_TOLERANCE * realMedianWithMask)) { testStatus = true; } else { @@ -280,5 +282,5 @@ printf("The expected Mode was %f; the calculated Mode was %f\n", realModeWithMask, myStats->robustMode); - if (fabs(myStats->robustMode - realModeWithMask) <= 2.0 * FLT_EPSILON) { + if (fabs(myStats->robustMode - realModeWithMask) < (ERROR_TOLERANCE * realModeWithMask)) { testStatus = true; } else { @@ -299,5 +301,5 @@ printf("The expected Stdev was %f; the calculated Stdev was %f\n", realStdevWithMask, myStats->robustStdev); - if (fabs(myStats->robustStdev - realStdevWithMask) <= 2.0 * FLT_EPSILON) { + if (fabs(myStats->robustStdev - realStdevWithMask) < (ERROR_TOLERANCE * realStdevWithMask)) { testStatus = true; } else { @@ -318,5 +320,5 @@ printf("The expected LQ was %f; the calculated LQ was %f\n", realLQWithMask, myStats->robustLQ); - if (fabs(myStats->robustLQ - realLQWithMask) <= 2.0 * FLT_EPSILON) { + if (fabs(myStats->robustLQ - realLQWithMask) < (ERROR_TOLERANCE * realLQWithMask)) { testStatus = true; } else { @@ -337,5 +339,5 @@ printf("The expected UQ was %f; the calculated UQ was %f\n", realUQWithMask, myStats->robustUQ); - if (fabs(myStats->robustUQ - realUQWithMask) <= 2.0 * FLT_EPSILON) { + if (fabs(myStats->robustUQ - realUQWithMask) < (ERROR_TOLERANCE * realUQWithMask)) { testStatus = true; } else { @@ -356,5 +358,5 @@ printf("The expected N50 was %f; the calculated N50 was %f\n", realN50WithMask, myStats->robustN50); - if (fabs(myStats->robustN50 - realN50WithMask) <= 2.0 * FLT_EPSILON) { + if (fabs(myStats->robustN50 - realN50WithMask) < (ERROR_TOLERANCE * realN50WithMask)) { testStatus = true; } else { @@ -375,5 +377,5 @@ printf("The expected Nfit was %f; the calculated Nfit was %f\n", realNfitWithMask, myStats->robustNfit); - if (fabs(myStats->robustNfit - realNfitWithMask) <= 2.0 * FLT_EPSILON) { + if (fabs(myStats->robustNfit - realNfitWithMask) < (ERROR_TOLERANCE * realNfitWithMask)) { testStatus = true; } else { @@ -389,5 +391,5 @@ /*************************************************************************/ - /* Deallocate data structures */ + /* Deallocate data structures */ /*************************************************************************/ printPositiveTestHeader(stdout,