//DateTime.ParseExact(SLDecodedData[i], "M/d/yyyy h:mm:ss tt", CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.None);
public void UpdateAll(bool save = false)
{
string[] Pairs = ForexConfiguration.Products.ToArray();
ServiceConfiguration.TimeFrame[] Frames = Enums.ToList<ServiceConfiguration.TimeFrame>().ToArray();
for (int p = 0; p < Pairs.Length; p++)
{
string pair = Pairs[p];
if (!ForexArchive.Data.ContainsKey(pair)) ForexArchive.Data.Add(pair, new ThreadedDictionary<ServiceConfiguration.TimeFrame, ThreadedDictionary<DateTime, Rate>>()); //Add missing Key before adding new values
for (int f = 0; f < Frames.Length; f++)
{
ServiceConfiguration.TimeFrame frame = Frames[f];
if (frame == ServiceConfiguration.TimeFrame.LIVE) continue;
if (!ForexArchive.Data[pair].ContainsKey(frame)) ForexArchive.Data[pair].Add(frame, new ThreadedDictionary<DateTime, Rate>()); //Add Missing Key before adding values
ThreadsUpdate.Run(() => this.Update(pair, frame), "UpdatePair" + pair + "Frame" + frame.ToString(), true, true);
}
ThreadsUpdate.JoinAll();
}
}
private void UnloadRates(string pair, ServiceConfiguration.TimeFrame frame)
{
string path;
lock (Locker.Get("GetPath")) path = this.GetPath(frame, pair);
Rate[] Rates = Data[pair][frame].Values.ToArray();
//Do not disassembly if no data is availible
if (Rates == null || Rates.Length <= 0)
{
return;
}
StringBuilder builder = new StringBuilder();
for (int i = 0; i < Rates.Length; i++)
{
Rate rate = Rates[i];
builder.Append(ChartPointInfo.Serialize(rate.ChartData) + "$");//ToStringQuick()
}
byte[] bytes = Asmodat.IO.Compression.Zip(builder.ToString());
lock (Locker.Get("DataDisassembler")) DataDisassembler.Add(path, bytes);
}
public void GetStatistics(string pair, ServiceConfiguration.TimeFrame frame, int span, double confidence, ref double max, ref double average, ref double min, ref double test)
{
double[][] data = GetMonteCarlo(pair, frame, span, Index);
double[] values;
if (Objects.IsNullOrEmpty(data))
{
return;
}
values = Doubles.ToArray(data.ToArray(), span - 1, true, false);
if (Objects.IsNullOrEmpty(values))
{
return;
}
average = values.Average();
double change = AMath.StandarConfidence(values, average, confidence, false);
max = average + change;
min = average - change;
double success = 0;
for (int i = 1; i < Indexes.Length; i++)
{
var pack = GetMonteCarlo(pair, frame, span, Indexes[i]);
if (pack == null)
{
success = 0;
break;
}
double[][] packet = pack.ToArray();
values = Doubles.ToArray(packet, span - 1, true, false);
if (Objects.IsNullOrEmpty(values))
{
success = 0;
break;
}
double avg = values.Average();
double ch = AMath.StandarConfidence(values, avg, confidence, false);
double mx = avg + ch;
double mn = avg - ch;
double value = TestData[Indexes[i] + span];
if (value >= mn && value <= mx)
{
++success;
}
}
test = ((double)success / (Indexes.Length - 1)) * 100;
}
public static int ToPeriodsAccess(ServiceConfiguration.TimeFrame TimeFrame)
{
switch (TimeFrame)
{
case TimeFrame.LIVE: return(0);
case TimeFrame.ONE_MINUTE: return(15750); //45*350
case TimeFrame.FIVE_MINUTE: return(10150); //29*350 ~35 days
case TimeFrame.TEN_MINUTE: return(8750); //25*350 ~60 days
case TimeFrame.FIFTEEN_MINUTE: return(8400); //24*350 ~85 days
case TimeFrame.THIRTY_MINUTE: return(7700); //22*350 ~160 days
case TimeFrame.ONE_HOUR: return(7350); //21*350 ~305 days
case TimeFrame.TWO_HOUR: return(7350); //21*350 ~605 days
case TimeFrame.FOUR_HOUR: return(7350);
case TimeFrame.DAILY: return(3850); //11*350 ~10years
case TimeFrame.WEEKLY: return(1050); //3*350 ~15years
case TimeFrame.MONTHLY: return(350); //1*350~15years
default: return(-1);
}
}
/// <summary>
/// This method returns all chartpoints based on pair nad frame values
/// </summary>
/// <param name="pair"></param>
/// <param name="frame"></param>
/// <returns></returns>
public ChartPoint[] GetChartPoints(string pair, ServiceConfiguration.TimeFrame frame, int start = 0)
{
if (System.String.IsNullOrEmpty(pair) || !Data.ContainsKey(pair) || !Data[pair].ContainsKey(frame) || Data[pair][frame].Count <= 0)
{
return(new ChartPoint[0]);
}
Rate[] data = Data[pair][frame].ValuesArray;
int count = data.Length;
if (start >= count)
{
return(new ChartPoint[0]);
}
ChartPoint[] ACPoints = new ChartPoint[count - start];
Parallel.For(start, count, i =>//KeyValuePair<DateTime, Rate> KVP = Data[pair][frame].ElementAt(i);
{
ACPoints[i - start] = data[i].ChartData;
});
return(ACPoints);
}
public void Update(ServiceConfiguration.TimeFrame TimeFrame, List <Rate> Rates)
{
if (Rates == null || Rates.Count <= 0)
{
return;
}
string pair;
foreach (Rate Rate in Rates)
{
pair = Rate.Pair;
if (!Data.ContainsKey(pair))
{
Data.Add(pair, new ThreadedDictionary <ServiceConfiguration.TimeFrame, ThreadedDictionary <DateTime, Rate> >());
}
if (!Data[pair].ContainsKey(TimeFrame))
{
Data[pair].Add(TimeFrame, new ThreadedDictionary <DateTime, Rate>());
}
Data[pair][TimeFrame].Add(Rate.DateTime, Rate);
}
LastUpdate = DateTime.Now;
}
public string GetChartData(string tokem, string pair, ServiceConfiguration.TimeFrame frame, DateTime DateStart, DateTime DateEnd, bool wait = false)
{
string packet = "";
bool exception = false;
AsmodatForex.com.efxnow.democharting.chartingservice.TimeFrame OriginFrame = ForexConfiguration.TimeFrames[frame];
do
{
if (wait)
{
Thread.Sleep(1);
if (!ForexAuthentication.Connected) continue;
}
try
{
packet = CED_ChartingService.GetChartData(ForexAuthentication.Token, pair, OriginFrame, DateStart, DateEnd).Data;
exception = false;
}
catch(Exception Ex)
{
exception = true;
if (!wait) throw Ex;
}
} while (exception);
return packet;
}
public DateTime GetUpToDate(string pair, ServiceConfiguration.TimeFrame frame)
{
if (!UpToDate.ContainsKey(pair + frame))
{
UpToDate.Add(pair + frame, DateTime.MinValue);
}
return(UpToDate[pair + frame]);
}
public void SetUpToDate(string pair, ServiceConfiguration.TimeFrame frame, DateTime date)
{
if (!UpToDate.ContainsKey(pair + frame))
{
UpToDate.Add(pair + frame, date);
}
else
{
UpToDate[pair + frame] = date;
}
}
/// <summary>
/// Returns folder localisation for specified currency pair and time frame
/// </summary>
/// <param name="pair"></param>
/// <param name="frame"></param>
/// <returns></returns>
private string GetFolder(ServiceConfiguration.TimeFrame frame)
{
string FolderFrame = DirectoryData + @"\" + frame;
if (!Directory.Exists(FolderFrame))
{
Directory.CreateDirectory(FolderFrame);
}
return(FolderFrame);
}
/// <summary>
/// This method returns last rate based on pair nad frame values
/// </summary>
/// <param name="pair"></param>
/// <param name="frame"></param>
/// <returns></returns>
public Rate GetRate(string pair, ServiceConfiguration.TimeFrame frame)
{
if (System.String.IsNullOrEmpty(pair) || !Data.ContainsKey(pair) || !Data[pair].ContainsKey(frame) || Data[pair][frame].Count <= 0)
{
return(null);
}
Rate rate = Data[pair][frame].Last().Value;
rate.Frame = frame;
return(rate);
}
public void MonteCarlo(string pair, ServiceConfiguration.TimeFrame frame, int span, int tests)
{
if (Methods.Count >= tests + 1)
{
return;
}
Rate[] Rates = ForexArchive.Data.GetValuesArray <ServiceConfiguration.TimeFrame, DateTime, Rate>(pair, frame); //Manager.ForexArchive.Data[pair][ServiceConfiguration.TimeFrame.DAILY].ValuesArray;// //
if (Objects.IsNullOrEmpty(Rates) || !ServiceConfiguration.IsSpan(frame))
{
return;
}
double[] data = Objects.ToArray <double>(RateInfo.Extract(Rates, RateInfo.Properties.CLOSE));
TestData = data;
Key = pair + frame + span;
int[] points = AMath.Random(Rates.Length / 2, Rates.Length - 2 - span, tests);
if (Objects.IsNullOrEmpty(points) && tests > 0)
{
return;
}
List <int> indexes = new List <int>();
indexes.Add(data.Length - 1);
if (points != null)
{
indexes.AddRange(points);
}
Indexes = indexes.ToArray();
if (Objects.IsNullOrEmpty(Indexes))
{
return;
}
StopSimulations = false;
foreach (int i in Indexes)
{
Methods.Run(() => this.MonteCarlo(data, Key + "idx" + i, span, i), Key + "idx" + i, true, false);
}
}
public double[][] GetMonteCarlo(string pair, ServiceConfiguration.TimeFrame frame, int span, int index = -1)
{
if (index < 0)
{
index = Index;
}
string key = pair + frame + span + "idx" + index;
var data = MonteCarloData.GetValue(key);
if (Objects.IsNullOrEmpty(data))
{
return(null);
}
return(data.ValuesArray);
}
private string GetPath(ServiceConfiguration.TimeFrame frame, string pair)
{
string FolderFrame = DirectoryData + @"\" + frame;
string path = FolderFrame + @"\" + pair.Replace("/", "-") + FileDataExtention;
if (!Directory.Exists(FolderFrame))
{
Directory.CreateDirectory(FolderFrame);
}
if (!File.Exists(path))
{
File.CreateText(path).Close();
}
return(path);
}
private void UpdateItemsPair()
{
if (Manager == null)
{
return;
}
string pair = CmbxPair.Text;
string sframe = CmbxTimeFrame.Text;
if (System.String.IsNullOrEmpty(sframe) || !Manager.IsLoadedRate)
{
return;
}
ServiceConfiguration.TimeFrame frame = (ServiceConfiguration.TimeFrame)Enum.Parse(typeof(ServiceConfiguration.TimeFrame), sframe);
List <string> Pairs = new List <string>();
if (frame == ServiceConfiguration.TimeFrame.LIVE)
{
Pairs.AddRange(Manager.Service.Rates.Data.Keys);
}
else
{
Pairs.AddRange(Manager.Service.Archive.Data.Keys);
}
CmbxPair.Items.Clear();
CmbxPair.Items.AddRange(Pairs.ToArray());
if (System.String.IsNullOrEmpty(pair) || !Pairs.Contains(pair))
{
CmbxPair.SelectedIndex = 0;
}
else
{
CmbxPair.Text = pair;
}
}
public void Update(string pair, ServiceConfiguration.TimeFrame frame)
{
List<DateTime> frames = this.GetMissingDates(pair, frame);
if (frames.Count <= 1)
return;
//frames.Reverse();
double dTimePeriod = ServiceConfiguration.ToMinutes(frame);
//Decimals must be backchecked with number of decimals in order to set correct value;
int decimals = ForexConfiguration.GetDecimals(pair);
string data = "";
for (int i = 0; i < frames.Count - 1; i++)
{
DateTime DateStart = frames[i + 1];
DateTime DateEnd = frames[i];
Thread.Sleep(1); //Wait not to spam the server with requests
string packet = this.GetChartData(ForexAuthentication.Token, pair, frame, DateStart, DateEnd, true); //fresh data cames first
if (!System.String.IsNullOrEmpty(packet))
data = data + "$" + packet;
}
List<Rate> Rates;
if (!System.String.IsNullOrEmpty(data))
Rates = this.DecodeRates(pair, data); //Data is sorted by threaded dictionary
else Rates = new List<Rate>();
foreach (Rate rate in Rates)
{
if (ForexArchive.Data[pair][frame].ContainsKey(rate.DateTime)) continue;
ForexArchive.Data[pair][frame].Add(rate.DateTime, rate);
++ForexArchive.Updates;
}
}
private SplitOptions ToSplitOption(ServiceConfiguration.TimeFrame frame)
{
if (frame <= ServiceConfiguration.TimeFrame.LIVE)
{
return(SplitOptions.Daily);
}
else if (frame <= ServiceConfiguration.TimeFrame.THIRTY_MINUTE)
{
return(SplitOptions.Monthly);
}
else if (frame <= ServiceConfiguration.TimeFrame.FOUR_HOUR)
{
return(SplitOptions.Yearly);
}
else if (frame > ServiceConfiguration.TimeFrame.FOUR_HOUR)
{
return(SplitOptions.AllTimes);
}
throw new Exception("Unknown frame option");
}
/// <summary>
/// This method loads specified pair-frame data from file in hard drive
/// </summary>
/// <param name="pair"></param>
/// <param name="frame"></param>
private void LoadRates(string pair, ServiceConfiguration.TimeFrame frame)
{
if (DataAssembler.ContainsKey(frame) && DataAssembler[frame].ContainsKey(pair))
{
Dictionary <DateTime, Rate> Rates = RateInfo.ParseRates(DataAssembler[frame][pair]);
if (Rates == null || Rates.Count <= 0)
{
return;
}
this.Data[pair][frame].AddRange(Rates);
lock (Locker.Get("DataAssembler")) SetUpToDate(pair, frame, this.Data[pair][frame].Keys.Last());
/*
* string data;
* lock (Locker.Get("DataAssembler")) data = DataAssembler[frame][pair];//.ToString();
* Dictionary<DateTime, Rate> Rates = RateInfo.ParseRates(data);
* this.Data[pair][frame].AddRange(Rates);
* lock (Locker.Get("DataAssembler")) SetUpToDate(pair, frame, this.Data[pair][frame].Keys.Last());
*/
}
}
private void Peacemaker()
{
if (!IsFeed || !Manager.IsLoadedRate)
{
return;
}
string pair = this.Pair;
ServiceConfiguration.TimeFrame frame = this.Frame;
int span = this.Span;
double confidence = this.Confidecne;
int tests = TTbxBacktests.GetInt(this);
Rate[] Rates = Manager.ForexArchive.Data.GetValuesArray <ServiceConfiguration.TimeFrame, DateTime, Rate>(pair, frame); //Manager.ForexArchive.Data[pair][ServiceConfiguration.TimeFrame.DAILY].ValuesArray;// //
// TTbxMax.dec
if (Objects.IsNullOrEmpty(Rates) || !ServiceConfiguration.IsSpan(frame))
{
return;
}
Manager.ForexAnalysis.MonteCarlo(pair, frame, span, tests);
double[][] MonteCarloData = Manager.ForexAnalysis.GetMonteCarlo(pair, frame, span, -1);
if (Objects.IsNullOrEmpty(MonteCarloData))
{
Chart.Main.ClearSeries(this);
return;
}
double[] data = Objects.ToArray <double>(RateInfo.Extract(Rates, RateInfo.Properties.CLOSE));
DateTime[] dates = Objects.ToArray <DateTime>(RateInfo.Extract(Rates, RateInfo.Properties.DateTime));
double Min = 0;
double Avg = 0;
double Max = 0;
double Test = 0;
Manager.ForexAnalysis.GetStatistics(pair, frame, span, confidence, ref Max, ref Avg, ref Min, ref Test);
this.SetOutputStatistic(pair, Max, Avg, Min);
TTbxBacktestConfidence.SetValue(this, Test);
TTbxBacktestSamples.SetValue(this, Manager.ForexAnalysis.MonteCarloBacktestSamples);
double[] next = MonteCarloData.Last();// MonteCarloSimulation.Next(data, 50).ToArray();
if (next == null)
{
return;
}
TTbxTestSamples.SetValue(this, MonteCarloData.Length);
List <double> combine = new List <double>();
combine.AddRange(data);
combine.AddRange(next);
if (Chart.Main.Series.Count <= 0 || Chart.Main.Series[0].Name != pair || Chart.Main.ID != frame + pair + span + tests)
{
Chart.Main.ID = frame + pair + span + tests;
Chart.Main.ClearSeries(this);
Chart.Main.Add(pair, SeriesChartType.Line, this);
DataPoint[] points = ChartPointInfo.ToDataPoints(data, dates, ServiceConfiguration.Span(frame));
Chart.Main.AddRange(this, pair, points, ChartValueType.DateTime, ChartValueType.Double);
}
else
{
DataPoint[] points = ChartPointInfo.ToDataPoints(next, dates.Last(), ServiceConfiguration.Span(frame));
Chart.Main.UpdateRange(this, pair, points, ChartValueType.DateTime, ChartValueType.Double);
}
}
/// <summary>
/// This method searches and returns missing time periods in DateTime list in archive data.
/// This data is stored in UTC format
/// </summary>
/// <param name="pair"></param>
/// <param name="TimeFrame"></param>
public List<DateTime> GetMissingDates(string pair, ServiceConfiguration.TimeFrame TimeFrame)
{
double dTimePeriod = ServiceConfiguration.ToMinutes(TimeFrame);
int iPeriodMultiplayer = 350; //This value defines time span between values inside list
int iMaxPeriods = ServiceConfiguration.ToPeriodsAccess(TimeFrame); //Maximum periods of data that are avalaible for download
List<DateTime> Data = ForexArchive.Data[pair][TimeFrame].Keys.ToList();// .SortedKeys;
List<DateTime> DataMissing = new List<DateTime>();
int iDataCount = Data.Count;
if (dTimePeriod <= 0) throw new Exception("This time period is not vaild.");
DateTime CurrentDate = LatestMarketOppened;
DateTime EndDate;
if (Data.Count <= 0)
EndDate = DateTime.UtcNow.AddMinutes(-dTimePeriod * iMaxPeriods);
else EndDate = Data.Max();
DataMissing.Add(CurrentDate);
do
{
DateTime DateChangeStart = CurrentDate;
do
CurrentDate = CurrentDate.AddMinutes(-1);
while ((DateChangeStart - CurrentDate).TotalMinutes < iPeriodMultiplayer * dTimePeriod);//Continue while period change is less then multiplayer
if (CurrentDate >= EndDate)
{
//CurrentDate = FutureMarketOppened(CurrentDate);
DataMissing.Add(CurrentDate);
}
else
{
DataMissing.Add(EndDate);
break;
}
} while (CurrentDate > EndDate);
DateTime[] DateArray = DataMissing.ToArray();
//remove spare data
if (DateArray != null)
for (int i = 1; i < DateArray.Length - 1; )
{
DateTime last = DateArray[i - 1];
DateTime current = DateArray[i];
DateTime future = DateArray[i + 1];
bool lastClosed = !IsMarketOppened(last);
bool currentClosed = !IsMarketOppened(current);
bool futureCloased = !IsMarketOppened(future);
if (lastClosed && currentClosed && futureCloased)
DataMissing.Remove(current);
if ((currentClosed && futureCloased && i + 1 == DateArray.Length - 1))
DataMissing.Remove(future);
++i;
}
if (DataMissing.Count <= 1 || DataMissing.Last() >= DataMissing.First())
return new List<DateTime>();
return DataMissing;
}
