Example #1
0
        public static ICartesianCoordinate Mean(this IEnumerable<ICartesianCoordinate> pointcloud)
        {
            var X = pointcloud.Average(p => p.X);
            var Y = pointcloud.Average(p => p.Y);

            return new Point(X, Y);
        }
Example #2
0
        /// <summary>
        /// Return a Rect structure indicating the bounding rectangle for the vertex
        /// from the specified tuple and the next tuple.
        /// </summary>
        public static Rect AsSextantBoundingBox(this List<Tuple<double, double>> verticies, int startingPoint)
        {
            var centerX = verticies.Average(v => v.Item1);
            var centerY = verticies.Average(v => v.Item2);

            var point1X = verticies[startingPoint].Item1;
            var point1Y = verticies[startingPoint].Item2;
            var point2X = startingPoint == 5 ? verticies[0].Item1 : verticies[startingPoint + 1].Item1;
            var point2Y = startingPoint == 5 ? verticies[0].Item2 : verticies[startingPoint + 1].Item2;

            return new Rect(Math.Min(centerX, Math.Min(point1X, point2X)),
                Math.Min(centerY, Math.Min(point1Y, point2Y)),
                (Math.Max(centerX, Math.Max(point1X, point2X)) - Math.Min(centerX, Math.Min(point1X, point2X))),
                (Math.Max(centerY, Math.Max(point1Y, point2Y)) - Math.Min(centerY, Math.Min(point1Y, point2Y))));
        }
Example #3
0
        /// <summary>
        /// Return a point collection of the specified point in the List of Tuples
        /// and the next point and the derived center point, for a single sextant of the hexagon
        /// </summary>
        public static PointCollection AsSextant(this List<Tuple<double, double>> verticies, int startingPoint)
        {
            var pointCollection = new PointCollection(3);

            var centerX = verticies.Average(v => v.Item1);
            var centerY = verticies.Average(v => v.Item2);

            var vertex1 = verticies[startingPoint];
            var vertex2 = startingPoint == 5 ? verticies[0] : verticies[startingPoint + 1];

            pointCollection.Add(new Point(centerX, centerY));
            pointCollection.Add(vertex1.AsPoint());
            pointCollection.Add(vertex2.AsPoint());

            return pointCollection;
        }
 public static float Variance(this IEnumerable<float> source)
 {
     float avg = source.Average();
     float d = source.Aggregate(0.0f,
                                (total, next) => total + (float) Math.Pow(next - avg, 2));
     return d/(source.Count() - 1);
 }
Example #5
0
        public static double StdDev(this double[] data)
        {
            double avg = data.Average();

            double sum = data.Sum(x => Math.Pow(x - avg, 2));

            return Math.Sqrt(sum / data.Length);
        }
 /// <summary>
 /// Computes the average of a sequence of TimeSpan objects
 /// </summary>
 /// <param name="spans">A sequence of values to calculate the average of</param>
 /// <returns>The average of the sequence of values</returns>
 public static TimeSpan Average(this IEnumerable<TimeSpan> Spans)
 {
     double ticks = 0;
     Spans.Check(Enumerable.Empty<TimeSpan>());
     if (Spans.Any())
         ticks = Spans.Average(a => a.Ticks);
     return new TimeSpan((long)ticks);
 }
Example #7
0
        /// <summary>
        /// Standard dev of population sqrt(sum((item-mean)^2) / (N-1))
        /// </summary>
        public static double StdevS(this IEnumerable<double> items)
        {
            double count = items.Count();
              if (count < 2) throw new ArgumentException("StdevP called with < 2 items", "StdevP");

              double mean = items.Average();
              double sum = items.Sum<double>(d => (d - mean) * (d - mean));
              return Math.Sqrt(sum / (count - 1));
        }
Example #8
0
        public static double GetStdDev(this float[] source)
        {
            if (source.Length <= 0)
                return 0;

            var avg = source.Average();
            var sum = source.Sum(d => Math.Pow(d - avg, 2));
            return Math.Sqrt(sum / (source.Length - 1));
        }
Example #9
0
        private static IEnumerable<Tuple<double, double>> Deviations(this ICollection<double> values)
        {
            if (values.Count == 0)
                yield break;

            var avg = values.Average();
            foreach (var d in values)
                yield return Tuple.Create(d, avg - d);
        }
Example #10
0
        public static double StdDev(this int[] values)
        {
            var mean = values.Average();

            var variance = values
                .Select(x => Math.Pow(mean - x, 2))
                .Average();

            return Math.Sqrt(variance);
        }
        /// <summary>
        /// Computes the standard deviation of the given values.
        /// </summary>
        public static float StandardDeviation(this List<float> values)
        {
            if (values.Count == 0)
                return 0;

            float avg = values.Average();
            // Calculates sum((xi - avg)²)
            float sum = values.ConvertAll(val => (float)Math.Pow(val - avg, 2)).Sum();
            return (float)Math.Sqrt(sum / values.Count);
        }
Example #12
0
 public static double StandardDeviation(this IEnumerable<float> val)
 {
     double sumOfSqrs = 0;
     double avg = val.Average();
     foreach (var item in val)
     {
         sumOfSqrs += Math.Pow(((double)item - avg), 2);
     }
     double n = (double)val.Count();
     return Math.Sqrt(sumOfSqrs / (n - 1));
 }
        /// <summary>
        /// Calculates decremental running average and variance.
        /// </summary>
        /// <param name="samples">Sample data.</param>
        /// <param name="onCalculated">
        /// Action callback which fires on each element removal. 
        /// <para>Parameters are: (index, decremental average, decremental variance).</para>
        /// </param>
        /// <param name="weights">Sample weights.</param>
        public static void RunningVarianceDecremental(this IList<double> samples, Action<int, double, double> onCalculated, IList<double> weights)
        {
            double sumWeight = weights.Sum(), 
                   mean = samples.Average(weights), 
                   M2 = samples.Variance(weights) * sumWeight;

            for (int i = 0; i < samples.Count; i++)
            {
                var variance = UpdateVarianceDecremental(ref M2, ref sumWeight, ref mean, samples[i], weights[i]);
                onCalculated(i, mean, variance);
            }
        }
        /// <summary>
        /// Calculates decremental running average.
        /// </summary>
        /// <param name="data">Sample data.</param>
        /// <param name="onCalculated">
        /// Action callback which fires on each element removal. 
        /// <para>Parameters are: (index, decremental average).</para>
        /// </param>
        public static void RunningAverageDecremental(this IList<double> data, Action<int, double> onCalculated)
        {
            var avg = data.Average();

            for (int i = 0; i < data.Count; i++)
            {
                var item = data[i];

                avg -= UpdateAverageDecremental(avg, data.Count - i, item);
                onCalculated(i, avg);
            }
        }
Example #15
0
 public static double AverageSafe(this IList<double> source)
 {
     if (source == null)
     {
         throw new ArgumentNullException("source");
     }
     if (source.Count == 0)
     {
         return 0;
     }
     return source.Average();
 }
 public static decimal StandardDeviation(this IEnumerable<decimal> values)
 {
     Contract.Requires(values != null);
     decimal ret = 0;
     var count = values.Count();
     if (count > 1)
     {
         var avg = values.Average();
         var sum = values.Sum(d => (d - avg) * (d - avg));
         ret = (decimal) Math.Sqrt((double) (sum / count));
     }
     return ret;
 }
 public static double StandardDeviation(this IEnumerable<double> values)
 {
     double ret = 0;
     if (values.Count() > 0)
     {
         //Compute the Average
         double avg = values.Average();
         //Perform the Sum of (value-avg)_2_2
         double sum = values.Sum(d => Math.Pow(d - avg, 2));
         //Put it all together
         ret = Math.Sqrt((sum) / (values.Count() - 1));
     }
     return ret;
 }
        /// <summary>
        /// Calculates decremental running average and variance.
        /// </summary>
        /// <param name="data">Sample data.</param>
        /// <param name="onCalculated">
        /// Action callback which fires on each element removal. 
        /// <para>Parameters are: (index, decremental average, decremental variance).</para>
        /// </param>
        public static void RunningVarianceDecremental(this IList<double> data, Action<int, double, double> onCalculated)
        {
            double avg = data.Average(), variance = data.Variance();

            for (int i = 0; i < data.Count; i++)
            {
                var item = data[i];

                var postAvg = avg;
                avg -= RunningAverage.UpdateAverageDecremental(avg, data.Count - i, item);
                variance -= UpdateVarianceDecremental(postAvg, avg, variance, data.Count - i, item);
                onCalculated(i, avg, variance);
            }
        }
    public static Tuple<double, double> ConfidenceIntervals(this double[] values, double alpha) {
      double lower, upper;
      int n = values.Length;
      if (n <= 1) return new Tuple<double, double>(double.NaN, double.NaN);

      double s = values.StandardDeviation();
      double x = values.Average();
      double t = alglib.invstudenttdistribution(n - 1, (1.0 - alpha) / 2.0);

      lower = x + t * (s / Math.Sqrt(n));
      upper = x - t * (s / Math.Sqrt(n));

      return new Tuple<double, double>(lower, upper);
    }
Example #20
0
        /// <summary>
        /// Calculates the sample standard deviation.
        /// </summary>
        public static double Stdev(this IEnumerable<int> data)
        {
            if (data.Count() < 2)
                return 0;

            double avg = data.Average();
            double numerator = 0;
            foreach (double d in data)
                numerator += (d - avg) * (d - avg);

            double variance = numerator / (double)(data.Count() - 1);

            return Math.Sqrt((double)variance);
        }
        /// <summary>
        /// Calculates incremental and decremental running average.
        /// </summary>
        /// <param name="data">Sample data.</param>
        /// <param name="onCalculated">
        /// Action callback which fires on each element addition-removal. 
        /// <para>Parameters are: (index, incremental average, decremental average).</para>
        /// </param>
        public static void RunningAverageIncDec(this IList<double> data, Action<int, double, double> onCalculated)
        {
            var avgInc = 0d;
            var avgDec = data.Average();

            for (int i = 0; i < data.Count; i++)
            {
                var item = data[i];

                avgInc += UpdateAverageIncremental(avgInc, i, item);
                avgDec -= UpdateAverageDecremental(avgDec, data.Count - i, item);
                onCalculated(i, avgInc, avgDec);
            }
        }
Example #22
0
        public static double StdDev(this IEnumerable<int> values)
        {
            var mean = values.Average();

            var deltas = new List<double>();

            foreach (var value in values)
            {
                deltas.Add((double)Math.Pow((value - mean), 2));
            }

            var deltaMean = deltas.Average();

            return (double)Math.Sqrt(deltaMean);
        }
        /// <summary>
        /// Calculates decremental running average and variance.
        /// </summary>
        /// <param name="data">Sample data.</param>
        /// <param name="onCalculated">
        /// Action callback which fires on each element removal. 
        /// <para>Parameters are: (index, decremental average, decremental variance).</para>
        /// </param>
        public static void RunningVarianceDecremental(this IList<double[]> data, Action<int, double[], double> onCalculated)
        {
            double[] avg = data.Average();
            double varianceSum = data.Variance().Sum();

            for (int i = 0; i < data.Count; i++)
            {
                var item = data[i];

                var postAvg = avg;
                avg = avg.Subtract(RunningAverage.UpdateAverageDecremental(avg, data.Count - i, item));
                varianceSum -= UpdateVarianceDecremental(postAvg, avg, varianceSum, data.Count - i, item);
                onCalculated(i, avg, varianceSum);
            }
        }
Example #24
0
        /// <summary>
        /// Calculates the mean of a given list
        /// </summary>
        /// <param name="list">A list of numbers</param>
        /// <returns>Returns the mean value</returns>
        public static decimal Mean(this List<decimal> list)
        {
            decimal result;

            try
            {
                result = list.Average();
            }
            catch
            {
                result = 0;
            }
            
            return result;
        }
Example #25
0
        public static double StdDev(this IEnumerable<double> data)
        {
            double stdDev = 0;

            if (data.Count() > 1)
            {
                //Compute the Average      
                var avg = data.Average();
                //Perform the Sum of (value-avg)_2_2      
                var sum = data.Sum(d => Math.Pow(d - avg, 2));
                //Put it all together      
                stdDev = Math.Sqrt((sum) / (data.Count() - 1));
            }

            return stdDev;
        }
Example #26
0
 public static double Variance(this ICollection<double> values, bool unbiased = true)
 {
     if (values.Count == 0 || (unbiased && values.Count == 1))
     {
         return 0;
     }
     var ave = values.Average();
     double acc = 0;
     double div = unbiased ? values.Count - 1 : values.Count;
     foreach (var item in values)
     {
         var delta = item - ave;
         acc += delta * delta;
     }
     return acc / div;
 }
Example #27
0
        public static double StdDev(this IEnumerable<long> values)
        {
            double ret = 0;
            int count = values.Count();
            if (count > 1)
            {
                //Compute the Average
                double avg = values.Average();

                //Perform the Sum of (value-avg)^2
                double sum = values.Sum(d => (d - avg) * (d - avg));

                //Put it all together
                ret = Math.Sqrt(sum / count);
            }
            return ret;
        }
        /// <summary>
        /// Calculates incremental and decremental running variance.
        /// </summary>
        /// <param name="samples">Sample data.</param>
        /// <param name="onCalculated">
        /// Action callback which fires on each element addition-removal. 
        /// <para>Parameters are: (index, incremental average, incremental variance, decremental average, decremental variance).</para>
        /// </param>
        /// <param name="weights">Sample weights.</param>
        /// <param name="returnSSE">True to return unnormalized variance (SSE). False to return variance instead.</param>
        public static void RunningVarianceIncDec(this IReadOnlyList<double> samples, Action<int, double, double, double, double> onCalculated, IList<double> weights, bool returnSSE = false)
        {
            double sumWeightInc = 0, meanInc = 0, M2_Inc = 0;
            double sumWeightDec = weights.Sum(),
                   meanDec = samples.Average(weights),
                   M2_Dec = samples.Variance(weights) * sumWeightDec;
            
            for (int i = 0; i < samples.Count; i++)
            {
                var varInc = UpdateVarianceIncremental(ref M2_Inc, ref sumWeightInc, ref meanInc, samples[i], weights[i]);
                var varDec = UpdateVarianceDecremental(ref M2_Dec, ref sumWeightDec, ref meanDec, samples[i], weights[i]);

                if(!returnSSE)
                    onCalculated(i, meanInc, varInc, meanDec, varDec);
                else
                    onCalculated(i, meanInc, M2_Inc, meanDec, M2_Dec);
            }
        }
Example #29
0
        public static double WeightedVariance(this IList<double> values, IList<double> weights, bool unbiased = true)
        {
            if (values.Count != weights.Count) throw new ArgumentException("Two collections count must be equal each other");
            if (values.Count == 0 || (unbiased && values.Count == 1))
            {
                return 0;
            }
            var ave = values.Average();
            double acc = 0;
            double div = unbiased ? values.Count - 1 : values.Count;
            for (int i = 0; i < values.Count; i++)
            {
                var delta = values[i] - ave;
                acc += (delta * delta) * weights[i];
            }

            return acc / div;
        }
Example #30
0
        public static double Mean(
            this IList<Point> array
            )
        {
            if (array == null)
            {
                throw new ArgumentNullException("array");
            }
            if (array.Count == 0)
            {
                return
                    0.0;
            }

            var mean = array.Average(j => j.Diff);

            return
                mean;
        }