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); }
/// <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)))); }
/// <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); }
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); }
/// <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)); }
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)); }
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); }
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); }
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); } }
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); }
/// <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); } }
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); } }
/// <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; }
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; }
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; }
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); } }
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; }
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; }