Esempio n. 1
0
        /// <summary>
        /// Computes the endpoint deviation of the trials in this condition. For ribbon targets, the univariate
        /// result is the standard deviation of x-coordinates. The bivariate result is undefined. For circle
        /// targets, the univariate result is the standard deviation of x-coordinates. The bivariate result is
        /// the deviation of points around the centroid.
        /// </summary>
        /// <param name="bivariate">If true, a result considering deviation in both x- and y-dimensions is given.
        /// If false, only the deviation in x, defined as "along the task axis," is given.</param>
        /// <returns>The endpoint deviation for normalized trials in this condition.</returns>
        /// <remarks>Spatial outliers are excluded from this calculation so that the
        /// measure remains consistent with its counterpart, We.</remarks>
        public double GetSD(bool bivariate)
        {
            double stdev = 0.0;

            // compute the normalized endpoint locations for each trial in this condition
            List <PointF> pts = new List <PointF>(_trials.Count);

            for (int i = 0; i < _trials.Count; i++)
            {
                if (!_trials[i].IsPractice && _trials[i].IsComplete && !_trials[i].IsSpatialOutlier)
                {
                    pts.Add(_trials[i].NormalizedEnd); // normalized selection endpoints
                }
            }

            // compute the desired endpoint deviation
            if (pts.Count > 0)
            {
                if (bivariate)
                {
                    stdev = _circular ? StatsEx.StdDev2D(pts) : 0.0; // 0.0 is for ribbon task--no bivariate deviation
                }
                else
                {
                    double[] dxs = new double[pts.Count];
                    for (int j = 0; j < pts.Count; j++)
                    {
                        dxs[j] = pts[j].X;
                    }
                    stdev = StatsEx.StdDev(dxs); // stdev in x-dimension only
                }
            }
            return(stdev);
        }
Esempio n. 2
0
 /// <summary>
 /// Calculates the movement variability of this movement path. This is the wigglyness of
 /// the path and is based on the standard deviation of movement points' distances from the
 /// task axis.
 /// </summary>
 /// <param name="pts">The points to analyze. These must be first rotated such that
 /// the task axis they are following is horizontal.</param>
 /// <param name="horizontal">The y-value coordinate of the horizontal task axis.</param>
 /// <returns>The movement variability computation.</returns>
 private double MovementVariability(List <PointF> pts, float horizontal)
 {
     double[] yvals = new double[pts.Count];
     for (int i = 0; i < pts.Count; i++)
     {
         yvals[i] = pts[i].Y - horizontal;
     }
     return(StatsEx.StdDev(yvals));
 }
Esempio n. 3
0
        private Graph gphErr;  // error rates

        /// <summary>
        ///
        /// </summary>
        /// <param name="sd"></param>
        public ResultsForm(SessionData sd, string filename)
        {
            InitializeComponent();
            this.Text = filename;

            // create a graph for speed
            gphWpm               = new Graph();
            gphWpm.Title         = "Speed";
            gphWpm.XAxisName     = "Trial No.";
            gphWpm.YAxisName     = "WPM";
            gphWpm.XAxisTicks    = (sd.NumTrials > 1) ? sd.NumTrials - 1 : 1;
            gphWpm.XAxisDecimals = 1;
            gphWpm.YAxisDecimals = 1;
            gphWpm.Legend        = true;

            // create a graph for error rates
            gphErr               = new Graph();
            gphErr.Title         = "Error Rates";
            gphErr.XAxisName     = "Trial No.";
            gphErr.YAxisName     = "Error Rate";
            gphErr.XAxisTicks    = (sd.NumTrials > 1) ? sd.NumTrials - 1 : 1;
            gphErr.XAxisDecimals = 1;
            gphErr.YAxisDecimals = 3;
            gphErr.Legend        = true;

            // create each series we wish to graph
            Graph.Series sWpm = new Graph.Series("WPM", Color.Red, Color.Red, true, true);
            Graph.Series sAdj = new Graph.Series("AdjWPM", Color.Gray, Color.Gray, true, true);
            Graph.Series sTot = new Graph.Series("Total", Color.Red, Color.Red, true, true);
            Graph.Series sUnc = new Graph.Series("Uncorrected", Color.Gray, Color.Gray, true, true);
            Graph.Series sCor = new Graph.Series("Corrected", Color.LightGray, Color.LightGray, true, true);

            // use these lists to compute the means and stdevs for each series
            List <double> mWpm  = new List <double>();
            List <double> sdWpm = new List <double>();
            List <double> mAdj  = new List <double>();
            List <double> sdAdj = new List <double>();
            List <double> mTot  = new List <double>();
            List <double> sdTot = new List <double>();
            List <double> mUnc  = new List <double>();
            List <double> sdUnc = new List <double>();
            List <double> mCor  = new List <double>();
            List <double> sdCor = new List <double>();

            // add the points for each series
            for (int i = 0; i < sd.NumTrials; i++)
            {
                if (sd[i].NumEntries > 0)
                {
                    sWpm.AddPoint(new PointR(i + 1, sd[i].WPM));
                    mWpm.Add(sd[i].WPM);
                    sdWpm.Add(sd[i].WPM);

                    sAdj.AddPoint(new PointR(i + 1, sd[i].AdjWPM));
                    mAdj.Add(sd[i].AdjWPM);
                    sdAdj.Add(sd[i].AdjWPM);

                    sTot.AddPoint(new PointR(i + 1, sd[i].TotalErrorRate));
                    mTot.Add(sd[i].TotalErrorRate);
                    sdTot.Add(sd[i].TotalErrorRate);

                    sUnc.AddPoint(new PointR(i + 1, sd[i].UncorrectedErrorRate));
                    mUnc.Add(sd[i].UncorrectedErrorRate);
                    sdUnc.Add(sd[i].UncorrectedErrorRate);

                    sCor.AddPoint(new PointR(i + 1, sd[i].CorrectedErrorRate));
                    mCor.Add(sd[i].CorrectedErrorRate);
                    sdCor.Add(sd[i].CorrectedErrorRate);
                }
            }

            // add the means and standard deviations to the series' names
            sWpm.Name = String.Format("{0} (µ={1:f1}, σ={2:f1})", sWpm.Name, StatsEx.Mean(mWpm.ToArray()), StatsEx.StdDev(sdWpm.ToArray()));
            sAdj.Name = String.Format("{0} (µ={1:f1}, σ={2:f1})", sAdj.Name, StatsEx.Mean(mAdj.ToArray()), StatsEx.StdDev(sdAdj.ToArray()));
            sTot.Name = String.Format("{0} (µ={1:f3}, σ={2:f3})", sTot.Name, StatsEx.Mean(mTot.ToArray()), StatsEx.StdDev(sdTot.ToArray()));
            sUnc.Name = String.Format("{0} (µ={1:f3}, σ={2:f3})", sUnc.Name, StatsEx.Mean(mUnc.ToArray()), StatsEx.StdDev(sdUnc.ToArray()));
            sCor.Name = String.Format("{0} (µ={1:f3}, σ={2:f3})", sCor.Name, StatsEx.Mean(mCor.ToArray()), StatsEx.StdDev(sdCor.ToArray()));

            // add the origin point to the graphs
            Graph.Series origin = new Graph.Series(String.Empty, Color.Black, Color.Black, false, false);
            origin.AddPoint(1.0, 0.0);
            gphWpm.AddSeries(origin);
            gphErr.AddSeries(origin);

            // finally, add the series
            gphWpm.AddSeries(sWpm);
            gphWpm.AddSeries(sAdj);
            gphErr.AddSeries(sTot);
            gphErr.AddSeries(sUnc);
            gphErr.AddSeries(sCor);
        }