/// <summary>
///
/// </summary>
public TimeSeries()
{
Name = "Series1";
IntegrationOrder = 1;
Frequency = DataFrequency.Daily;
_timeDataDict = new SortedList <DateTime, T>();
}
public TimeSeries(IEnumerable <TSDataPoint <T> > datapoints, string name, uint integrationOrder, DataFrequency freq = DataFrequency.Daily)
{
Name = "Series1";
IntegrationOrder = integrationOrder;
Frequency = freq;
_timeDataDict = new SortedList <DateTime, T>();
foreach (var d in datapoints)
{
_timeDataDict.Add(d.Date, d.Value);
}
}
private List <DataFrequency> SortFrequenciesByDescending(Dictionary <string, int> dict)
{
List <DataFrequency> data = new List <DataFrequency>();
foreach (KeyValuePair <string, int> entry in dict)
{
DataFrequency dataPoint = new DataFrequency(entry.Key, entry.Value);
data.Add(dataPoint);
}
data = data.OrderByDescending(location => location.frequency).ToList();
return(data);
}
/// <summary>
/// Create a single variable time series object with a specific length, given an enumerable sequence with 'infinite' length
/// </summary>
/// <param name="data">Infinite enumerable sequence</param>
/// <param name="integrationOrder">The time series integration order, in finance this translates to 0 for returns series and 1 for a price series</param>
/// <param name="numperiods">The length (number of time periods) of the time series, takes the first n samples from the enumerable sequence</param>
/// <param name="freq">The frequency of the data, i.e. Daily, Weekly, Monthly etc</param>
/// <returns>A single variable time series object that implements the generic ITimeSeries interface</returns>
public static ITimeSeries <T> Create(IEnumerable <T> data, uint integrationOrder, int numperiods, DataFrequency freq)
{
string name = "series1";
List <TSDataPoint <T> > datapoints = new List <TSDataPoint <T> >();
switch (freq)
{
case DataFrequency.Monthly:
{
int count = 0;
// Use TakeWhile ??
foreach (var d in data)
{
datapoints.Add(new TSDataPoint <T>(DateTime.Today.AddMonths(-count), d));
count++;
if (count >= numperiods)
{
break;
}
}
}
break;
case DataFrequency.Daily:
{
int count = 0;
foreach (var d in data)
{
datapoints.Add(new TSDataPoint <T>(DateTime.Today.AddDays(-count), d));
count++;
if (count >= numperiods)
{
break;
}
}
}
break;
default:
{
int count = 0;
foreach (var d in data)
{
datapoints.Add(new TSDataPoint <T>(DateTime.Today.AddDays(-count), d));
count++;
if (count >= numperiods)
{
break;
}
}
}
break;
}
return(new TimeSeries <T>(datapoints, name, integrationOrder, freq));
}
public static ITimeSeries <T> Create(IEnumerable <TSDataPoint <T> > timeseries, uint integrationOrder = 1, DataFrequency frequency = DataFrequency.Daily)
{
return(new TimeSeries <T>(timeseries, "Series1", integrationOrder, frequency));
}
public static ITimeSeries <double> RandomWalk(double drift, double stepsigma, int numsteps = 100, DataFrequency freq = DataFrequency.Daily)
{
var norm = new Normal(drift, stepsigma);
norm.RandomSource = new Random(RandomSeed);
var data = norm.Samples();
var walk = new List <double>();
var last = 1.0;
walk.Add(last);
int count = 0;
// Use TakeWhile ??
foreach (var d in data)
{
last = last + d;
walk.Add(last);
count++;
if (count >= numsteps)
{
break;
}
}
return(TimeSeriesFactory <double> .Create(walk, integrationOrder : 1, freq : freq));
}
public static ITimeSeries <double> Gaussian(double mu, double sigma, int numperiods = 100, DataFrequency freq = DataFrequency.Daily)
{
var norm = new Normal(mu, sigma);
norm.RandomSource = new Random(RandomSeed);
var data = norm.Samples();
return(TimeSeriesFactory <double> .Create(data, 0, numperiods, freq));
}
