Pierre8rTeam
322 lines
25 KiB
Plaintext
322 lines
25 KiB
Plaintext
//+------------------------------------------------------------------+
|
||
//| TimeSeries.mqh |
|
||
//| Copyright 2017, Vasiliy Sokolov. |
|
||
//| http://www.mql5.com |
|
||
//+------------------------------------------------------------------+
|
||
#property copyright "Copyright 2017, Vasiliy Sokolov."
|
||
#property link "http://www.mql5.com"
|
||
#include <Arrays\ArrayObj.mqh>
|
||
|
||
#include "TimeValue.mqh"
|
||
//+------------------------------------------------------------------+
|
||
//| Universal timeseries: stores the values of TimeValue and |
|
||
//| provides quick access to them |
|
||
//+------------------------------------------------------------------+
|
||
class CTimeSeries
|
||
{
|
||
private:
|
||
CArrayObj m_series;
|
||
bool m_reverse;
|
||
datetime FromFinamData(string data);
|
||
public:
|
||
bool Add(datetime time, double value);
|
||
bool Add(datetime time, double& values[]);
|
||
void AddOrChange(datetime time, double value, int buff_index=0);
|
||
void Clear();
|
||
int Total(void){return m_series.Total();}
|
||
double operator[](int index);
|
||
double operator[](datetime time);
|
||
bool GetReverse(void);
|
||
void SetReverse(bool reverse);
|
||
CTimeValue* GetTimeValue(datetime time);
|
||
CTimeValue* GetTimeValue(int index);
|
||
void OrderBy(ENUM_COMP_TYPE comp_type);
|
||
int SearchLessOrEqual(datetime time);
|
||
bool SaveToCsv(datetime begin_time, datetime end_time, string path, int common=FILE_COMMON, int time_format=TIME_DATE|TIME_MINUTES, int digits = 4, uchar del = ';');
|
||
CTimeSeries(void);
|
||
bool LoadFromCsv(string path_csv, uchar del=',', int line_begin=0, int common = FILE_COMMON);
|
||
int LoadFromArray(uchar& array[], uchar del=',', int line_begin=0);
|
||
bool ExitsDataByTime(datetime time);
|
||
void ToDoubleArray(double& array[]);
|
||
void ToDoubleArray(int column, double& array[]);
|
||
};
|
||
//+------------------------------------------------------------------+
|
||
//| Default initialization |
|
||
//+------------------------------------------------------------------+
|
||
CTimeSeries::CTimeSeries() : m_reverse(false)
|
||
{
|
||
OrderBy(COMP_BY_TIME);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Sorting series |
|
||
//+------------------------------------------------------------------+
|
||
void CTimeSeries::OrderBy(ENUM_COMP_TYPE comp_type)
|
||
{
|
||
m_series.Sort(comp_type);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Adds a new value to the collection. If the data for the specified|
|
||
//| date already exist, returns false, and the data are not added |
|
||
//+------------------------------------------------------------------+
|
||
bool CTimeSeries::Add(datetime time,double value)
|
||
{
|
||
if(ExitsDataByTime(time))
|
||
return false;
|
||
CTimeValue* tv = new CTimeValue(time, value);
|
||
return m_series.InsertSort(tv);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Returns the first column as an array of type double |
|
||
//+------------------------------------------------------------------+
|
||
void CTimeSeries::ToDoubleArray(double &array[])
|
||
{
|
||
ToDoubleArray(0, array);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Returns column with number 'column' as an array of type double |
|
||
//+------------------------------------------------------------------+
|
||
void CTimeSeries::ToDoubleArray(int column,double &array[])
|
||
{
|
||
int total = m_series.Total();
|
||
ArrayResize(array, total);
|
||
for(int i = 0; i < total; i++)
|
||
{
|
||
CTimeValue* tv = m_series.At(i);
|
||
array[i] = tv.Value(column);
|
||
}
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Returns true if the data for the specified date exist |
|
||
//| returns false otherwise |
|
||
//+------------------------------------------------------------------+
|
||
bool CTimeSeries::ExitsDataByTime(datetime time)
|
||
{
|
||
if(m_series.Total() == 0)
|
||
return false;
|
||
CTimeValue* t = m_series.At(m_series.Total()-1);
|
||
if(t.Time() < time)
|
||
return false;
|
||
if(t.Time() == time)
|
||
return true;
|
||
CTimeValue* tv_s = new CTimeValue(time, 0.0);
|
||
int index = m_series.Search(tv_s);
|
||
delete tv_s;
|
||
return (index != -1);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Adds a new value to the collection, if a value with such time |
|
||
//| is not present. If an element with this time at the specified |
|
||
//| index exists, modifies its values |
|
||
//+------------------------------------------------------------------+
|
||
void CTimeSeries::AddOrChange(datetime time,double value, int buff_index=0)
|
||
{
|
||
if(m_series.SortMode() != COMP_BY_TIME)
|
||
m_series.Sort(COMP_BY_TIME);
|
||
int index = -1;
|
||
if(m_series.Total() > 0)
|
||
{
|
||
CTimeValue* t = m_series.At(m_series.Total()-1);
|
||
if(t.Time() > time)
|
||
{
|
||
CTimeValue* tv_s = new CTimeValue(time, value);
|
||
index = m_series.Search(tv_s);
|
||
delete tv_s;
|
||
}
|
||
}
|
||
CTimeValue* tv = NULL;
|
||
if(index == -1)
|
||
{
|
||
tv = new CTimeValue(time, value);
|
||
m_series.InsertSort(tv);
|
||
}
|
||
else
|
||
{
|
||
tv = m_series.At(index);
|
||
tv.Value(buff_index, value);
|
||
}
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Saves content to a CSV file |
|
||
//+------------------------------------------------------------------+
|
||
bool CTimeSeries::SaveToCsv(datetime begin_time, datetime end_time, string path, int common=FILE_COMMON, int time_format=TIME_DATE|TIME_MINUTES, int digits = 4, uchar del = ';')
|
||
{
|
||
string lines[];
|
||
int total = ArrayResize(lines, m_series.Total());
|
||
string s = "";
|
||
int count = 0;
|
||
for(int i = 0; i < total; i++)
|
||
{
|
||
CTimeValue* tv = m_series.At(i);
|
||
if(tv.Time() < begin_time)
|
||
continue;
|
||
if(tv.Time() > end_time)
|
||
break;
|
||
lines[count] = tv.ToString(time_format, digits, del)+"\r\n";
|
||
count++;
|
||
s = lines[i];
|
||
}
|
||
total = ArrayResize(lines, count);
|
||
int h = FileOpen(path, FILE_WRITE|FILE_TXT|common, del, CP_ACP);
|
||
if(h == INVALID_HANDLE)
|
||
return false;
|
||
for(int i = 0; i < total; i++)
|
||
FileWriteString(h, lines[i]);
|
||
FileClose(h);
|
||
return true;
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Removes all items from the collection |
|
||
//+------------------------------------------------------------------+
|
||
void CTimeSeries::Clear(void)
|
||
{
|
||
m_series.Clear();
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Adds a list of new values to the collection |
|
||
//+------------------------------------------------------------------+
|
||
bool CTimeSeries::Add(datetime time,double& values[])
|
||
{
|
||
if(time == D'2017.06.12')
|
||
int dbg = 4;
|
||
if(ExitsDataByTime(time))
|
||
return false;
|
||
CTimeValue* tv = new CTimeValue(time, values);
|
||
return m_series.InsertSort(tv);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Sets direct or reverse indexation in a collection |
|
||
//+------------------------------------------------------------------+
|
||
void CTimeSeries::SetReverse(bool reverse)
|
||
{
|
||
m_reverse = reverse;
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Returns true if reverse indexation is used, returns false |
|
||
//| if otherwise. |
|
||
//+------------------------------------------------------------------+
|
||
bool CTimeSeries::GetReverse(void)
|
||
{
|
||
return m_reverse;
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Get the index value |
|
||
//+------------------------------------------------------------------+
|
||
double CTimeSeries::operator[](int index)
|
||
{
|
||
CTimeValue* tv = NULL;
|
||
if(!m_reverse)
|
||
tv = m_series.At(index);
|
||
else
|
||
{
|
||
int ri = m_series.Total() - index - 1;
|
||
tv = m_series.At(ri);
|
||
}
|
||
return tv.Value();
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Returns the closest value with a smaller or the same time |
|
||
//+------------------------------------------------------------------+
|
||
double CTimeSeries::operator[](datetime time)
|
||
{
|
||
int index = SearchLessOrEqual(time);
|
||
if(index == -1)
|
||
return EMPTY_VALUE;
|
||
CTimeValue* tv = m_series.At(index);
|
||
return tv.Value();
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Returns the closest value with a smaller or the same time |
|
||
//| TimeValue |
|
||
//+------------------------------------------------------------------+
|
||
CTimeValue* CTimeSeries::GetTimeValue(datetime time)
|
||
{
|
||
CTimeValue* tv = NULL;
|
||
int index = SearchLessOrEqual(time);
|
||
if(index == -1)
|
||
return tv;
|
||
tv = m_series.At(index);
|
||
return tv;
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Returns the TimeValue corresponding to the index |
|
||
//+------------------------------------------------------------------+
|
||
CTimeValue* CTimeSeries::GetTimeValue(int index)
|
||
{
|
||
return m_series.At(index);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Returns index of element with time equal to specified. |
|
||
//| If no element with this time exist, returns an element with time |
|
||
//| less than specified but greater than other elements with smaller |
|
||
//| time |
|
||
//+------------------------------------------------------------------+
|
||
int CTimeSeries::SearchLessOrEqual(datetime time)
|
||
{
|
||
CTimeValue* tv_s = new CTimeValue(time, EMPTY_VALUE);
|
||
if(m_series.SortMode() != COMP_BY_TIME)
|
||
m_series.Sort(COMP_BY_TIME);
|
||
int index = m_series.SearchLessOrEqual(tv_s);
|
||
delete tv_s;
|
||
return index;
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Loads a CSV file from the drive to a timeseries |
|
||
//+------------------------------------------------------------------+
|
||
bool CTimeSeries::LoadFromCsv(string path_csv, uchar del=',', int line_begin=0, int common = FILE_COMMON)
|
||
{
|
||
int h = FileOpen(path_csv, FILE_READ|FILE_BIN|common);
|
||
if(h == INVALID_HANDLE)
|
||
{
|
||
printf("Failed open file " + path_csv + " Last error: " + (string)GetLastError());
|
||
return false;
|
||
}
|
||
uchar array[];
|
||
FileReadArray(h, array, 0, WHOLE_ARRAY);
|
||
FileClose(h);
|
||
return (LoadFromArray(array, del, line_begin)>0);
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Loads a CSV file passed as a byte array to a timeseries. |
|
||
//| |
|
||
//| Returns the number of lines added |
|
||
//+------------------------------------------------------------------+
|
||
int CTimeSeries::LoadFromArray(uchar &array[], uchar del=',',int line_begin=0)
|
||
{
|
||
string csv = CharArrayToString(array, 0, WHOLE_ARRAY, CP_ACP);
|
||
string lines[];
|
||
StringSplit(csv, '\n', lines);
|
||
int total = ArraySize(lines);
|
||
int count = 0;
|
||
for(int i = line_begin; i < total; i++)
|
||
{
|
||
string col[];
|
||
double values[];
|
||
string l = lines[i];
|
||
if(StringSplit(lines[i], del, col)<=1)
|
||
continue;
|
||
int col_size = ArraySize(col)-1;
|
||
ArrayResize(values, col_size);
|
||
datetime time = FromFinamData(col[0]);
|
||
for(int c = 1; c <= col_size; c++)
|
||
values[c-1] = StringToDouble(col[c]);
|
||
if(Add(time, values))
|
||
count++;
|
||
}
|
||
return count;
|
||
}
|
||
//+------------------------------------------------------------------+
|
||
//| Parses the broker date |
|
||
//+------------------------------------------------------------------+
|
||
datetime CTimeSeries::FromFinamData(string data)
|
||
{
|
||
int l = StringLen(data);
|
||
uchar ch = (uchar)StringGetCharacter(data, 0);
|
||
int year = (int)StringSubstr(data, 0, 4);
|
||
int month = (int)StringSubstr(data, 4, 2);
|
||
int day = (int)StringSubstr(data, 6, 2);
|
||
MqlDateTime time_str={0};
|
||
time_str.day = day;
|
||
time_str.year = year;
|
||
time_str.mon = month;
|
||
return StructToTime(time_str);
|
||
} |