Пример #1
0
        private double SSTOk(int kperiod, DateTime FromDate)
        {
            TradingDay mod   = History.OrderBy(x => Math.Abs(x.TradeDate.Ticks - FromDate.Ticks)).First();
            int        index = History.IndexOf(mod);

            double High = 0;
            double Low  = 99999999;

            for (int i = 0; i < kperiod; i++)
            {
                if (History[i + index].Low < Low)
                {
                    Low = History[i + index].Low;
                }
                if (History[i + index].High > High)
                {
                    High = History[i + index].High;
                }
            }



            double K = 100 * ((History[0 + index].AdjustedClose) - Low) / (High - Low);

            return(K);
        }
Пример #2
0
        public void tawrap(int fastk, int k, int d, DateTime from, int period, out int begid, out int noblemen, out Core.RetCode b)
        {
            TradingDay mod   = History.OrderBy(x => Math.Abs(x.TradeDate.Ticks - from.Ticks)).First();
            int        index = History.IndexOf(mod);

            double[] Highs    = History.Select(x => x.High).ToArray();
            double[] Lows     = History.Select(x => x.Low).ToArray();
            double[] Close    = History.Select(x => x.ClosingPrice).ToArray();
            int      endindex = index + period;

            int begidx;
            int NBElement;

            double[]     slowk = new double[endindex];
            double[]     slowd = new double[endindex];
            Core.RetCode a     = TicTacTec.TA.Library.Core.Stoch(index, endindex, Highs, Lows, Close, fastk, k, Core.MAType.Ema, d, Core.MAType.Ema, out begidx, out NBElement, slowk, slowd);

            begid    = begidx;
            noblemen = NBElement;
            b        = a;

            Stoick = slowk.ToList();
            Stoicd = slowd.ToList();

            System.IO.StreamWriter t = new System.IO.StreamWriter(@"C:\Temp\Res.csv");


            for (int i = 0; i < endindex; i++)
            {
                string wrietline = Environment.NewLine + slowk[i] + " ," + slowd[i];
                t.Write(wrietline);
            }
        }
Пример #3
0
        public static List <TradingDay> DownloadStocksUsingString(string Ticks, DateTime From)
        {
            List <TradingDay> Market = new List <TradingDay>();
            int c = 1;

            HistQuotesDownload dl = new HistQuotesDownload();

            dl.Settings.IDs      = new string[] { Ticks };
            dl.Settings.FromDate = From;
            dl.Settings.ToDate   = DateTime.Today;
            dl.Settings.Interval = HistQuotesInterval.Daily;

            Response <HistQuotesResult> resp = dl.Download();

            foreach (HistQuotesDataChain hqc in resp.Result.Chains)
            {
                foreach (HistQuotesData hqd in hqc)
                {
                    TradingDay tempday = new TradingDay(hqc.ID, c, hqd.TradingDate.ToLocalTime(), hqd.Open, hqd.Close,
                                                        hqd.High,
                                                        hqd.Low, hqd.CloseAdjusted, hqd.PreviousClose, (int)hqd.Volume);

                    c++;
                    Market.Add(tempday);
                }
            }

            return(Market);
        }
Пример #4
0
        private double SSTOd(int dPeriod, int kPeriod, DateTime FromDate)
        {
            TradingDay mod   = History.OrderBy(x => Math.Abs(x.TradeDate.Ticks - FromDate.Ticks)).First();
            int        index = History.IndexOf(mod);
            double     Ks    = new double();

            for (int i = 0; i < dPeriod; i++)
            {
                Ks += SSTOk(kPeriod, History[i + index].TradeDate);
            }
            Ks = Ks / dPeriod;
            return(Ks);
        }
Пример #5
0
        public List <double> GetSSTO(int kperiod, int dperiod, DateTime Fromdte, bool useEMA)
        {
            List <double> result = new List <double>();
            TradingDay    mod    = History.OrderBy(x => Math.Abs(x.TradeDate.Ticks - Fromdte.Ticks)).First();
            int           index  = History.IndexOf(mod);
            double        k      = SSTOk(kperiod, History[index].TradeDate);
            double        d;

            if (useEMA)
            {
                d = SSTOdEMA(dperiod, kperiod, History[index].TradeDate);
            }
            else
            {
                d = SSTOd(dperiod, kperiod, History[index].TradeDate);
            }
            result.Add(k);
            result.Add(d);



            if (useEMA)
            {
                double Period    = Convert.ToDouble(dperiod);
                double Weight    = (2.0 / (Period + 1.0));
                double numerator = d;
                double denomn    = 1.0;

                for (int i = dperiod; i >= 1; i--)
                {
                    numerator += Math.Pow((1.0 - Weight), i) * SSTOdEMA(dperiod, kperiod, History[i + index].TradeDate);
                    denomn    += Math.Pow((1.0 - Weight), i);
                }
                double EMA = numerator / denomn;

                d = EMA;
            }
            else
            {
                for (int i = 1; i < dperiod; i++)
                {
                    d += SSTOd(dperiod, kperiod, History[index + i].TradeDate);
                }

                d = d / dperiod;
            }

            result.Add(d);

            return(result);
        }
Пример #6
0
        public double GetSMA(int period, DateTime FromDate)
        {
            double     SMA    = 0.0;
            double     Period = Convert.ToDouble(period);
            TradingDay mod    = History.OrderBy(x => Math.Abs(x.TradeDate.Ticks - FromDate.Ticks)).First();
            int        index  = History.IndexOf(mod);

            for (int i = 0; i < period; i++)
            {
                SMA += History[i + index].AdjustedClose;
            }

            SMA = SMA / Period;

            return(SMA);
        }
Пример #7
0
        public List <double> GetMACD(int LongPeriod, int ShortPeriod, int Signal, DateTime From)
        {
            List <double> result = new List <double>();
            TradingDay    mod    = History.OrderBy(x => Math.Abs(x.TradeDate.Ticks - From.Ticks)).First();
            int           index  = History.IndexOf(mod);
            double        l      = GetEMA(LongPeriod, From);
            double        s      = GetEMA(ShortPeriod, From);
            double        sig    = GetEMA(Signal, From);



            result.Add(l);
            result.Add(s);
            result.Add(sig);
            return(result);
        }
Пример #8
0
        private double SSTOdEMA(int dPeriod, int kPeriod, DateTime FromDate)
        {
            TradingDay mod    = History.OrderBy(x => Math.Abs(x.TradeDate.Ticks - FromDate.Ticks)).First();
            int        index  = History.IndexOf(mod);
            double     Period = Convert.ToDouble(dPeriod);
            double     Weight = (2.0 / (Period + 1.0));

            double numerator = SSTOk(kPeriod, History[index].TradeDate);
            double denomn    = 1.0;

            for (int i = dPeriod; i >= 1; i--)
            {
                numerator += Math.Pow((1.0 - Weight), i) * SSTOk(kPeriod, History[i + index].TradeDate);
                denomn    += Math.Pow((1.0 - Weight), i);
            }
            double EMA = numerator / denomn;

            return(EMA);
        }
Пример #9
0
        public double GetEMA(int period, DateTime FromDate)
        {
            TradingDay mod    = History.OrderBy(x => Math.Abs(x.TradeDate.Ticks - FromDate.Ticks)).First();
            int        index  = History.IndexOf(mod);
            double     Period = Convert.ToDouble(period);

            double Weight = (2.0 / (Period + 1.0));

            double numerator = History[index].AdjustedClose;
            double denomn    = 1.0;

            for (int i = period; i >= 1; i--)
            {
                numerator += Math.Pow((1.0 - Weight), i) * History[i + index].AdjustedClose;
                denomn    += Math.Pow((1.0 - Weight), i);
            }
            double EMA = numerator / denomn;

            return(EMA);
        }
Пример #10
0
        public List <Stock> InitialiseStocks(bool test)
        {
            List <Stock> Result = new List <Stock>();

            System.Data.SqlClient.SqlConnection con = new System.Data.SqlClient.SqlConnection();
            con.ConnectionString = @"Data Source=(LocalDB)\MSSQLLocalDB;
                          AttachDbFilename=C:\Users\Ben Roberts\Dropbox\WOERK.mdf;
                          Integrated Security=True;
                          Connect Timeout=30;";

            con.Open();
            DbCommand t = con.CreateCommand();

            if (test)
            {
                Result.Add(new Stock());
                Result.Add(new Stock());
                Result[0].Ticker = "CBA.AX";
                Result[1].Ticker = "BHP.AX";
            }
            else
            {
                t.Connection  = con;
                t.CommandText = "SELECT DISTINCT Ticker FROM StockHist;";

                using (DbDataReader dr = t.ExecuteReader())
                {
                    int i = 0;
                    if (dr.HasRows)
                    {
                        while (dr.Read())
                        {
                            Stock  temp = new Stock();
                            object c    = dr.GetValue(0);
                            temp.Ticker = (string)c;
                            Result.Add(temp);

                            i++;
                        }
                    }
                }
            }

            foreach (var c in Result)
            {
                c.History = new List <TradingDay>();
                string temp = "SELECT * FROM StockHist WHERE Ticker = '" + c.Ticker + "';";
                t.CommandText = temp;
                using (DbDataReader dr = t.ExecuteReader())
                {
                    int i = 0;
                    if (dr.HasRows)
                    {
                        while (dr.Read())
                        {
                            object   x         = dr.GetValue(2);
                            DateTime date      = (DateTime)dr.GetValue(2);
                            double   Opening   = (double)dr.GetValue(3);
                            double   Closing   = (double)dr.GetValue(4);
                            double   High      = (double)dr.GetValue(5);
                            double   Low       = (double)dr.GetValue(6);
                            int      Volume    = (int)dr.GetValue(7);
                            double   PrevClose = (double)dr.GetValue(9);
                            double   AdjClose  = (double)dr.GetValue(10);

                            TradingDay tempDay = new TradingDay(c.Ticker, i, date, Opening, Closing, High, Low, AdjClose,
                                                                PrevClose, Volume);
                            c.History.Add(tempDay);

                            i++;
                        }
                    }
                }
                c.SortDates();
            }
            return(Result);
        }