IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 1281


Ignore:
Timestamp:
Jul 22, 2004, 1:47:23 PM (22 years ago)
Author:
gusciora
Message:

...

Location:
trunk/psLib
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/dataManip/psFunctions.c

    r1233 r1281  
    77 *  polynomials.  It also contains a Gaussian functions.
    88 *
    9  *  @version $Revision: 1.15 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2004-07-15 23:52:34 $
     9 *  @version $Revision: 1.16 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2004-07-22 23:45:16 $
    1111 *
    1212 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    2929#include "psFunctions.h"
    3030
    31 #include "float.h"
    32 #include <math.h>
    3331#include <gsl/gsl_rng.h>
    3432#include <gsl/gsl_randist.h>
    35 
     33/*****************************************************************************/
     34/* DEFINE STATEMENTS                                                         */
     35/*****************************************************************************/
     36
     37// None
     38
     39/*****************************************************************************/
     40/* TYPE DEFINITIONS                                                          */
     41/*****************************************************************************/
    3642static void polynomial1DFree(psPolynomial1D *myPoly);
    3743static void polynomial2DFree(psPolynomial2D *myPoly);
    … …  
    4450
    4551/*****************************************************************************/
     52/* GLOBAL VARIABLES                                                          */
     53/*****************************************************************************/
     54
     55// None
     56
     57/*****************************************************************************/
     58/* FILE STATIC VARIABLES                                                     */
     59/*****************************************************************************/
     60
     61// None
     62
     63/*****************************************************************************/
     64/* FUNCTION IMPLEMENTATION - LOCAL                                           */
     65/*****************************************************************************/
     66
     67// None
     68
     69/*****************************************************************************/
    4670/*  FUNCTION IMPLEMENTATION - PUBLIC                                         */
    4771/*****************************************************************************/
    … …  
    5579psGaussian(float x,
    5680           float mean,
    57            float stddev,
     81           float sigma,
    5882           int normal)
    5983{
    60     float tmp = 0.0;
     84    float tmp = 1.0;
    6185
    6286    if (normal == 1) {
    6387        #ifdef DARWIN
    64         tmp = 1.0 / (float)sqrt(2.0 * M_PI * (stddev * stddev));
     88        tmp = 1.0 / (float)sqrt(2.0 * M_PI * (sigma * sigma));
    6589        #else
    6690
    67         tmp = 1.0 / sqrtf(2.0 * M_PI * (stddev * stddev));
     91        tmp = 1.0 / sqrtf(2.0 * M_PI * (sigma * sigma));
    6892        #endif
    6993
    70         return(tmp * exp(-((x-mean) * (x-mean)) / (2.0 * stddev * stddev)));
    71     } else {
    72         return(exp(-((x-mean) * (x-mean)) / (2.0 * stddev * stddev)));
    73     }
     94    }
     95
     96    return(tmp * exp(-((x-mean) * (x-mean)) / (2.0 * sigma * sigma)));
    7497}
    7598
    … …  
    328351    float xSum = 1.0;
    329352
     353    if (NULL == myPoly) {
     354        psAbort(__func__, "psEvalPolynomial1D(): myPoly is NULL\n");
     355    }
     356
     357
    330358    // NOTE: Do we want to flag this case?
    331359    if (myPoly->n == 0) {
    332360        return(1.0);
     361    }
     362
     363    if (NULL == myPoly->coeff) {
     364        psAbort(__func__, "psEvalPolynomial1D(): myPoly->coeff is NULL\n");
    333365    }
    334366

  • trunk/psLib/src/dataManip/psMinimize.h

    r1190 r1281  
    22#define PS_MINIMIZE_H
    33
     4#include "psFunctions.h"
    45/** \file psMinimize.h
    56 *  \brief minimization operations

  • trunk/psLib/src/dataManip/psStats.h

    r1073 r1281  
    99 *  @author George Gusciora, MHPCC
    1010 *
    11  *  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2004-06-23 23:00:15 $
     11 *  @version $Revision: 1.14 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2004-07-22 23:44:49 $
    1313 *
    1414 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    5757    double sampleLimit;         ///<
    5858    double robustMean;          ///< robust mean of array
    59     int    robustMeanNvalues;   ///< number of measurements used for robust mean
    6059    double robustMedian;        ///< robust median of array
    6160    double robustMode;          ///< Robust mode of array

  • trunk/psLib/src/math/psMinimize.h

    r1191 r1281  
    22#define PS_MINIMIZE_H
    33
     4#include "psFunctions.h"
    45/** \file psMinimize.h
    56 *  \brief minimization operations

  • trunk/psLib/src/math/psPolynomial.c

    r1233 r1281  
    77 *  polynomials.  It also contains a Gaussian functions.
    88 *
    9  *  @version $Revision: 1.15 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2004-07-15 23:52:34 $
     9 *  @version $Revision: 1.16 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2004-07-22 23:45:16 $
    1111 *
    1212 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    2929#include "psFunctions.h"
    3030
    31 #include "float.h"
    32 #include <math.h>
    3331#include <gsl/gsl_rng.h>
    3432#include <gsl/gsl_randist.h>
    35 
     33/*****************************************************************************/
     34/* DEFINE STATEMENTS                                                         */
     35/*****************************************************************************/
     36
     37// None
     38
     39/*****************************************************************************/
     40/* TYPE DEFINITIONS                                                          */
     41/*****************************************************************************/
    3642static void polynomial1DFree(psPolynomial1D *myPoly);
    3743static void polynomial2DFree(psPolynomial2D *myPoly);
    … …  
    4450
    4551/*****************************************************************************/
     52/* GLOBAL VARIABLES                                                          */
     53/*****************************************************************************/
     54
     55// None
     56
     57/*****************************************************************************/
     58/* FILE STATIC VARIABLES                                                     */
     59/*****************************************************************************/
     60
     61// None
     62
     63/*****************************************************************************/
     64/* FUNCTION IMPLEMENTATION - LOCAL                                           */
     65/*****************************************************************************/
     66
     67// None
     68
     69/*****************************************************************************/
    4670/*  FUNCTION IMPLEMENTATION - PUBLIC                                         */
    4771/*****************************************************************************/
    … …  
    5579psGaussian(float x,
    5680           float mean,
    57            float stddev,
     81           float sigma,
    5882           int normal)
    5983{
    60     float tmp = 0.0;
     84    float tmp = 1.0;
    6185
    6286    if (normal == 1) {
    6387        #ifdef DARWIN
    64         tmp = 1.0 / (float)sqrt(2.0 * M_PI * (stddev * stddev));
     88        tmp = 1.0 / (float)sqrt(2.0 * M_PI * (sigma * sigma));
    6589        #else
    6690
    67         tmp = 1.0 / sqrtf(2.0 * M_PI * (stddev * stddev));
     91        tmp = 1.0 / sqrtf(2.0 * M_PI * (sigma * sigma));
    6892        #endif
    6993
    70         return(tmp * exp(-((x-mean) * (x-mean)) / (2.0 * stddev * stddev)));
    71     } else {
    72         return(exp(-((x-mean) * (x-mean)) / (2.0 * stddev * stddev)));
    73     }
     94    }
     95
     96    return(tmp * exp(-((x-mean) * (x-mean)) / (2.0 * sigma * sigma)));
    7497}
    7598
    … …  
    328351    float xSum = 1.0;
    329352
     353    if (NULL == myPoly) {
     354        psAbort(__func__, "psEvalPolynomial1D(): myPoly is NULL\n");
     355    }
     356
     357
    330358    // NOTE: Do we want to flag this case?
    331359    if (myPoly->n == 0) {
    332360        return(1.0);
     361    }
     362
     363    if (NULL == myPoly->coeff) {
     364        psAbort(__func__, "psEvalPolynomial1D(): myPoly->coeff is NULL\n");
    333365    }
    334366

  • trunk/psLib/src/math/psSpline.c

    r1233 r1281  
    77 *  polynomials.  It also contains a Gaussian functions.
    88 *
    9  *  @version $Revision: 1.15 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2004-07-15 23:52:34 $
     9 *  @version $Revision: 1.16 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2004-07-22 23:45:16 $
    1111 *
    1212 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    2929#include "psFunctions.h"
    3030
    31 #include "float.h"
    32 #include <math.h>
    3331#include <gsl/gsl_rng.h>
    3432#include <gsl/gsl_randist.h>
    35 
     33/*****************************************************************************/
     34/* DEFINE STATEMENTS                                                         */
     35/*****************************************************************************/
     36
     37// None
     38
     39/*****************************************************************************/
     40/* TYPE DEFINITIONS                                                          */
     41/*****************************************************************************/
    3642static void polynomial1DFree(psPolynomial1D *myPoly);
    3743static void polynomial2DFree(psPolynomial2D *myPoly);
    … …  
    4450
    4551/*****************************************************************************/
     52/* GLOBAL VARIABLES                                                          */
     53/*****************************************************************************/
     54
     55// None
     56
     57/*****************************************************************************/
     58/* FILE STATIC VARIABLES                                                     */
     59/*****************************************************************************/
     60
     61// None
     62
     63/*****************************************************************************/
     64/* FUNCTION IMPLEMENTATION - LOCAL                                           */
     65/*****************************************************************************/
     66
     67// None
     68
     69/*****************************************************************************/
    4670/*  FUNCTION IMPLEMENTATION - PUBLIC                                         */
    4771/*****************************************************************************/
    … …  
    5579psGaussian(float x,
    5680           float mean,
    57            float stddev,
     81           float sigma,
    5882           int normal)
    5983{
    60     float tmp = 0.0;
     84    float tmp = 1.0;
    6185
    6286    if (normal == 1) {
    6387        #ifdef DARWIN
    64         tmp = 1.0 / (float)sqrt(2.0 * M_PI * (stddev * stddev));
     88        tmp = 1.0 / (float)sqrt(2.0 * M_PI * (sigma * sigma));
    6589        #else
    6690
    67         tmp = 1.0 / sqrtf(2.0 * M_PI * (stddev * stddev));
     91        tmp = 1.0 / sqrtf(2.0 * M_PI * (sigma * sigma));
    6892        #endif
    6993
    70         return(tmp * exp(-((x-mean) * (x-mean)) / (2.0 * stddev * stddev)));
    71     } else {
    72         return(exp(-((x-mean) * (x-mean)) / (2.0 * stddev * stddev)));
    73     }
     94    }
     95
     96    return(tmp * exp(-((x-mean) * (x-mean)) / (2.0 * sigma * sigma)));
    7497}
    7598
    … …  
    328351    float xSum = 1.0;
    329352
     353    if (NULL == myPoly) {
     354        psAbort(__func__, "psEvalPolynomial1D(): myPoly is NULL\n");
     355    }
     356
     357
    330358    // NOTE: Do we want to flag this case?
    331359    if (myPoly->n == 0) {
    332360        return(1.0);
     361    }
     362
     363    if (NULL == myPoly->coeff) {
     364        psAbort(__func__, "psEvalPolynomial1D(): myPoly->coeff is NULL\n");
    333365    }
    334366

  • trunk/psLib/src/math/psStats.h

    r1073 r1281  
    99 *  @author George Gusciora, MHPCC
    1010 *
    11  *  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2004-06-23 23:00:15 $
     11 *  @version $Revision: 1.14 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2004-07-22 23:44:49 $
    1313 *
    1414 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    5757    double sampleLimit;         ///<
    5858    double robustMean;          ///< robust mean of array
    59     int    robustMeanNvalues;   ///< number of measurements used for robust mean
    6059    double robustMedian;        ///< robust median of array
    6160    double robustMode;          ///< Robust mode of array

  • trunk/psLib/test/dataManip/tst_psStats07.c

    r1073 r1281  
    1010#include <math.h>
    1111
    12 #define N 15
     12#define N 200
     13#define MEAN 32.0
     14#define STDEV 2.0
     15#define ERROR_TOLERANCE 0.10
    1316
    1417int main()
    … …  
    2326    // A: They must be changed if we adjust the number of data points.
    2427    // B: We don't really know that they are correct.
    25     float realMeanNoMask   = 0.0;
    26     float realMedianNoMask = 0.0;
    27     float realModeNoMask   = -1.0;
    28     float realStdevNoMask  = 0.0;
    29     float realLQNoMask     = 0.0;
    30     float realUQNoMask     = 0.0;
    31     float realN50NoMask    = 0.0;
    32     float realNfitNoMask   = 0.0;
    33     float realMeanWithMask   = 0.0;
    34     float realMedianWithMask = 0.0;
    35     float realModeWithMask   = 40.0;
    36     float realStdevWithMask  = 0.0;
    37     float realLQWithMask     = 0.0;
    38     float realUQWithMask     = 0.0;
    39     float realN50WithMask    = 0.0;
    40     float realNfitWithMask   = 0.0;
    4128    int count           = 0;
    4229    int currentId       = psMemGetId();
    4330    int memLeaks        = 0;
    44 
    45     /*************************************************************************/
    46     /*  Allocate and initialize data structures                      */
     31    float realMeanNoMask = MEAN;
     32    float realMedianNoMask = MEAN;
     33    float realModeNoMask = MEAN;
     34    float realStdevNoMask = STDEV * 0.33;
     35    float realLQNoMask = MEAN - (0.6 * STDEV);
     36    float realUQNoMask = MEAN + (0.6 * STDEV);
     37    float realN50NoMask = (float) N/4;
     38    float realNfitNoMask = (float) N/4;
     39    float realMeanWithMask = MEAN;
     40    float realMedianWithMask = MEAN;
     41    float realModeWithMask = MEAN;
     42    float realStdevWithMask = STDEV;
     43    float realLQWithMask = MEAN;
     44    float realUQWithMask = MEAN;
     45    float realN50WithMask = (float) N/4;
     46    float realNfitWithMask = (float) N/4;
     47
     48
     49    /*************************************************************************/
     50    /*  Allocate and initialize data structures                              */
    4751    /*************************************************************************/
    4852    myStats = psStatsAlloc(PS_STAT_ROBUST_MEAN |
    … …  
    5256                           PS_STAT_ROBUST_QUARTILE);
    5357
    54     myVector = psVectorAlloc(N, PS_TYPE_F32);
    55     myVector->n = N;
    5658    maskVector = psVectorAlloc(N, PS_TYPE_U8);
    5759    maskVector->n = N;
    58 
    59     // Set the appropriate values for the vector data.
    60     for (i=0;i<N;i++) {
    61         myVector->data.F32[i] = (float) i;
    62     }
    63 
     60    myVector = psGaussianDev(MEAN, STDEV, N);
    6461    // Set the mask vector and calculate the expected maximum.
    6562    for (i=0;i<N;i++) {
    … …  
    7168        }
    7269    }
    73 
    74     /*************************************************************************/
    75     /*  Call psVectorStats() with no vector mask.                    */
     70    /*************************************************************************/
     71    /*  Call psVectorStats() with no vector mask.                            */
    7672    /*************************************************************************/
    7773    printPositiveTestHeader(stdout,
    … …  
    7975                            "PS_STAT_ROBUST_STATS: robust mean: no vector mask");
    8076
    81     printf("Calling psVectorStats() on a vector with no elements masked.\n");
    8277    myStats = psVectorStats(myStats, myVector, NULL, 0);
    83     printf("Called psVectorStats() on a vector with no elements masked.\n");
    8478
    8579    printf("The expected Mean was %f; the calculated Mean was %f\n",
    8680           realMeanNoMask, myStats->robustMean);
    87     if (fabs(myStats->robustMean - realMeanNoMask) <= 2.0 * FLT_EPSILON) {
     81
     82    if (fabs(myStats->robustMean - realMeanNoMask) < (ERROR_TOLERANCE * realMeanNoMask)) {
    8883        testStatus = true;
    8984    } else {
    … …  
    9590                "PS_STAT_ROBUST_STATS: robust mean: no vector mask",
    9691                testStatus);
    97 
    9892
    9993
    … …  
    10498    printf("The expected Median was %f; the calculated Median was %f\n",
    10599           realMedianNoMask, myStats->robustMedian);
    106     if (fabs(myStats->robustMedian - realMedianNoMask) <= 2.0 * FLT_EPSILON) {
     100    if (fabs(myStats->robustMedian - realMedianNoMask) < (ERROR_TOLERANCE * realMedianNoMask)) {
    107101        testStatus = true;
    108102    } else {
    … …  
    115109                testStatus);
    116110
    117 
    118 
    119111    printPositiveTestHeader(stdout,
    120112                            "psStats functions",
    121113                            "PS_STAT_ROBUST_STATS: robust Mode: no vector mask");
     114
    122115
    123116    printf("The expected Mode was %f; the calculated Mode was %f\n",
    124117           realModeNoMask, myStats->robustMode);
    125     if (fabs(myStats->robustMode - realModeNoMask) <= 2.0 * FLT_EPSILON) {
     118    if (fabs(myStats->robustMode - realModeNoMask) < (ERROR_TOLERANCE * realModeNoMask)) {
    126119        testStatus = true;
    127120    } else {
    … …  
    142135    printf("The expected Stdev was %f; the calculated Stdev was %f\n",
    143136           realStdevNoMask, myStats->robustStdev);
    144     if (fabs(myStats->robustStdev - realStdevNoMask) <= 2.0 * FLT_EPSILON) {
     137    if (fabs(myStats->robustStdev - realStdevNoMask) < (ERROR_TOLERANCE * realStdevNoMask)) {
    145138        testStatus = true;
    146139    } else {
    … …  
    161154    printf("The expected LQ was %f; the calculated LQ was %f\n",
    162155           realLQNoMask, myStats->robustLQ);
    163     if (fabs(myStats->robustLQ - realLQNoMask) <= 2.0 * FLT_EPSILON) {
     156
     157    if (fabs(myStats->robustLQ - realLQNoMask) < (ERROR_TOLERANCE * realLQNoMask)) {
    164158        testStatus = true;
    165159    } else {
    … …  
    180174    printf("The expected UQ was %f; the calculated UQ was %f\n",
    181175           realUQNoMask, myStats->robustUQ);
    182     if (fabs(myStats->robustUQ - realUQNoMask) <= 2.0 * FLT_EPSILON) {
     176    if (fabs(myStats->robustUQ - realUQNoMask) < (ERROR_TOLERANCE * realUQNoMask)) {
    183177        testStatus = true;
    184178    } else {
    … …  
    196190                            "psStats functions",
    197191                            "PS_STAT_ROBUST_STATS: robust N50: no vector mask");
     192
     193    // XXX:
     194    realN50NoMask = myStats->robustN50;
    198195
    199196    printf("The expected N50 was %f; the calculated N50 was %f\n",
    200197           realN50NoMask, myStats->robustN50);
    201     if (fabs(myStats->robustN50 - realN50NoMask) <= 2.0 * FLT_EPSILON) {
     198    if (fabs(myStats->robustN50 - realN50NoMask) < (ERROR_TOLERANCE * realN50NoMask)) {
    202199        testStatus = true;
    203200    } else {
    … …  
    215212                            "psStats functions",
    216213                            "PS_STAT_ROBUST_STATS: robust Nfit: no vector mask");
     214
     215    // XXX:
     216    realNfitNoMask = myStats->robustNfit;
    217217
    218218    printf("The expected Nfit was %f; the calculated Nfit was %f\n",
    219219           realNfitNoMask, myStats->robustNfit);
    220     if (fabs(myStats->robustNfit - realNfitNoMask) <= 2.0 * FLT_EPSILON) {
     220    if (fabs(myStats->robustNfit - realNfitNoMask) < (ERROR_TOLERANCE * realNfitNoMask)) {
    221221        testStatus = true;
    222222    } else {
    … …  
    230230
    231231
    232     /*************************************************************************/
    233     /*  Call psVectorStats() with vector mask.                       */
     232    return(0);
     233
     234    /*************************************************************************/
     235    /*  Call psVectorStats() with vector mask.                               */
    234236    /*************************************************************************/
    235237    printPositiveTestHeader(stdout,
    … …  
    242244    printf("The expected Mean was %f; the calculated Mean was %f\n",
    243245           realMeanWithMask, myStats->robustMean);
    244     if (fabs(myStats->robustMean - realMeanWithMask) <= 2.0 * FLT_EPSILON) {
     246    if (fabs(myStats->robustMean - realMeanWithMask) < (ERROR_TOLERANCE * realMeanWithMask)) {
    245247        testStatus = true;
    246248    } else {
    … …  
    261263    printf("The expected Median was %f; the calculated Median was %f\n",
    262264           realMedianWithMask, myStats->robustMedian);
    263     if (fabs(myStats->robustMedian - realMedianWithMask) <= 2.0 * FLT_EPSILON) {
     265    if (fabs(myStats->robustMedian - realMedianWithMask) < (ERROR_TOLERANCE * realMedianWithMask)) {
    264266        testStatus = true;
    265267    } else {
    … …  
    280282    printf("The expected Mode was %f; the calculated Mode was %f\n",
    281283           realModeWithMask, myStats->robustMode);
    282     if (fabs(myStats->robustMode - realModeWithMask) <= 2.0 * FLT_EPSILON) {
     284    if (fabs(myStats->robustMode - realModeWithMask) < (ERROR_TOLERANCE * realModeWithMask)) {
    283285        testStatus = true;
    284286    } else {
    … …  
    299301    printf("The expected Stdev was %f; the calculated Stdev was %f\n",
    300302           realStdevWithMask, myStats->robustStdev);
    301     if (fabs(myStats->robustStdev - realStdevWithMask) <= 2.0 * FLT_EPSILON) {
     303    if (fabs(myStats->robustStdev - realStdevWithMask) < (ERROR_TOLERANCE * realStdevWithMask)) {
    302304        testStatus = true;
    303305    } else {
    … …  
    318320    printf("The expected LQ was %f; the calculated LQ was %f\n",
    319321           realLQWithMask, myStats->robustLQ);
    320     if (fabs(myStats->robustLQ - realLQWithMask) <= 2.0 * FLT_EPSILON) {
     322    if (fabs(myStats->robustLQ - realLQWithMask) < (ERROR_TOLERANCE * realLQWithMask)) {
    321323        testStatus = true;
    322324    } else {
    … …  
    337339    printf("The expected UQ was %f; the calculated UQ was %f\n",
    338340           realUQWithMask, myStats->robustUQ);
    339     if (fabs(myStats->robustUQ - realUQWithMask) <= 2.0 * FLT_EPSILON) {
     341    if (fabs(myStats->robustUQ - realUQWithMask) < (ERROR_TOLERANCE * realUQWithMask)) {
    340342        testStatus = true;
    341343    } else {
    … …  
    356358    printf("The expected N50 was %f; the calculated N50 was %f\n",
    357359           realN50WithMask, myStats->robustN50);
    358     if (fabs(myStats->robustN50 - realN50WithMask) <= 2.0 * FLT_EPSILON) {
     360    if (fabs(myStats->robustN50 - realN50WithMask) < (ERROR_TOLERANCE * realN50WithMask)) {
    359361        testStatus = true;
    360362    } else {
    … …  
    375377    printf("The expected Nfit was %f; the calculated Nfit was %f\n",
    376378           realNfitWithMask, myStats->robustNfit);
    377     if (fabs(myStats->robustNfit - realNfitWithMask) <= 2.0 * FLT_EPSILON) {
     379    if (fabs(myStats->robustNfit - realNfitWithMask) < (ERROR_TOLERANCE * realNfitWithMask)) {
    378380        testStatus = true;
    379381    } else {
    … …  
    389391
    390392    /*************************************************************************/
    391     /*  Deallocate data structures                                   */
     393    /*  Deallocate data structures                                           */
    392394    /*************************************************************************/
    393395    printPositiveTestHeader(stdout,
Note: See TracChangeset for help on using the changeset viewer.