E:/Projects/Visual Studio/CSharp/GEP .NET Framework/GEP.Core/Float/TimeSeries/NormalTimeSeries.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Globalization;
using System.IO;

namespace GEP.Core.Float.TimeSeries
{
    [Serializable]
    public class NormalTimeSeries : ITimeSeries
    {
        public int _dateTimeColIndex;
        public int _dataColIndex;
        public string[] _colDelimiters;
        public int _dataStartRow;
        public int _dataEndRow;
        public DateTimeFormatInfo _dateTimeFormats;
        public string[] _dateTimeFormatsArr;
        public CultureInfo _cultureInfo;
        public DateTime _from;
        public DateTime _to;
        public float _devider;
        public string _timePeriod;
        public int _delay;
        public int _n_TimeFramesToSkip = -1;

        public NormalTimeSeries() { }

        public float[] ReadFile(string filePath, int maxLookBehind)
        {
            CultureInfo replacedCultureInfo = System.Threading.Thread.CurrentThread.CurrentCulture;
            FileStream readStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
            StreamReader streamReader = new StreamReader(readStream);
            SortedDictionary<DateTime, float> list = new SortedDictionary<DateTime, float>();
            int rowIndex = 0;
            float parsed;
            string line;
            string[] row;
            line = streamReader.ReadLine();
            row = line.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);
            _dataStartRow = int.Parse(row[0]);
            _dataEndRow = int.Parse(row[1]);
            _dateTimeColIndex = int.Parse(row[2]);
            _dataColIndex = int.Parse(row[3]);
            _devider = float.Parse(row[4]);
            _delay = int.Parse(row[5]);
            _timePeriod = streamReader.ReadLine();
            _cultureInfo = new CultureInfo(streamReader.ReadLine());
            System.Threading.Thread.CurrentThread.CurrentCulture = _cultureInfo;
            string emptyStr = "";
            List<string> dateTimePatternsL = new List<string>();
            while ((line = streamReader.ReadLine()) != emptyStr)
            {
                dateTimePatternsL.Add(line);
            }
            _dateTimeFormatsArr = dateTimePatternsL.ToArray();
            _dateTimeFormats = new DateTimeFormatInfo();
            _dateTimeFormats.SetAllDateTimePatterns(_dateTimeFormatsArr, 'd');
            List<string> colDelimitersL = new List<string>();
            while ((line = streamReader.ReadLine()) != emptyStr)
            {
                colDelimitersL.Add(line);
            }
            _colDelimiters = colDelimitersL.ToArray();
            _delay = -_delay;
            maxLookBehind = -maxLookBehind;
            DateTime from = _from;
            DateTime to = _to;
            switch (_timePeriod)
            {
                case "M1":
                    from = from.AddMinutes(_delay + maxLookBehind);
                    to = to.AddMinutes(_delay);
                    break;
                case "M5":
                    from = from.AddMinutes((_delay + maxLookBehind) * 5);
                    to = to.AddMinutes(_delay * 5);
                    break;
                case "M15":
                    from = from.AddMinutes((_delay + maxLookBehind) * 15);
                    to = to.AddMinutes(_delay * 15);
                    break;
                case "M30":
                    from = from.AddMinutes((_delay + maxLookBehind) * 30);
                    to = to.AddMinutes(_delay * 30);
                    break;
                case "H1":
                    from = from.AddHours(_delay + maxLookBehind);
                    to = to.AddHours(_delay);
                    break;
                case "H4":
                    from = from.AddHours((_delay + maxLookBehind) * 4);
                    to = to.AddHours(_delay * 4);
                    break;
                case "D1":
                    from = from.AddDays(_delay + maxLookBehind);
                    to = to.AddDays(_delay);
                    break;
                case "W1":
                    from = from.AddDays((_delay + maxLookBehind) * 7);
                    to = to.AddDays(_delay);
                    break;
                case "MN":
                    from = from.AddMonths(_delay + maxLookBehind);
                    to = to.AddMonths(_delay);
                    break;
                case "Q1":
                    from = from.AddMonths((_delay + maxLookBehind) * 3);
                    to = to.AddMonths(_delay * 3);
                    break;
                case "Y1":
                    from = from.AddYears(_delay + maxLookBehind);
                    to = to.AddYears(_delay);
                    break;
                default:
                    from = from.AddMonths(_delay + maxLookBehind);
                    to = to.AddMonths(_delay);
                    break;
            }
            DateTime previousDate = new DateTime(1, from.Month + 1, 1);
            while (!streamReader.EndOfStream && (rowIndex <= _dataEndRow || _dataEndRow < 0))
            {
                line = streamReader.ReadLine();
                if (rowIndex >= _dataStartRow)
                {
                    row = line.Split(_colDelimiters, StringSplitOptions.RemoveEmptyEntries);
                    DateTime rowDateTime;
                    rowDateTime = DateTime.ParseExact(row[_dateTimeColIndex], _dateTimeFormatsArr,
                        _dateTimeFormats, DateTimeStyles.None);
                    if (row[_dateTimeColIndex].Contains('q') || row[_dateTimeColIndex].Contains('Q'))
                    {
                        rowDateTime = rowDateTime.AddMonths((rowDateTime.Month - 1) * 2);
                    }
                    if (from <= rowDateTime && rowDateTime <= to)
                    {
                        if (_n_TimeFramesToSkip > -1)
                        {
                            switch (_timePeriod)
                            {
                                default:
                                    DateTime thresholdDate =
                                        new DateTime(rowDateTime.Year, rowDateTime.Month, _n_TimeFramesToSkip);
                                    if (previousDate.Month == rowDateTime.Month)
                                        continue;
                                    else if (rowDateTime < thresholdDate)
                                        continue;
                                    else
                                        previousDate = rowDateTime;
                                    break;
                            }
                        }
                        parsed = float.Parse(row[_dataColIndex]);
                        list.Add(rowDateTime, parsed);
                    }
                }
                rowIndex++;
            }
            streamReader.Close();
            float[] result = new float[list.Count];
            int j = 0;
            foreach (KeyValuePair<DateTime, float> pair in list)
            {
                result[j++] = pair.Value / _devider;
            }
            System.Threading.Thread.CurrentThread.CurrentCulture = replacedCultureInfo;
            return result;
        }

        public float[][] ReadFile(string filePath, int[] lookBehinds, int frequency)
        {
            int maxLookBehind = 0;
            for (int i = 0; i < lookBehinds.Length; i++)
            {
                if (maxLookBehind < lookBehinds[i])
                    maxLookBehind = lookBehinds[i];
            }
            
            float[] all = ReadFile(filePath, maxLookBehind);
            float[][] result = new float[lookBehinds.Length][];
            int timeSeriesLength = (all.Length - maxLookBehind) * frequency;
            for (int i = 0; i < result.Length; i++)
            {
                result[i] = new float[timeSeriesLength];
                for (int k = maxLookBehind - lookBehinds[i], m = 0; m < timeSeriesLength; k++, m++)
                {
                    for (int l = 0; l < frequency; l++, m++)
                    {
                        result[i][m] = all[k];
                    }
                    m--;
                }
            }
            return result;
        }

        public void ReadFileAndAddToAlphabet(Alphabet variablesSet, ref int variablesSetStartIndex,
            string filePath, int[] variableDisplayIndexs, string variableName, int[] lookBehinds, int frequency)
        {
            float[][] varVals = ReadFile(filePath, lookBehinds, frequency);
            for (int i = 0; i < varVals.Length; i++)
            {
                variablesSet[variablesSetStartIndex++] =
                    new Variable(varVals[i], variableName + " " + variableDisplayIndexs[i]);
            }
        }

        public void ReadFileAndAddToAlphabet(Alphabet variablesSet, ref int variablesSetIndex,
            string filePath, int variableDisplayIndex, string variableName)
        {
            float[] varVals = ReadFile(filePath, 0);
            variablesSet[variablesSetIndex++] = new Variable(varVals, variableName + " " + variableDisplayIndex);
        }
    }
}

GEP .NET Framwork Main Page