示例#1
0
        /// <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);
        }
示例#2
0
        /// <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))));
        }
示例#3
0
        /// <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));
        }
示例#4
0
        /// <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));
        }
示例#5
0
        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);
        }
示例#6
0
        /// <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);
        }
示例#7
0
        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));
            }
        }
示例#8
0
        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));
        }
示例#10
0
 public static double?GetRiskPerAnnumWorkdays(this IEnumerable <double> values)
 {
     if (values == null)
     {
         return(null);
     }
     return(values.StandardDeviation() * Math.Pow(260, 0.5));
 }
示例#11
0
        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);
        }
示例#13
0
        public void StdevNullableInt()
        {
            IEnumerable <int?> source = TestData.GetNullableInts();

            double?result = source.StandardDeviation();

            Assert.AreEqual((double)result, 1.707825127659933, double.Epsilon);
        }
示例#14
0
        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));
        }
示例#15
0
        public void StdevNullableDouble()
        {
            IEnumerable <double?> source = TestData.GetNullableDoubles();

            double?result = source.StandardDeviation();

            Assert.AreEqual((double)result, 2.0271079563424013, double.Epsilon);
        }
示例#16
0
        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));
        }
示例#17
0
        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);
        }
示例#20
0
    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();
    }
示例#21
0
 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));
 }
示例#22
0
        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);
        }
示例#23
0
        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);
        }
示例#24
0
        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);
        }
示例#25
0
 public MeanStandardDeviation(IEnumerable<double> values)
 {
   this.Mean = values.Mean();
   this.StdDev = values.StandardDeviation();
   this.Count = values.Count();
 }
示例#26
0
 public static double SampleStandardDeviation(this IEnumerable <double> numberSet)
 {
     return(numberSet.StandardDeviation(numberSet.Count() - 1));
 }
示例#27
0
 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;
            }
        }
示例#29
0
        /// <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));
        }
示例#30
0
        /// <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));
        }
示例#31
0
 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();
 }
示例#33
0
 public MeanStandardDeviation(IEnumerable <double> values)
 {
     this.Mean   = values.Mean();
     this.StdDev = values.StandardDeviation();
     this.Count  = values.Count();
 }