/// <summary> /// Computes the Pearson product-moment correlation coefficient. /// </summary> /// <param name="dataA">Sample data A.</param> /// <param name="dataB">Sample data B.</param> /// <returns>The Pearson product-moment correlation coefficient.</returns> public static double Pearson(IEnumerable<double> dataA, IEnumerable<double> dataB) { int n = 0; double r = 0.0; // BUG: PERFORMANCE degraded due to tripple iteration over both IEnumerables double meanA = dataA.Mean(); double meanB = dataB.Mean(); double sdevA = dataA.StandardDeviation(); double sdevB = dataB.StandardDeviation(); using (IEnumerator<double> ieA = dataA.GetEnumerator()) using (IEnumerator<double> ieB = dataB.GetEnumerator()) { while (ieA.MoveNext()) { if (!ieB.MoveNext()) { throw new ArgumentOutOfRangeException("dataB", "Datasets dataA and dataB need to have the same length. dataB is shorter."); } n++; r += (ieA.Current - meanA) * (ieB.Current - meanB) / (sdevA * sdevB); } if (ieB.MoveNext()) { throw new ArgumentOutOfRangeException("dataA", "Datasets dataA and dataB need to have the same length. dataA is shorter."); } } return r / (n - 1); }
/// <summary> /// Computes the sample Skewness of a sequence of double values /// </summary> /// <param name="source">A sequence of double values to calculate the Skewness of.</param> /// <returns>The Skewness of the sequence of values.</returns> /// <remarks>![equation](~/images/skewness.gif)</remarks> public static double Skewness(this IEnumerable <double> source) { if (source == null) { throw new ArgumentNullException(nameof(source)); } double mean = (double)source.Average(); double s = (double)source.StandardDeviation(); double M3 = 0; long n = 0; checked { foreach (var x in source) { n++; M3 += Math.Pow(((double)x - mean) / s, 3.0); } } if (n < 3) { throw new InvalidOperationException("Source must have at least 3 elements"); } return((double)((M3 * n) / ((n - 1) * (n - 2)))); }
/// <summary> /// Computes the Pearson product-moment correlation coefficient. /// </summary> /// <param name="dataA">Sample data A.</param> /// <param name="dataB">Sample data B.</param> /// <returns>The Pearson product-moment correlation coefficient.</returns> public static double Pearson(IEnumerable <double> dataA, IEnumerable <double> dataB) { int n = 0; double r = 0.0; // BUG: PERFORMANCE degraded due to tripple iteration over both IEnumerables double meanA = dataA.Mean(); double meanB = dataB.Mean(); double sdevA = dataA.StandardDeviation(); double sdevB = dataB.StandardDeviation(); using (IEnumerator <double> ieA = dataA.GetEnumerator()) using (IEnumerator <double> ieB = dataB.GetEnumerator()) { while (ieA.MoveNext()) { if (!ieB.MoveNext()) { throw new ArgumentOutOfRangeException("dataB", "Datasets dataA and dataB need to have the same length. dataB is shorter."); } n++; r += (ieA.Current - meanA) * (ieB.Current - meanB) / (sdevA * sdevB); } if (ieB.MoveNext()) { throw new ArgumentOutOfRangeException("dataA", "Datasets dataA and dataB need to have the same length. dataA is shorter."); } } return(r / (n - 1)); }
/// <summary> /// Calculates the standard deviation using a value and the frequency (the amount of /// times that values occurs) of that value /// </summary> /// <param name="frequencyPlusValues">A collection of values and the frequency /// of those values</param> /// <returns>the standard deviation for the provided values</returns> public static double StandardDeviation(this IEnumerable <Tuple <double, int> > frequencyPlusValues) { // Compute the mean double mean = frequencyPlusValues.Mean(); return(frequencyPlusValues.StandardDeviation(mean)); }
protected virtual (double, double) CalcReturnAndRisk(IEnumerable <double> returnSeries) { var annualizedReturn = 252.0 * returnSeries.Average(); var annualizedVolatility = 100.0 * Math.Sqrt(252.0) * returnSeries.StandardDeviation(); return(annualizedReturn, annualizedVolatility); }
/// <summary> /// Computes the Pearson product-moment correlation coefficient. /// </summary> /// <param name="dataA">Sample data A.</param> /// <param name="dataB">Sample data B.</param> /// <returns>The Pearson product-moment correlation coefficient.</returns> public static double Pearson(IEnumerable<double> dataA, IEnumerable<double> dataB) { int n = 0; double r = 0.0; double meanA = dataA.Mean(); double meanB = dataB.Mean(); double sdevA = dataA.StandardDeviation(); double sdevB = dataB.StandardDeviation(); IEnumerator<double> ieA = dataA.GetEnumerator(); IEnumerator<double> ieB = dataB.GetEnumerator(); while (ieA.MoveNext()) { if (ieB.MoveNext() == false) { throw new ArgumentOutOfRangeException("Datasets dataA and dataB need to have the same length."); } n++; r += (ieA.Current - meanA) * (ieB.Current - meanB) / (sdevA * sdevB); } if (ieB.MoveNext() == true) { throw new ArgumentOutOfRangeException("Datasets dataA and dataB need to have the same length."); } return r / (n - 1); }
public static double SharpeRatio <TSource>(this IEnumerable <TSource> source, Func <TSource, double> portfolioReturnSelector, Func <TSource, double> riskFreeRateSelector) { if (source == null) { throw new ArgumentNullException(nameof(source)); } if (portfolioReturnSelector == null) { throw new ArgumentNullException(nameof(portfolioReturnSelector)); } if (riskFreeRateSelector == null) { throw new ArgumentNullException(nameof(riskFreeRateSelector)); } checked { var portfolioReturn = source.AccumulateCompoundInterest(portfolioReturnSelector) / 100; var riskFreeRate = source.AccumulateCompoundInterest(riskFreeRateSelector) / 100; var standardDeviation = source.StandardDeviation(portfolioReturnSelector); return(portfolioReturn.SharpeRatio(riskFreeRate, standardDeviation)); } }
public decimal?StandardDev(string symbol) { int k = List.Where(it => it.firma.Symbol == symbol).Count(); if (k == 0) { return(null); } //decimal SumOfSquares = List // .Where(it => it.Symbol == symbol) // .Sum(it => (decimal)Math.Pow((double)(it.Price - AverageVolume("") ?? 0), (double)2)); //de ce nu merge asa din moment ce eu am deja calculat Average Price? IEnumerable <double> AllValues = List.Where(it => it.firma.Symbol == symbol).Select(it => (double)it.Price).ToArray(); var q = AllValues.StandardDeviation(); // MathNet.Numerics.Statistics.Statistics.StandardDeviation(AllValues) decimal Avg = List.Where(it => it.firma.Symbol == symbol).Average(it => it.Price); double SumOfSquares = List .Where(it => it.firma.Symbol == symbol) .Sum(it => Math.Pow((double)(it.Price - Avg), 2)); double StDev = Math.Sqrt(SumOfSquares / (k - 1)); return((decimal)StDev); }
/// <summary> /// Computes the Pearson product-moment correlation coefficient. /// </summary> /// <param name="dataA">Sample data A.</param> /// <param name="dataB">Sample data B.</param> /// <returns>The Pearson product-moment correlation coefficient.</returns> public static double Pearson(IEnumerable <double> dataA, IEnumerable <double> dataB) { int n = 0; double r = 0.0; double meanA = dataA.Mean(); double meanB = dataB.Mean(); double sdevA = dataA.StandardDeviation(); double sdevB = dataB.StandardDeviation(); IEnumerator <double> ieA = dataA.GetEnumerator(); IEnumerator <double> ieB = dataB.GetEnumerator(); while (ieA.MoveNext()) { if (ieB.MoveNext() == false) { throw new ArgumentOutOfRangeException("Datasets dataA and dataB need to have the same length."); } n++; r += (ieA.Current - meanA) * (ieB.Current - meanB) / (sdevA * sdevB); } if (ieB.MoveNext() == true) { throw new ArgumentOutOfRangeException("Datasets dataA and dataB need to have the same length."); } return(r / (n - 1)); }
public static double?GetRiskPerAnnumWorkdays(this IEnumerable <double> values) { if (values == null) { return(null); } return(values.StandardDeviation() * Math.Pow(260, 0.5)); }
public void TwoAggregatesIntoExpando() { IEnumerable <Person> source = TestData.GetPeople(); var result = source.Query <Person, dynamic>("SELECT avg(AGE) AS a, stdev(AGE) AS s FROM this").First(); Assert.IsTrue(result.a == source.Average(p => p.Age)); Assert.IsTrue(result.s == source.StandardDeviation(p => p.Age)); }
public void StdevInt() { IEnumerable <int> source = TestData.GetInts(); double result = source.QueryScalar <int, double>("SELECT Stdev(value()) FROM this"); Assert.AreEqual(result, source.StandardDeviation(), TestData.Epsilon); }
public void StdevNullableInt() { IEnumerable <int?> source = TestData.GetNullableInts(); double?result = source.StandardDeviation(); Assert.AreEqual((double)result, 1.707825127659933, double.Epsilon); }
public void TwoAggregatesIntoTuple() { IEnumerable <Person> source = TestData.GetPeople(); Tuple <double, double> result = source.Query <Person, Tuple <double, double> >("SELECT avg(AGE) AS a, stdev(AGE) AS s FROM this").First(); Assert.IsTrue(result.Item1 == source.Average(p => p.Age)); Assert.IsTrue(result.Item2 == source.StandardDeviation(p => p.Age)); }
public void StdevNullableDouble() { IEnumerable <double?> source = TestData.GetNullableDoubles(); double?result = source.StandardDeviation(); Assert.AreEqual((double)result, 2.0271079563424013, double.Epsilon); }
public void TwoAggregatesIntoTypedDictionary() { IEnumerable <Person> source = TestData.GetPeople(); IDictionary <string, double> result = source.Query <Person, IDictionary <string, double> >("SELECT avg(AGE) AS a, stdev(AGE) AS s FROM this").First(); Assert.IsTrue(result["a"] == source.Average(p => p.Age)); Assert.IsTrue(result["s"] == source.StandardDeviation(p => p.Age)); }
public static IEnumerable <T> BoundBySigmas <T>(this IEnumerable <T> ld, Func <T, double> transform, double minBound, double maxBound) { double mean = ld.Average(transform); double stdev = ld.StandardDeviation(transform); SigmaBoundingContext context = new SigmaBoundingContext { Mean = mean, StdDev = stdev, MinBound = minBound, MaxBound = maxBound }; return(BoundBySigmasIter(ld, transform, context)); }
// // Summary: // Computes the StandardDeviation of a sequence of nullable System.Int32 values. // // Parameters: // source: // A sequence of nullable System.Int32values to calculate the StandardDeviation of. // // Returns: // The StandardDeviation of the sequence of values, or null if the source sequence is // empty or contains only values that are null. // // Exceptions: // System.ArgumentNullException: // source is null. // // System.OverflowException: // The sum of the elements in the sequence is larger than System.Int64.MaxValue. public static double?StandardDeviation(this IEnumerable <int?> source) { IEnumerable <double> values = source.Where(d => d.HasValue).Select(x => (double)x); if (values.Any()) { return(values.StandardDeviation()); } return(null); }
// // Summary: // Computes the StandardDeviation of a sequence of nullable System.Double values. // // Parameters: // source: // A sequence of nullable System.Double values to calculate the StandardDeviation of. // // Returns: // The StandardDeviation of the sequence of values, or null if the source sequence is // empty or contains only values that are null. // // Exceptions: // System.ArgumentNullException: // source is null. public static double?StandardDeviation(this IEnumerable <double?> source) { IEnumerable <double> values = source.Coalesce(); if (values.Any()) { return(values.StandardDeviation()); } return(null); }
public static void Main() { List <Tweet> tweets = new TwitterService().GetTweets(/* HTML DATA SOURCE */); List <Tweet> shortTweetsArchive = tweets.Where(t => t.Content.Length < 100).ToList(); List <Tweet> longTweetsArchive = tweets.Where(t => t.Content.Length >= 100).ToList(); List <Tweet> shortTweetsSample = new List <Tweet>(); List <Tweet> longTweetsSample = new List <Tweet>(); int sampleSize = 30; Random rand = new Random(); for (int i = 0; i < sampleSize; i++) { int r = rand.Next(shortTweetsArchive.Count); shortTweetsSample.Add(shortTweetsArchive[r]); shortTweetsArchive.RemoveAt(r); // Sampling without replacement } for (int i = 0; i < sampleSize; i++) { int r = rand.Next(longTweetsArchive.Count); longTweetsSample.Add(longTweetsArchive[r]); longTweetsArchive.RemoveAt(r); } Func <Tweet, int> getEngagements = t => (t.RetweetCount + t.FavoriteCount); IEnumerable <int> shortTweetsSampleData = shortTweetsSample.Select(getEngagements); IEnumerable <int> longTweetsSampleData = longTweetsSample.Select(getEngagements); double shortAvg = shortTweetsSampleData.Average(); double shortSD = shortTweetsSampleData.StandardDeviation(); double longAvg = longTweetsSampleData.Average(); double longSD = longTweetsSampleData.StandardDeviation(); Console.WriteLine("Short Tweets Sample Size: {0}", shortTweetsSample.Count); Console.WriteLine(" Mean Engagements: {0}", shortAvg); Console.WriteLine(" Std Dev: {0}", shortSD); Console.WriteLine(" Long Tweets Sample Size: {0}", longTweetsSample.Count); Console.WriteLine(" Mean Engagements: {0}", longAvg); Console.WriteLine(" Std Dev: {0}", longSD); IOUtils.Export(shortTweetsSampleData, /* OUTPUT LOCATION */); IOUtils.Export(longTweetsSampleData, /* OUTPUT LOCATION */); Console.WriteLine("* Done"); Console.ReadKey(); }
public static IEnumerable <double> BoundBySigmas(this IEnumerable <double> ld, double minBound, double maxBound, ref object context) { if (!ld.Any()) { return(ld); } if (context == null) { double mean = ld.Average(); double stdev = ld.StandardDeviation(); context = new SigmaBoundingContext { Mean = mean, StdDev = stdev, MinBound = minBound, MaxBound = maxBound }; } return(BoundBySigmasIter(ld, (SigmaBoundingContext)context)); }
public IPortfolioStatisticsData GetPortfolioStatisticsData(IPortfolioValuationHistory portfolioValuationHistory) { IEnumerable <double> portfolioValuationData = portfolioValuationHistory.ValuationData.Select(x => (x.Valuation)); IEnumerable <double> portfolioDailyReturnsData = GetPortfolioValuationDailyReturnsData(portfolioValuationData.ToList()); double standardDeviation = portfolioDailyReturnsData.StandardDeviation(); double portfolioReturn = GetTotalReturnAsPercentage_NoDividend(portfolioValuationData); double initialValuation = portfolioValuationHistory.InitialValuation; double finalValuation = portfolioValuationData.Last(); double returnsToVolatilityRatio = portfolioReturn / standardDeviation; var portfolioStatistics = new PortfolioStatisticsData(portfolioValuationHistory.PortfolioName, portfolioValuationHistory.StartDate, portfolioValuationHistory.EndDate, initialValuation, finalValuation, portfolioReturn, standardDeviation, returnsToVolatilityRatio); return(portfolioStatistics); }
public static double Skewness <TSource>(this IEnumerable <TSource> lhi, Func <TSource, double> transform) { double skewness = double.NaN; double avg = lhi.Average(transform); double stDevCubed = Math.Pow(lhi.StandardDeviation(transform), 3); int nSamplesMinus1 = lhi.Count(n => !double.IsNaN(transform(n))) - 1; if (nSamplesMinus1 > 0) { double devCubedSum = 0.0; // ReSharper disable once LoopCanBeConvertedToQuery (Clearer as written.) foreach (double d in lhi.Select(transform)) { if (!double.IsNaN(d)) { devCubedSum += Math.Pow((avg - d), 3); } } skewness = devCubedSum / (nSamplesMinus1 * stDevCubed); } return(skewness); }
public static double Skewness(this IEnumerable <double> ld) { double skewness = double.NaN; double avg = ld.Average(); double stDevCubed = Math.Pow(ld.StandardDeviation(), 3); int nSamplesMinus1 = ld.Count(d => !double.IsNaN(d)) - 1; if (nSamplesMinus1 > 0) { double devCubedSum = 0.0; // ReSharper disable once LoopCanBeConvertedToQuery (Clearer as-written.) foreach (double d in ld) { if (!double.IsNaN(d)) { devCubedSum += Math.Pow((avg - d), 3); } } skewness = devCubedSum / (nSamplesMinus1 * stDevCubed); } return(skewness); }
public MeanStandardDeviation(IEnumerable<double> values) { this.Mean = values.Mean(); this.StdDev = values.StandardDeviation(); this.Count = values.Count(); }
public static double SampleStandardDeviation(this IEnumerable <double> numberSet) { return(numberSet.StandardDeviation(numberSet.Count() - 1)); }
public static double PopulationStandardDeviation(this IEnumerable <double> numberSet) { return(numberSet.StandardDeviation(numberSet.Count())); }
// Design philosophy: whenever possible this function should delay source enumeration since source data sets could be very large. private static IEnumerable <DataSourceValue> ExecuteSeriesFunctionOverSource(IEnumerable <DataSourceValue> source, SeriesFunction seriesFunction, string[] parameters, bool isSliceOperation = false) { DataSourceValue[] values; DataSourceValue result = new DataSourceValue(); double lastValue = double.NaN; double lastTime = 0.0D; string lastTarget = null; IEnumerable <double> trackedValues = source.Select(dataValue => { lastTime = dataValue.Time; lastTarget = dataValue.Target; return(dataValue.Value); }); double baseTime, timeStep, value, low, high; bool normalizeTime, lowInclusive, highInclusive; int count; TargetTimeUnit timeUnit; AngleUnit angleUnit; switch (seriesFunction) { case SeriesFunction.Minimum: DataSourceValue minValue = new DataSourceValue { Value = double.MaxValue }; foreach (DataSourceValue dataValue in source) { if (dataValue.Value <= minValue.Value) { minValue = dataValue; } } if (minValue.Time > 0.0D) { yield return(minValue); } break; case SeriesFunction.Maximum: DataSourceValue maxValue = new DataSourceValue { Value = double.MinValue }; foreach (DataSourceValue dataValue in source) { if (dataValue.Value >= maxValue.Value) { maxValue = dataValue; } } if (maxValue.Time > 0.0D) { yield return(maxValue); } break; case SeriesFunction.Average: result.Value = trackedValues.Average(); result.Time = lastTime; result.Target = lastTarget; yield return(result); break; case SeriesFunction.Total: result.Value = trackedValues.Sum(); result.Time = lastTime; result.Target = lastTarget; yield return(result); break; case SeriesFunction.Range: DataSourceValue rangeMin = new DataSourceValue { Value = double.MaxValue }; DataSourceValue rangeMax = new DataSourceValue { Value = double.MinValue }; foreach (DataSourceValue dataValue in source) { if (dataValue.Value <= rangeMin.Value) { rangeMin = dataValue; } if (dataValue.Value >= rangeMax.Value) { rangeMax = dataValue; } } if (rangeMin.Time > 0.0D && rangeMax.Time > 0.0D) { result = rangeMax; result.Value = rangeMax.Value - rangeMin.Value; yield return(result); } break; case SeriesFunction.Count: result.Value = trackedValues.Count(); result.Time = lastTime; result.Target = lastTarget; yield return(result); break; case SeriesFunction.Distinct: foreach (DataSourceValue dataValue in source.DistinctBy(dataValue => dataValue.Value)) { yield return(dataValue); } break; case SeriesFunction.AbsoluteValue: foreach (DataSourceValue dataValue in source.Select(dataValue => new DataSourceValue { Value = Math.Abs(dataValue.Value), Time = dataValue.Time, Target = dataValue.Target })) { yield return(dataValue); } break; case SeriesFunction.Add: value = ParseFloat(parameters[0], source, false, isSliceOperation); foreach (DataSourceValue dataValue in source.Select(dataValue => new DataSourceValue { Value = dataValue.Value + value, Time = dataValue.Time, Target = dataValue.Target })) { yield return(dataValue); } break; case SeriesFunction.Subtract: value = ParseFloat(parameters[0], source, false, isSliceOperation); foreach (DataSourceValue dataValue in source.Select(dataValue => new DataSourceValue { Value = dataValue.Value - value, Time = dataValue.Time, Target = dataValue.Target })) { yield return(dataValue); } break; case SeriesFunction.Multiply: value = ParseFloat(parameters[0], source, false, isSliceOperation); foreach (DataSourceValue dataValue in source.Select(dataValue => new DataSourceValue { Value = dataValue.Value * value, Time = dataValue.Time, Target = dataValue.Target })) { yield return(dataValue); } break; case SeriesFunction.Divide: value = ParseFloat(parameters[0], source, false, isSliceOperation); foreach (DataSourceValue dataValue in source.Select(dataValue => new DataSourceValue { Value = dataValue.Value / value, Time = dataValue.Time, Target = dataValue.Target })) { yield return(dataValue); } break; case SeriesFunction.Round: count = parameters.Length == 0 ? 0 : ParseInt(parameters[0]); foreach (DataSourceValue dataValue in source.Select(dataValue => new DataSourceValue { Value = Math.Round(dataValue.Value, count), Time = dataValue.Time, Target = dataValue.Target })) { yield return(dataValue); } break; case SeriesFunction.Floor: foreach (DataSourceValue dataValue in source.Select(dataValue => new DataSourceValue { Value = Math.Floor(dataValue.Value), Time = dataValue.Time, Target = dataValue.Target })) { yield return(dataValue); } break; case SeriesFunction.Ceiling: foreach (DataSourceValue dataValue in source.Select(dataValue => new DataSourceValue { Value = Math.Ceiling(dataValue.Value), Time = dataValue.Time, Target = dataValue.Target })) { yield return(dataValue); } break; case SeriesFunction.Truncate: foreach (DataSourceValue dataValue in source.Select(dataValue => new DataSourceValue { Value = Math.Truncate(dataValue.Value), Time = dataValue.Time, Target = dataValue.Target })) { yield return(dataValue); } break; case SeriesFunction.StandardDeviation: result.Value = trackedValues.StandardDeviation(parameters.Length > 0 && parameters[0].Trim().ParseBoolean()); result.Time = lastTime; result.Target = lastTarget; yield return(result); break; case SeriesFunction.Median: values = source.Median(); if (values.Length == 0) //-V3080 { yield break; } result = values.Last(); if (values.Length > 1) { result.Value = values.Select(dataValue => dataValue.Value).Average(); } yield return(result); break; case SeriesFunction.Mode: values = source.ToArray(); yield return(values.MajorityBy(values.Last(), dataValue => dataValue.Value, false)); break; case SeriesFunction.Top: values = source.ToArray(); if (values.Length == 0) { yield break; } count = ParseCount(parameters[0], values, isSliceOperation); if (count > values.Length) { count = values.Length; } normalizeTime = parameters.Length == 1 || parameters[1].Trim().ParseBoolean(); baseTime = values[0].Time; timeStep = (values[values.Length - 1].Time - baseTime) / (count - 1).NotZero(1); Array.Sort(values, (a, b) => a.Value < b.Value ? -1 : (a.Value > b.Value ? 1 : 0)); foreach (DataSourceValue dataValue in values.Take(count).Select((dataValue, i) => new DataSourceValue { Value = dataValue.Value, Time = normalizeTime ? baseTime + i * timeStep : dataValue.Time, Target = dataValue.Target })) { yield return(dataValue); } break; case SeriesFunction.Bottom: values = source.ToArray(); if (values.Length == 0) { yield break; } count = ParseCount(parameters[0], values, isSliceOperation); if (count > values.Length) { count = values.Length; } normalizeTime = parameters.Length == 1 || parameters[1].Trim().ParseBoolean(); baseTime = values[0].Time; timeStep = (values[values.Length - 1].Time - baseTime) / (count - 1).NotZero(1); Array.Sort(values, (a, b) => a.Value > b.Value ? -1 : (a.Value < b.Value ? 1 : 0)); foreach (DataSourceValue dataValue in values.Take(count).Select((dataValue, i) => new DataSourceValue { Value = dataValue.Value, Time = normalizeTime ? baseTime + i * timeStep : dataValue.Time, Target = dataValue.Target })) { yield return(dataValue); } break; case SeriesFunction.Random: values = source.ToArray(); if (values.Length == 0) { yield break; } count = ParseCount(parameters[0], values, isSliceOperation); if (count > values.Length) { count = values.Length; } normalizeTime = parameters.Length == 1 || parameters[1].Trim().ParseBoolean(); baseTime = values[0].Time; timeStep = (values[values.Length - 1].Time - baseTime) / (count - 1).NotZero(1); List <int> indexes = new List <int>(Enumerable.Range(0, values.Length)); indexes.Scramble(); foreach (DataSourceValue dataValue in indexes.Take(count).Select((index, i) => new DataSourceValue { Value = values[index].Value, Time = normalizeTime ? baseTime + i * timeStep : values[index].Time, Target = values[index].Target })) { yield return(dataValue); } break; case SeriesFunction.First: values = source.ToArray(); if (values.Length == 0) { yield break; } count = parameters.Length == 0 ? 1 : ParseCount(parameters[0], values, isSliceOperation); if (count > values.Length) { count = values.Length; } for (int i = 0; i < count; i++) { yield return(values[i]); } break; case SeriesFunction.Last: values = source.ToArray(); if (values.Length == 0) { yield break; } count = parameters.Length == 0 ? 1 : ParseCount(parameters[0], values, isSliceOperation); if (count > values.Length) { count = values.Length; } for (int i = 0; i < count; i++) { yield return(values[values.Length - 1 - i]); } break; case SeriesFunction.Percentile: double percent = ParsePercentage(parameters[0]); values = source.ToArray(); if (values.Length == 0) { yield break; } Array.Sort(values, (a, b) => a.Value < b.Value ? -1 : (a.Value > b.Value ? 1 : 0)); count = values.Length; if (percent == 0.0D) { yield return(values.First()); } else if (percent == 100.0D) { yield return(values.Last()); } else { double n = (count - 1) * (percent / 100.0D) + 1.0D; int k = (int)n; DataSourceValue kData = values[k]; double d = n - k; double k0 = values[k - 1].Value; double k1 = kData.Value; result.Value = k0 + d * (k1 - k0); result.Time = kData.Time; result.Target = kData.Target; yield return(result); } break; case SeriesFunction.Difference: foreach (DataSourceValue dataValue in source) { if (lastTime > 0.0D) { yield return new DataSourceValue { Value = dataValue.Value - lastValue, Time = dataValue.Time, Target = lastTarget } } ; lastValue = dataValue.Value; lastTime = dataValue.Time; lastTarget = dataValue.Target; } break; case SeriesFunction.TimeDifference: if (parameters.Length == 0 || !TargetTimeUnit.TryParse(parameters[0], out timeUnit)) { timeUnit = new TargetTimeUnit { Unit = TimeUnit.Seconds } } ; foreach (DataSourceValue dataValue in source) { if (lastTime > 0.0D) { yield return new DataSourceValue { Value = ToTimeUnits((dataValue.Time - lastTime) * SI.Milli, timeUnit), Time = dataValue.Time, Target = lastTarget } } ; lastTime = dataValue.Time; lastTarget = dataValue.Target; } break; case SeriesFunction.Derivative: if (parameters.Length == 0 || !TargetTimeUnit.TryParse(parameters[0], out timeUnit)) { timeUnit = new TargetTimeUnit { Unit = TimeUnit.Seconds } } ; foreach (DataSourceValue dataValue in source) { if (lastTime > 0.0D) { yield return new DataSourceValue { Value = (dataValue.Value - lastValue) / ToTimeUnits((dataValue.Time - lastTime) * SI.Milli, timeUnit), Time = dataValue.Time, Target = lastTarget } } ; lastValue = dataValue.Value; lastTime = dataValue.Time; lastTarget = dataValue.Target; } break; case SeriesFunction.TimeIntegration: if (parameters.Length == 0 || !TargetTimeUnit.TryParse(parameters[0], out timeUnit)) { timeUnit = new TargetTimeUnit { Unit = TimeUnit.Hours } } ; result.Value = 0.0D; foreach (DataSourceValue dataValue in source) { if (lastTime > 0.0D) { result.Value += dataValue.Value * ToTimeUnits((dataValue.Time - lastTime) * SI.Milli, timeUnit); } lastTime = dataValue.Time; lastTarget = dataValue.Target; } if (lastTime > 0.0D) { result.Time = lastTime; result.Target = lastTarget; yield return(result); } break; case SeriesFunction.Interval: if (parameters.Length == 1 || !TargetTimeUnit.TryParse(parameters[1], out timeUnit)) { timeUnit = new TargetTimeUnit { Unit = TimeUnit.Seconds } } ; value = FromTimeUnits(ParseFloat(parameters[0], source, true, isSliceOperation), timeUnit) / SI.Milli; foreach (DataSourceValue dataValue in source) { if (lastTime > 0.0D) { if (dataValue.Time - lastTime > value) { lastTime = dataValue.Time; yield return(dataValue); } } else { lastTime = dataValue.Time; yield return(dataValue); } } break; case SeriesFunction.IncludeRange: low = ParseFloat(parameters[0], source, false, isSliceOperation); high = ParseFloat(parameters[1], source, false, isSliceOperation); lowInclusive = parameters.Length > 2 && parameters[2].Trim().ParseBoolean(); highInclusive = parameters.Length > 3 ? parameters[3].Trim().ParseBoolean() : lowInclusive; foreach (DataSourceValue dataValue in source.Where(dataValue => (lowInclusive ? dataValue.Value >= low : dataValue.Value > low) && (highInclusive ? dataValue.Value <= high : dataValue.Value < high))) { yield return(dataValue); } break; case SeriesFunction.ExcludeRange: low = ParseFloat(parameters[0], source, false, isSliceOperation); high = ParseFloat(parameters[1], source, false, isSliceOperation); lowInclusive = parameters.Length > 2 && parameters[2].Trim().ParseBoolean(); highInclusive = parameters.Length > 3 ? parameters[3].Trim().ParseBoolean() : lowInclusive; foreach (DataSourceValue dataValue in source.Where(dataValue => (lowInclusive ? dataValue.Value <= low : dataValue.Value < low) || (highInclusive ? dataValue.Value >= high : dataValue.Value > high))) { yield return(dataValue); } break; case SeriesFunction.FilterNaN: bool alsoFilterInifinity = parameters.Length == 0 || parameters[0].Trim().ParseBoolean(); foreach (DataSourceValue dataValue in source.Where(dataValue => !(double.IsNaN(dataValue.Value) || alsoFilterInifinity && double.IsInfinity(dataValue.Value)))) //-V3130 { yield return(dataValue); } break; case SeriesFunction.UnwrapAngle: if (parameters.Length == 0 || !Enum.TryParse(parameters[0], true, out angleUnit)) { angleUnit = AngleUnit.Degrees; } values = source.ToArray(); foreach (DataSourceValue dataValue in Angle.Unwrap(values.Select(dataValue => Angle.ConvertFrom(dataValue.Value, angleUnit))).Select((angle, index) => new DataSourceValue { Value = angle.ConvertTo(angleUnit), Time = values[index].Time, Target = values[index].Target })) { yield return(dataValue); } break; case SeriesFunction.WrapAngle: if (parameters.Length == 0 || !Enum.TryParse(parameters[0], true, out angleUnit)) { angleUnit = AngleUnit.Degrees; } foreach (DataSourceValue dataValue in source.Select(dataValue => new DataSourceValue { Value = Angle.ConvertFrom(dataValue.Value, angleUnit).ToRange(-Math.PI, false).ConvertTo(angleUnit), Time = dataValue.Time, Target = dataValue.Target })) { yield return(dataValue); } break; } }
/// <summary> /// Return the standard deviation (not the sample standard deviation) of an enumeration /// of doubles. /// </summary> /// <typeparam name="T">The Type of each element in the population</typeparam> /// <param name="population">The population of data</param> /// <param name="selector"> /// Transform each element of the population into a "double" value /// </param> /// <returns>The standard deviation of the population</returns> public static double StandardDeviation <T>(this IEnumerable <T> population, Func <T, double> selector) { var average = population.Average(selector); return(population.StandardDeviation(selector, average)); }
/// <summary> /// Return the standard deviation (not the sample standard deviation) of an enumeration /// of doubles. The generalized form, using selectors to convert from your data to a /// double, are found below. /// </summary> /// <param name="population">The data to get the standard deviation for</param> /// <returns>The standard deviation for the collection of double values</returns> public static double StandardDeviation(this IEnumerable <double> population) { var average = population.Average(); return(population.StandardDeviation(average)); }
public static double StandardDeviation(this IEnumerable <double> values) { return(values.StandardDeviation(x => x)); }
public override void ConfigureParameters(IEnumerable <double> data) { OriginalStandardDeviation = data.StandardDeviation(); OriginalMean = data.Average(); }
public MeanStandardDeviation(IEnumerable <double> values) { this.Mean = values.Mean(); this.StdDev = values.StandardDeviation(); this.Count = values.Count(); }