コード例 #1
0
        private static IKLineData Transfer_SrcIs1Minute(IKLineData data, KLinePeriod targetPeriod, ITradingTimeReader_Code startTimeReader)
        {
            KLinePeriod sourcePeriod = data.Period;

            if (sourcePeriod.PeriodType != targetPeriod.PeriodType)
            {
                return(Transfer_DifferentPeriod(data, targetPeriod, startTimeReader));
            }

            List <KLineBar> charts = new List <KLineBar>();
            int             period = targetPeriod.Period;

            int startIndex = 0;
            int endIndex   = startIndex + period - 1;

            endIndex = FindRealLastIndex_1Minute(data, startIndex, endIndex);

            while (startIndex < data.Length && endIndex < data.Length)
            {
                charts.Add(GetChart(data, startIndex, endIndex));
                startIndex = endIndex + 1;
                endIndex   = startIndex + period - 1;

                endIndex = FindRealLastIndex_1Minute(data, startIndex, endIndex);
            }

            return(GetKLineData(data.Code, charts));
        }
コード例 #2
0
        private void Executor_OnDayFinished(object sender, StrategyDayFinishedArguments arguments)
        {
            IKLineData klineData = arguments.ExecutorInfo.CurrentKLineData;

            //Console.WriteLine(klineData.Code + "," + klineData + " Finished");
            Console.WriteLine(arguments.ExecutorInfo.CurrentDayIndex + "|" + arguments.ExecutorInfo.TotalDayCount);
        }
コード例 #3
0
ファイル: TestKLineDataStore.cs プロジェクト: wanwei/sc2
        private void TestKLineDataStore_SaveLoad(string uri)
        {
            string          code           = "m1005";
            KLinePeriod     period         = KLinePeriod.KLinePeriod_1Minute;
            IDataStore      dataStore      = DataStoreFactory.CreateDataStore(uri);
            IKLineDataStore klineDataStore = dataStore.CreateKLineDataStore();

            try
            {
                IKLineData klineData = MockDataLoader.GetKLineData(code, 20100107, 20100120, period);

                klineDataStore.Save(code, period, klineData);

                KLineData klineData2 = klineDataStore.LoadAll(code, period);
                AssertUtils.AssertEqual_KLineData(klineData, klineData2);

                Assert.AreEqual(20100107, klineDataStore.GetFirstTradingDay(code, period));
                Assert.AreEqual(20100120, klineDataStore.GetLastTradingDay(code, period));
                Console.WriteLine(klineDataStore.GetLastTradingTime(code, period));
            }
            finally
            {
                klineDataStore.Delete(code, period);
            }
        }
コード例 #4
0
        private static IKLineData Transfer_SrcIs1Minute(IKLineData data, KLinePeriod targetPeriod)
        {
            KLinePeriod sourcePeriod = data.Period;
            if (sourcePeriod.PeriodType != targetPeriod.PeriodType)
                return Transfer_DifferentPeriod(data, targetPeriod);

            List<KLineBar> charts = new List<KLineBar>();
            int period = targetPeriod.Period;

            int startIndex = 0;
            int endIndex = startIndex + period - 1;
            endIndex = FindRealLastIndex_1Minute(data, startIndex, endIndex);

            while (startIndex < data.Length && endIndex < data.Length)
            {
                charts.Add(GetChart(data, startIndex, endIndex));
                startIndex = endIndex + 1;
                endIndex = startIndex + period - 1;

                endIndex = FindRealLastIndex_1Minute(data, startIndex, endIndex);
            }

            KLineData klineData = GetKLineData(charts);
            klineData.Period = targetPeriod;
            return klineData;
        }
コード例 #5
0
ファイル: TestRealDataNavigate.cs プロジェクト: wanwei/sc2
        public void TestCreateRealTimeDataNavigater()
        {
            DataReaderFactory      fac           = ResourceLoader.GetDefaultDataReaderFactory();
            IRealTimeDataNavigater dataNavigater = fac.RealTimeDataNavigaterFactory.CreateNavigater("m05", 20100105.100521);

            IKLineData klineData = dataNavigater.GetKLineData(KLinePeriod.KLinePeriod_15Minute);

            Console.WriteLine(klineData);
            klineData = dataNavigater.GetKLineData(KLinePeriod.KLinePeriod_1Minute);
            Console.WriteLine(klineData);
            klineData = dataNavigater.GetKLineData(KLinePeriod.KLinePeriod_5Minute);
            Console.WriteLine(klineData);
            klineData = dataNavigater.GetKLineData(KLinePeriod.KLinePeriod_1Hour);
            Console.WriteLine(klineData);
            klineData = dataNavigater.GetKLineData(KLinePeriod.KLinePeriod_1Day);
            Console.WriteLine(klineData);
            klineData = dataNavigater.GetKLineData(KLinePeriod.KLinePeriod_5Second);
            Console.WriteLine(klineData);

            dataNavigater.NavigateForward_Period(KLinePeriod.KLinePeriod_1Minute, 1);
            klineData = dataNavigater.GetKLineData(KLinePeriod.KLinePeriod_15Minute);
            Console.WriteLine(klineData);
            klineData = dataNavigater.GetKLineData(KLinePeriod.KLinePeriod_1Minute);
            Console.WriteLine(klineData);
            klineData = dataNavigater.GetKLineData(KLinePeriod.KLinePeriod_5Minute);
            Console.WriteLine(klineData);
            klineData = dataNavigater.GetKLineData(KLinePeriod.KLinePeriod_1Hour);
            Console.WriteLine(klineData);
            klineData = dataNavigater.GetKLineData(KLinePeriod.KLinePeriod_1Day);
            Console.WriteLine(klineData);
            klineData = dataNavigater.GetKLineData(KLinePeriod.KLinePeriod_5Second);
            Console.WriteLine(klineData);
        }
コード例 #6
0
        public void TestCreate()
        {
            DataReaderFactory fac = ResourceLoader.GetDefaultDataReaderFactory();

            List <KLinePeriod> periods = new List <KLinePeriod>();

            periods.Add(KLinePeriod.KLinePeriod_5Minute);
            periods.Add(KLinePeriod.KLinePeriod_15Minute);
            periods.Add(KLinePeriod.KLinePeriod_1Hour);
            periods.Add(KLinePeriod.KLinePeriod_1Day);
            RealTimeDataNavigateForward_KLine navigater = new RealTimeDataNavigateForward_KLine(fac, "m05", 20100101, 20100701, KLinePeriod.KLinePeriod_1Minute, periods);

            IKLineData klineData_1Minute = navigater.GetKLineData(KLinePeriod.KLinePeriod_1Minute);

            Console.WriteLine(klineData_1Minute);
            IKLineData klineData_5Minute = navigater.GetKLineData(KLinePeriod.KLinePeriod_5Minute);

            Console.WriteLine(klineData_5Minute);
            IKLineData klineData_15Minute = navigater.GetKLineData(KLinePeriod.KLinePeriod_15Minute);

            Console.WriteLine(klineData_15Minute);
            IKLineData klineData_Hour = navigater.GetKLineData(KLinePeriod.KLinePeriod_1Hour);

            Console.WriteLine(klineData_Hour);
            //DataReaderFactory fac = ResourceLoader.GetDefaultDataReaderFactory();
            //RealTimeDataNavigater_KLine navigater = new RealTimeDataNavigater_KLine(fac, "m05", 20100101, 20100701);
            //IKLineData klineData = navigater.GetKLineData(KLinePeriod.KLinePeriod_1Minute);

            //Assert.AreEqual("20100104.09,3121,3135,3121,3132,5090,0,520956", klineData.ToString());
        }
コード例 #7
0
ファイル: Strategy_DrawPoints.cs プロジェクト: wanwei/sc2
        public override void OnBar(Object sender, IStrategyOnBarArgument currentData)
        {
            IKLineData klineData = currentData.CurrentData.GetKLineData(MainKLinePeriod);

            GenMa(klineData);
            GenPoint(klineData);
        }
コード例 #8
0
ファイル: Plugin_HistoryData_Csv.cs プロジェクト: wanwei/sc2
        private IKLineData GetKLineData(string code, KLinePeriod klinePeriod, IList <int> openDates, float lastEndPrice, int lastEndHold)
        {
            List <IKLineData> klineDataList = new List <IKLineData>();

            for (int i = 0; i < openDates.Count; i++)
            {
                int        openDate  = openDates[i];
                IKLineData klineData = GetKLineData(code, openDate, klinePeriod);
                if (klineData != null)
                {
                    klineDataList.Add(klineData);
                    lastEndPrice = klineData.Arr_End[klineData.Length - 1];
                    lastEndHold  = klineData.Arr_Hold[klineData.Length - 1];
                }
                else
                {
                    IList <double[]> tradingTime = GetTradingTime(code, openDate);
                    IList <double[]> klineTimes  = TradingTimeUtils.GetKLineTimeList(tradingTime, klinePeriod);
                    klineData = DataTransfer_Tick2KLine.GetEmptyKLineData(klineTimes, lastEndPrice, lastEndHold);
                    klineDataList.Add(klineData);
                }
            }

            return(KLineData.Merge(klineDataList));
        }
コード例 #9
0
ファイル: Step_KLineData_OneDay.cs プロジェクト: wanwei/sc2
        public string Proceed()
        {
            string path = dataUpdateHelper.GetPath_KLineData(codeInfo.Code, date, klinePeriod);
            //if (!(codeInfo.Code.EndsWith("0000") || codeInfo.Code.EndsWith("MI")))
            //if (!overwrite && File.Exists(path))
            //    return codeInfo.Code + "-" + date + "的K线数据已存在";

            TickData tickData = (TickData)dataUpdateHelper.GetUpdatedTickData(codeInfo.Code, date);

            if (tickData == null)
            {
                tickData = (TickData)dataUpdateHelper.GetNewTickData(codeInfo.ServerCode, date);
            }
            //tick数据没有,则不生成对应K线数据
            if (tickData == null)
            {
                string msg = codeInfo.Code + "-" + date + "的tick数据不存在";
                LogHelper.Warn(GetType(), msg);
                return(msg);
            }

            IList <double[]> tradingPeriod = dataUpdateHelper.GetTradingTime(codeInfo.Code, date).TradingPeriods;

            //List<double[]> klineTimes = TradingTimeUtils.GetKLineTimeList_Full(tradingPeriod, KLinePeriod.KLinePeriod_1Minute);
            //timeListGetter.GetKLineTimeList(code, date, klinePeriod);
            this.klineData = DataTransfer_Tick2KLine.Transfer(tickData, tradingPeriod, KLinePeriod.KLinePeriod_1Minute, lastEndPrice, lastEndHold);
            CsvUtils_KLineData.Save(path, klineData);
            return("更新" + codeInfo.Code + "-" + date + "的" + klinePeriod + "K线完成");
        }
コード例 #10
0
 private void KlineDataForward_OnBar(object sender, IKLineData klineData, int index)
 {
     if (OnBar != null)
     {
         OnBar(this, klineData, index);
     }
 }
コード例 #11
0
 public static void PrintKLineData(IKLineData klineData)
 {
     for (int i = 0; i < klineData.Length; i++)
     {
         Console.WriteLine(klineData.GetBar(i));
     }
 }
コード例 #12
0
        public override void OnBar(Object sender, IStrategyOnBarArgument currentData)
        {
            IKLineData klineData     = currentData.CurrentData.GetKLineData(KLinePeriod.KLinePeriod_1Minute);
            int        currentBarPos = klineData.BarPos;
            int        lastBarPos    = currentBarPos - 5;

            if (lastBarPos < 0)
            {
                return;
            }

            //float endPrice = klineData.End;
            //float startPrice = klineData.GetBar(lastBarPos).Start;

            //int lowIndex = -1;
            //float lowPrice = float.MaxValue;
            //int highIndex = -1;
            //float highPrice = 0;
            //for (int i = lastBarPos; i <= currentBarPos; i++)
            //{

            //}

            //float percent = (float)Math.Round((highPrice - lowPrice) / startPrice * 100, 2);
            //5分钟内涨幅超过
            //if (percent > 0.5)
            //{

            //}
            //currentData.GetKLineData(KLinePeriod.KLinePeriod_15Minute);
        }
コード例 #13
0
 public KLineAbstract(IKLineData klineData, int endIndex, int length)
 {
     this.klineData  = klineData;
     this.length     = length;
     this.startIndex = endIndex - length + 1;
     this.endIndex   = endIndex;
 }
コード例 #14
0
        public void TestKLineDataReaderGetAll()
        {
            IKLineDataReader reader   = DataReaderFactory.CreateDataReader(DataCenterUri.URI).KLineDataReader;
            IKLineData       data_m01 = reader.GetAllData("m01", KLinePeriod.KLinePeriod_1Minute);

            IKLineData data_m03 = reader.GetAllData("m03", KLinePeriod.KLinePeriod_1Minute);

            AssertKLineTime(data_m01, data_m03);
            IKLineData data_m05 = reader.GetAllData("m05", KLinePeriod.KLinePeriod_1Minute);

            AssertKLineTime(data_m01, data_m05);
            IKLineData data_m07 = reader.GetAllData("m07", KLinePeriod.KLinePeriod_1Minute);

            AssertKLineTime(data_m01, data_m07);
            IKLineData data_m08 = reader.GetAllData("m08", KLinePeriod.KLinePeriod_1Minute);

            AssertKLineTime(data_m01, data_m08);
            IKLineData data_m09 = reader.GetAllData("m09", KLinePeriod.KLinePeriod_1Minute);

            AssertKLineTime(data_m01, data_m09);
            IKLineData data_m11 = reader.GetAllData("m11", KLinePeriod.KLinePeriod_1Minute);

            AssertKLineTime(data_m01, data_m11);
            IKLineData data_m12 = reader.GetAllData("m12", KLinePeriod.KLinePeriod_1Minute);

            AssertKLineTime(data_m01, data_m12);
            IKLineData data_m13 = reader.GetAllData("m13", KLinePeriod.KLinePeriod_1Minute);

            AssertKLineTime(data_m01, data_m13);
            IKLineData data_mmi = reader.GetAllData("mmi", KLinePeriod.KLinePeriod_1Minute);

            AssertKLineTime(data_m01, data_mmi);
        }
コード例 #15
0
        private void KlineDataForward_OnTick(object sender, IForwardOnTickArgument argument)
        {
            IKLineData klineData = ((IDataForward_Code)sender).GetKLineData(KLinePeriod.KLinePeriod_1Minute);

            //Console.WriteLine(tickData);
            Console.WriteLine(klineData);
        }
コード例 #16
0
        public IKLineData GetKLineDataByTick(string code, DataReaderFactory dataReaderFactory, KLinePeriod period, IList <int> dates)
        {
            IKLineData        lastKLineData = null;
            float             lastPrice     = -1;
            List <IKLineData> klineDataList = new List <IKLineData>();

            for (int i = 0; i < dates.Count; i++)
            {
                int             openDate  = dates[i];
                TickData        tickdata  = dataReaderFactory.TickDataReader.GetTickData(code, openDate);
                List <double[]> openTimes = dataProvider.GetOpenTime(code, openDate);
                KLineData       klineData;
                if (tickdata != null)
                {
                    klineData = DataTransfer_Tick2KLine.Transfer(tickdata, period, openTimes, lastPrice);
                    klineDataList.Add(klineData);
                    lastPrice = klineData.arr_end[klineData.Length - 1];
                }
                else
                {
                    klineData = GetEmptyDayKLineData(code, openDate, openTimes, dataReaderFactory.OpenDateReader, lastKLineData);
                    klineDataList.Add(klineData);
                }
                lastKLineData = klineData;
            }
            if (klineDataList.Count == 0)
            {
                return(null);
            }
            IKLineData data = KLineData.Merge(klineDataList);

            return(data);
        }
コード例 #17
0
        public void TestKLineDataIndex_DoIndex_Normal()
        {
            KLineData  data_ = ResourceLoader.GetKLineData_1Min();
            IKLineData data  = data_.GetRange(0, 449);

            MockDataProvider provider = new MockDataProvider();

            provider.DataPathDir = "testindex";
            String targetPath = provider.GetDataPath() + "\\testindex.kline";

            KLineDataStore store = new KLineDataStore(targetPath);

            store.Save(data);

            KLineDataIndexer indexer = new KLineDataIndexer(targetPath);

            indexer.DoIndex();

            KLineDataIndexResult result = indexer.GetIndexResult();

            Assert.AreEqual(2, result.DateList.Count);
            Assert.AreEqual(20131202, result.DateList[0]);
            Assert.AreEqual(20131203, result.DateList[1]);

            data = data_.GetRange(450, data_.Length - 1);
            store.Append(data);
            indexer.DoIndex();
            result = indexer.GetIndexResult();
            Assert.AreEqual(10, result.DateList.Count);

            Directory.Delete(provider.GetDataPath(), true);
        }
コード例 #18
0
 public void Change(IKLineData data, double time)
 {
     this.klineData = (KLineData_RealTime)data;
     this.code      = data.Code;
     this.period    = data.Period;
     this.ChangeTime(time);
 }
コード例 #19
0
        public void TestNavigate()
        {
            DataReaderFactory fac = ResourceLoader.GetDefaultDataReaderFactory();

            List <KLinePeriod> periods = new List <KLinePeriod>();

            periods.Add(KLinePeriod.KLinePeriod_5Minute);
            periods.Add(KLinePeriod.KLinePeriod_15Minute);
            periods.Add(KLinePeriod.KLinePeriod_1Hour);
            periods.Add(KLinePeriod.KLinePeriod_1Day);
            RealTimeDataNavigateForward_KLine navigater = new RealTimeDataNavigateForward_KLine(fac, "m05", 20100101, 20100701, KLinePeriod.KLinePeriod_1Minute, periods);

            navigater.NavigateForward(1);

            IKLineData klineData_1Minute = navigater.GetKLineData(KLinePeriod.KLinePeriod_1Minute);

            Console.WriteLine(klineData_1Minute);
            IKLineData klineData_5Minute = navigater.GetKLineData(KLinePeriod.KLinePeriod_5Minute);

            Console.WriteLine(klineData_5Minute);
            IKLineData klineData_15Minute = navigater.GetKLineData(KLinePeriod.KLinePeriod_15Minute);

            Console.WriteLine(klineData_15Minute);
            IKLineData klineData_Hour = navigater.GetKLineData(KLinePeriod.KLinePeriod_1Hour);

            Console.WriteLine(klineData_Hour);
            //IKLineData klineData_1Day = navigater.GetKLineData(KLinePeriod.KLinePeriod_1Day);
            //Console.WriteLine(klineData_1Day);
        }
コード例 #20
0
ファイル: DataCache_Code.cs プロジェクト: wanwei/sc2
        public IDataCache_CodeDate GetCache_CodeDate(int date)
        {
            if (dicDateCache.ContainsKey(date))
            {
                return(dicDateCache[date]);
            }
            lock (lockObj)
            {
                if (dicDateCache.ContainsKey(date))
                {
                    return(dicDateCache[date]);
                }

                IKLineData         klineData = minuteDataGetter.GetKLineData(date);
                DataCache_CodeDate cache     = new DataCache_CodeDate(dataReaderFactory, code, date, klineData, minuteDataGetter.LastEndPrice(date));
                if (cachedKeies.Count > maxCacheDateCount)
                {
                    int removedKey = cachedKeies[0];
                    cachedKeies.RemoveAt(0);
                    dicDateCache.Remove(removedKey);
                }
                cachedKeies.Add(date);
                dicDateCache.Add(date, cache);
                return(cache);
            }
        }
コード例 #21
0
        private static KLineBar GetChart(IKLineData data, int startIndex, int endIndex)
        {
            //KLineChart chart = new KLineChart();
            KLineBar chart = new KLineBar();
            chart.Code = data.Code;
            chart.Time = data.Arr_Time[startIndex];
            chart.Start = data.Arr_Start[startIndex];
            chart.End = data.Arr_End[endIndex];
            chart.Hold = data.Arr_Hold[endIndex];

            float high = float.MinValue;
            float low = float.MaxValue;
            int mount = 0;
            float money = 0;
            for (int i = startIndex; i <= endIndex; i++)
            {
                float chigh = data.Arr_High[i];
                float clow = data.Arr_Low[i];
                high = high < chigh ? chigh : high;
                low = low > clow ? clow : low;
                mount += data.Arr_Mount[i];
                money += data.Arr_Money[i];
            }
            chart.High = high;
            chart.Low = low;
            chart.Mount = mount;
            chart.Money = money;
            return chart;
        }
コード例 #22
0
        public KLineData_Present(IKLineData historyKLineData, List <double> todayKlineTimeList, KLinePeriod period) : base(todayKlineTimeList.Count)
        {
            this.Period = period;
            int length = todayKlineTimeList.Count;

            this.arr_time  = todayKlineTimeList.ToArray();
            this.arr_start = new float[length];
            this.arr_high  = new float[length];
            this.arr_low   = new float[length];
            this.arr_end   = new float[length];
            this.arr_mount = new int[length];
            this.arr_money = new float[length];
            this.arr_hold  = new int[length];

            this.historyKLineData = historyKLineData;

            this.list_Time  = new ReadOnlyList_Merge <double>(historyKLineData.Arr_Time, arr_time);
            this.list_Start = new ReadOnlyList_Merge <float>(historyKLineData.Arr_Start, arr_start);
            this.list_High  = new ReadOnlyList_Merge <float>(historyKLineData.Arr_High, arr_high);
            this.list_Low   = new ReadOnlyList_Merge <float>(historyKLineData.Arr_Low, arr_low);
            this.list_End   = new ReadOnlyList_Merge <float>(historyKLineData.Arr_End, arr_end);
            this.list_Mount = new ReadOnlyList_Merge <int>(historyKLineData.Arr_Mount, arr_mount);
            this.list_Money = new ReadOnlyList_Merge <float>(historyKLineData.Arr_Money, arr_money);
            this.list_Hold  = new ReadOnlyList_Merge <int>(historyKLineData.Arr_Hold, arr_hold);
            this.BarPos     = historyKLineData.Length;
        }
コード例 #23
0
        public static List <ITimeLineData> ConvertTimeLineDataList(IKLineData data, float lastEndPrice, ITradingDayReader openDateReader)
        {
            List <SplitterResult> splitResult = DaySplitter.Split(data, openDateReader);

            List <ITimeLineData> realdataList = new List <ITimeLineData>(splitResult.Count);

            for (int i = 0; i < splitResult.Count; i++)
            {
                SplitterResult split           = splitResult[i];
                int            date            = split.Date;
                int            todayStartIndex = split.Index;
                int            todayEndIndex;
                if (i == splitResult.Count - 1)
                {
                    todayEndIndex = data.Length - 1;
                }
                else
                {
                    todayEndIndex = splitResult[i + 1].Index;
                }
                int          len = todayEndIndex - todayStartIndex + 1;
                TimeLineData r   = new TimeLineData(lastEndPrice, len);
                r.Code = data.Code;
                Convert2RealData(data, todayStartIndex, todayEndIndex, r);
                realdataList.Add(r);
            }

            return(realdataList);
        }
コード例 #24
0
ファイル: DataForward_Code_Tick3.cs プロジェクト: wanwei/sc2
 private void DealEvent_OnBar()
 {
     if (isDayStart)
     {
         return;
     }
     if (OnBar != null && forwardPeriod.KlineForwardPeriod != null)
     {
         bool isForwardPeriodEnd = dic_KLinePeriod_IsEnd[forwardPeriod.KlineForwardPeriod];
         if (isForwardPeriodEnd)
         {
             barFinishedInfos.Clear();
             for (int i = 0; i < forwardData.ReferedKLinePeriods.Count; i++)
             {
                 KLinePeriod period      = forwardData.ReferedKLinePeriods[i];
                 bool        isPeriodEnd = dic_KLinePeriod_IsEnd[period];
                 if (isPeriodEnd)
                 {
                     IKLineData klineData = forwardData.GetKLineData(period);
                     int        barPos    = klineData.BarPos - 1;
                     if (IsDayEnd)
                     {
                         barPos++;
                     }
                     barFinishedInfos.Add(new ForwardOnbar_Info(klineData, barPos));
                 }
             }
             //OnBar(this, mainKlineData, mainKlineData.BarPos);
             OnBar(this, onBarArgument);
         }
     }
 }
コード例 #25
0
        private void Init(IKLineData klineData, IList <ITradingTime> tradingTimes)
        {
            int currentKLineBarPos = 0;

            for (int i = 0; i < tradingTimes.Count; i++)
            {
                ITradingTime tradingTime = tradingTimes[i];
                KLineDataTradingTimeInfo_Day timeInfo = CalcKLineTimeInfo_Day(tradingTime, klineData, currentKLineBarPos);
                if (timeInfo == null)
                {
                    continue;
                }
                this.dic_TradingDay_KLineTimeInfo.Add(timeInfo.TradingDay, timeInfo);
                this.timeInfo_DayList.Add(timeInfo);
                currentKLineBarPos = timeInfo.EndPos;
                tradingDays.Add(tradingTime.TradingDay);
            }

            for (int i = 1; i < timeInfo_DayList.Count; i++)
            {
                int lastTradingDay = timeInfo_DayList[i - 1].TradingDay;
                KLineDataTradingTimeInfo_Day tradingTimeInfo_Day = (KLineDataTradingTimeInfo_Day)timeInfo_DayList[i];
                int currentTradingDay = tradingTimeInfo_Day.TradingDay;
                tradingTimeInfo_Day.holidayCount = TimeUtils.Substract(currentTradingDay, lastTradingDay).Days - 1;
            }
        }
コード例 #26
0
 public virtual void OnStart(Object sender, IStrategyOnStartArgument argument)
 {
     if (mainKlineData == null && MainKLinePeriod != null)
     {
         mainKlineData = argument.CurrentData.GetKLineData(MainKLinePeriod);
     }
 }
コード例 #27
0
ファイル: TestKLineDataStore.cs プロジェクト: wanwei/sc2
        private void TestKLineDataStore_LoadByDate(string uri)
        {
            string          code           = "m1005";
            KLinePeriod     klinePeriod    = KLinePeriod.KLinePeriod_1Minute;
            IDataStore      dataStore      = DataStoreFactory.CreateDataStore(uri);
            IKLineDataStore klineDataStore = dataStore.CreateKLineDataStore();

            try
            {
                IKLineData data = MockDataLoader.GetKLineData(code, 20100107, 20100120, klinePeriod);
                klineDataStore.Save(code, klinePeriod, data);

                IKLineData        klineData  = klineDataStore.Load(code, 20100107, 20100111, klinePeriod);
                IKLineData        klineData2 = klineDataStore.Load(code, 20100112, 20100120, klinePeriod);
                List <IKLineData> ks         = new List <IKLineData>();
                ks.Add(klineData);
                ks.Add(klineData2);
                IKLineData klineData_Merge = KLineData.Merge(ks);

                //AssertUtils.PrintKLineData(data);
                //AssertUtils.PrintKLineData(klineData_Merge);
                AssertUtils.PrintKLineData(klineData);
                //AssertUtils.PrintKLineData(klineData_Merge);
                AssertUtils.AssertEqual_KLineData(data, klineData_Merge);
            }
            finally
            {
                klineDataStore.Delete(code, klinePeriod);
            }
        }
コード例 #28
0
        public void TestTransferTimeLineData()
        {
            IKLineData    klineData    = MockDataLoader.GetKLineData("m1505", 20150107, 20150107, KLinePeriod.KLinePeriod_1Minute);
            ITimeLineData timeLineData = DataTransfer_KLine2TimeLine.ConvertTimeLineData(klineData, 2849);

            AssertUtils.AssertEqual_TimeLineData("KLine2TimeLine_M05_20150107", GetType(), timeLineData);
        }
コード例 #29
0
ファイル: TestKLineDataStore.cs プロジェクト: wanwei/sc2
        private void TestKLineDataStore_Append(string uri)
        {
            string          code           = "m1005";
            KLinePeriod     period         = KLinePeriod.KLinePeriod_1Minute;
            IDataStore      dataStore      = DataStoreFactory.CreateDataStore(uri);
            IKLineDataStore klineDataStore = dataStore.CreateKLineDataStore();

            try
            {
                IKLineData klineData  = MockDataLoader.GetKLineData(code, 20100107, 20100114, period);
                IKLineData klineData2 = MockDataLoader.GetKLineData(code, 20100115, 20100120, period);

                List <IKLineData> ks = new List <IKLineData>();
                ks.Add(klineData);
                ks.Add(klineData2);
                IKLineData klineData_Merge = KLineData.Merge(ks);


                klineDataStore.Save(code, period, klineData);
                klineDataStore.Append(code, period, klineData2);

                IKLineData klineData_Merge2 = klineDataStore.LoadAll(code, period);
                AssertUtils.AssertEqual_KLineData(klineData_Merge, klineData_Merge2);
            }
            finally
            {
                klineDataStore.Delete(code, period);
            }
        }
コード例 #30
0
        private static KLineBar GetChart_Day(IKLineData data, int startIndex, int endIndex)
        {
            KLineBar chart = GetChart(data, startIndex, endIndex);

            chart.Time = (int)data.Arr_Time[endIndex];
            return(chart);
        }