E:/Projects/Visual Studio/CSharp/GEP .NET Framework/GEP.Core/Float/TimeSeries/InterestRateTimeSeries.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 InterestRateTimeSeries : 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 InterestRateTimeSeries() { }

        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 closestToFrom = new DateTime(0);
            float closestToFromValue = 0;
            DateTime closestToTo = new DateTime(0);
            float closestToToValue = 0;
            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)
                    {
                        parsed = float.Parse(row[_dataColIndex]);
                        list.Add(rowDateTime, parsed);
                    }
                    else
                    {
                        parsed = float.Parse(row[_dataColIndex]);
                        if (Math.Abs(from.Ticks - rowDateTime.Ticks) < Math.Abs(from.Ticks - closestToFrom.Ticks))
                        {
                            closestToFrom = rowDateTime;
                            closestToFromValue = parsed;
                        }
                        if (Math.Abs(rowDateTime.Ticks - to.Ticks) < Math.Abs(closestToTo.Ticks - to.Ticks))
                        {
                            closestToTo = rowDateTime;
                            closestToToValue = parsed;
                        }
                    }
                }
                rowIndex++;
            }
            list.Add(closestToTo, closestToToValue);
            list.Add(closestToFrom, closestToFromValue);
            streamReader.Close();
            List<float> result = new List<float>();
            KeyValuePair<DateTime, float>? previousPair = null;
            if (_timePeriod == "MN")
            {
                SortedDictionary<DateTime, float> rates = new SortedDictionary<DateTime, float>();
                DateTime monthStart = (from == from.Date ? from : from.Date.AddMonths(1));
                DateTime monthEnd = monthStart.AddMonths(1).AddTicks(-1);
                long ticksInMonth;
                float monthRate;
                do
                {
                    closestToFrom = new DateTime(0);
                    closestToFromValue = 0;
                    closestToTo = new DateTime(0);
                    closestToToValue = 0;
                    foreach (KeyValuePair<DateTime, float> pair in list)
                    {
                        if (monthStart <= pair.Key && pair.Key <= monthEnd)
                        {
                            rates.Add(pair.Key, pair.Value);
                        }
                        else
                        {
                            if (pair.Key < monthStart &&
                                Math.Abs(monthStart.Ticks - pair.Key.Ticks) <
                                Math.Abs(monthStart.Ticks - closestToFrom.Ticks))
                            {
                                closestToFrom = pair.Key;
                                closestToFromValue = pair.Value;
                            }
                            if (monthEnd < pair.Key &&
                                Math.Abs(pair.Key.Ticks - monthEnd.Ticks) <
                                Math.Abs(closestToTo.Ticks - monthEnd.Ticks))
                            {
                                closestToTo = pair.Key;
                                closestToToValue = pair.Value;
                            }
                        }
                    }
                    rates.Add(closestToTo, closestToToValue);
                    rates.Add(closestToFrom, closestToFromValue);
                    monthRate = 0;
                    ticksInMonth = monthEnd.Subtract(monthStart).Ticks;
                    foreach (KeyValuePair<DateTime, float> pair in rates)
                    {
                        if (previousPair != null)
                            monthRate += previousPair.Value.Value *
                                Intersect(monthStart, monthEnd, previousPair.Value.Key, pair.Key).Ticks / ticksInMonth;
                        previousPair = pair;
                    }
                    previousPair = null;
                    result.Add(monthRate);
                    rates.Clear();
                    monthStart = monthStart.AddMonths(1);
                    monthEnd = monthStart.AddMonths(1).AddTicks(-1);
                } while (monthStart <= to);
            }
            System.Threading.Thread.CurrentThread.CurrentCulture = replacedCultureInfo;
            return result.ToArray();
        }

        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);
        }

        protected TimeSpan Intersect(DateTime i1Start, DateTime i1End, DateTime i2Start, DateTime i2End)
        {
            DateTime min = DateTime.MaxValue;
            DateTime max = DateTime.MinValue;
            if (i2Start <= i1Start && i1Start <= i2End)
            {
                max = (max < i1Start ? i1Start : max);
                min = (min < i1Start ? min : i1Start);
            }
            if (i2Start <= i1End && i1End <= i2End)
            {
                max = (max < i1End ? i1End : max);
                min = (min < i1End ? min : i1End);
            }
            if (i1Start <= i2Start && i2Start <= i1End)
            {
                max = (max < i2Start ? i2Start : max);
                min = (min < i2Start ? min : i2Start);
            }
            if (i1Start <= i2End && i2End <= i1End)
            {
                max = (max < i2End ? i2End : max);
                min = (min < i2End ? min : i2End);
            }
            return max.Subtract(min);
        }
    }
}

GEP .NET Framwork Main Page