public void LoadFromMetaSaverFile(string fileName)
{
string[] tokens = Path.GetFileNameWithoutExtension(fileName).Split(new char[1] {
'-'
});
this.Symbol = tokens[0];
int currencyPrecision = Int32.Parse(tokens[1]);
using (StreamReader str = new StreamReader(fileName))
{
string buf;
int koef = (int)Math.Pow(10, currencyPrecision);
while ((buf = str.ReadLine()) != null)
{
try
{
if (buf.Length != 0)
{
GroupTick gr = ParseMetaSaverGroupTick(buf, koef);
Data.Add(gr);
TickHistory.AddTick(gr.Tick);
}
}
catch (Exception exc)
{
System.Diagnostics.Trace.WriteLine(string.Format("Cannot Parse string {0}. Exception:{1}.", buf, exc.Message));
System.Diagnostics.Trace.Flush();
throw;
}
}
}
}
public void TickTack(GroupTick tick)
{
if (dayForTickTack != tick.DateTime.Day)
{
if (balanceLogger != null)
{
balanceLogger.AddMessage("{0}, {1}", tick.DateTime.ToLongDateString(), GetEquity());
}
dayForTickTack = tick.DateTime.Day;
this.Account.Statistics.AddEquityMarginStatistics(tick.DateTime, GetEquity(), Math.Max(TestAccount.MarginBuy, TestAccount.MarginSell));
}
//if (filterMinuteDateTime.Ticks / TickHistory.tickInOneMinute != tick.DateTime.Ticks / TickHistory.tickInOneMinute)
//{
// this.Account.Statistics.AddEquityMarginStatistics(tick.DateTime, GetEquity(), Math.Max(TestAccount.MarginBuy, TestAccount.MarginSell));
// filterMinuteDateTime = tick.DateTime;
//}
if (tick.DateTime.Hour == 23 && currentTick.DateTime.Hour == 22)
{
RunRollover();
}
currentTick = tick;
ActivateMarketOrders(marketBuyOrders);
ActivateMarketOrders(marketSellOrders);
ActivateLimitOrders(limitBuyOrders);
ActivateLimitOrders(limitSellOrders);
strategy.TesterTick(tick.Tick);
}
private void ButtonBuildMirror_Click(object sender, RoutedEventArgs e)
{
foreach (SymbolChooser.SymbolViewItem svi in symbolChooser.SymbolViewItems)
{
InputData inDataAll = new InputData();
inDataAll.LoadFromDirectory(svi.FullPath, null);
GroupTick baseTick = inDataAll.Data.First();
List <GroupTick> newTicks = new List <GroupTick>();
foreach (GroupTick grTick in inDataAll.Data)
{
GroupTick newTick = new GroupTick();
newTick.DateTime = baseTick.DateTime.Add(baseTick.DateTime - grTick.DateTime);
newTick.OpenBid = grTick.OpenBid;
newTick.OpenAsk = grTick.OpenAsk;
newTick.CloseAsk = grTick.CloseAsk;
newTick.CloseBid = grTick.CloseBid;
newTick.MaxBid = grTick.MaxBid;
newTick.MaxAsk = grTick.MaxAsk;
newTick.MinBid = grTick.MinBid;
newTick.MinAsk = grTick.MinAsk;
newTick.volume = grTick.volume;
newTicks.Add(newTick);
}
newTicks.Reverse();
newTicks.AddRange(inDataAll.Data);
inDataAll.Data = newTicks;
inDataAll.SaveToDirectory(Path.Combine(TextBoxDestinationPath.Text, svi.Symbol),
inDataAll.Data.First().DateTime, inDataAll.Data.Last().DateTime);
}
}
public void Orders(Order order, GroupTick tick, OrderModificationType type)
{
if (logger != null)
{
logger.AddMessage(string.Format("{0}, {1}, {2}, {3}", tick.DateTime.ToString("yyyyMMdd HH:mm:ss"), tick.OpenAsk, OrderModificationTypeConvertor.ToString(type), order.ToString()));
}
}
private void Run(bool isCloseAtTheEnd)
{
try
{
if (!strategy.TesterStart(inputData.Data.Count, this, this, this, this, this, inputData.Symbol))
{
return;
}
if (inputData.Data.Count > 0)
{
currentTick = inputData.Data[0];
}
else
{
isTestSuccessfull = true;
return;
}
DateTime filterMinuteDateTime = DateTime.MinValue;
foreach (GroupTick tick in inputData.Data)
{
TickTack(tick);
}
if (inputData.Data.Count > 0)
{
this.Account.Statistics.AddEquityMarginStatistics(inputData.Data.Last().DateTime, GetEquity(), Math.Max(TestAccount.MarginBuy, TestAccount.MarginSell));
}
if (isCloseAtTheEnd)
{
CloseAllOrders();
strategy.TesterEnd();
if (onEndStrategy != null)
{
onEndStrategy(this, new EventArgs());
}
}
isTestSuccessfull = true;
}
catch (ApplicationException exc)
{
if (orderLogger != null)
{
orderLogger.AddMessage(exc.ToString());
}
}
catch (Exception exc)
{
if (orderLogger != null)
{
orderLogger.AddMessage(exc.ToString());
}
}
}
public bool AddGroupTick(GroupTick gt)
{
if (this.Data == null || this.Data.Count == 0 || this.Data.Last().DateTime < gt.DateTime)
{
this.Data.Add(gt);
this.TickHistory.AddGroupTick(gt);
return(true);
}
return(false);
}
internal void AddGroupTick(GroupTick groupTick)
{
int index = 0;
if (!timeToIndexDictionary.TryGetValue(groupTick.DateTime.Ticks / tickInOneMinute, out index))
{
historyTicks.Add(groupTick);
timeToIndexDictionary[groupTick.DateTime.Ticks / tickInOneMinute] = historyTicks.Count - 1;
return;
}
historyTicks[index] = groupTick;
}
private void Run(bool debugMode)
{
if (inputData.Data.Count > 0)
{
currentTick = inputData.Data[0];
}
ordersCollection.ActivatingLimitOrder += new EventHandler <OrdersExecutor.OrderEventArgs>(ordersCollection_ActivatingLimitOrder);
ordersCollection.ActivatingMarketSLOrder += new EventHandler <OrdersExecutor.OrderEventArgs>(ordersCollection_ActivatingMarketSLOrder);
ordersCollection.ActivatingMarketTPOrder += new EventHandler <OrdersExecutor.OrderEventArgs>(ordersCollection_ActivatingMarketTPOrder);
if (!strategy.TesterStart(inputData.Data.Count, this, this, this, this, this, inputData.Symbol))
{
return;
}
int nextInterrupt = 0;
bool isReadOnlyActivated = false;
for (currentTickIndex = 0; currentTickIndex < inputData.Data.Count;)
{
if (!isReadOnlyActivated && currentTickIndex >= this.ReadOnlyPoint)
{
isReadOnlyActivated = true;
strategy.SetReadOnly(true);
}
IsBlankTick = true;
currentTick = inputData.Data[currentTickIndex];
ordersCollection.Proccess(currentTick);
strategy.TesterTick(currentTick.Tick);
if (IsBlankTick == false && nextInterrupt != currentTickIndex)
{
throw new ApplicationException("Wrong fast logic");
}
nextInterrupt = fPredictor.CalculateNextInterruption(currentTickIndex);
if (debugMode)
{
currentTickIndex++;
}
else
{
currentTickIndex = nextInterrupt;
}
}
CloseAllOrders();
strategy.TesterEnd();
}
internal InputDataShift NormalizeInputData(DateTime startTime, DateTime endTime, long tickInPeriod, InputData inputData)
{
startTime = new DateTime((startTime.Ticks / tickInPeriod) * tickInPeriod).AddTicks(tickInPeriod);
DateTime currTime = startTime;
InputDataShift ids = new InputDataShift();
ids.Symbol = inputData.Symbol;
int iterator = 0;
if (inputData.Data[iterator].DateTime > currTime)
{
throw new ArgumentException("InputData contains less information than requested startTime");
}
GroupTick firstTick = null;
int shiftCounter = 0;
do
{
while (inputData.Data[iterator + 1].DateTime < currTime)
{
if (iterator + 1 >= inputData.Data.Count)
{
throw new ArgumentException("InputData contains less information than requested endTime");
}
iterator++;
}
if (firstTick == null)
{
firstTick = inputData.Data[iterator];
}
InputDataShift.GroupTickShift tickShift = new InputDataShift.GroupTickShift();
tickShift.GroupTick.CloseAsk = inputData.Data[iterator].CloseAsk - firstTick.CloseAsk;
tickShift.GroupTick.CloseBid = inputData.Data[iterator].CloseBid - firstTick.CloseBid;
tickShift.GroupTick.DateTime = currTime;
tickShift.GroupTick.MaxAsk = inputData.Data[iterator].MaxAsk - firstTick.MaxAsk;
tickShift.GroupTick.MaxBid = inputData.Data[iterator].MaxBid - firstTick.MaxBid;
tickShift.GroupTick.MinAsk = inputData.Data[iterator].MinAsk - firstTick.MinAsk;
tickShift.GroupTick.MinBid = inputData.Data[iterator].MinBid - firstTick.MinBid;
tickShift.GroupTick.OpenAsk = inputData.Data[iterator].OpenAsk - firstTick.OpenAsk;
tickShift.GroupTick.OpenBid = inputData.Data[iterator].OpenBid - firstTick.OpenBid;
tickShift.TimeShift = shiftCounter++;
ids.tickShift.Add(tickShift);
currTime = currTime.AddTicks(tickInPeriod);
} while (currTime <= endTime);
return(ids);
}
public void Proccess(GroupTick groupTick)
{
while (BuyLimits.Count > 0 && groupTick.MinAsk <= BuyLimits.Keys[0])
{
BuyLimits.Values[0].RemoveAll(p => p == null);
if (BuyLimits.Values[0].Count == 0)
{
BuyLimits.RemoveAt(0);
continue;
}
Order[] orders = BuyLimits.Values[0].ToArray();
Array.ForEach(orders, p => Activate(p, groupTick));
}
while (SellLimits.Count > 0 && groupTick.MaxBid >= SellLimits.Keys[0])
{
SellLimits.Values[0].RemoveAll(p => p == null);
if (SellLimits.Values[0].Count == 0)
{
SellLimits.RemoveAt(0);
continue;
}
Order[] orders = SellLimits.Values[0].ToArray();
Array.ForEach(orders, p => Activate(p, groupTick));
}
while (BuyStops.Count > 0 && groupTick.MaxAsk >= BuyStops.Keys[0])
{
BuyStops.Values[0].RemoveAll(p => p == null);
if (BuyStops.Values[0].Count == 0)
{
BuyStops.RemoveAt(0);
continue;
}
Order[] orders = BuyStops.Values[0].ToArray();
Array.ForEach(orders, p => Activate(p, groupTick));
}
while (SellStops.Count > 0 && groupTick.MinBid >= SellStops.Keys[0])
{
SellStops.Values[0].RemoveAll(p => p == null);
if (SellStops.Values[0].Count == 0)
{
SellStops.RemoveAt(0);
continue;
}
Order[] orders = SellStops.Values[0].ToArray();
Array.ForEach(orders, p => Activate(p, groupTick));
}
}
public void LoadFromUniversalFile(string filePath, int currencyPrecision, DateTime start, DateTime end)
{
MemoryStream mem = new MemoryStream();
using (ZipFile zip = ZipFile.Read(filePath))
{
foreach (ZipEntry ze in zip)
{
ze.Extract(mem);
}
}
mem.Position = 0;
using (StreamReader str = new StreamReader(mem))
{
string buf;
int koef = (int)Math.Pow(10, currencyPrecision);
while ((buf = str.ReadLine()) != null)
{
try
{
if (buf.Length != 0)
{
GroupTick gr = ParseMetaSaverGroupTick(buf, koef);
if (gr.DateTime < start)
{
continue;
}
if (gr.DateTime > end)
{
return;
}
Data.Add(gr);
TickHistory.AddTick(gr.Tick);
}
}
catch (Exception exc)
{
System.Diagnostics.Trace.WriteLine(string.Format("Cannot Parse string {0}. Exception:{1}.", buf, exc.Message));
System.Diagnostics.Trace.Flush();
throw;
}
}
}
}
//internal TickHistory Select( fromDate, DateTime toDate)
//{
// TickHistory newTickHistory = new TickHistory();
// var a = from currGT in historyTicks
// where currGT.Key > fromDate.Ticks / tickInOneMinute && currGT.Key < toDate.Ticks / tickInOneMinute
// select currGT;
// foreach (KeyValuePair<long, GroupTick> curr in a)
// newTickHistory.historyTicks.Add(curr.Key, curr.Value);
// return newTickHistory;
//}
internal void AddTick(Tick <int> tick)
{
GroupTick gt = null;
int index = 0;
if (!timeToIndexDictionary.TryGetValue(tick.DateTime.Ticks / tickInOneMinute, out index))
{
gt = new GroupTick();
gt.DateTime = tick.DateTime;
gt.CloseAsk = tick.Ask;
gt.CloseBid = tick.Bid;
gt.MaxAsk = tick.Ask;
gt.MaxBid = tick.Bid;
gt.MinAsk = tick.Ask;
gt.MinBid = tick.Bid;
gt.OpenAsk = tick.Ask;
gt.OpenBid = tick.Bid;
historyTicks.Add(gt);
timeToIndexDictionary[tick.DateTime.Ticks / tickInOneMinute] = historyTicks.Count - 1;
return;
}
gt = historyTicks[index];
gt.CloseAsk = tick.Ask;
gt.CloseBid = tick.Bid;
if (gt.MaxAsk < tick.Ask)
{
gt.MaxAsk = tick.Ask;
}
if (gt.MaxBid < tick.Bid)
{
gt.MaxBid = tick.Bid;
}
if (gt.MinAsk > tick.Ask)
{
gt.MinAsk = tick.Ask;
}
if (gt.MinBid > tick.Bid)
{
gt.MinBid = tick.Bid;
}
}
private void ButtonBuildToUSD_Click(object sender, RoutedEventArgs e)
{
foreach (SymbolChooser.SymbolViewItem svi in symbolChooser.SymbolViewItems)
{
if (!svi.Symbol.ToUpper().Contains("USD"))
{
continue;
}
InputData inDataAll = new InputData();
inDataAll.LoadFromDirectory(svi.FullPath, null);
if (svi.Symbol.ToUpper().EndsWith("USD"))
{
inDataAll.SaveToDirectory(Path.Combine(TextBoxDestinationPath.Text, svi.Symbol),
inDataAll.Data.First().DateTime, inDataAll.Data.Last().DateTime);
continue;
}
double coef = 10000000000;
List <GroupTick> newTicks = new List <GroupTick>();
GroupTick baseTick = inDataAll.Data.First();
foreach (GroupTick grTick in inDataAll.Data)
{
GroupTick newTick = new GroupTick();
newTick.DateTime = grTick.DateTime;
newTick.OpenBid = (int)(coef / grTick.OpenBid);
newTick.OpenAsk = (int)(coef / grTick.OpenAsk);
newTick.CloseAsk = (int)(coef / grTick.CloseAsk);
newTick.CloseBid = (int)(coef / grTick.CloseBid);
newTick.MaxBid = (int)(coef / grTick.MaxBid);
newTick.MaxAsk = (int)(coef / grTick.MaxAsk);
newTick.MinBid = (int)(coef / grTick.MinBid);
newTick.MinAsk = (int)(coef / grTick.MinAsk);
newTick.volume = grTick.volume;
newTicks.Add(newTick);
}
inDataAll.Data = newTicks;
inDataAll.SaveToDirectory(Path.Combine(TextBoxDestinationPath.Text, svi.Symbol.Remove(0, 3) + "USD"),
inDataAll.Data.First().DateTime, inDataAll.Data.Last().DateTime);
}
}
private GroupTick ParseMetaExportStandardGroupTick(string str, int fixedSpread, int koef)
{
try
{
string[] arrString = str.Split(',');
GroupTick tick = new GroupTick();
tick.DateTime = DateTime.ParseExact(arrString[0] + " " + arrString[1], "yyyy.MM.dd H:mm", CultureInfo.InvariantCulture);
tick.OpenBid = (int)(Decimal.Parse(arrString[2]) * koef);
tick.OpenAsk = tick.OpenBid + fixedSpread;
tick.MaxBid = (int)(Decimal.Parse(arrString[3]) * koef);
tick.MinBid = (int)(Decimal.Parse(arrString[4]) * koef);
tick.MinAsk = tick.MinBid + fixedSpread;
tick.MaxAsk = tick.MaxBid + fixedSpread;
tick.CloseBid = (int)(Decimal.Parse(arrString[5]) * koef);
tick.CloseAsk = tick.CloseBid + fixedSpread;
return(tick);
}
catch (Exception exc)
{
throw;
}
}
private GroupTick ParseMetaSaverGroupTick(string str, int koef)
{
try
{
string[] arrString = str.Split(',');
GroupTick tick = new GroupTick();
tick.DateTime = DateTime.ParseExact(arrString[0], "yyyy.MM.dd H:mm:ss", CultureInfo.InvariantCulture);
tick.OpenBid = (int)(Decimal.Parse(arrString[2]) * koef);
tick.OpenAsk = (int)(Decimal.Parse(arrString[1]) * koef);
tick.MaxBid = tick.OpenBid;
tick.MinBid = tick.OpenBid;
tick.MinAsk = tick.OpenAsk;
tick.MaxAsk = tick.OpenAsk;
tick.CloseBid = tick.OpenBid;
tick.CloseAsk = tick.OpenAsk;
return(tick);
}
catch (Exception exc)
{
throw;
}
}
private void Activate(Order order, GroupTick groupTick)
{
if (order.Type == OrderType.Limit)
{
RemoveLimitOrder(order);
OnActivatingLimitOrder(order);
return;
}
if (order.Side == OrderSide.Buy && order.TP <= groupTick.MaxBid && order.TP != 0 ||
order.Side == OrderSide.Sell && order.TP >= groupTick.MinAsk)
{
RemoveMarketOrder(order);
onActivatingMarketTPOrder(order);
return;
}
if (order.Side == OrderSide.Buy && order.SL >= groupTick.MinBid ||
order.Side == OrderSide.Sell && order.SL <= groupTick.MaxAsk && order.SL != 0)
{
RemoveMarketOrder(order);
onActivatingMarketSLOrder(order);
return;
}
}
public IEnumerable <Order> Init(DateTime currentDateTime, DateTime startSimulate, out List <string> logRecords)
{
logRecords = new List <string>();
string swapFilePath = Path.Combine(rootPath, "swap.txt");
string symbolPath = Path.Combine(rootPath, Symbol);
InputData inData = new InputData();
inData.LoadFromDirectory(symbolPath, new SwapCollection().LoadSwap(swapFilePath),
/*currentDateTime.AddMinutes( - CustomParam.InitHistoryMinutes)*/
startSimulate, currentDateTime);
DateTime dateTemp = inData.Data.Count == 0 ? startSimulate : inData.Data.Last().DateTime;
int shift = Meta.iBarShift(Symbol, CurrentGraphPeriod, dateTemp, false);
for (int i = shift; i > 0; i--)
{
GroupTick gt = new GroupTick();
gt.DateTime = currentDateTime.AddMinutes(-i);
gt.OpenBid = gt.OpenAsk = Meta.iOpen(CustomParam.Symbol, CurrentGraphPeriod, i);
gt.MaxBid = gt.MaxAsk = Meta.iHigh(CustomParam.Symbol, CurrentGraphPeriod, i);
gt.MinBid = gt.MinAsk = Meta.iLow(CustomParam.Symbol, CurrentGraphPeriod, i);
if (gt.OpenBid == 0 || gt.MaxBid == 0 || gt.MinBid == 0)
{
continue;
}
inData.AddGroupTick(gt);
}
logRecords.Add(string.Format("{0} {1} were loaded.", Symbol, inData.Data.Count));
CustomParam.InitHistoryMinutes = 0;
InputData inputData = inData;
Logger = new Log4Smart.Logger(false);
Engine = new Engine(Logger, Logger);
//save state of CurrentStrategyParam
int temp = CurrentStrategyParam["InitHistoryMinutes"];
CurrentStrategyParam["InitHistoryMinutes"] = 0;
string firstRawParam = CurrentStrategyParam.GetStringParameter("P1String");
CurrentStrategyParam.SetStringParameter("P1String", CustomParam.RawStrategyParam);
Advisor.TesterInit(CurrentStrategyParam, Logger);
Account acc = new Account(10000000, 4);
Engine.StartTest(inputData, Advisor, acc, false);
//restor state of CurrentStrategyParam
CurrentStrategyParam["InitHistoryMinutes"] = temp;
CurrentStrategyParam.SetStringParameter("P1String", firstRawParam);
IsSuccessful = Engine.IsTestSuccessfull;
if (!Engine.IsTestSuccessfull)
{
string directory = Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly().Location);
string fullDir = directory + string.Format("/errors/{0}/{1}/{2}/", inputData.Symbol, Guid.NewGuid().ToString(), inputData.Data.First().DateTime.ToString("yyyyMMdd"));
Logger.SaveLogToFile(fullDir, "error");
}
return(Engine.GetLimitOrders().Union(Engine.GetMarketOrders()));
}
public InputData BuildForPeriod(IEnumerable <PartialQuote> partQuotes)
{
foreach (PartialQuote pq in partQuotes)
{
pq.Verify();
}
if (partQuotes.Sum(p => p.Coefficient) - 1 > Double.Epsilon)
{
throw new ArgumentException("Sum of coef is not equal 1");
}
List <GroupTick> listGroupTick = new List <GroupTick>();
for (int i = 0; i < dictDataShifts.Values.First().tickShift.Count; i++)
{
GroupTick newTick = new GroupTick();
double CloseAsk = StartValue;
double CloseBid = StartValue;
double MaxAsk = StartValue;
double MaxBid = StartValue;
double MinAsk = StartValue;
double MinBid = StartValue;
double OpenAsk = StartValue;
double OpenBid = StartValue;
bool isFirstTime = true;
foreach (PartialQuote pq in partQuotes)
{
InputDataShift currIDS = dictDataShifts[pq.Symbol];
if (isFirstTime)
{
newTick.DateTime = currIDS.tickShift[i].GroupTick.DateTime;
isFirstTime = false;
}
else
if (newTick.DateTime != currIDS.tickShift[i].GroupTick.DateTime)
{
throw new ApplicationException("newTick.DateTime != pq.inputDataShift.tickShift[i].GroupTick.DateTime");
}
CloseAsk += (pq.Coefficient * currIDS.tickShift[i].GroupTick.CloseAsk);
CloseBid += (pq.Coefficient * currIDS.tickShift[i].GroupTick.CloseBid);
MaxAsk += (pq.Coefficient * currIDS.tickShift[i].GroupTick.MaxAsk);
MaxBid += (pq.Coefficient * currIDS.tickShift[i].GroupTick.MaxBid);
MinAsk += (pq.Coefficient * currIDS.tickShift[i].GroupTick.MinAsk);
MinBid += (pq.Coefficient * currIDS.tickShift[i].GroupTick.MinBid);
OpenAsk += (pq.Coefficient * currIDS.tickShift[i].GroupTick.OpenAsk);
OpenBid += (pq.Coefficient * currIDS.tickShift[i].GroupTick.OpenBid);
}
newTick.CloseAsk = (int)CloseAsk;
newTick.CloseBid = (int)CloseBid;
newTick.MaxAsk = (int)MaxAsk;
newTick.MaxBid = (int)MaxBid;
newTick.MinAsk = (int)MinAsk;
newTick.MinBid = (int)MinBid;
newTick.OpenAsk = (int)OpenAsk;
newTick.OpenBid = (int)OpenBid;
listGroupTick.Add(newTick);
}
InputData resultPeriod = new InputData(listGroupTick);
resultPeriod.Symbol = partQuotes.Select(p => p.Name).ToString();
return(resultPeriod);
}
