public void TestTimeFactoryApplyRuleC()
{
System.Threading.Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("zh-Hans");
TimeSeriesFactory ts = new TimeSeriesFactory(new[] {
new DateTime(2017, 5, 10),
new DateTime(2017, 5, 11),
new DateTime(2017, 5, 13),
new DateTime(2017, 7, 10),
new DateTime(2017, 8, 10),
new DateTime(2017, 9, 10),
});
ts.Apply(new RulePeriodSequence(PeriodType.Month, 3, TimeUnit.Day));
ts.Apply(new RuleDistinct());
ts.Apply(new RuleConditionShift(DateType.TradingDay, -1, TimeUnit.TradingDay));
var resultA = string.Join(",", ts.DateTimes.Select(x => x.ToShortDateString()));
var resultB = string.Join(",", new[] {
"2017/5/3",
"2017/7/3",
"2017/8/3",
"2017/9/1",
});
Assert.AreEqual(resultA, resultB);
}
public void CanCreateWaterLevelSeries()
{
var waterLevelSeries = TimeSeriesFactory.CreateWaterLevelTimeSeries();
Assert.IsTrue(waterLevelSeries.IsWaterLevelSeries());
Assert.AreEqual("m AD", waterLevelSeries.Components[0].Unit.Symbol);
}
public void ZeroChangeData()
{
var ts = TimeSeriesFactory <double> .Create(Enumerable.Repeat(10.0, 100), 1, DataFrequency.Daily);
var sd = PortfolioAnalytics.AnnualisedStdDev(ts);
Assert.AreEqual(0, sd);
}
public void ZeroStdDev()
{
// Create zero std dev time series object
var ts = TimeSeriesFactory <double> .Create(Enumerable.Repeat(10.0, 100), 1, DataFrequency.Daily);
var res = PortfolioEngine.PortfolioAnalytics.SharpeRatio(ts, 0.04);
Assert.IsTrue(double.IsInfinity(res));
}
private List <string> CalculateTimeByTimeRule(TimeRuleViewModel timeRule, TimeSeriesFactory timeSeries)
{
if (!timeRule.IsExistRule)
{
return(timeSeries.DateTimes.Select(x => Toolkit.DateToString(x)).ToList());
}
var order = 0;
foreach (var item in timeRule.TimeRuleOrder)
{
order++;
var timeRuleType = CommUtils.ParseEnum <TimeRuleType>(item);
switch (timeRuleType)
{
case TimeRuleType.MoveAppointDate:
var shiftRule = timeRule.ShiftList.Single(x => x.Ranking == order);
var shiftRuleUnitType = CommUtils.ParseEnum <TimeUnit>(shiftRule.ConditionUnitType);
var shiftRuleInterval = shiftRule.TimeMoveDirection == TimeMoveDirection.Minus.ToString()
? shiftRule.Interval * -1 : shiftRule.Interval;
timeSeries.Apply(new RuleShift(shiftRuleInterval, shiftRuleUnitType));
break;
case TimeRuleType.FindAppointDate:
var periodSequence = timeRule.PeriodSequenceList.Single(x => x.Ranking == order);
var periodSequenceUnitType = CommUtils.ParseEnum <TimeUnit>(periodSequence.ConditionUnitType);
var periodType = CommUtils.ParseEnum <PeriodType>(periodSequence.PeriodType);
timeSeries.Apply(new RulePeriodSequence(periodType, periodSequence.Interval, periodSequenceUnitType));
break;
case TimeRuleType.ReplaceAppointDate:
var conditionShift = timeRule.ConditionShiftList.Single(x => x.Ranking == order);
var conditionShiftUnitType = CommUtils.ParseEnum <TimeUnit>(conditionShift.ConditionUnitType);
var conditionShiftInterval = conditionShift.TimeMoveDirection == TimeMoveDirection.Minus.ToString()
? conditionShift.Interval * -1 : conditionShift.Interval;
var conditionShiftDateType = CommUtils.ParseEnum <DateType>(conditionShift.DateType);
timeSeries.Apply(new RuleConditionShift(conditionShiftDateType, conditionShiftInterval, conditionShiftUnitType));
break;
case TimeRuleType.RemoveRepeatDate:
timeSeries.Apply(new RuleDistinct());
break;
default:
break;
}
}
return(timeSeries.DateTimes.Select(x => Toolkit.DateToString(x)).ToList());
}
public TimeSeriesFactory Transform(TimeSeriesFactory timeSeries)
{
return(new TimeSeriesFactory(timeSeries.DateTimes
.Select(x => {
var time = PeriodStart(x);
if (CheckCondition(time))
{
return time.AddTimeUnit(m_sequence - 1, m_unitType);
}
return time.AddTimeUnit(m_sequence, m_unitType);
})));
}
public void FirstDifferenceTest()
{
var tsl = new List <TSDataPoint <double> >();
tsl.Add(new TSDataPoint <double>(DateTime.Now.AddDays(2), 10));
tsl.Add(new TSDataPoint <double>(DateTime.Now.AddDays(1), 11));
tsl.Add(new TSDataPoint <double>(DateTime.Now.AddDays(3), 13));
tsl.Add(new TSDataPoint <double>(DateTime.Now.AddDays(5), 11));
tsl.Add(new TSDataPoint <double>(DateTime.Now.AddDays(8), 12));
tsl.Add(new TSDataPoint <double>(DateTime.Now.AddDays(7), 14));
tsl.Add(new TSDataPoint <double>(DateTime.Now.AddDays(11), 15));
var ts = TimeSeriesFactory <double> .Create(tsl, "Lala", frequency : DataFrequency.Daily);
var ret = ts.FirstDifference(ReturnMethod.Arithmetic);
}
public void TestTimeFactoryConstructD()
{
TimeSeriesFactory ts = new TimeSeriesFactory(
new DateTime(2017, 5, 5),
new TimeStep {
Interval = 1, Unit = TimeUnit.Year
},
new DateTime(2019, 5, 10));
var resultA = string.Join(",", ts.DateTimes.Select(x => x.ToShortDateString()));
var resultB = string.Join(",", new[] {
"2017/5/5",
"2018/5/5",
"2019/5/5",
});
Assert.AreEqual(resultA, resultB);
}
private List <string> GetTimeListByTimeRuleOrigin(TimeRuleViewModel timeRule, TimeOriginViewModel timeOrigin)
{
var timeOriginType = CommUtils.ParseEnum <TimeOriginType>(timeOrigin.TimeOriginType);
TimeSeriesFactory timeSeriesFactory;
var result = new List <string>();
if (timeOriginType == TimeOriginType.CustomInput)
{
var customTimeList = CommUtils.Split(timeOrigin.CustomInput.CustomTimeList).Select(x => DateTime.Parse(x));
timeSeriesFactory = new TimeSeriesFactory(customTimeList);
result = CalculateTimeByTimeRule(timeRule, timeSeriesFactory);
}
if (timeOriginType == TimeOriginType.Loop)
{
var startTime = DateTime.Parse(timeOrigin.Loop.BeginTime);
var endTime = DateTime.Parse(timeOrigin.Loop.EndTime);
var ruleUnitType = CommUtils.ParseEnum <TimeUnit>(timeOrigin.Loop.RuleUnitType);
timeSeriesFactory = new TimeSeriesFactory(
new DateTime(startTime.Year, startTime.Month, startTime.Day),
new TimeStep {
Interval = timeOrigin.Loop.Interval, Unit = ruleUnitType
},
new DateTime(endTime.Year, endTime.Month, endTime.Day));
result = CalculateTimeByTimeRule(timeRule, timeSeriesFactory);
}
if (timeOriginType == TimeOriginType.MetaTask)
{
result = GetTimeListByPrevMetaTask(timeRule, timeOrigin.PrevMetaTask.MetaTaskGuid, timeOrigin.PrevMetaTask.MetaTaskTimeType);
}
if (timeOriginType == TimeOriginType.TaskSelfTime)
{
var timeSeries = m_dbAdapter.TimeSeries.GetByGuid(timeOrigin.TaskSelfTime.TimeSeriesGuid);
var CurrTimeRule = GetTimeRuleDetail(timeSeries.Id);
var CurrTimeOrigin = GetTimeOriginDetail(timeSeries.Guid, timeSeries.Id);
var timeList = GetTimeListByTimeRuleOrigin(CurrTimeRule, CurrTimeOrigin).Select(x => DateTime.Parse(x));
timeSeriesFactory = new TimeSeriesFactory(timeList);
result = CalculateTimeByTimeRule(timeRule, timeSeriesFactory);
}
return(result);
}
public void TestTimeFactoryConstructB()
{
TimeSeriesFactory ts = new TimeSeriesFactory(new[] {
new DateTime(2017, 5, 10),
new DateTime(2017, 5, 11),
new DateTime(2017, 5, 13),
new DateTime(2017, 7, 10),
new DateTime(2017, 8, 10),
});
var resultA = string.Join(",", ts.DateTimes.Select(x => x.ToShortDateString()));
var resultB = string.Join(",", new[] {
"2017/5/10",
"2017/5/11",
"2017/5/13",
"2017/7/10",
"2017/8/10",
});
Assert.AreEqual(resultA, resultB);
}
public void TestTimeFactoryApplyRuleA()
{
TimeSeriesFactory ts = new TimeSeriesFactory(
new DateTime(2017, 5, 5),
new TimeStep {
Interval = 1, Unit = TimeUnit.TradingDay
},
new DateTime(2017, 5, 10));
ts.Apply(new RuleShift(3, TimeUnit.Day));
var resultA = string.Join(",", ts.DateTimes.Select(x => x.ToShortDateString()));
var resultB = string.Join(",", new[] {
"2017/5/8",
"2017/5/11",
"2017/5/12",
"2017/5/13",
});
Assert.AreEqual(resultA, resultB);
}
/// <summary>
///
/// </summary>
/// <param name="portfolio"></param>
/// <param name="timeseries"></param>
public static ITimeSeries <double> GetTimeSeries(this fPortfolio portfolio)
{
string[] timevector;
double[,] timeseries;
var expr = fPortfolio.Engine.CallFunction("getSeries", portfolio.Expression);
var timeexpr = fPortfolio.Engine.CallFunction("time", expr);
var timestring = fPortfolio.Engine.CallFunction("as.character", timeexpr);
var mat = expr.AsNumericMatrix();
var time = timestring.AsCharacter();
timevector = time.ToArray <string>();
int numrows = mat.RowCount;
int numcols = mat.ColumnCount;
timeseries = new double[numrows, numcols];
mat.CopyTo(timeseries, numrows, numcols);
return(TimeSeriesFactory <double> .Create(timeseries, timevector));
}
public void TestTimeFactoryApplyRuleB()
{
System.Threading.Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("zh-Hans");
TimeSeriesFactory ts = new TimeSeriesFactory(
new DateTime(2017, 5, 5),
new TimeStep {
Interval = 1, Unit = TimeUnit.TradingDay
},
new DateTime(2017, 5, 10));
ts.Apply(new RuleShift(3, TimeUnit.TradingDay));
var resultA = string.Join(",", ts.DateTimes.Select(x => x.ToShortDateString()));
var resultB = string.Join(",", new[] {
"2017/5/10",
"2017/5/11",
"2017/5/12",
"2017/5/15",
});
Assert.AreEqual(resultA, resultB);
}
private List <string> GetTimeListByPrevMetaTask(TimeRuleViewModel timeRule, string metaTaskGuid, string metaTaskTimeType)
{
var metaTask = m_dbAdapter.MetaTask.GetByGuid(metaTaskGuid);
var timeType = CommUtils.ParseEnum <MetaTaskTimeType>(metaTaskTimeType);
var result = new List <string>();
TimeSeriesFactory timeSeriesFactory;
if (timeType == MetaTaskTimeType.StartTime)
{
if (!metaTask.StartTimeSeriesId.HasValue || metaTask.StartTimeSeriesId.Value == 0)
{
return(null);
}
var timeSeries = m_dbAdapter.TimeSeries.GetById(metaTask.StartTimeSeriesId.Value);
var timeRuleDetail = GetTimeRuleDetail(timeSeries.Id);
var timeOriginDetail = GetTimeOriginDetail(timeSeries.Guid, timeSeries.Id);
var timeStrList = GetTimeListByTimeRuleOrigin(timeRuleDetail, timeOriginDetail);
var timeList = timeStrList.ConvertAll(x => DateTime.Parse(x));
timeSeriesFactory = new TimeSeriesFactory(timeList);
result = CalculateTimeByTimeRule(timeRule, timeSeriesFactory);
}
if (timeType == MetaTaskTimeType.EndTime)
{
var timeSeries = m_dbAdapter.TimeSeries.GetById(metaTask.EndTimeSeriesId);
var timeRuleDetail = GetTimeRuleDetail(timeSeries.Id);
var timeOriginDetail = GetTimeOriginDetail(timeSeries.Guid, timeSeries.Id);
var timeStrList = GetTimeListByTimeRuleOrigin(timeRuleDetail, timeOriginDetail);
var timeList = timeStrList.ConvertAll(x => DateTime.Parse(x));
timeSeriesFactory = new TimeSeriesFactory(timeList);
result = CalculateTimeByTimeRule(timeRule, timeSeriesFactory);
}
return(result);
}
public TimeSeriesFactory Transform(TimeSeriesFactory timeSeries)
{
return(new TimeSeriesFactory(timeSeries.DateTimes.Distinct()));
}
public TimeSeriesFactory Transform(TimeSeriesFactory timeSeries)
{
return(new TimeSeriesFactory(timeSeries.DateTimes
.Select(x => x.AddTimeUnit(m_interval, m_timeUnit))));
}
public void CreateFromVector()
{
var data = TimeSeriesFactory <double> .Create(new[] { 0, 0.02, -0.03, 0.02, -0.015, 0, 0.02, 0.03, 0.02, -0.015, 0, -0.02, 0.03, 0.02, -0.015 }, 0, DataFrequency.Monthly);
}
