Пример #1
0
        public bool RangeConvergeWithElliotForBuy(DateTime StartDate, DateTime EndDate, out TradingRecommendation TradingRecommendation)
        {
            List <Wave> oWaves = GetListOfWavesFromRange(StartDate, EndDate);
            List <ConfirmedElliottWave> oConfirmedWaves;

            TradingRecommendation = new TradingRecommendation();
            int LastWaveNumberHit;

            if (oWaves.Count > 1 && m_oED.FindElliottDefinitioninWaves(oWaves, out LastWaveNumberHit, out oConfirmedWaves))
            {
                if (LastWaveNumberHit > 0)
                {
                    TradingRecommendation = GetTradingRecommendationFromWaves(oConfirmedWaves, StartDate, EndDate);
                    if (TradingRecommendation.Equals(new TradingRecommendation()))
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }
                }
                else
                {
                    return(false);
                }
            }
            return(false);
        }
Пример #2
0
        private List <TradingRecommendation> GetTradingRecommendationsForElliot()
        {
            List <TradingRecommendation> Recommendations = new List <TradingRecommendation>();;
            bool bReccomend;

            int[] Intervals = { 20, 50, 100, 180 };
            TradingRecommendation Recommendation = new TradingRecommendation();

            try
            {
                foreach (int Interval in Intervals)
                {
                    bReccomend = RangeConvergeWithElliotForBuy(Interval, out Recommendation);
                    if (bReccomend)
                    {
                        Recommendations.Add(Recommendation);
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                ImperaturGlobal.GetLog().Error(string.Format("Error calculating the Elliot waves for instrument {0}, {1}", Instrument.Symbol, Instrument.Name), ex);
            }

            return(Recommendations);
        }
Пример #3
0
 public bool RangeConvergeWithElliotForBuy(int IntervalInDays, out TradingRecommendation TradingRecommendation)
 {
     return(RangeConvergeWithElliotForBuy(DateTime.Now.AddDays(-IntervalInDays), DateTime.Now, out TradingRecommendation));
 }
Пример #4
0
        private TradingRecommendation GetTradingRecommendationForBollinger()
        {
            int[]    Intervals  = { 20, 50, 100, 180 };
            double[] Multiplies = new double[] { 2 };


            TradingRecommendation Recommendation = new TradingRecommendation();

            foreach (int Interval in Intervals)
            {
                try
                {
                    List <List <double> > oB = BollingerForRange(DateTime.Now.AddDays(-Interval), DateTime.Now, 20, Multiplies);

                    if (oB.Select(b => b.Count()).Sum() == 0)
                    {
                        //no range found, try next interval
                        continue;
                    }
                    //Now create the pricerange list as well
                    var PriceInfo = GetDataForRange(DateTime.Now.AddDays(-Interval), DateTime.Now);
                    if (PriceInfo.Count() < 2)
                    {
                        continue;
                    }
                    var BDiffVariable = oB.Where(bc => bc.Count() > 1).Select(b => b[0] - b[2]).ToArray();
                    if (BDiffVariable == null || BDiffVariable.Count() == 0)
                    {
                        continue;
                    }

                    double SlopeTrend = Fit.Line(
                        PriceInfo.Select((s, i2) => new { i2, s }).Select(t => Convert.ToDouble(t.i2)).ToArray(),
                        PriceInfo.Select(y => Convert.ToDouble(y.Close)).ToArray()
                        ).Item2;

                    double StandarDevForPercentB = BDiffVariable.StandardDeviation();
                    if (BDiffVariable[BDiffVariable.Length - 1] < StandarDevForPercentB && SlopeTrend > 0 && Convert.ToDouble(QuoteFromInstrument.LastTradePrice.Amount) <= oB[2][oB.Count() - 1])
                    {
                        return(new TradingRecommendation(
                                   Instrument,
                                   QuoteFromInstrument.LastTradePrice,
                                   ImperaturGlobal.GetMoney(0, Instrument.CurrencyCode),
                                   DateTime.Now,
                                   DateTime.Now,
                                   TradingForecastMethod.Bollinger
                                   ));
                    }
                    if (BDiffVariable[BDiffVariable.Length - 1] > StandarDevForPercentB && SlopeTrend <0 && Convert.ToDouble(QuoteFromInstrument.LastTradePrice.Amount)> oB[2][oB.Count() - 1])
                    {
                        return(new TradingRecommendation(
                                   Instrument,
                                   ImperaturGlobal.GetMoney(0, Instrument.CurrencyCode),
                                   QuoteFromInstrument.LastTradePrice,
                                   DateTime.Now,
                                   DateTime.Now,
                                   TradingForecastMethod.Bollinger
                                   ));
                    }
                }
                catch (Exception ex)
                {
                    ImperaturGlobal.GetLog().Error(string.Format("Couldn't calculate recommendations from Bollinger bands on {0}, {1}", Instrument.Symbol, Instrument.Name), ex);
                    continue;
                }
            }
            return(new TradingRecommendation());
        }
Пример #5
0
        private TradingRecommendation GetTradingRecommendationForCrossOver()
        {
            int[] Intervals = { 50, 200 };
            TradingRecommendation Recommendation      = new TradingRecommendation();
            List <double[]>       MovingAverageObject = new List <double[]>();


            List <double> d1 = Statistics.MovingAverage(
                GetBusinessDayDataForRange(DateTime.Now, Intervals[0]).
                Select(s => Convert.ToDouble(s.Close)).ToArray(), Intervals[0]).ToList();
            List <double> d2 = Statistics.MovingAverage(
                GetBusinessDayDataForRange(DateTime.Now, Intervals[1]).
                Select(s => Convert.ToDouble(s.Close)).ToArray(), Intervals[1]).ToList();

            double[] xd = d1.ToArray();
            double[] yd = d2.Skip(d2.Count() - d1.Count()).ToArray();

            CubicSpline Curvedata = CubicSpline.InterpolateAkima(
                d1.Select((s, i2) => new { i2, s })
                .Select(t => Convert.ToDouble(t.i2)).ToArray(),
                d1);


            while (d1.Count() != d2.Count())
            {
                if (d1.Count() > d2.Count())
                {
                    d2.Insert(0, 0);
                }
                else
                {
                    d1.Insert(0, 0);
                }
            }

            double[] intersects0 = Polyfit(xd, yd, 0);


            List <Tuple <int, double> > Intersects = new List <Tuple <int, double> >();
            int i = 0;

            foreach (double di in yd)
            {
                if (di * 0.999 <= intersects0[0] && di * 1.001 >= intersects0[0])
                {
                    Intersects.Add(new Tuple <int, double>(i, di));
                }
                i++;
            }


            /*
             *
             *
             * CubicSpline Curvedata = CubicSpline.InterpolateAkima(
             * d1.Select((s, i2) => new { i2, s })
             * .Select(t => Convert.ToDouble(t.i2)).ToArray(),
             * d1);
             *
             *
             * while (d1.Count() != d2.Count())
             * {
             *  if (d1.Count() > d2.Count())
             *  {
             *      d2.Insert(0, double.NaN);
             *  }
             *  else
             *  {
             *      d1.Insert(0, double.NaN);
             *  }
             * }
             * List<Tuple<int, double>> Intersects = new List<Tuple<int, double>>();
             * int i = 0;
             * foreach (double di in d1)
             * {
             *  //need to add a little bit of gliding here as well...
             *  if (!double.IsNaN(di) && !double.IsNaN(d2[i]) && (di <= d2[i]*0.92 && di >= d2[i] * 1.07))
             *  {
             *      Intersects.Add(new Tuple<int, double>(i, di));
             *  }
             *  i++;
             * }*/
            try
            {
                int Sellmax = (Intersects.Where(x => Curvedata.Differentiate(x.Item2) < 0).Count() > 0) ? Intersects.Where(x => Curvedata.Differentiate(x.Item2) < 0).Last().Item1 : 0;
                int Buymax  = (Intersects.Where(x => Curvedata.Differentiate(x.Item2) > 0).Count() > 0) ? Intersects.Where(x => Curvedata.Differentiate(x.Item2) > 0).Last().Item1 : 0;

                if (Sellmax > Buymax && Sellmax > 0)
                {
                    return(new TradingRecommendation(
                               Instrument,
                               ImperaturGlobal.GetMoney(0, Instrument.CurrencyCode),
                               ImperaturGlobal.GetMoney(Convert.ToDecimal(Intersects.Where(x => x.Item1.Equals(Sellmax)).Last().Item2), Instrument.CurrencyCode),
                               DateTime.Now,
                               DateTime.Now,
                               TradingForecastMethod.Crossover
                               ));
                }
                if (Buymax > Sellmax && Buymax > 0)
                {
                    return(new TradingRecommendation(
                               Instrument,
                               ImperaturGlobal.GetMoney(Convert.ToDecimal(Intersects.Where(x => x.Item1.Equals(Buymax)).Last().Item2), Instrument.CurrencyCode),
                               ImperaturGlobal.GetMoney(0, Instrument.CurrencyCode),
                               DateTime.Now,
                               DateTime.Now,
                               TradingForecastMethod.Crossover
                               ));
                }
            }
            catch (Exception ex)
            {
                int gg = 0;
            }

            return(Recommendation);
        }