示例#1
0
        protected override IList <AnnDataPoint> GetRawAnnDataPoints(Stock stock, HistoricalData historicalData)
        {
            var result = new List <AnnDataPoint>();

            lock (Locker)
            {
                if (!data.ContainsKey(historicalData))
                {
                    data.Add(historicalData, Data.GetData(stock, DownloaderService, historicalData));
                }
            }

            var movingAverageFast = DataProcessorService.CalculateMovingAverage(data[historicalData].Quotes, Settings.MovingAverageCloseFast);
            var cci  = DataProcessorService.CalculateCci(data[historicalData].Quotes, Settings.CCI);
            var rsi  = DataProcessorService.CalculateRsi(data[historicalData].Quotes, Settings.RSI);
            var macD = DataProcessorService.CalculateMacd(data[historicalData].Quotes, Settings.MacdFast, Settings.MacdSlow, Settings.MacdSignal);
            var atr  = DataProcessorService.CalculateAtr(data[historicalData].Quotes, Settings.Atr);
            var ema  = DataProcessorService.CalculateEMA(data[historicalData].Quotes, Settings.Ema);
            var obv  = DataProcessorService.CalculateObv(data[historicalData].Quotes, Settings.Obv);
            var crsi = DataProcessorService.CalculateConnorsRsi(data[historicalData].Quotes, Settings.ConnorsRsi);
            var pmo  = DataProcessorService.CalculatePmo(data[historicalData].Quotes, Settings.Pmo);
            var roc  = DataProcessorService.CalculateRoc(data[historicalData].Quotes, Settings.Roc);

            int fwdDays       = Settings.FwdDays;
            int yesterdayStep = 1;

            for (int i = 0; i < historicalData.Quotes.Values.Count; i++)
            {
                var fwdDate = i + fwdDays >= historicalData.Quotes.Values.Count
                    ? historicalData.Quotes.Values.Count - 1
                    : i + fwdDays;

                var yesterdayIndex = i - yesterdayStep >= 0 ? i - yesterdayStep : 0;
                var yesterday      = historicalData.Quotes.Values[yesterdayIndex];
                var today          = historicalData.Quotes.Values[i];

                var future = historicalData.Quotes.Values[fwdDate];

                var percentageChange = (future.Close - today.Close) / today.Close * 100d;

                var annDataPoint = new AnnDataPoint
                {
                    Date   = today.Date,
                    Inputs = new[]
                    {
                        today.Close,
                        today.High,
                        today.Volume,
                        Compare(today.Close, yesterday.Close),
                        Compare(today.High, yesterday.High),
                        Compare(today.Volume, yesterday.Volume),
                        (double)movingAverageFast.Single(x => x.Date.Date == today.Date.Date).Sma.GetValueOrDefault(),
                        (double)ema.Single(x => x.Date.Date == today.Date.Date).Ema.GetValueOrDefault(),
                        (double)cci.Single(x => x.Date.Date == today.Date.Date).Cci.GetValueOrDefault(),
                        (double)rsi.Single(x => x.Date.Date == today.Date.Date).Rsi.GetValueOrDefault(),
                        (double)atr.Single(x => x.Date.Date == today.Date.Date).Atrp.GetValueOrDefault(),
                        (double)macD.Single(x => x.Date.Date == today.Date.Date).Macd.GetValueOrDefault(),
                        (double)obv.Single(x => x.Date.Date == today.Date.Date).Obv,
                        (double)crsi.Single(x => x.Date.Date == today.Date.Date).ConnorsRsi.GetValueOrDefault(),
                        (double)pmo.Single(x => x.Date.Date == today.Date.Date).Pmo.GetValueOrDefault(),
                        (double)roc.Single(x => x.Date.Date == today.Date.Date).Roc.GetValueOrDefault()
                    },
                    Outputs = new[]
                    {
                        percentageChange > Settings.PercentageChangeHigh ? 1d :
                        percentageChange < Settings.PercentageChangeLow ? -1d : 0d
                    }
                };

                result.Add(annDataPoint);
            }

            return(result);
        }
示例#2
0
        protected override IList <AnnDataPoint> GetRawAnnDataPoints(HistoricalData historicalData)
        {
            var result           = new List <AnnDataPoint>();
            var historicalQuotes = historicalData.Quotes.Values;

            var close  = historicalQuotes.Select(x => x.Close).ToArray();
            var volume = historicalQuotes.Select(x => x.Volume).ToArray();

            var movingAverageCloseFast = this.DataProcessorService.CalculateMovingAverage(close, this.Settings.MovingAverageCloseFast);
            var movingAverageCloseSlow = this.DataProcessorService.CalculateMovingAverage(close, this.Settings.MovingAverageCloseSlow);
            var cci      = this.DataProcessorService.CalculateCCI(historicalQuotes, this.Settings.CCI);
            var rsi      = this.DataProcessorService.CalculateRSI(close, this.Settings.RSI);
            var rsi2     = this.DataProcessorService.CalculateRSI(close, this.Settings.RSI2);
            var macD     = this.DataProcessorService.CalculateMacD(close, this.Settings.MacdFast, this.Settings.MacdSlow, this.Settings.MacdSignal);
            var hv       = this.DataProcessorService.CalculateHV(close, this.Settings.Hv1);
            var fitClose = this.DataProcessorService.CalculateMovingLinearFit(close, this.Settings.FitClose);
            var fitOfFit = this.DataProcessorService.CalculateMovingLinearFit(fitClose.Item2, this.Settings.FitOfFit);
            var fitRSI   = this.DataProcessorService.CalculateMovingLinearFit(this.DataProcessorService.CalculateRSI(close, this.Settings.RSI1Fit), this.Settings.RSI2Fit);

            int fwdDays       = this.Settings.FwdDays;
            int yesterdayStep = 1;

            for (int i = 0; i < historicalQuotes.Count; i++)
            {
                var fwdDate = i + fwdDays >= historicalQuotes.Count
                                  ? historicalQuotes.Count - 1
                                  : i + fwdDays;

                var yesterdayIndex = i - yesterdayStep >= 0 ? i - yesterdayStep : 0;
                var yesterday      = historicalQuotes[yesterdayIndex];
                var today          = historicalQuotes[i];
                var future         = historicalQuotes[fwdDate];

                var percentageChange = ((future.Close - today.Close) / today.Close) * 100d;

                var annDataPoint = new AnnDataPoint
                {
                    Date   = today.Date,
                    Inputs = new[]
                    {
                        Math.Sinh(rsi[i]) + Math.Sinh(rsi2[i]),
                        today.Close - today.High,
                        yesterday.Close - yesterday.High,
                        Math.Abs(volume[i] - volume[yesterdayIndex]),
                        movingAverageCloseFast[i] / (movingAverageCloseSlow[yesterdayIndex] + 1E-6),
                        movingAverageCloseSlow[i] / (movingAverageCloseFast[yesterdayIndex] + 1E-6),
                        cci[i],
                        today.Date.Month,
                        macD.Item1[i],
                        macD.Item2[i],
                        rsi[i],
                        hv[i],
                        fitClose.Item2[i],
                        fitOfFit.Item2[i],
                        fitRSI.Item2[i],
                        MathNet.Numerics.Distance.Pearson(
                            new[]
                        {
                            today.Close, today.High, today.Open, today.Low, today.Volume,
                            rsi[i], cci[i], macD.Item2[i]
                        },
                            new[]
                        {
                            yesterday.Close, yesterday.High, yesterday.Open, yesterday.Low, yesterday.Volume,
                            rsi[yesterdayIndex], cci[yesterdayIndex], macD.Item2[yesterdayIndex]
                        })
                    },
                    Outputs = new[]
                    {
                        percentageChange > this.Settings.PercentageChangeHigh ? 1d : percentageChange < this.Settings.PercentageChangeLow ? -1d : 0d
                    }
                };

                result.Add(annDataPoint);
            }

            return(result);
        }