public DataNavigate_Code_KLine(IDataPackage_Code dataPackage, double time, KLinePeriod klinePeriod)
{
this.dataPackage = dataPackage;
this.klinePeriod = klinePeriod;
this.sessionReader = dataPackage.GetTradingTimeReader();
this.ChangeTime(time);
}
public List <ITimeLineData> GetData(String code, int startDate, int endDate)
{
if (startDate > endDate)
{
return(new List <ITimeLineData>());
}
CodeInfo codeInfo = dataReader.CodeReader.GetCodeInfo(code);
if (codeInfo == null)
{
return(new List <ITimeLineData>());
}
if ((codeInfo.End != 0 && codeInfo.End < startDate) || (codeInfo.Start != 0 && codeInfo.Start > endDate))
{
return(new List <ITimeLineData>());
}
int lastTradingDay = dataReader.TradingDayReader.GetPrevTradingDay(startDate);
IKLineData klineData_Day = dataReader.KLineDataReader.GetData(code, lastTradingDay, lastTradingDay, KLinePeriod.KLinePeriod_1Day);
IKLineData klineData_1Min = dataReader.KLineDataReader.GetData(code, startDate, endDate, KLinePeriod.KLinePeriod_1Minute);
ITradingTimeReader_Code tradingSessionReader = dataReader.CreateTradingTimeReader(code);
float lastEndPrice = klineData_Day == null ? -1 : klineData_Day.Arr_End[0];
return(DataTransfer_KLine2TimeLine.ConvertTimeLineDataList(klineData_1Min, lastEndPrice, tradingSessionReader));
}
public ITradingTimeReader_Code GetTradingTimeReader()
{
if (this.tradingTimeReader == null)
{
this.tradingTimeReader = dataReader.CreateTradingTimeReader(this.code);
}
return(this.tradingTimeReader);
}
public void TestTradingSession_GetTradingDay()
{
ITradingTimeReader_Code reader = GetTradingSessionCache_Instrument("m1405");
int date = reader.GetTradingDay(20140505.092000);
Assert.AreEqual(20140505, date);
date = reader.GetTradingDay(20140505.082000);
Assert.AreEqual(-1, date);
date = reader.GetRecentTradingDay(20140505.082000);
Assert.AreEqual(20140430, date);
date = reader.GetRecentTradingDay(20140505.192000);
Assert.AreEqual(20140505, date);
reader = GetTradingSessionCache_Instrument("m1605");
date = reader.GetTradingDay(20150717.220000);
Assert.AreEqual(20150720, date);
date = reader.GetTradingDay(20150718.220000);
Assert.AreEqual(20150720, date);
date = reader.GetRecentTradingDay(20150816.100000, true);
Assert.AreEqual(20150817, date);
date = reader.GetRecentTradingDay(20150816.100000, false);
Assert.AreEqual(20150817, date);
date = reader.GetRecentTradingDay(20150816.100000, false);
Assert.AreEqual(20150817, date);
date = reader.GetRecentTradingDay(20150814.160000, true);
Assert.AreEqual(20150817, date);
date = reader.GetRecentTradingDay(20150814.160000, false);
Assert.AreEqual(20150814, date);
date = reader.GetRecentTradingDay(30150718.220000);
Assert.AreEqual(20160520, date);
reader = GetTradingSessionCache_Instrument("m1705");
date = reader.GetRecentTradingDay(20170130.10, false);
Assert.AreEqual(20170126, date);
date = reader.GetRecentTradingDay(20170130.10);
Assert.AreEqual(20170126, date);
reader = GetTradingSessionCache_Instrument("m0405");
date = reader.GetRecentTradingDay(10150718.220000);
Assert.AreEqual(-1, date);
reader = GetTradingSessionCache_Instrument("RB1805");
date = reader.GetRecentTradingDay(20171221.2101);
Assert.AreEqual(20171222, date);
}
public void TestGetTradingDay()
{
ITradingTimeReader_Code reader = GetTradingSessionCache_Instrument("M1305");
int day = reader.GetTradingDay(20130105.093000);
Assert.AreEqual(-1, day);
day = reader.GetTradingDay(20130108.090000);
Assert.AreEqual(20130108, day);
day = reader.GetTradingDay(20130108.085900);
Assert.AreEqual(-1, day);
}
public void TestTradingTime_GetRecentTime()
{
ITradingTimeReader_Code reader = GetTradingSessionCache_Instrument("RB1801");
double time = reader.GetRecentTradingTime(20170930.0900, false);
Assert.AreEqual(20170929.15, time);
time = reader.GetRecentTradingTime(20170929.1501, false);
Assert.AreEqual(20170929.15, time);
time = reader.GetRecentTradingTime(20170929.1401, false);
Assert.AreEqual(20170929.1401, time);
time = reader.GetRecentTradingTime(20170929.1201, false);
Assert.AreEqual(20170929.1130, time);
time = reader.GetRecentTradingTime(20170929.0801, false);
Assert.AreEqual(20170928.2300, time);
}
private IList <double[]>[] GetPeriodArr(string code, int startDate, int endDate, KLinePeriod klinePeriod)
{
ITradingTimeReader_Code tradingTimeReader_Code = this.dataReader.CreateTradingTimeReader(code);
List <int> allTradingDays = klineDataStore.GetAllTradingDay(code, klinePeriod);
CacheUtils_TradingDay cache = new CacheUtils_TradingDay(allTradingDays);
IList <int> tradingDays = cache.GetTradingDays(startDate, endDate);
IList <double[]>[] periodArr = new List <double[]> [tradingDays.Count];
for (int i = 0; i < tradingDays.Count; i++)
{
int tradingDay = tradingDays[i];
ITradingTime time = tradingTimeReader_Code.GetTradingTime(tradingDay);
IList <double[]> periods = time.TradingPeriods;
periodArr[i] = periods;
}
return(periodArr);
}
/// <summary>
/// 返回一个整型数组的list
/// 整型数组第一项是日期，第二项是index
/// </summary>
/// <param name="timeGetter"></param>
/// <returns></returns>
public static List <SplitterResult> Split(TimeGetter timeGetter, ITradingTimeReader_Code tradingSessionReader)
{
List <SplitterResult> indeies = new List <SplitterResult>(500);
double time = timeGetter.GetTime(0);
int date = tradingSessionReader.GetTradingDay(time);
indeies.Add(new SplitterResult(date, 0));
for (int index = 1; index < timeGetter.Count; index++)
{
time = timeGetter.GetTime(index);
if (tradingSessionReader.IsStartTime(time))
{
date = tradingSessionReader.GetTradingDay(time);
indeies.Add(new SplitterResult(date, index));
}
}
return(indeies);
}
/// <summary>
/// 将源k线数据转换成目标k线数据
/// 源只可能是1分钟、1小时、1日
/// </summary>
/// <param name="data"></param>
/// <param name="targetPeriod"></param>
/// <param name="openTimeList"></param>
/// <returns></returns>
public static IKLineData Transfer(IKLineData data, KLinePeriod targetPeriod, ITradingTimeReader_Code tradingSessionReader)
{
if (targetPeriod.PeriodType == KLineTimeType.DAY)
{
return(Transfer_Day(data, targetPeriod, tradingSessionReader));
}
KLinePeriod sourcePeriod = data.Period;
if (sourcePeriod.PeriodType == KLineTimeType.MINUTE)
{
if (targetPeriod.PeriodType == KLineTimeType.HOUR)
{
targetPeriod = new KLinePeriod(sourcePeriod.PeriodType, targetPeriod.Period * 60);
}
return(Transfer_SrcIs1Minute(data, targetPeriod, tradingSessionReader));
}
if (sourcePeriod.PeriodType == KLineTimeType.HOUR)
{
return(Transfer_SrcIs1Minute(data, targetPeriod, tradingSessionReader));
}
return(null);
}
internal static IDataPackage_Code CreateDataPackage(IDataReader dataReader, string code, int openDate, int beforeDays, int afterDays, int minKlineBefore, int minKlineAfter)
{
ITradingTimeReader_Code tradingTimeReader = dataReader.CreateTradingTimeReader(code);
ITradingDayReader tradingDayReader = dataReader.TradingDayReader;
int index = dataReader.TradingDayReader.GetTradingDayIndex(openDate);
int startIndex = index - beforeDays;
startIndex = startIndex < 0 ? 0 : startIndex;
int startDate = tradingDayReader.GetTradingDay(startIndex);
startDate = tradingTimeReader.GetRecentTradingDay(startDate, true);
int endIndex = index + afterDays;
if (endIndex >= tradingDayReader.GetAllTradingDays().Count)
{
endIndex = tradingDayReader.GetAllTradingDays().Count - 1;
}
int endDate = tradingDayReader.GetTradingDay(endIndex);
//endDate = tradingTimeReader.GetRecentTradingDay(endDate, false);
return(CreateDataPackage(dataReader, code, startDate, endDate, minKlineBefore, minKlineAfter));
}
public static List <ITimeLineData> ConvertTimeLineDataList(IKLineData data, float lastEndPrice, ITradingTimeReader_Code tradingSessionReader)
{
List <SplitterResult> splitResult = DaySplitter.Split(data, tradingSessionReader);
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);
}
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));
}
/// <summary>
/// 将k线转换成日线
/// </summary>
/// <param name="data"></param>
/// <param name="targetPeriod"></param>
/// <param name="timeSplit"></param>
/// <returns></returns>
public static IKLineData Transfer_Day(IKLineData data, KLinePeriod targetPeriod, ITradingTimeReader_Code startTimeReader)
{
List <SplitterResult> results = DaySplitter.Split(data, startTimeReader);
List <KLineBar> charts = new List <KLineBar>(results.Count);
for (int i = 0; i < results.Count; i++)
{
int startIndex = results[i].Index;
int endIndex = (i == results.Count - 1) ? data.Length - 1 : results[i + 1].Index - 1;
charts.Add(GetChart_Day(data, startIndex, endIndex));
}
return(GetKLineData(data.Code, charts));
}
private static IKLineData Transfer_DifferentPeriod(IKLineData data, KLinePeriod targetPeriod, ITradingTimeReader_Code startTimeReader)
{
KLinePeriod srcPeriod = data.Period;
if (targetPeriod.PeriodType == KLineTimeType.HOUR && srcPeriod.PeriodType == KLineTimeType.MINUTE)
{
KLinePeriod p = new KLinePeriod(srcPeriod.PeriodType, targetPeriod.Period * 60);
return(Transfer(data, p, startTimeReader));
}
return(null);
}
public DataNavigate_Code_TimeLine(IDataPackage_Code dataPackage, double time)
{
this.dataPackage = dataPackage;
this.sessionReader = dataPackage.GetTradingTimeReader();
this.ChangeTime(time);
}
public static List <SplitterResult> Split(IKLineData data, ITradingTimeReader_Code tradingSessionReader)
{
return(Split(new KLineDataTimeGetter(data), tradingSessionReader));
}
public KLineData_DaySplitter(IKLineData klineData, ITradingTimeReader_Code tradingSessionReader)
{
this.results = DaySplitter.Split(klineData, tradingSessionReader);
}
