Index: trunk/psLib/src/math/psRandom.h =================================================================== --- trunk/psLib/src/math/psRandom.h (revision 4288) +++ trunk/psLib/src/math/psRandom.h (revision 4293) @@ -10,6 +10,6 @@ * @author GLG, MHPCC * -* @version $Revision: 1.4 $ $Name: not supported by cvs2svn $ -* @date $Date: 2005-06-08 23:40:45 $ +* @version $Revision: 1.5 $ $Name: not supported by cvs2svn $ +* @date $Date: 2005-06-17 00:11:05 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -33,24 +33,64 @@ */ +/** Enumeration containing a flag for psRandom types. */ typedef enum { - PS_RANDOM_TAUS ///< A maximally equidistributed combined Tausworthe generator. + PS_RANDOM_TAUS ///< A maximally equidistributed combined Tausworthe generator. } psRandomType; +/** Data structure for psRandom. + * Contains information on the psRandom type and GNU Scientific Library random number generator. + */ typedef struct { - psRandomType type; ///< The type of RNG - gsl_rng *gsl; ///< The RNG itself + psRandomType type; ///< The type of RNG + gsl_rng *gsl; ///< The RNG itself } psRandom; -psRandom *psRandomAlloc(psRandomType type, - psU64 seed); +/** Allocates a psRandom struct. + * + * @return psRandom*: A new psRandom structure. + */ +psRandom *psRandomAlloc( + psRandomType type, ///< The type of RNG + psU64 seed ///< Known value with which to seed the RNG +); -void psRandomReset(psRandom *rand, - psU64 seed); +/** Resets an existing psRandom struct. + * + * @return void + */ +void psRandomReset( + psRandom *rand, ///< Existing psRandom struct to reset + psU64 seed ///< Known value with which to seed the RNG +); -psF64 psRandomUniform(const psRandom *r); -psF64 psRandomGaussian(const psRandom *r); -psF64 psRandomPoisson(const psRandom *r, psF64 mean); +/** Random number generator based on a uniform distribution on [0,1). + * Uses gsl_rng_uniform. + * + * @return psF64: Random number. + */ +psF64 psRandomUniform( + const psRandom *r ///< psRandom struct for RNG +); + +/** Random number generator based on a Gaussian deviate, N(0,1). + * Uses gsl_ran_gaussian. + * + * @return psF64: Random number. + */ +psF64 psRandomGaussian( + const psRandom *r ///< psRandom struct for RNG +); + +/** Random number generator based on a Poisson distribution with the given mean. + * Uses gsl_ran_poisson. + * + * @return psF64: Random number. + */ +psF64 psRandomPoisson( + const psRandom *r, ///< psRandom struct for RNG + psF64 mean ///< Mean value +); /* \} */// End of MathGroup Functions Index: trunk/psLib/src/math/psStats.h =================================================================== --- trunk/psLib/src/math/psStats.h (revision 4288) +++ trunk/psLib/src/math/psStats.h (revision 4293) @@ -14,6 +14,6 @@ * @author GLG, MHPCC * - * @version $Revision: 1.42 $ $Name: not supported by cvs2svn $ - * @date $Date: 2005-06-08 23:40:45 $ + * @version $Revision: 1.43 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-06-17 00:11:05 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -37,20 +37,20 @@ // XXX: Is PS_STAT_ROBUST_FOR_SAMPLE obsolete? typedef enum { - PS_STAT_SAMPLE_MEAN = 0x000001, - PS_STAT_SAMPLE_MEDIAN = 0x000002, - PS_STAT_SAMPLE_STDEV = 0x000004, - PS_STAT_SAMPLE_QUARTILE = 0x000008, - PS_STAT_ROBUST_MEAN = 0x000010, - PS_STAT_ROBUST_MEDIAN = 0x000020, - PS_STAT_ROBUST_MODE = 0x000040, - PS_STAT_ROBUST_STDEV = 0x000080, - PS_STAT_ROBUST_QUARTILE = 0x000100, - PS_STAT_CLIPPED_MEAN = 0x000200, - PS_STAT_CLIPPED_STDEV = 0x000400, - PS_STAT_MAX = 0x000800, - PS_STAT_MIN = 0x001000, - PS_STAT_USE_RANGE = 0x002000, - PS_STAT_USE_BINSIZE = 0x004000, - PS_STAT_ROBUST_FOR_SAMPLE = 0x008000 + PS_STAT_SAMPLE_MEAN = 0x000001, ///< Sample Mean + PS_STAT_SAMPLE_MEDIAN = 0x000002, ///< Sample Median + PS_STAT_SAMPLE_STDEV = 0x000004, ///< Sample Standard Deviation + PS_STAT_SAMPLE_QUARTILE = 0x000008, ///< Sample Quartile + PS_STAT_ROBUST_MEAN = 0x000010, ///< Robust Mean + PS_STAT_ROBUST_MEDIAN = 0x000020, ///< Robust Median + PS_STAT_ROBUST_MODE = 0x000040, ///< Robust Mode + PS_STAT_ROBUST_STDEV = 0x000080, ///< Robust Standarad Deviation + PS_STAT_ROBUST_QUARTILE = 0x000100, ///< Robust Quartile + PS_STAT_CLIPPED_MEAN = 0x000200, ///< Clipped Mean + PS_STAT_CLIPPED_STDEV = 0x000400, ///< Clipped Standard Deviation + PS_STAT_MAX = 0x000800, ///< Maximum + PS_STAT_MIN = 0x001000, ///< Minumum + PS_STAT_USE_RANGE = 0x002000, ///< Range + PS_STAT_USE_BINSIZE = 0x004000, ///< Binsize + PS_STAT_ROBUST_FOR_SAMPLE = 0x008000 ///< Robust for sample } psStatsOptions; @@ -180,14 +180,74 @@ // XXX: Create a single, generic, version of the vector normalize function. // XXX: Ask IfA for a public psLib function. -void p_psNormalizeVectorRangeU8(psVector* myData, psU8 low, psU8 high); -void p_psNormalizeVectorRangeU16(psVector* myData, psU16 low, psU16 high); -void p_psNormalizeVectorRangeU32(psVector* myData, psU32 low, psU32 high); -void p_psNormalizeVectorRangeU64(psVector* myData, psU64 low, psU64 high); -void p_psNormalizeVectorRangeS8(psVector* myData, psS8 low, psS8 high); -void p_psNormalizeVectorRangeS16(psVector* myData, psS16 low, psS16 high); -void p_psNormalizeVectorRangeS32(psVector* myData, psS32 low, psS32 high); -void p_psNormalizeVectorRangeS64(psVector* myData, psS64 low, psS64 high); -void p_psNormalizeVectorRangeF32(psVector* myData, psF32 low, psF32 high); -void p_psNormalizeVectorRangeF64(psVector* myData, psF64 low, psF64 high); + +/** Normalize the range of a vector containing U8 values */ +void p_psNormalizeVectorRangeU8( + psVector* myData, ///< Vector containing the U8 values + psU8 low, ///< Minimum value + psU8 high ///< Maximum value +); + +/** Normalize the range of a vector containing U16 values */ +void p_psNormalizeVectorRangeU16( + psVector* myData, ///< Vector containing the U16 values + psU16 low, ///< Minimum value + psU16 high ///< Maximum value +); + +/** Normalize the range of a vector containing U32 values */ +void p_psNormalizeVectorRangeU32( + psVector* myData, ///< Vector containing the U32 values + psU32 low, ///< Minimum value + psU32 high ///< Maximum value +); + +/** Normalize the range of a vector containing U64 values */ +void p_psNormalizeVectorRangeU64( + psVector* myData, ///< Vector containing the U64 values + psU64 low, ///< Minimum value + psU64 high ///< Maximum value +); + +/** Normalize the range of a vector containing S8 values */ +void p_psNormalizeVectorRangeS8( + psVector* myData, ///< Vector containing the S8 values + psS8 low, ///< Minimum value + psS8 high ///< Maximum value +); + +/** Normalize the range of a vector containing S16 values */ +void p_psNormalizeVectorRangeS16( + psVector* myData, ///< Vector containing the S16 values + psS16 low, ///< Minimum value + psS16 high ///< Maximum value +); + +/** Normalize the range of a vector containing S32 values */ +void p_psNormalizeVectorRangeS32( + psVector* myData, ///< Vector containing the S32 values + psS32 low, ///< Minimum value + psS32 high ///< Maximum value +); + +/** Normalize the range of a vector containing S64 values */ +void p_psNormalizeVectorRangeS64( + psVector* myData, ///< Vector containing the S64 values + psS64 low, ///< Minimum value + psS64 high ///< Maximum value +); + +/** Normalize the range of a vector containing F32 values */ +void p_psNormalizeVectorRangeF32( + psVector* myData, ///< Vector containing the F32 values + psF32 low, ///< Minimum value + psF32 high ///< Maximum value +); + +/** Normalize the range of a vector containing F64 values */ +void p_psNormalizeVectorRangeF64( + psVector* myData, ///< Vector containing the F64 values + psF64 low, ///< Minimum value + psF64 high ///< Maximum value +); /// @}