Пример #1
0
        /// <summary>
        ///     Converts a data period from DataPeriods type to string.
        /// </summary>
        public static string DataPeriodToString(DataPeriod dataPeriod)
        {
            switch (dataPeriod)
            {
            case DataPeriod.M1:
                return("1 " + Language.T("Minute"));

            case DataPeriod.M5:
                return("5 " + Language.T("Minutes"));

            case DataPeriod.M15:
                return("15 " + Language.T("Minutes"));

            case DataPeriod.M30:
                return("30 " + Language.T("Minutes"));

            case DataPeriod.H1:
                return("1 " + Language.T("Hour"));

            case DataPeriod.H4:
                return("4 " + Language.T("Hours"));

            case DataPeriod.D1:
                return("1 " + Language.T("Day"));

            case DataPeriod.W1:
                return("1 " + Language.T("Week"));

            default:
                return(String.Empty);
            }
        }
Пример #2
0
 public DataId(string source, string symbol, DataPeriod period)
     : this()
 {
     Source = source;
     Symbol = symbol;
     Period = period;
 }
Пример #3
0
        /// <summary>EPGデータ更新</summary>
        protected override bool ReloadInfoData()
        {
            EpgViewPeriod newPeriod = RestoreState.isDefPeriod == true ? DefPeriod.DefPeriod : RestoreState.period ?? (IsDataDefPeriod ? DefPeriod.DefPeriod : ViewPeriod);

            if (!viewData.ReloadEpgData(newPeriod, !this.IsVisible))
            {
                return(false);
            }
            ViewPeriod = DataPeriod.DeepClone();
            RefreshMoveButtonStatus();

            ReloadReserveInfoFlg = true;
            ReloadProgramViewItem();
            if (ReloadReserveInfoFlg == true)
            {
                ReloadReserveInfoFlg = !ReloadReserveInfoData();
            }
            restoreState = null;

            if (viewData.EpgTabInfo.SearchMode && Settings.Instance.NgAutoEpgLoadNW && Settings.Instance.PrebuildEpg == false &&
                ViewPeriod.End > CommonUtil.EdcbNowEpg && CommonManager.Instance.DB.ReserveList.Values.Any(r => r.IsManual))
            {
                CommonManager.MainWindow.MainProc(MainProcItem.EpgDataSearch);
            }
            return(true);
        }
Пример #4
0
        public static byte[] GetSensorData(byte[] sensorIds, DataPeriod dataPeriod)
        {
            var values = databaseCache[(byte)dataPeriod];

            Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
            StringBuilder strb = new StringBuilder($"{firstTimestampCache[(byte)dataPeriod]}|{{");
            int           j    = 0;

            foreach (var sensorId in sensorIds)
            {
                var sensor = values[sensorId];
                strb.Append($"\"{sensorId}\":{{");
                int i = 0;
                foreach (var sensorValue in sensor)
                {
                    strb.Append($"\"{sensorValue.Key}\":[{string.Join(',', sensorValue.Value)}]");
                    if (++i != sensor.Count)
                    {
                        strb.Append(',');
                    }
                }
                strb.Append('}');
                if (++j != values.Keys.Count)
                {
                    strb.Append(',');
                }
            }
            strb.Append('}');
            return(Encoding.UTF8.GetBytes(strb.ToString()));
        }
Пример #5
0
        /// <summary>
        /// Represents the strategy in a readable form.
        /// </summary>
        public override string ToString()
        {
            string str = String.Empty;
            string nl  = Environment.NewLine;
            string nl2 = Environment.NewLine + Environment.NewLine;

            str += "Strategy Name - " + strategyName + nl;
            str += "Symbol - " + Symbol + nl;
            str += "Period - " + DataPeriod.ToString() + nl;
            str += "Same dir signal - " + sameDirSignlAct.ToString() + nl;
            str += "Opposite dir signal - " + oppDirSignlAct.ToString() + nl;
            str += "Use account % entry - " + UseAccountPercentEntry + nl;
            str += "Max open lots - " + MaxOpenLots + nl;
            str += "Entry lots - " + EntryLots + nl;
            str += "Adding lots - " + AddingLots + nl;
            str += "Reducing lots - " + ReducingLots + nl;
            str += "Use Permanent S/L - " + usePermanentSL.ToString() + nl;
            str += "Permanent S/L - " + permanentSLType.ToString() + " " + permanentSL.ToString() + nl;
            str += "Use Permanent T/P - " + usePermanentTP.ToString() + nl;
            str += "Permanent T/P - " + permanentTPType.ToString() + " " + permanentTP.ToString() + nl;
            str += "Use Break Even - " + useBreakEven.ToString() + nl;
            str += "Break Even - " + breakEven.ToString() + " " + permanentTP.ToString() + nl2;
            str += "Description" + nl2 + nl;

            for (int iSlot = 0; iSlot < Slots; iSlot++)
            {
                str += Slot[iSlot].SlotType.ToString() + nl;
                str += indicatorSlot[iSlot].IndParam.ToString() + nl2;
            }

            return(str);
        }
Пример #6
0
 public DataId(string source, string symbol, DataPeriod period)
     : this()
 {
     Source = source;
     Symbol = symbol;
     Period = period;
 }
        private List <Bar> CompileBars(IEnumerable <Bar> minuteBars, DataPeriod period)
        {
            var barList        = new List <Bar>();
            var lastBarEndTime = new DateTime();

            foreach (Bar bar in minuteBars)
            {
                if (bar.Time >= lastBarEndTime)
                {
                    DateTime lastBarStartTime = GetBarStartTime(bar.Time, (int)period);
                    lastBarEndTime = lastBarStartTime.AddMinutes((int)period);
                    Bar newBar = bar;
                    newBar.Time = lastBarStartTime;
                    barList.Add(newBar);
                    continue;
                }

                Bar lastBar = barList[barList.Count - 1];

                if (lastBar.High < bar.High)
                {
                    lastBar.High = bar.High;
                }
                if (lastBar.Low > bar.Low)
                {
                    lastBar.Low = bar.Low;
                }
                lastBar.Close   = bar.Close;
                lastBar.Volume += bar.Volume;

                barList[barList.Count - 1] = lastBar;
            }

            return(barList);
        }
        /// <summary>
        ///     Saves bar data to a CSV file.
        /// </summary>
        private void SaveBars(List <Bar> barList, DataPeriod period)
        {
            var sb = new StringBuilder();

            foreach (Bar bar in barList)
            {
                sb.AppendLine(
                    String.Format("{0:D4}-{1:D2}-{2:D2}\t{3:D2}:{4:D2}\t{5}\t{6}\t{7}\t{8}\t{9}",
                                  bar.Time.Year, bar.Time.Month, bar.Time.Day, bar.Time.Hour, bar.Time.Minute, bar.Open,
                                  bar.High, bar.Low, bar.Close, bar.Volume));
            }

            string fileName = TxbSymbol.Text + (int)period + ".csv";
            string path     = Path.Combine(outFolder, fileName);

            try
            {
                var sw = new StreamWriter(path);
                sw.Write(sb.ToString());
                sw.Close();

                SetInfoText(Language.T("Saved") + " " + Data.DataPeriodToString(period) + " " + Language.T("bars") +
                            " - " + barList.Count + Environment.NewLine);
            }
            catch (Exception exc)
            {
                MessageBox.Show(exc.Message);
            }
        }
Пример #9
0
        private void InitializeDataSet(string symbol, DataPeriod period, int bars)
        {
            ResetData(bars);

            Symbol = symbol;
            Period = period;
        }
Пример #10
0
        /// <summary>
        /// Updates the chart.
        /// </summary>
        protected void UpdateChart()
        {
            if (chart == null)
                return;

            bool repaintChart = (
                chartSymbol != Data.Symbol ||
                chartPeriod != Data.Period ||
                chartBars   != Data.Bars   ||
                chartTime   != Data.Time[Data.Bars - 1] ||
                chartTime10 != Data.Time[Data.Bars - 11]);

            chartSymbol = Data.Symbol;
            chartPeriod = Data.Period;
            chartBars   = Data.Bars;
            chartTime   = Data.Time[Data.Bars - 1];
            chartTime10 = Data.Time[Data.Bars - 11];

            // Prepares chart data.
            ChartData chartData = GetChartDataObject();

            try
            {
                UpdateChartThreadSafely(repaintChart, chartData);
            }
            catch (ObjectDisposedException)
            {
            }
            catch (Exception exc)
            {
                MessageBox.Show(exc.Message, Language.T("Indicator Chart"), MessageBoxButtons.OK, MessageBoxIcon.Error);
                DisposeChart();
                CreateChart();
            }
        }
Пример #11
0
        private void StoreConfigs()
        {
            maxBarsDefault         = Configs.MaxBars;
            isCheckDataDefault     = Configs.CheckData;
            isFillDataGapsDefault  = Configs.FillInDataGaps;
            isCutBadDataDefault    = Configs.CutBadData;
            isCutSatSunDataDefault = Configs.CutSatSunData;
            isUseEndTimeDefault    = Configs.UseEndTime;
            isUseStartTimeDefault  = Configs.UseStartTime;
            isUseTickDataDefault   = Configs.UseTickData;
            isAutoscanDefault      = Configs.Autoscan;

            isAccountInCurrencyDefault    = Configs.AccountInMoney;
            accountCurrencyDefault        = Configs.AccountCurrency;
            initialAccountDefault         = Configs.InitialAccount;
            leverageDefault               = Configs.Leverage;
            isTradeUntilMarginCallDefault = Configs.TradeUntilMarginCall;
            isUseLogicalGroupsDefault     = Configs.UseLogicalGroups;

            symbolDefault          = Data.Symbol;
            periodDefault          = Data.Period;
            instrPropertiesDefault = Instruments.InstrumentList[symbolDefault].Clone();

            strategyDefault = Data.Strategy.Clone();
        }
Пример #12
0
        public IDataSet LoadDataSet(string dataSourceName, string symbol, DataPeriod period)
        {
            DataId      dataId     = new DataId(dataSourceName, symbol, period);
            IDataSource dataSource = LoadDataSource(dataId.Source);
            DataParams  dataParams = GetDataParams(dataId, UserFilesFolder, dataSource);
            IDataSet    dataSet    = LoadCsvFile(dataParams);

            dataSet.Properties = dataSource.InstrumentProperties[symbol];

            return(dataSet);
        }
Пример #13
0
        public IDataSet LoadDataSet(string dataSourceName, string symbol, DataPeriod period)
        {
            DataId dataId = new DataId(dataSourceName, symbol, period);
            IDataSource dataSource = LoadDataSource(dataId.Source);
            DataParams dataParams = GetDataParams(dataId, UserFilesFolder, dataSource);
            IDataSet dataSet = LoadCsvFile(dataParams);

            dataSet.Properties = dataSource.InstrumentProperties[symbol];

            return dataSet;
        }
Пример #14
0
        private void GenerateDataFile()
        {
            symbol          = "GBPUSD";
            instrProperties = new InstrumentProperties(symbol, InstrumetType.Forex)
            {
                Commission      = 0,
                CommissionScope = CommissionScope.deal,
                CommissionTime  = CommissionTime.openclose,
                Digits          = 5,
                LotSize         = 10000,
                RateToEUR       = 2.3456,
                RateToUSD       = 2.3456,
                Slippage        = 1,
                Spread          = 6,
                SwapLong        = 0.25,
                SwapShort       = 0.25,
                SwapUnit        = ChargeUnit.Points
            };

            int    maxBars = 2 * Configs.MaxBars;
            var    sb      = new StringBuilder(maxBars);
            var    time    = new DateTime(2000, 1, 1, 0, 0, 0);
            double open    = 1.12345;
            int    volume  = 300;

            period = DataPeriod.H4;
            for (int i = 0; i < maxBars; i++)
            {
                time = time.AddMinutes((int)DataPeriod.H1);
                int multiplier = (time.DayOfYear % 2 == 0) ? 1 : -1;
                open = open + multiplier * 0.00005;
                double high  = open + 0.00025;
                double low   = open - 0.00025;
                double close = open + 0.00005;
                volume = volume + multiplier * 5;

                sb.AppendLine(string.Format("{0} {1} {2} {3} {4} {5}",
                                            time.ToString("yyyy-MM-dd HH:mm:ss"),
                                            open.ToString("F5"),
                                            high.ToString("F5"),
                                            low.ToString("F5"),
                                            close.ToString("F5"),
                                            volume));
            }

            dataFile = sb.ToString();
        }
Пример #15
0
        //public static void MethodManipulation(REngine engine, Methods method)
        //{
        //    engine.Evaluate(String.Format("Fit <- {0}(tsValue)", method.ToString())); // Fit <- Arima(tsValue)
        //}

        public List <double> GetCorrespondingDataByPeriod(DataPeriod period, int productId)
        {
            //FFCEntities db = new FFCEntities();
            List <double> values = new List <double>();

            if (period == DataPeriod.Daily)
            {
                var list = db.sp_Forecast_GetProductCountYearDayByProductId(productId).ToList();
                values = list.Select(r => Double.Parse(r.Count.ToString())).ToList();
            }
            else if (period == DataPeriod.Day)
            {
                var list = db.sp_Forecast_GetProductCountDayByProductId(productId).ToList();
                values = list.Select(r => Double.Parse(r.Count.ToString())).ToList();
            }

            return(values);
        }
Пример #16
0
        public static List<double> GetCorrespondingData(DataPeriod data, int productId)
        {
            FFCEntities db = new FFCEntities();
            List<double> values = new List<double>();

            if (data == DataPeriod.Daily)
            {
                var list = db.sp_Forecast_GetProductCountYearDayByProductId(productId).ToList();
                values = list.Select(r => Double.Parse(r.Count.ToString())).ToList();
            }
            else if (data == DataPeriod.Day)
            {
                var list = db.sp_Forecast_GetProductCountDayByProductId(productId).ToList();
                values = list.Select(r => Double.Parse(r.Count.ToString())).ToList();
            }

            return values;
        }
Пример #17
0
        public static void Test()
        {
            int        productId = 1;
            Methods    method    = Methods.rwf; //meanf(YYMMDD,MMDD,MMWWDD,DD), rtw, rtw(with Drift), Moving AVG,ets, Arima, HoltWinters, msts
            DataPeriod dataType  = DataPeriod.Daily;
            int        periods   = 50;

            var values = GetCorrespondingData(dataType, productId);

            //FFCEntities db = new FFCEntities();
            //var list = db.sp_Forecast_GetProductCountYearDayByProductId(productId).ToList();
            //List<double> values = list.Select(r => Double.Parse(r.Count.ToString())).ToList();

            REngine.SetEnvironmentVariables();

            // There are several options to initialize the engine, but by default the following suffice:
            REngine engine = REngine.GetInstance();

            // .NET Framework array to R vector.
            //NumericVector testTs = engine.CreateNumericVector(new double[] { 30.02, 29.99, 30.11, 29.97, 30.01, 29.99, 1000 });
            //NumericVector testTs = engine.CreateNumericVector(new double[] { 6, 5, 6, 5, 6, 5 });
            NumericVector testTs = engine.CreateNumericVector(values);

            engine.SetSymbol("testTs", testTs);

            //auto arima for monthly
            engine.Evaluate("tsValue <- ts(testTs, frequency=1, start=c(2010, 1, 1))");
            engine.Evaluate("library(forecast)");
            //engine.Evaluate(String.Format("Fit <- {0}(tsValue)", method)); // Fit <- Arima(tsValue)
            MethodManipulation(engine, method);
            engine.Evaluate(String.Format("fcast <- forecast(Fit, h={0})", periods));

            Plot(engine);

            //var a = engine.Evaluate("fcast <- forecast(tsValue, h=5)").AsCharacter();
            NumericVector forecasts = engine.Evaluate("fcast$mean").AsNumeric();

            foreach (var item in forecasts)
            {
                Console.WriteLine(item);
            }

            engine.Dispose();
        }
Пример #18
0
        protected EpgViewPeriod SearchJumpPeriod(DateTime time)
        {
            if (DataPeriod.Contains(time) == true)
            {
                return(DataPeriod);
            }
            if (DefPeriod.DefPeriod.Contains(time) == true)
            {
                return(DefPeriod.DefPeriod);
            }

            //見つからない場合はそのまま
            if (CommonManager.Instance.DB.IsEventTimePossible(time) == false)
            {
                return(DataPeriod);
            }

            return(new EpgViewPeriod(time - TimeSpan.FromDays(this.EpgStyle().EpgArcStartSunday ? (int)time.DayOfWeek : 0), DefPeriod.InitDays));
        }
Пример #19
0
        /// <summary>
        ///     Loads the data file
        /// </summary>
        /// <returns>0 - success</returns>
        public int LoadResourceData(string data, DataPeriod period)
        {
            var dataParser = new DataParser();
            int respond    = -1;
            int parsedBars = dataParser.Parse(data, (int)period);

            if (parsedBars > 0)
            {
                aBar = dataParser.Bar.ToArray();
                Bars = parsedBars;
                RefineData();
                DataHorizon();
                CheckMarketData();
                SetDataStats();
                Update  = aBar[Bars - 1].Time.AddMinutes((int)period);
                respond = 0;
            }

            return(respond);
        }
Пример #20
0
        static void AddToCacheArray(SensorData sensorData, int count, DataPeriod dataPeriod, int skipEvery)
        {
            if (firstTimestampCache[(byte)dataPeriod] == 0)
            {
                return;
            }

            if (dataPeriod != DataPeriod.AllData)
            {
                int removeCount = (sensorData.Timestamp - firstTimestampCache[(byte)dataPeriod] - count * skipEvery) / skipEvery;
                firstTimestampCache[(byte)dataPeriod] += removeCount * skipEvery;

                foreach (var sensor in databaseCache[(byte)dataPeriod].Values)
                {
                    foreach (var sensorValue in sensor)
                    {
                        if (sensorValue.Value.Count > removeCount)
                        {
                            sensorValue.Value.RemoveRange(0, removeCount);
                        }
                        else
                        {
                            sensor.Remove(sensorValue.Key);
                        }
                    }
                }
            }

            foreach (var sensor in sensorData.Sensors)
            {
                var list = databaseCache[(byte)dataPeriod].GetValueCreateNew(sensor.id).GetValueCreateNew((byte)sensor.type);
                if (dataPeriod == DataPeriod.AllData)
                {
                    list.Add(sensor.value);
                }
                else
                {
                    list.IndexCreateNew(count - 1, sensor.value);
                }
            }
        }
Пример #21
0
        /// <summary>
        /// Updates the chart.
        /// </summary>
        protected void UpdateChart()
        {
            if (chart == null)
            {
                return;
            }

            bool repaintChart = (
                chartSymbol != Data.Symbol ||
                chartPeriod != Data.Period ||
                chartBars != Data.Bars ||
                chartTime != Data.Time[Data.Bars - 1] ||
                chartTime10 != Data.Time[Data.Bars - 11]);

            chartSymbol = Data.Symbol;
            chartPeriod = Data.Period;
            chartBars   = Data.Bars;
            chartTime   = Data.Time[Data.Bars - 1];
            chartTime10 = Data.Time[Data.Bars - 11];

            // Prepares chart data.
            ChartData chartData = GetChartDataObject();

            try
            {
                UpdateChartThreadSafely(repaintChart, chartData);
            }
            catch (ObjectDisposedException)
            {
            }
            catch (Exception exc)
            {
                MessageBox.Show(exc.Message, Language.T("Indicator Chart"), MessageBoxButtons.OK, MessageBoxIcon.Error);
                DisposeChart();
                CreateChart();
            }
        }
Пример #22
0
        public async Task OnGetAsync()
        {
            //SetDefaultTimePeriod
            DataPeriod = DataPeriod.Week;
            SetDefaultTimePeriod();

            //Search for user salary the last 7 days
            var result = await _userDataService.GetSalaryForUserPagedAsync(
                HttpContext.SubjectId(),
                FromDate,
                ToDate);

            //Sort data labels
            if (result != null)
            {
                SortBarDataSet(result, FromDate, ToDate);
                SortPieDataSet(result);
            }



            WorkHourList = result;
            PayList      = result;
        }
Пример #23
0
        /// <summary>
        ///     LoadInstrument
        /// </summary>
        private void LoadInstrument()
        {
            const string     symbol     = "EURUSD";
            const DataPeriod dataPeriod = DataPeriod.D1;

            var instrProperties  = new InstrumentProperties(symbol);
            var instrument       = new Instrument(instrProperties, (int)dataPeriod);
            int loadResourceData = instrument.LoadResourceData();

            if (instrument.Bars <= 0 || loadResourceData != 0)
            {
                return;
            }

            Data.InstrProperties = instrProperties.Clone();
            Data.Bars            = instrument.Bars;
            Data.Period          = dataPeriod;
            Data.Time            = new DateTime[Data.Bars];
            Data.Open            = new double[Data.Bars];
            Data.High            = new double[Data.Bars];
            Data.Low             = new double[Data.Bars];
            Data.Close           = new double[Data.Bars];
            Data.Volume          = new int[Data.Bars];

            for (int bar = 0; bar < Data.Bars; bar++)
            {
                Data.Open[bar]   = instrument.Open(bar);
                Data.High[bar]   = instrument.High(bar);
                Data.Low[bar]    = instrument.Low(bar);
                Data.Close[bar]  = instrument.Close(bar);
                Data.Time[bar]   = instrument.Time(bar);
                Data.Volume[bar] = instrument.Volume(bar);
            }

            Data.IsData = true;
        }
        // TODO: Refine this together with TaskExecutor class. Maybe this is more like a task class.
        public TaskContext(
            string id,
            int taskIndex,
            string jobId,
            FilterScope filterScope,
            DataPeriod dataPeriod,
            DateTimeOffset since,
            IList <TypeFilter> typeFilters,
            IList <PatientWrapper> patients             = null,
            SearchProgress searchProgress               = null,
            Dictionary <string, int> outputFileIndexMap = null,
            Dictionary <string, int> searchCount        = null,
            Dictionary <string, int> processedCount     = null,
            Dictionary <string, int> skippedCount       = null,
            bool isCompleted = false)
        {
            // immutable fields
            Id          = id;
            TaskIndex   = taskIndex;
            JobId       = jobId;
            FilterScope = filterScope;
            DataPeriod  = dataPeriod;
            Since       = since;
            TypeFilters = typeFilters;
            Patients    = patients;

            // fields to record progress
            SearchProgress     = searchProgress ?? new SearchProgress();
            OutputFileIndexMap = outputFileIndexMap ?? new Dictionary <string, int>();
            IsCompleted        = isCompleted;

            // statistical fields
            SearchCount    = searchCount ?? new Dictionary <string, int>();
            ProcessedCount = processedCount ?? new Dictionary <string, int>();
            SkippedCount   = skippedCount ?? new Dictionary <string, int>();
        }
        /// <summary>
        ///     Check if the incoming data is from the same chart.
        /// </summary>
        private bool IsChartChangeged(string symbol, DataPeriod period)
        {
            if (!Data.IsConnected)
                return true;

            if (Data.Symbol != symbol || Data.Period != period)
                return true;

            return false;
        }
Пример #26
0
 public DataSet(string symbol, DataPeriod period, int bars)
 {
     InitializeDataSet(symbol, period, bars);
 }
Пример #27
0
        private void InitializeDataSet(string symbol, DataPeriod period, int bars)
        {
            ResetData(bars);

            Symbol = symbol;
            Period = period;
        }
Пример #28
0
 public DataId(string symbol, DataPeriod period)
     : this()
 {
     Symbol = symbol;
     Period = period;
 }
Пример #29
0
 /// <summary>
 ///     Converts a data period from DataPeriods type to string.
 /// </summary>
 public static string DataPeriodToString(DataPeriod dataPeriod)
 {
     switch (dataPeriod)
     {
         case DataPeriod.M1:
             return "1 " + Language.T("Minute");
         case DataPeriod.M5:
             return "5 " + Language.T("Minutes");
         case DataPeriod.M15:
             return "15 " + Language.T("Minutes");
         case DataPeriod.M30:
             return "30 " + Language.T("Minutes");
         case DataPeriod.H1:
             return "1 " + Language.T("Hour");
         case DataPeriod.H4:
             return "4 " + Language.T("Hours");
         case DataPeriod.D1:
             return "1 " + Language.T("Day");
         case DataPeriod.W1:
             return "1 " + Language.T("Week");
         default:
             return String.Empty;
     }
 }
        protected override void TsbtTradingClick(object sender, EventArgs e)
        {
            if (isTrading)
            {
                StopTrade();

                symbolReconnect = "";
                periodReconnect = DataPeriod.W1;
                accountReconnect = 0;
            }
            else
            {
                StartTrade();
            }
        }
        private List<Bar> CompileBars(IEnumerable<Bar> minList, DataPeriod period)
        {
            var barList = new List<Bar>();
            var lastBarEndTime = new DateTime();
            foreach (Bar bar in minList)
            {
                if (bar.Time >= lastBarEndTime)
                {
                    DateTime lastBarStartTime = GetBarStartTime(bar.Time, (int) period);
                    lastBarEndTime = lastBarStartTime.AddMinutes((int) period);
                    Bar newBar = bar;
                    newBar.Time = lastBarStartTime;
                    barList.Add(newBar);
                    continue;
                }

                Bar lastBar = barList[barList.Count - 1];

                if (lastBar.High < bar.High)
                    lastBar.High = bar.High;
                if (lastBar.Low > bar.Low)
                    lastBar.Low = bar.Low;
                lastBar.Close = bar.Close;
                lastBar.Volume += bar.Volume;

                barList[barList.Count - 1] = lastBar;
            }

            return barList;
        }
        /// <summary>
        ///     Loads the data file
        /// </summary>
        /// <returns>0 - success</returns>
        public int LoadResourceData(string data, DataPeriod period)
        {
            var dataParser = new DataParser();
            int respond = -1;
            int parsedBars = dataParser.Parse(data, (int) period);

            if (parsedBars > 0)
            {
                aBar = dataParser.Bar.ToArray();
                Bars = parsedBars;
                RefineData();
                DataHorizon();
                CheckMarketData();
                SetDataStats();
                Update = aBar[Bars - 1].Time.AddMinutes((int) period);
                respond = 0;
            }

            return respond;
        }
Пример #33
0
 public DataId(string symbol, DataPeriod period)
     : this()
 {
     Symbol = symbol;
     Period = period;
 }
        /// <summary>
        ///     Sets the market according to the strategy
        /// </summary>
        private void SetMarket(string symbol, DataPeriod dataPeriod)
        {
            Data.InstrProperties = Instruments.InstrumentList[symbol].Clone();
            Data.Period = dataPeriod;

            IsDiscardSelectedIndexChange = true;
            ComboBoxSymbol.SelectedIndex = ComboBoxSymbol.Items.IndexOf(symbol);

            switch (dataPeriod)
            {
                case DataPeriod.M1:
                    ComboBoxPeriod.SelectedIndex = 0;
                    break;
                case DataPeriod.M5:
                    ComboBoxPeriod.SelectedIndex = 1;
                    break;
                case DataPeriod.M15:
                    ComboBoxPeriod.SelectedIndex = 2;
                    break;
                case DataPeriod.M30:
                    ComboBoxPeriod.SelectedIndex = 3;
                    break;
                case DataPeriod.H1:
                    ComboBoxPeriod.SelectedIndex = 4;
                    break;
                case DataPeriod.H4:
                    ComboBoxPeriod.SelectedIndex = 5;
                    break;
                case DataPeriod.D1:
                    ComboBoxPeriod.SelectedIndex = 6;
                    break;
                case DataPeriod.W1:
                    ComboBoxPeriod.SelectedIndex = 7;
                    break;
            }

            IsDiscardSelectedIndexChange = false;
        }
Пример #35
0
        /// <summary>
        ///     Loads the Intrabar data.
        /// </summary>
        private int LoadIntrabarData(DataPeriod period)
        {
            var instrument = new Instrument(Data.InstrProperties.Clone(), (int) period)
                {
                    DataDir = Data.OfflineDataDir,
                    MaxBars = Configs.MaxIntraBars
                };

            // Loads the data
            int loadingResult = instrument.LoadData();
            int loadedIntrabars = instrument.Bars;

            if (loadingResult == 0 && loadedIntrabars > 0)
            {
                if (Data.Period != DataPeriod.W1)
                {
                    if (instrument.DaysOff > 5)
                        warningMessage += Environment.NewLine + Language.T("Data for:") + " " + Data.Symbol + " " +
                                          Data.DataPeriodToString(period) + " - " + Language.T("Maximum days off:") +
                                          " " + instrument.DaysOff;
                    if (Data.Update - instrument.Update > new TimeSpan(24, 0, 0))
                        warningMessage += Environment.NewLine + Language.T("Data for:") + " " + Data.Symbol + " " +
                                          Data.DataPeriodToString(period) + " - " + Language.T("Updated on:") + " " +
                                          instrument.Update.ToString(CultureInfo.InvariantCulture);
                }

                int startBigBar;
                for (startBigBar = 0; startBigBar < Data.Bars; startBigBar++)
                    if (Data.Time[startBigBar] >= instrument.Time(0))
                        break;

                int stopBigBar;
                for (stopBigBar = startBigBar; stopBigBar < Data.Bars; stopBigBar++)
                    if (Data.IntraBarsPeriods[stopBigBar] != Data.Period)
                        break;

                // Seek for a place to put the intrabars.
                int lastIntraBar = 0;
                for (int bar = startBigBar; bar < stopBigBar; bar++)
                {
                    Data.IntraBarData[bar] = new Bar[(int) Data.Period/(int) period];
                    DateTime endTime = Data.Time[bar] + new TimeSpan(0, (int) Data.Period, 0);
                    int indexBar = 0;
                    for (int intrabar = lastIntraBar;
                         intrabar < loadedIntrabars && instrument.Time(intrabar) < endTime;
                         intrabar++)
                    {
                        if (instrument.Time(intrabar) >= Data.Time[bar])
                        {
                            Data.IntraBarData[bar][indexBar].Time = instrument.Time(intrabar);
                            Data.IntraBarData[bar][indexBar].Open = instrument.Open(intrabar);
                            Data.IntraBarData[bar][indexBar].High = instrument.High(intrabar);
                            Data.IntraBarData[bar][indexBar].Low = instrument.Low(intrabar);
                            Data.IntraBarData[bar][indexBar].Close = instrument.Close(intrabar);
                            Data.IntraBarsPeriods[bar] = period;
                            Data.IntraBarBars[bar]++;
                            indexBar++;
                            lastIntraBar = intrabar;
                        }
                    }
                }
            }

            return loadedIntrabars;
        }
Пример #36
0
 public virtual void SetViewData(EpgViewData data)
 {
     viewData   = data;
     ViewPeriod = DataPeriod.DeepClone();;
 }
Пример #37
0
        public static void FillCacheArray(byte[] sensorIds, DataPeriod dataPeriod)
        {
            try {
                ConnectToDb();
                using (sql) {
                    int firstTimestamp = int.MaxValue, skipEvery = 1;

                    switch (dataPeriod)
                    {
                    case DataPeriod.LastMinute:
                        firstTimestamp = (int)((DateTimeOffset)(DateTime.Now - TimeSpan.FromMinutes(1)))
                                         .ToUnixTimeSeconds();
                        break;

                    case DataPeriod.LastHour:
                        skipEvery      = 60;
                        firstTimestamp =
                            (int)((DateTimeOffset)(DateTime.Now - TimeSpan.FromHours(1))
                                  .Floor(TimeSpan.FromMinutes(1))).ToUnixTimeSeconds();
                        break;

                    case DataPeriod.LastDay:
                        skipEvery      = 300;
                        firstTimestamp =
                            (int)((DateTimeOffset)(DateTime.Now - TimeSpan.FromDays(1))
                                  .Floor(TimeSpan.FromMinutes(5))).ToUnixTimeSeconds();
                        break;

                    case DataPeriod.LastWeek:
                        skipEvery      = 1800;
                        firstTimestamp =
                            (int)((DateTimeOffset)(DateTime.Now - TimeSpan.FromDays(7))
                                  .Floor(TimeSpan.FromMinutes(30))).ToUnixTimeSeconds();
                        break;

                    case DataPeriod.AllData:
                        skipEvery = 3600;
                        var command = sql.CreateCommand();

                        foreach (var sensorId in sensorIds)
                        {
                            command.CommandText = $"SELECT Timestamp FROM S{sensorId} LIMIT 1";
                            using var reader    = command.ExecuteReader();
                            while (reader.Read())
                            {
                                int timestamp = reader.GetInt32(0);
                                if (timestamp < firstTimestamp)
                                {
                                    firstTimestamp = timestamp;
                                }
                            }
                        }

                        firstTimestamp = (int)((DateTimeOffset)SensorData.UnixTimeToDateTime(firstTimestamp)
                                               .Round(TimeSpan.FromHours(1))).ToUnixTimeSeconds();
                        break;
                    }

                    databaseCache[(byte)dataPeriod] = new Dictionary <byte, Dictionary <byte, List <float> > >();

                    for (byte i = 0; i < sensorIds.Length; ++i)
                    {
                        var command = sql.CreateCommand();
                        command.CommandText = $"SELECT * FROM S{sensorIds[i]}";

                        switch (dataPeriod)
                        {
                        case DataPeriod.LastMinute:
                            command.CommandText += " WHERE Timestamp >= $startTime";
                            break;

                        case DataPeriod.LastHour:
                        case DataPeriod.LastDay:
                        case DataPeriod.LastWeek:
                            command.CommandText +=
                                $" WHERE Timestamp >= $startTime AND Timestamp % {skipEvery} = 0";
                            break;

                        case DataPeriod.AllData:
                            command.CommandText += " WHERE Timestamp % 3600 = 0";
                            break;
                        }

                        if (dataPeriod != DataPeriod.AllData)
                        {
                            command.Parameters.AddWithValue("$startTime", firstTimestamp);
                        }

                        try { databaseCache[(byte)dataPeriod].Add(sensorIds[i], new Dictionary <byte, List <float> >()); } catch { }

                        Dictionary <byte, int> times = new Dictionary <byte, int>();
                        using (var reader = command.ExecuteReader()) {
                            while (reader.Read())
                            {
                                int  t          = reader.GetInt32(0);
                                byte sensorType = reader.GetByte(1);
                                if (!times.ContainsKey(sensorType))
                                {
                                    times[sensorType] = firstTimestamp;
                                }
                                times[sensorType] += skipEvery;
                                for (; times[sensorType] < t; times[sensorType] += skipEvery)
                                {
                                    databaseCache[(byte)dataPeriod][sensorIds[i]].GetValueCreateNew(sensorType).Add(0);
                                }
                                databaseCache[(byte)dataPeriod][sensorIds[i]].GetValueCreateNew(sensorType).Add(reader.GetFloat(2));
                            }
                        }
                    }
                    firstTimestampCache[(byte)dataPeriod] = firstTimestamp;
                }
            } finally {
                CloseDb();
            }
        }
Пример #38
0
        //public List<sp_Forecast_GetDailyAvereageProductTransactions_Result> GetDailyAvereageProductTransactions()
        //{
        //    var result = db.sp_Forecast_GetDailyAvereageProductTransactions();
        //    return result.ToList();
        //}

        //public List<sp_Forecast_GetDailyTimeSpecificAvereageProductTransactions_Result> GetDailyTimeSpecificAvereageProductTransactions()
        //{
        //    var result = db.sp_Forecast_GetDailyTimeSpecificAvereageProductTransactions();
        //    return result.ToList();
        //}

        //public List<sp_Forecast_GetWeeklyAverageTransactions_Result> GetWeeklyAverageTransactions()
        //{
        //    var result = db.sp_Forecast_GetWeeklyAverageTransactions();
        //    return result.ToList();
        //}

        //public List<sp_Forecast_GetWeeklyAvereageProductTransactions_Result> GetWeeklyAvereageProductTransactions()
        //{
        //    var result = db.sp_Forecast_GetWeeklyAvereageProductTransactions();
        //    return result.ToList();
        //}

        //public List<sp_Forecast_GetProductCountYearDayByProductId_Result> GetProductCountYearDayByProductId(int productId)
        //{
        //    var result = db.sp_Forecast_GetProductCountYearDayByProductId(productId);
        //    return result.ToList();
        //}

        //public List<sp_Forecast_GetProductCountMonthDayByProductId_Result> GetProductCountMonthDayByProductId(int productId)
        //{
        //    var result = db.sp_Forecast_GetProductCountMonthDayByProductId(productId);
        //    return result.ToList();
        //}

        //public List<sp_Forecast_GetProductCountDayByProductId_Result> GetProductCountDayByProductId(int productId)
        //{
        //    var result = db.sp_Forecast_GetProductCountDayByProductId(productId);
        //    return result.ToList();
        //}
        #endregion

        #region R_Related

        public ForecastResult ForecastByMethod(int branchId, int productId, string method, string dataType, int periods)
        {
            ForecastResult forecastResult = new ForecastResult();

            //Methods method1 = (Methods)Enum.Parse(typeof(Methods), method, true);
            DataPeriod datatype1 = (DataPeriod)Enum.Parse(typeof(DataPeriod), dataType, true);

            //int productId = 1;
            //Methods method = Methods.rwf; //meanf(YYMMDD,MMDD,MMWWDD,DD), rtw, rtw(with Drift), Moving AVG,ets, Arima, HoltWinters, msts
            //DataPeriod dataType = DataPeriod.Daily;
            //int periods = 50;

            var values = GetCorrespondingDataByPeriod(datatype1, productId);

            //FFCEntities db = new FFCEntities();
            //var list = db.sp_Forecast_GetProductCountYearDayByProductId(productId).ToList();
            //List<double> values = list.Select(r => Double.Parse(r.Count.ToString())).ToList();
            //REngine.SetEnvironmentVariables(@"C:\Program Files\R\R-2.13.1\bin\i386");

            //SetupPath();
            //Log();

            REngine.SetEnvironmentVariables();

            // There are several options to initialize the engine, but by default the following suffice:
            REngine engine = REngine.GetInstance();

            //engine.Initialize();

            // .NET Framework array to R vector.
            //NumericVector testTs = engine.CreateNumericVector(new double[] { 30.02, 29.99, 30.11, 29.97, 30.01, 29.99, 1000 });
            //NumericVector testTs = engine.CreateNumericVector(new double[] { 10, 20, 30, 40, 50 });
            NumericVector data = engine.CreateNumericVector(values);

            engine.SetSymbol("data", data);
            //auto arima for monthly
            engine.Evaluate("tsValue <- ts(data, frequency=160, start=c(2013.5))");
            engine.Evaluate("library(forecast)");
            engine.Evaluate(String.Format("Fit <- {0}(tsValue)", method.ToString())); // Fit <- Arima(tsValue)
            //MethodManipulation(engine, method);
            engine.Evaluate(String.Format("fcast <- forecast(Fit, h={0})", periods));

            string image = PlotForecast(engine, method.ToString());

            //var a = engine.Evaluate("fcast <- forecast(tsValue, h=5)").AsCharacter();
            NumericVector forecasts = engine.Evaluate("fcast$mean").AsNumeric();

            //NumericVector forecasts = engine.Evaluate("fcast$lower[,2]").AsNumeric();

            forecastResult.BranchId       = branchId;
            forecastResult.ProductId      = productId;
            forecastResult.Method         = db.Forecast_Methods.Where(r => r.ForecastIdentifier == method).Select(a => a.ForecastMethod).FirstOrDefault();
            forecastResult.DatePeriod     = datatype1.ToString();
            forecastResult.ForecastPeriod = periods;
            forecastResult.Values         = forecasts.ToList();
            forecastResult.ImagePath      = "~/Content/Images/" + image;

            //foreach (var item in forecasts)
            //{
            //    Console.WriteLine(item);
            //}

            //engine.Dispose();

            return(forecastResult);
        }
Пример #39
0
        /// <summary>
        /// Serialize to a JSON object
        /// </summary>
        public new void SerializeJson(Utf8JsonWriter writer, JsonSerializerOptions options, bool includeStartObject = true)
        {
            if (includeStartObject)
            {
                writer.WriteStartObject();
            }

            ((Fhir.R4.Models.BackboneElement) this).SerializeJson(writer, options, false);

            if (!string.IsNullOrEmpty(Type))
            {
                writer.WriteString("type", (string)Type !);
            }

            if (_Type != null)
            {
                writer.WritePropertyName("_type");
                _Type.SerializeJson(writer, options);
            }

            if (Period != null)
            {
                writer.WritePropertyName("period");
                Period.SerializeJson(writer, options);
            }

            if ((Actor != null) && (Actor.Count != 0))
            {
                writer.WritePropertyName("actor");
                writer.WriteStartArray();

                foreach (ConsentProvisionActor valActor in Actor)
                {
                    valActor.SerializeJson(writer, options, true);
                }

                writer.WriteEndArray();
            }

            if ((Action != null) && (Action.Count != 0))
            {
                writer.WritePropertyName("action");
                writer.WriteStartArray();

                foreach (CodeableConcept valAction in Action)
                {
                    valAction.SerializeJson(writer, options, true);
                }

                writer.WriteEndArray();
            }

            if ((SecurityLabel != null) && (SecurityLabel.Count != 0))
            {
                writer.WritePropertyName("securityLabel");
                writer.WriteStartArray();

                foreach (Coding valSecurityLabel in SecurityLabel)
                {
                    valSecurityLabel.SerializeJson(writer, options, true);
                }

                writer.WriteEndArray();
            }

            if ((Purpose != null) && (Purpose.Count != 0))
            {
                writer.WritePropertyName("purpose");
                writer.WriteStartArray();

                foreach (Coding valPurpose in Purpose)
                {
                    valPurpose.SerializeJson(writer, options, true);
                }

                writer.WriteEndArray();
            }

            if ((Class != null) && (Class.Count != 0))
            {
                writer.WritePropertyName("class");
                writer.WriteStartArray();

                foreach (Coding valClass in Class)
                {
                    valClass.SerializeJson(writer, options, true);
                }

                writer.WriteEndArray();
            }

            if ((Code != null) && (Code.Count != 0))
            {
                writer.WritePropertyName("code");
                writer.WriteStartArray();

                foreach (CodeableConcept valCode in Code)
                {
                    valCode.SerializeJson(writer, options, true);
                }

                writer.WriteEndArray();
            }

            if (DataPeriod != null)
            {
                writer.WritePropertyName("dataPeriod");
                DataPeriod.SerializeJson(writer, options);
            }

            if ((Data != null) && (Data.Count != 0))
            {
                writer.WritePropertyName("data");
                writer.WriteStartArray();

                foreach (ConsentProvisionData valData in Data)
                {
                    valData.SerializeJson(writer, options, true);
                }

                writer.WriteEndArray();
            }

            if ((Provision != null) && (Provision.Count != 0))
            {
                writer.WritePropertyName("provision");
                writer.WriteStartArray();

                foreach (ConsentProvision valProvision in Provision)
                {
                    valProvision.SerializeJson(writer, options, true);
                }

                writer.WriteEndArray();
            }

            if (includeStartObject)
            {
                writer.WriteEndObject();
            }
        }
        /// <summary>
        ///     Sets the instrument's properties after connecting;
        /// </summary>
        private bool UpdateDataFeedInfo(DateTime time, string symbol, DataPeriod period)
        {
            lock (lockerDataFeed)
            {
                Data.ResetBidAskClose();
                Data.ResetAccountStats();
                Data.ResetPositionStats();
                Data.ResetBarStats();
                Data.ResetTicks();

                // Reads market info from the chart
                MT4Bridge.MarketInfo marketInfo = bridge.GetMarketInfoAll(symbol);
                if (marketInfo == null)
                {
                    if (JournalShowSystemMessages)
                    {
                        var jmsgsys = new JournalMessage(JournalIcons.System, DateTime.Now,
                                                         symbol + " " + (PeriodType) (int) period + " " +
                                                         Language.T("Cannot update market info."));
                        AppendJournalMessage(jmsgsys);
                        Log(jmsgsys.Message);
                    }
                    return false;
                }

                // Sets instrument properties
                Data.Period = period;
                Data.InstrProperties.Symbol = symbol;
                Data.InstrProperties.LotSize = (int) marketInfo.ModeLotSize;
                Data.InstrProperties.MinLot = marketInfo.ModeMinLot;
                Data.InstrProperties.MaxLot = marketInfo.ModeMaxLot;
                Data.InstrProperties.LotStep = marketInfo.ModeLotStep;
                Data.InstrProperties.Digits = (int) marketInfo.ModeDigits;
                Data.InstrProperties.Spread = marketInfo.ModeSpread;
                Data.InstrProperties.SwapLong = marketInfo.ModeSwapLong;
                Data.InstrProperties.SwapShort = marketInfo.ModeSwapShort;
                Data.InstrProperties.TickValue = marketInfo.ModeTickValue;
                Data.InstrProperties.StopLevel = marketInfo.ModeStopLevel;
                Data.InstrProperties.MarginRequired = marketInfo.ModeMarginRequired;

                SetNumUpDownLots(marketInfo.ModeMinLot, marketInfo.ModeLotStep, marketInfo.ModeMaxLot);

                // Sets Market Info
                var values = new[]
                    {
                        symbol,
                        Data.DataPeriodToString(period),
                        marketInfo.ModeLotSize.ToString(CultureInfo.InvariantCulture),
                        marketInfo.ModePoint.ToString("F" + marketInfo.ModeDigits.ToString(CultureInfo.InvariantCulture))
                        ,
                        marketInfo.ModeSpread.ToString(CultureInfo.InvariantCulture),
                        marketInfo.ModeSwapLong.ToString(CultureInfo.InvariantCulture),
                        marketInfo.ModeSwapShort.ToString(CultureInfo.InvariantCulture)
                    };
                UpdateStatusPageMarketInfo(values);

                Bars bars = bridge.GetBars(symbol, (PeriodType) (int) period);
                if (bars == null)
                {
                    if (JournalShowSystemMessages)
                    {
                        Data.SoundError.Play();
                        var jmsgsys = new JournalMessage(JournalIcons.System, DateTime.Now,
                                                         symbol + " " + (PeriodType) (int) period + " " +
                                                         Language.T("Cannot receive bars!"));
                        AppendJournalMessage(jmsgsys);
                        Log(jmsgsys.Message);
                    }
                    return false;
                }
                if (bars.Count < MaxBarsCount((int) period))
                {
                    if (JournalShowSystemMessages)
                    {
                        Data.SoundError.Play();
                        var jmsgsys = new JournalMessage(JournalIcons.Error, DateTime.Now,
                                                         symbol + " " + (PeriodType) (int) period + " " +
                                                         Language.T("Cannot receive enough bars!"));
                        AppendJournalMessage(jmsgsys);
                        Log(jmsgsys.Message);
                    }
                    return false;
                }
                if (JournalShowSystemMessages)
                {
                    var jmsgsys = new JournalMessage(JournalIcons.System, DateTime.Now,
                                                     symbol + " " + (PeriodType) (int) period + " " +
                                                     Language.T("Market data updated, bars downloaded."));
                    AppendJournalMessage(jmsgsys);
                    Log(jmsgsys.Message);
                }

                // Account Information.
                AccountInfo account = bridge.GetAccountInfo();
                if (account == null)
                {
                    if (JournalShowSystemMessages)
                    {
                        Data.SoundError.Play();
                        var jmsgsys = new JournalMessage(JournalIcons.Error, DateTime.Now,
                                                         symbol + " " + (PeriodType) (int) period + " " +
                                                         Language.T("Cannot receive account information!"));
                        AppendJournalMessage(jmsgsys);
                        Log(jmsgsys.Message);
                    }
                    return false;
                }
                if (JournalShowSystemMessages)
                {
                    var jmsgsys = new JournalMessage(JournalIcons.System, DateTime.Now,
                                                     symbol + " " + (PeriodType) (int) period + " " +
                                                     Language.T("Account information received."));
                    AppendJournalMessage(jmsgsys);
                    Log(jmsgsys.Message);
                }
                Data.AccountName = account.Name;
                Data.IsDemoAccount = account.IsDemo;
                Data.AccountCurrency = account.Currency;
                Data.SetCurrentAccount(time, account.Balance, account.Equity, account.Profit, account.FreeMargin);
                UpdateBalanceChart(Data.BalanceData, Data.BalanceDataPoints);

                SetTradeStrip();
                SetLblSymbolText(symbol);
            }

            return true;
        }
        /// <summary>
        ///     Saves bar data to a CSV file.
        /// </summary>
        private void SaveBars(List<Bar> barList, DataPeriod period)
        {
            var sb = new StringBuilder();
            foreach (Bar bar in barList)
                sb.AppendLine(
                    String.Format("{0:D4}-{1:D2}-{2:D2}\t{3:D2}:{4:D2}\t{5}\t{6}\t{7}\t{8}\t{9}",
                                  bar.Time.Year, bar.Time.Month, bar.Time.Day, bar.Time.Hour, bar.Time.Minute, bar.Open,
                                  bar.High, bar.Low, bar.Close, bar.Volume));

            string fileName = symbol + (int) period + ".csv";
            string path = Path.Combine(outFolder, fileName);

            try
            {
                var sw = new StreamWriter(path);
                sw.Write(sb.ToString());
                sw.Close();

                SetInfoText(Language.T("Saved") + " " + Data.DataPeriodToString(period) + " " + Language.T("bars") +
                            " - " + barList.Count + Environment.NewLine);
            }
            catch (Exception exc)
            {
                MessageBox.Show(exc.Message);
            }
        }
Пример #42
0
        /// <summary>
        ///     Paints the chart
        /// </summary>
        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);
            if (ClientSize.Width == 0 || ClientSize.Height == 0)
            {
                return;
            }
            var      bitmap = new Bitmap(ClientSize.Width, ClientSize.Height);
            Graphics g      = Graphics.FromImage(bitmap);

            // Caption bar
            Data.GradientPaint(g, rectfCaption, LayoutColors.ColorCaptionBack, LayoutColors.DepthCaption);
            g.DrawString(chartTitle, Font, new SolidBrush(LayoutColors.ColorCaptionText), rectfCaption,
                         stringFormatCaption);

            // Border
            g.DrawLine(penBorder, 1, captionHeight, 1, ClientSize.Height);
            g.DrawLine(penBorder, ClientSize.Width - Border + 1, captionHeight, ClientSize.Width - Border + 1,
                       ClientSize.Height);
            g.DrawLine(penBorder, 0, ClientSize.Height - Border + 1, ClientSize.Width, ClientSize.Height - Border + 1);

            // Paints the background by gradient
            var rectChartField = new RectangleF(Border, captionHeight, ClientSize.Width - 2 * Border,
                                                ClientSize.Height - captionHeight - Border);

            Data.GradientPaint(g, rectChartField, LayoutColors.ColorChartBack, LayoutColors.DepthControl);

            if (isNotPaint)
            {
                return;
            }

            // Grid and Price labels
            for (int labelPrice = data.Minimum;
                 labelPrice <= data.Minimum + countLabels * labelStep;
                 labelPrice += labelStep)
            {
                var labelY = (int)(yBottom - (labelPrice - data.Minimum) * yScale);
                g.DrawString(labelPrice.ToString(CultureInfo.InvariantCulture), Font, brushFore, xRight,
                             labelY - Font.Height / 2 - 1);
                g.DrawLine(penGrid, xLeft, labelY, xRight, labelY);
            }

            // Price close
            if (showPriceLine)
            {
                g.DrawLines(new Pen(LayoutColors.ColorChartGrid), closePricePoints);
            }

            // Equity line
            g.DrawLines(new Pen(LayoutColors.ColorChartEquityLine), equityPoints);

            // Draw Long and Short balance
            if (Configs.AdditionalStatistics)
            {
                g.DrawLines(new Pen(Color.Red), shortBalancePoints);
                g.DrawLines(new Pen(Color.Green), longBalancePoints);
            }

            // Out of Sample
            if (IsOOS && OOSBar > 0)
            {
                g.DrawLine(new Pen(LayoutColors.ColorChartFore), xOOSBar, yTop, xOOSBar, yBottom);
                Brush brushOOS = new Pen(LayoutColors.ColorChartFore).Brush;
                g.DrawString("OOS", Font, brushOOS, xOOSBar, yBottom - Font.Height);
                float widthOOSBarDate = g.MeasureString(data.DataTimeBarOOS.ToShortDateString(), Font).Width;
                g.DrawString(data.DataTimeBarOOS.ToShortDateString(), Font, brushOOS, xOOSBar - widthOOSBarDate,
                             yBottom - Font.Height);
            }

            // Draw Balance Line
            if (data.MarginCallBar > 0) // In case of Margin Call
            {
                // Draw balance line up to Margin Call
                var balPoints = new PointF[data.MarginCallBar - data.FirstBar];
                for (int i = 0; i < balPoints.Length; i++)
                {
                    balPoints[i] = balancePoints[i];
                }
                if (balPoints.Length > 1)
                {
                    g.DrawLines(new Pen(LayoutColors.ColorChartBalanceLine), balPoints);
                }

                // Draw balance line after Margin Call
                var redBalancePoints = new PointF[data.Bars - data.MarginCallBar];
                for (int i = 0; i < redBalancePoints.Length; i++)
                {
                    redBalancePoints[i] = balancePoints[i + data.MarginCallBar - data.FirstBar];
                }
                g.DrawLines(new Pen(LayoutColors.ColorSignalRed), redBalancePoints);

                // Margin Call line
                g.DrawLine(new Pen(LayoutColors.ColorChartCross), xMarginCallBar, yTop, xMarginCallBar, yBottom);

                // Margin Call label
                float widthMarginCallLabel = g.MeasureString(Language.T("Margin Call"), Font).Width;
                if (xMarginCallBar < xRight - widthMarginCallLabel)
                {
                    g.DrawString(Language.T("Margin Call"), Font, brushFore, xMarginCallBar, yTop);
                }
                else if (xMarginCallBar > Space + widthMarginCallLabel)
                {
                    g.DrawString(Language.T("Margin Call"), Font, brushFore, xMarginCallBar - widthMarginCallLabel,
                                 yTop);
                }
                else
                {
                    g.DrawString("MC", Font, brushFore, xMarginCallBar, yTop);
                }
            }
            else
            {
                // Draw the balance line
                g.DrawLines(new Pen(LayoutColors.ColorChartBalanceLine), balancePoints);
            }

            // Scanning note
            var fontNote = new Font(Font.FontFamily, Font.Size - 1);

            if (Data.Period != DataPeriod.M1 && Configs.Autoscan && !Data.IsIntrabarData)
            {
                g.DrawString(Language.T("Load intrabar data"), fontNote, Brushes.Red, xLeft, captionHeight - 2);
            }
            else if (Data.Period != DataPeriod.M1 && isScanPerformed)
            {
                g.DrawString(Language.T("Scanned") + data.ModellingQuolity, fontNote, Brushes.LimeGreen, xLeft,
                             captionHeight - 2);
            }

            // Scanned bars
            if (isScanPerformed && !isHideScanningLine &&
                (Data.IntraBars != null && Data.IsIntrabarData ||
                 Data.Period == DataPeriod.M1 && Data.IsTickData && Configs.UseTickData))
            {
                DataPeriod dataPeriod = Data.Period;
                Color      color      = Data.PeriodColor[Data.Period];
                int        fromBar    = data.FirstBar;
                for (int bar = data.FirstBar; bar < data.Bars; bar++)
                {
                    if (Data.IntraBarsPeriods[bar] == dataPeriod && bar != data.Bars - 1)
                    {
                        continue;
                    }
                    int xStart = (int)((fromBar - data.FirstBar) * xScale) + xLeft;
                    int xEnd   = (int)((bar - data.FirstBar) * xScale) + xLeft;
                    fromBar    = bar;
                    dataPeriod = Data.IntraBarsPeriods[bar];
                    Data.GradientPaint(g, new RectangleF(xStart, yBottom + 4, xEnd - xStart + 2, 5), color, 60);
                    color = Data.PeriodColor[Data.IntraBarsPeriods[bar]];
                }

                // Tick Data
                if (Data.IsTickData && Configs.UseTickData)
                {
                    int firstBarWithTicks = -1;
                    int lastBarWithTicks  = -1;
                    for (int b = 0; b < data.Bars; b++)
                    {
                        if (firstBarWithTicks == -1 && Data.TickData[b] != null)
                        {
                            firstBarWithTicks = b;
                        }
                        if (Data.TickData[b] != null)
                        {
                            lastBarWithTicks = b;
                        }
                    }
                    int xStart = (int)(firstBarWithTicks * xScale) + xLeft;
                    int xEnd   = (int)((lastBarWithTicks - data.FirstBar) * xScale) + xLeft;
                    if (xStart < xLeft)
                    {
                        xStart = xLeft;
                    }
                    if (xEnd < xStart)
                    {
                        xEnd = xStart;
                    }

                    Data.DrawCheckerBoard(g, Color.ForestGreen, new Rectangle(xStart, yBottom + 5, xEnd - xStart + 2, 3));
                }

                // Vertical coordinate axes
                g.DrawLine(new Pen(LayoutColors.ColorChartFore), xLeft - 1, yBottom, xLeft - 1, yBottom + 9);
            }

            // Coordinate axes
            g.DrawLine(new Pen(LayoutColors.ColorChartFore), xLeft - 1, yTop - Space, xLeft - 1, yBottom + 1);
            g.DrawLine(new Pen(LayoutColors.ColorChartFore), xLeft - 1, yBottom + 1, xRight, yBottom + 1);

            // Balance level
            g.DrawLine(new Pen(LayoutColors.ColorChartCross), xLeft, yBalance, xRight - Space + 1, yBalance);

            // Balance label
            var labelSize  = new Size(labelWidth + Space, Font.Height + 2);
            var labelPoint = new Point(xRight - Space + 2, (int)(yBalance - Font.Height / 2.0 - 1));
            var labelRect  = new Rectangle(labelPoint, labelSize);

            g.FillRectangle(new SolidBrush(LayoutColors.ColorLabelBack), labelRect);
            g.DrawRectangle(new Pen(LayoutColors.ColorChartCross), labelRect);
            g.DrawString((Math.Round(data.NetBalance)).ToString(CultureInfo.InvariantCulture), Font,
                         new SolidBrush(LayoutColors.ColorLabelText), labelRect, stringFormatCaption);

            DIBSection.DrawOnPaint(e.Graphics, bitmap, Width, Height);
        }
Пример #43
0
 public DataSet(string symbol, DataPeriod period, int bars)
 {
     InitializeDataSet(symbol, period, bars);
 }
        private void GenerateDataFile()
        {
            symbol = "GBPUSD";
            instrProperties = new InstrumentProperties(symbol, InstrumetType.Forex)
                {
                    Commission = 0,
                    CommissionScope = CommissionScope.deal,
                    CommissionTime = CommissionTime.openclose,
                    Digits = 5,
                    LotSize = 10000,
                    RateToEUR = 2.3456,
                    RateToUSD = 2.3456,
                    Slippage = 1,
                    Spread = 6,
                    SwapLong = 0.25,
                    SwapShort = 0.25,
                    SwapUnit = ChargeUnit.Points
                };

            int maxBars = 2*Configs.MaxBars;
            var sb = new StringBuilder(maxBars);
            var time = new DateTime(2000, 1, 1, 0, 0, 0);
            double open = 1.12345;
            int volume = 300;
            period = DataPeriod.H4;
            for (int i = 0; i < maxBars; i++)
            {
                time = time.AddMinutes((int) DataPeriod.H1);
                int multiplier = (time.DayOfYear%2 == 0) ? 1 : -1;
                open = open + multiplier*0.00005;
                double high = open + 0.00025;
                double low = open - 0.00025;
                double close = open + 0.00005;
                volume = volume + multiplier*5;

                sb.AppendLine(string.Format("{0} {1} {2} {3} {4} {5}",
                                            time.ToString("yyyy-MM-dd HH:mm:ss"),
                                            open.ToString("F5"),
                                            high.ToString("F5"),
                                            low.ToString("F5"),
                                            close.ToString("F5"),
                                            volume));
            }

            dataFile = sb.ToString();
        }
        private void StoreConfigs()
        {
            maxBarsDefault = Configs.MaxBars;
            isCheckDataDefault = Configs.CheckData;
            isFillDataGapsDefault = Configs.FillInDataGaps;
            isCutBadDataDefault = Configs.CutBadData;
            isCutSatSunDataDefault = Configs.CutSatSunData;
            isUseEndTimeDefault = Configs.UseEndTime;
            isUseStartTimeDefault = Configs.UseStartTime;
            isUseTickDataDefault = Configs.UseTickData;
            isAutoscanDefault = Configs.Autoscan;

            isAccountInCurrencyDefault = Configs.AccountInMoney;
            accountCurrencyDefault = Configs.AccountCurrency;
            initialAccountDefault = Configs.InitialAccount;
            leverageDefault = Configs.Leverage;
            isTradeUntilMarginCallDefault = Configs.TradeUntilMarginCall;
            isUseLogicalGroupsDefault = Configs.UseLogicalGroups;

            symbolDefault = Data.Symbol;
            periodDefault = Data.Period;
            instrPropertiesDefault = Instruments.InstrumentList[symbolDefault].Clone();

            strategyDefault = Data.Strategy.Clone();
        }
Пример #46
0
        /// <summary>
        ///     Loads the Intrabar data.
        /// </summary>
        private int LoadIntrabarData(DataPeriod period)
        {
            var instrument = new Instrument(Data.InstrProperties.Clone(), (int)period)
            {
                DataDir = Data.OfflineDataDir,
                MaxBars = Configs.MaxIntraBars
            };


            // Loads the data
            int loadingResult   = instrument.LoadData();
            int loadedIntrabars = instrument.Bars;

            if (loadingResult == 0 && loadedIntrabars > 0)
            {
                if (Data.Period != DataPeriod.W1)
                {
                    if (instrument.DaysOff > 5)
                    {
                        warningMessage += Environment.NewLine + Language.T("Data for:") + " " + Data.Symbol + " " +
                                          Data.DataPeriodToString(period) + " - " + Language.T("Maximum days off:") +
                                          " " + instrument.DaysOff;
                    }
                    if (Data.Update - instrument.Update > new TimeSpan(24, 0, 0))
                    {
                        warningMessage += Environment.NewLine + Language.T("Data for:") + " " + Data.Symbol + " " +
                                          Data.DataPeriodToString(period) + " - " + Language.T("Updated on:") + " " +
                                          instrument.Update.ToString(CultureInfo.InvariantCulture);
                    }
                }

                int startBigBar;
                for (startBigBar = 0; startBigBar < Data.Bars; startBigBar++)
                {
                    if (Data.Time[startBigBar] >= instrument.Time(0))
                    {
                        break;
                    }
                }

                int stopBigBar;
                for (stopBigBar = startBigBar; stopBigBar < Data.Bars; stopBigBar++)
                {
                    if (Data.IntraBarsPeriods[stopBigBar] != Data.Period)
                    {
                        break;
                    }
                }

                // Seek for a place to put the intrabars.
                int lastIntraBar = 0;
                for (int bar = startBigBar; bar < stopBigBar; bar++)
                {
                    Data.IntraBarData[bar] = new Bar[(int)Data.Period / (int)period];
                    DateTime endTime  = Data.Time[bar] + new TimeSpan(0, (int)Data.Period, 0);
                    int      indexBar = 0;
                    for (int intrabar = lastIntraBar;
                         intrabar < loadedIntrabars && instrument.Time(intrabar) < endTime;
                         intrabar++)
                    {
                        if (instrument.Time(intrabar) >= Data.Time[bar])
                        {
                            Data.IntraBarData[bar][indexBar].Time  = instrument.Time(intrabar);
                            Data.IntraBarData[bar][indexBar].Open  = instrument.Open(intrabar);
                            Data.IntraBarData[bar][indexBar].High  = instrument.High(intrabar);
                            Data.IntraBarData[bar][indexBar].Low   = instrument.Low(intrabar);
                            Data.IntraBarData[bar][indexBar].Close = instrument.Close(intrabar);
                            Data.IntraBarsPeriods[bar]             = period;
                            Data.IntraBarBars[bar]++;
                            indexBar++;
                            lastIntraBar = intrabar;
                        }
                    }
                }
            }

            return(loadedIntrabars);
        }
Пример #47
0
        /// <summary>
        ///     Paints the charts
        /// </summary>
        private void PnlChartPaint(object sender, PaintEventArgs e)
        {
            var      pnl = (Panel)sender;
            Graphics g   = e.Graphics;

            const int space  = 5;
            const int border = 2;

            // Chart Title
            string unit                = " [" + (Configs.AccountInMoney ? Configs.AccountCurrency : Language.T("points")) + "]";
            string str                 = Language.T("Balance Chart") + unit;
            var    font                = new Font(Font.FontFamily, 9);
            var    fCaptionHeight      = (float)Math.Max(font.Height, 18);
            var    rectfCaption        = new RectangleF(0, 0, pnl.ClientSize.Width, fCaptionHeight);
            var    stringFormatCaption = new StringFormat
            {
                Alignment = StringAlignment.Center, LineAlignment = StringAlignment.Center
            };

            Data.GradientPaint(g, rectfCaption, LayoutColors.ColorCaptionBack, LayoutColors.DepthCaption);
            g.DrawString(str, Font, new SolidBrush(LayoutColors.ColorCaptionText), rectfCaption, stringFormatCaption);

            // Paint the panel background
            var rectClient = new RectangleF(border, fCaptionHeight, pnl.ClientSize.Width - 2 * border,
                                            pnl.Height - fCaptionHeight - border);

            Data.GradientPaint(g, rectClient, LayoutColors.ColorChartBack, LayoutColors.DepthControl);

            var penBorder = new Pen(Data.GetGradientColor(LayoutColors.ColorCaptionBack, -LayoutColors.DepthCaption),
                                    border);

            g.DrawLine(penBorder, 1, fCaptionHeight, 1, pnl.ClientSize.Height);
            g.DrawLine(penBorder, pnl.ClientSize.Width - border + 1, fCaptionHeight, pnl.ClientSize.Width - border + 1,
                       pnl.ClientSize.Height);
            g.DrawLine(penBorder, 0, pnl.ClientSize.Height - border + 1, pnl.ClientSize.Width,
                       pnl.ClientSize.Height - border + 1);

            if (!isPaintChart)
            {
                if (Backtester.AmbiguousBars == 0)
                {
                    string sNote     = Language.T("The Comparator is useful when the backtest shows ambiguous bars!");
                    var    rectfNote = new RectangleF(0, 30, pnl.ClientSize.Width, Font.Height);
                    g.DrawString(sNote, Font, new SolidBrush(LayoutColors.ColorChartFore), rectfNote,
                                 stringFormatCaption);
                }
                return;
            }

            int bars = Data.Bars - Data.FirstBar;
            int max  = (int)Math.Max(maximum, maximumRandom) + 1;
            int min  = (int)Math.Min(minimum, minimumRandom) - 1;

            min = (int)Math.Floor(min / 10f) * 10;
            int yTop       = (int)fCaptionHeight + 2 * space + 1;
            int yBottom    = (pnl.ClientSize.Height - 2 * space - border);
            var labelWidth =
                (int)
                Math.Max(g.MeasureString(min.ToString(CultureInfo.InvariantCulture), Font).Width,
                         g.MeasureString(max.ToString(CultureInfo.InvariantCulture), Font).Width);

            labelWidth = Math.Max(labelWidth, 30);
            int xRight = pnl.ClientSize.Width - border - space - labelWidth;
            int xLeft  = border + space;

            //
            // Grid
            //
            int cntLabels = Math.Max((yBottom - yTop) / 20, 1);
            var delta     = (float)Math.Max(Math.Round((max - min) / (float)cntLabels), 10);
            int step      = (int)Math.Ceiling(delta / 10) * 10;

            cntLabels = (int)Math.Ceiling((max - min) / (float)step);
            max       = min + cntLabels * step;
            float scaleY    = (yBottom - yTop) / (cntLabels * (float)step);
            Brush brushFore = new SolidBrush(LayoutColors.ColorChartFore);
            var   penGrid   = new Pen(LayoutColors.ColorChartGrid)
            {
                DashStyle = DashStyle.Dash, DashPattern = new float[] { 4, 2 }
            };

            // Price labels
            for (int label = min; label <= max; label += step)
            {
                var labelY = (int)(yBottom - (label - min) * scaleY);
                g.DrawString(label.ToString(CultureInfo.InvariantCulture), Font, brushFore, xRight,
                             labelY - Font.Height / 2 - 1);
                g.DrawLine(penGrid, border + space, labelY, xRight, labelY);
            }

            float xScale = (xRight - 2 * space - border) / (float)bars;

            if (isRandom)
            {
                // Draws the random area and Min Max lines
                var apntMinRandom = new PointF[bars];
                var apntMaxRandom = new PointF[bars];
                for (int iBar = 0; iBar < bars; iBar++)
                {
                    apntMinRandom[iBar].X = border + space + iBar * xScale;
                    apntMinRandom[iBar].Y = yBottom - (afMinRandom[iBar] - min) * scaleY;
                    apntMaxRandom[iBar].X = border + space + iBar * xScale;
                    apntMaxRandom[iBar].Y = yBottom - (afMaxRandom[iBar] - min) * scaleY;
                }
                apntMinRandom[0].Y = apntMaxRandom[0].Y;
                var path = new GraphicsPath();
                path.AddLines(apntMinRandom);
                path.AddLine(apntMinRandom[bars - 1], apntMaxRandom[bars - 1]);
                path.AddLines(apntMaxRandom);
                var region = new Region(path);
                g.FillRegion(brushRandArea, region);
                g.DrawLines(penRandBands, apntMinRandom);
                g.DrawLines(penRandBands, apntMaxRandom);
            }

            // Draws the lines
            for (int m = 0; m < countMethods; m++)
            {
                if (!AchboxMethods[m].Checked)
                {
                    continue;
                }

                var apntLines = new PointF[bars];
                for (int iBar = 0; iBar < bars; iBar++)
                {
                    apntLines[iBar].X = border + space + iBar * xScale;
                    apntLines[iBar].Y = yBottom - (afMethods[m, iBar] - min) * scaleY;
                }

                var pen = new Pen(LayoutColors.ColorSignalRed);
                switch ((InterpolationMethod)AchboxMethods[m].Tag)
                {
                case InterpolationMethod.Pessimistic:
                    pen = penPessimistic;
                    break;

                case InterpolationMethod.Shortest:
                    pen = penShortest;
                    break;

                case InterpolationMethod.Nearest:
                    pen = penNearest;
                    break;

                case InterpolationMethod.Optimistic:
                    pen = penOptimistic;
                    break;

                case InterpolationMethod.Random:
                    pen = penRandom;
                    break;
                }
                g.DrawLines(pen, apntLines);
            }

            // Draws the average balance
            var apntBalance = new PointF[bars];

            for (int bar = 0; bar < bars; bar++)
            {
                apntBalance[bar].X = border + space + bar * xScale;
                apntBalance[bar].Y = yBottom - (afBalance[bar] - min) * scaleY;
            }
            g.DrawLines(penBalance, apntBalance);

            // Coordinate axes
            g.DrawLine(new Pen(LayoutColors.ColorChartFore), xLeft - 1, yTop - space, xLeft - 1, yBottom);
            g.DrawLine(new Pen(LayoutColors.ColorChartFore), xLeft, yBottom, xRight, yBottom);

            // Balance label
            float fBalanceY = yBottom - (afBalance[bars - 1] - min) * scaleY;

            g.DrawLine(new Pen(LayoutColors.ColorChartCross), xLeft, fBalanceY, xRight - space, fBalanceY);

            var    szBalance = new Size(labelWidth + space, Font.Height + 2);
            var    point     = new Point(xRight - space + 2, (int)(fBalanceY - Font.Height / 2.0 - 1));
            var    rec       = new Rectangle(point, szBalance);
            string sBalance  = ((int)afBalance[bars - 1]).ToString(CultureInfo.InvariantCulture);

            g.FillRectangle(new SolidBrush(LayoutColors.ColorLabelBack), rec);
            g.DrawRectangle(new Pen(LayoutColors.ColorChartCross), rec);
            g.DrawString(sBalance, Font, new SolidBrush(LayoutColors.ColorLabelText), rec, stringFormatCaption);

            // Scanning note
            var fontNote = new Font(Font.FontFamily, Font.Size - 1);

            if (Configs.Autoscan && !Data.IsIntrabarData)
            {
                g.DrawString(Language.T("Load intrabar data"), fontNote, Brushes.Red, xLeft, fCaptionHeight - 2);
            }
            else if (Backtester.IsScanPerformed)
            {
                g.DrawString(Language.T("Scanned") + " MQ " + Data.ModellingQuality.ToString("N2") + "%", fontNote,
                             Brushes.LimeGreen, border + space, fCaptionHeight - 2);
            }

            // Scanned bars
            if (Backtester.IsScanPerformed &&
                (Data.IntraBars != null && Data.IsIntrabarData ||
                 Data.Period == DataPeriod.M1 && Data.IsTickData && Configs.UseTickData))
            {
                g.DrawLine(new Pen(LayoutColors.ColorChartFore), xLeft - 1, yBottom, xLeft - 1,
                           yBottom + 8);
                DataPeriod dataPeriod = Data.Period;
                Color      color      = Data.PeriodColor[Data.Period];
                int        iFromBar   = Data.FirstBar;
                for (int bar = Data.FirstBar; bar < Data.Bars; bar++)
                {
                    if (Data.IntraBarsPeriods[bar] != dataPeriod || bar == Data.Bars - 1)
                    {
                        int xStart = (int)((iFromBar - Data.FirstBar) * xScale) + xLeft;
                        int xEnd   = (int)((bar - Data.FirstBar) * xScale) + xLeft;
                        iFromBar   = bar;
                        dataPeriod = Data.IntraBarsPeriods[bar];
                        Data.GradientPaint(g, new RectangleF(xStart, yBottom + 3, xEnd - xStart + 2, 5), color, 60);
                        color = Data.PeriodColor[Data.IntraBarsPeriods[bar]];
                    }
                }

                // Tick Data
                if (Data.IsTickData && Configs.UseTickData)
                {
                    int firstBarWithTicks = -1;
                    int lastBarWithTicks  = -1;
                    for (int b = 0; b < Data.Bars; b++)
                    {
                        if (firstBarWithTicks == -1 && Data.TickData[b] != null)
                        {
                            firstBarWithTicks = b;
                        }
                        if (Data.TickData[b] != null)
                        {
                            lastBarWithTicks = b;
                        }
                    }
                    int xStart = (int)(firstBarWithTicks * xScale) + xLeft;
                    int xEnd   = (int)((lastBarWithTicks - Data.FirstBar) * xScale) + xLeft;
                    if (xStart < xLeft)
                    {
                        xStart = xLeft;
                    }
                    if (xEnd < xStart)
                    {
                        xEnd = xStart;
                    }

                    Data.DrawCheckerBoard(g, Color.ForestGreen, new Rectangle(xStart, yBottom + 4, xEnd - xStart + 2, 3));
                }
            }
        }
        /// <summary>
        ///     Starts the trade.
        /// </summary>
        private void StartTrade()
        {
            if (Data.Strategy.FirstBar > Data.Bars)
            {
                string errorMessage = string.Format("The strategy requires {0} bars, but there are {1} bars loaded.",
                                                    Data.Strategy.FirstBar, Data.Bars);
                errorMessage += Environment.NewLine +
                                Language.T("Check \"Trade settings -> Minimum number of bars in the chart\" option.");
                MessageBox.Show(errorMessage, Language.T("Strategy"));
                return;
            }

            isTrading = true;

            // Resets trade global variables.
            InitTrade();

            Data.SetStartTradingTime();
            string message = Data.Symbol + " " + Data.PeriodMtStr + " " + Language.T("Automatic trade started.");
            var msg = new JournalMessage(JournalIcons.StartTrading, DateTime.Now, message);
            AppendJournalMessage(msg);
            Log(message);

            symbolReconnect = Data.Symbol;
            periodReconnect = Data.Period;
            accountReconnect = Data.AccountNumber;
            barOpenTimeForLastCloseEvent = Data.Time[Data.Bars - 1];

            SetTradeStrip();
        }