495 lines
27 KiB
MQL5
495 lines
27 KiB
MQL5
#define RESERVE_HISTORY_ORDERS 2000
|
|
|
|
#include "Order.mqh"
|
|
|
|
class HISTORYORDERS
|
|
{
|
|
private:
|
|
// HISTORYORDERS::Swap
|
|
int StartPos;
|
|
int LastPos;
|
|
|
|
int PrevAmountHistoryOrders;
|
|
|
|
int TradesProfit;
|
|
int TradesLoss;
|
|
|
|
int TradesShortTotal;
|
|
int TradesLongTotal;
|
|
|
|
int TradesShortProfit;
|
|
int TradesLongProfit;
|
|
|
|
double InitialDeposit;
|
|
double Withdrawal;
|
|
|
|
double GrossProfit;
|
|
double GrossLoss;
|
|
|
|
double MaxProfit;
|
|
double MaxLoss;
|
|
|
|
double Balance;
|
|
double MaxBalance;
|
|
double BalanceDD;
|
|
|
|
void InitStatistic()
|
|
{
|
|
this.LastPos = this.StartPos;
|
|
|
|
this.TradesProfit = 0;
|
|
this.TradesLoss = 0;
|
|
|
|
this.TradesShortTotal = 0;
|
|
this.TradesLongTotal = 0;
|
|
|
|
this.TradesShortProfit = 0;
|
|
this.TradesLongProfit = 0;
|
|
|
|
this.InitialDeposit = ((this.StartPos < this.AmountHistoryOrders) &&
|
|
(this.HistoryOrders[this.LastPos] == OP_BALANCE)) ? this.HistoryOrders[this.LastPos++].GetProfit() : 0;
|
|
this.Withdrawal = 0;
|
|
|
|
this.GrossProfit = 0;
|
|
this.GrossLoss = 0;
|
|
|
|
this.MaxProfit = 0;
|
|
this.MaxLoss = 0;
|
|
|
|
this.Balance = 0;
|
|
this.MaxBalance = 0;
|
|
this.BalanceDD = 0;
|
|
|
|
return;
|
|
}
|
|
|
|
void SetOrder( const double Profit, int &TradesLongShortProfit, int &TradesLongShortTotal )
|
|
{
|
|
if (Profit > 0)
|
|
{
|
|
if (Profit > this.MaxProfit)
|
|
this.MaxProfit = Profit;
|
|
|
|
this.GrossProfit += Profit;
|
|
|
|
this.TradesProfit++;
|
|
TradesLongShortProfit++;
|
|
}
|
|
else if (Profit < 0)
|
|
{
|
|
if (Profit < this.MaxLoss)
|
|
this.MaxLoss = Profit;
|
|
|
|
this.GrossLoss += Profit;
|
|
|
|
this.TradesLoss++;
|
|
}
|
|
|
|
this.Balance += Profit;
|
|
|
|
if (this.Balance > this.MaxBalance)
|
|
this.MaxBalance = this.Balance;
|
|
else if (this.MaxBalance - this.Balance > this.BalanceDD)
|
|
this.BalanceDD = this.MaxBalance - this.Balance;
|
|
|
|
TradesLongShortTotal++;
|
|
|
|
return;
|
|
}
|
|
|
|
void Refresh( void )
|
|
{
|
|
while (this.LastPos < this.AmountHistoryOrders)
|
|
{
|
|
switch (this.HistoryOrders[this.LastPos].GetType())
|
|
{
|
|
case ORDER_TYPE_BUY:
|
|
this.SetOrder(this.HistoryOrders[this.LastPos].GetFullProfit(), this.TradesLongProfit, this.TradesLongTotal);
|
|
|
|
break;
|
|
case ORDER_TYPE_SELL:
|
|
this.SetOrder(this.HistoryOrders[this.LastPos].GetFullProfit(), this.TradesShortProfit, this.TradesShortTotal);
|
|
|
|
break;
|
|
case OP_BALANCE:
|
|
if (this.LastPos != this.StartPos)
|
|
this.Withdrawal += this.HistoryOrders[this.LastPos].GetProfit();
|
|
else
|
|
this.InitialDeposit = this.HistoryOrders[this.LastPos].GetProfit();
|
|
}
|
|
|
|
this.LastPos++;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
static string DoubleToString( const double Num, const int digits )
|
|
{
|
|
return((Num == DBL_MAX) ? "Max" : ::DoubleToString(Num, digits));
|
|
}
|
|
|
|
protected:
|
|
// HISTORYORDERS::Swap
|
|
ORDER_BASE HistoryOrders[];
|
|
|
|
int ReserveHistoryOrders;
|
|
|
|
bool FlagChange;
|
|
|
|
bool Swap( HISTORYORDERS &OtherHistoryOrders )
|
|
{
|
|
#ifdef __MQL5__
|
|
const bool Res = ::ArraySwap(this.HistoryOrders, OtherHistoryOrders.HistoryOrders);
|
|
#else // #ifdef __MQL5__
|
|
const bool Res = false;
|
|
#endif // #ifdef __MQL5__ #else
|
|
|
|
if (Res)
|
|
{
|
|
this.AmountHistoryOrders = OtherHistoryOrders.AmountHistoryOrders;
|
|
this.ReserveHistoryOrders = OtherHistoryOrders.ReserveHistoryOrders;
|
|
this.FlagChange = OtherHistoryOrders.FlagChange;
|
|
|
|
this.StartPos = OtherHistoryOrders.StartPos;
|
|
this.LastPos = OtherHistoryOrders.LastPos;
|
|
|
|
this.PrevAmountHistoryOrders = OtherHistoryOrders.PrevAmountHistoryOrders;
|
|
|
|
this.TradesProfit = OtherHistoryOrders.TradesProfit;
|
|
this.TradesLoss = OtherHistoryOrders.TradesLoss;
|
|
|
|
this.TradesShortTotal = OtherHistoryOrders.TradesShortTotal;
|
|
this.TradesLongTotal = OtherHistoryOrders.TradesLongTotal;
|
|
|
|
this.TradesShortProfit = OtherHistoryOrders.TradesShortProfit;
|
|
this.TradesLongProfit = OtherHistoryOrders.TradesLongProfit;
|
|
|
|
this.InitialDeposit = OtherHistoryOrders.InitialDeposit;
|
|
this.Withdrawal = OtherHistoryOrders.Withdrawal;
|
|
|
|
this.GrossProfit = OtherHistoryOrders.GrossProfit;
|
|
this.GrossLoss = OtherHistoryOrders.GrossLoss;
|
|
|
|
this.MaxProfit = OtherHistoryOrders.MaxProfit;
|
|
this.MaxLoss = OtherHistoryOrders.MaxLoss;
|
|
|
|
this.Balance = OtherHistoryOrders.Balance;
|
|
this.MaxBalance = OtherHistoryOrders.MaxBalance;
|
|
this.BalanceDD = OtherHistoryOrders.BalanceDD;
|
|
}
|
|
|
|
return(Res);
|
|
}
|
|
|
|
public: // ORDER::IsChange2
|
|
void AddHistoryOrder( const ORDER_BASE &Order )
|
|
{
|
|
if (this.AmountHistoryOrders == this.ReserveHistoryOrders)
|
|
// https://www.mql5.com/ru/forum/282062/page48#comment_50770216
|
|
this.ReserveHistoryOrders = ::ArrayResize(this.HistoryOrders, ::MathMax(RESERVE_HISTORY_ORDERS,
|
|
this.ReserveHistoryOrders << 1));
|
|
|
|
// ORDER OrderTmp = Order; // https://www.mql5.com/ru/forum/492248/page3#comment_57718727
|
|
ORDER OrderTmp; OrderTmp = Order;
|
|
|
|
if (OrderTmp.IsNotNull() && this.AmountHistoryOrders < this.ReserveHistoryOrders)
|
|
{
|
|
OrderTmp.ToHistory();
|
|
|
|
this.HistoryOrders[this.AmountHistoryOrders++] = OrderTmp;
|
|
|
|
this.FlagChange = true;
|
|
}
|
|
|
|
return;
|
|
}
|
|
protected:
|
|
|
|
bool CopyFrom( const HISTORYORDERS* SourceOrders )
|
|
{
|
|
this.AmountHistoryOrders = SourceOrders.AmountHistoryOrders;
|
|
this.ReserveHistoryOrders = ::ArrayCopy(this.HistoryOrders, SourceOrders.HistoryOrders);
|
|
|
|
this.InitStat();
|
|
|
|
return(this.ReserveHistoryOrders == ::ArraySize(SourceOrders.HistoryOrders));
|
|
}
|
|
|
|
bool GetReduceOrder( ORDER_BASE &Order, const int Pos ) const
|
|
{
|
|
const bool Res = (Pos >= 0) && (Pos < this.AmountHistoryOrders);
|
|
|
|
if (Res)
|
|
{
|
|
double Sum = 0;
|
|
|
|
for (int i = 0; i <= Pos; i++)
|
|
Sum += this.HistoryOrders[i].GetFullProfit();
|
|
|
|
Order.Set(this.HistoryOrders[Pos].GetTicket(), OP_BALANCE, 0, NULL, "ReduceHistory", 0,
|
|
this.HistoryOrders[Pos].GetCloseTimeMsc(), 0, 0, 0,
|
|
this.HistoryOrders[Pos].GetCloseTimeMsc(), 0, Sum);
|
|
}
|
|
|
|
return(Res);
|
|
}
|
|
|
|
bool GetReduceOrder( ORDER_BASE &Order, const int Pos, const bool ChangeHistory )
|
|
{
|
|
const bool Res = this.GetReduceOrder(Order, Pos);
|
|
|
|
if (Res && ChangeHistory && Pos)
|
|
{
|
|
int Amount = 1;
|
|
|
|
for (int i = Pos + 1; i < this.AmountHistoryOrders; i++)
|
|
this.HistoryOrders[Amount++] = this.HistoryOrders[i];
|
|
|
|
this.HistoryOrders[0] = Order;
|
|
this.AmountHistoryOrders = Amount;
|
|
|
|
this.InitStatistic();
|
|
}
|
|
|
|
return(Res);
|
|
}
|
|
|
|
TICKET_TYPE GetMaxHistoryTicket( void ) const
|
|
{
|
|
TICKET_TYPE MaxTicket = 0;
|
|
|
|
for (int i = this.AmountHistoryOrders - 1; i >= 0; i--)
|
|
{
|
|
const TICKET_TYPE Ticket = this.HistoryOrders[i].GetTicket();
|
|
|
|
if (Ticket > MaxTicket)
|
|
MaxTicket = Ticket;
|
|
}
|
|
|
|
return(MaxTicket);
|
|
}
|
|
|
|
public:
|
|
int AmountHistoryOrders;
|
|
|
|
HISTORYORDERS() : AmountHistoryOrders(0), ReserveHistoryOrders(0), PrevAmountHistoryOrders(0), StartPos(0), FlagChange(true)
|
|
{
|
|
this.InitStatistic();
|
|
}
|
|
|
|
bool ResetTickets( void )
|
|
{
|
|
long Tickets[][2];
|
|
const int Size = ::ArrayResize(Tickets, this.AmountHistoryOrders);
|
|
|
|
#define VALUE 0
|
|
#define INDEX 1
|
|
for (int i = 0; i < Size; i++)
|
|
{
|
|
// Tickets[i][VALUE] = this.HistoryOrders[i].GetTicket();
|
|
Tickets[i][VALUE] = this.HistoryOrders[i].GetOpenTimeMsc();
|
|
Tickets[i][INDEX] = i;
|
|
}
|
|
|
|
::ArraySort(Tickets);
|
|
|
|
for (int i = 0; i < Size; i++)
|
|
this.HistoryOrders[(int)Tickets[i][INDEX]].SetTicket(i + 1);
|
|
#undef INDEX
|
|
#undef VALUE
|
|
|
|
ORDER::SetTicketCount(Size);
|
|
|
|
return(true);
|
|
}
|
|
|
|
bool InitStat( const long StartTime = 0 )
|
|
{
|
|
if (this.AmountHistoryOrders)
|
|
{
|
|
if (this.StartPos < this.AmountHistoryOrders)
|
|
{
|
|
if (this.HistoryOrders[this.StartPos] != StartTime)
|
|
{
|
|
if (this.HistoryOrders[this.StartPos] < StartTime)
|
|
{
|
|
while ((++this.StartPos < this.AmountHistoryOrders) && (this.HistoryOrders[this.StartPos] < StartTime))
|
|
;
|
|
|
|
this.InitStatistic();
|
|
}
|
|
else if (this.StartPos && (this.HistoryOrders[0] <= StartTime))
|
|
{
|
|
const int PrevStartPos = this.StartPos;
|
|
|
|
while ((--this.StartPos >= 0) && (this.HistoryOrders[this.StartPos] >= StartTime))
|
|
;
|
|
|
|
this.StartPos++;
|
|
|
|
if (this.StartPos != PrevStartPos)
|
|
this.InitStatistic();
|
|
}
|
|
}
|
|
}
|
|
else if (this.HistoryOrders[this.StartPos - 1] > StartTime)
|
|
{
|
|
while ((--this.StartPos >= 0) && (this.HistoryOrders[this.StartPos] >= StartTime))
|
|
;
|
|
|
|
this.StartPos++;
|
|
|
|
this.InitStatistic();
|
|
}
|
|
}
|
|
|
|
return(true);
|
|
}
|
|
|
|
double TesterStatistics( const ENUM_STATISTICS StatID )
|
|
{
|
|
double Res = 0;
|
|
|
|
this.Refresh();
|
|
|
|
switch (StatID)
|
|
{
|
|
case STAT_INITIAL_DEPOSIT: // Значение начального депозита
|
|
Res = this.InitialDeposit;
|
|
|
|
break;
|
|
case STAT_WITHDRAWAL: // Количество выведенных со счета средств
|
|
Res = this.Withdrawal;
|
|
|
|
break;
|
|
case STAT_PROFIT: // Чистая прибыль по окончании тестирования
|
|
Res = this.GrossLoss + this.GrossProfit;
|
|
|
|
break;
|
|
case STAT_GROSS_PROFIT: // Общая прибыль, сумма всех прибыльных (положительных) трейдов. Значение больше или равно нулю
|
|
Res = this.GrossProfit;
|
|
|
|
break;
|
|
case STAT_GROSS_LOSS: // Общий убыток, сумма всех убыточных (отрицательных) трейдов. Значение меньше или равно нулю
|
|
Res = this.GrossLoss;
|
|
|
|
break;
|
|
case STAT_MAX_PROFITTRADE: // Максимальная прибыль – наибольшее значение среди всех прибыльных трейдов. Значение больше или равно нулю
|
|
Res = this.MaxProfit;
|
|
|
|
break;
|
|
case STAT_MAX_LOSSTRADE: // Максимальный убыток – наименьшее значение среди всех убыточных трейдов. Значение меньше или равно нулю
|
|
Res = this.MaxLoss;
|
|
|
|
break;
|
|
case STAT_BALANCE_DD: // Максимальная просадка баланса в деньгах. В процессе торговли баланс может испытать множество просадок, берется наибольшее значение.
|
|
Res = this.BalanceDD;
|
|
|
|
break;
|
|
case STAT_EXPECTED_PAYOFF: // Математическое ожидание выигрыша
|
|
{
|
|
const int Total = this.TradesLongTotal + this.TradesShortTotal;
|
|
|
|
Res = Total ? (this.GrossLoss + this.GrossProfit) / Total : 0;
|
|
}
|
|
|
|
break;
|
|
case STAT_PROFIT_FACTOR: // Прибыльность – отношение STAT_GROSS_PROFIT/STAT_GROSS_LOSS. Если STAT_GROSS_LOSS=0, то прибыльность принимает значение DBL_MAX
|
|
Res = this.GrossLoss ? -this.GrossProfit / this.GrossLoss : DBL_MAX;
|
|
|
|
break;
|
|
case STAT_RECOVERY_FACTOR: // Фактор восстановления – отношение STAT_PROFIT/STAT_BALANCE_DD
|
|
Res = this.BalanceDD ? (this.GrossLoss + this.GrossProfit) / this.BalanceDD : 0;
|
|
|
|
break;
|
|
case STAT_DEALS: // Количество совершенных сделок
|
|
Res = (this.TradesLongTotal + this.TradesShortTotal) << 1;
|
|
|
|
break;
|
|
case STAT_TRADES: // Количество трейдов
|
|
Res = this.TradesLongTotal + this.TradesShortTotal;
|
|
|
|
break;
|
|
case STAT_PROFIT_TRADES: // Прибыльные трейды
|
|
Res = this.TradesProfit;
|
|
|
|
break;
|
|
case STAT_LOSS_TRADES: // Убыточные трейды
|
|
Res = this.TradesLoss;
|
|
|
|
break;
|
|
case STAT_SHORT_TRADES: // Короткие трейды
|
|
Res = this.TradesShortTotal;
|
|
|
|
break;
|
|
case STAT_LONG_TRADES: // Длинные трейды
|
|
Res = this.TradesLongTotal;
|
|
|
|
break;
|
|
case STAT_PROFIT_SHORTTRADES: // Короткие прибыльные трейды
|
|
Res = this.TradesShortProfit;
|
|
|
|
break;
|
|
case STAT_PROFIT_LONGTRADES: // Длинные прибыльные трейды
|
|
Res = this.TradesLongProfit;
|
|
|
|
break;
|
|
}
|
|
|
|
return(Res);
|
|
}
|
|
|
|
bool IsHistoryChanged( void )
|
|
{
|
|
const bool Res = (this.AmountHistoryOrders != this.PrevAmountHistoryOrders);
|
|
|
|
if (Res)
|
|
this.PrevAmountHistoryOrders = this.AmountHistoryOrders;
|
|
|
|
return(Res);
|
|
}
|
|
|
|
bool GetFlagChange( void )
|
|
{
|
|
const bool Res = this.FlagChange;
|
|
|
|
this.FlagChange = false;
|
|
|
|
return(Res);
|
|
}
|
|
|
|
string StatToString( const int &Amount )
|
|
{
|
|
return("Profit = " + HISTORYORDERS::DoubleToString(this.TesterStatistics(STAT_PROFIT) / Amount, 2) + ", " +
|
|
"Trades = " + HISTORYORDERS::DoubleToString(this.TesterStatistics(STAT_TRADES) / Amount, 0) + ", " +
|
|
"PF = " + HISTORYORDERS::DoubleToString(this.TesterStatistics(STAT_PROFIT_FACTOR), 2) + ", " +
|
|
"Mean = " + HISTORYORDERS::DoubleToString(this.TesterStatistics(STAT_EXPECTED_PAYOFF), 2) + ", " +
|
|
"MaxDD = " + HISTORYORDERS::DoubleToString(-this.TesterStatistics(STAT_BALANCE_DD) / Amount, 2) + ", " +
|
|
"RF = " + HISTORYORDERS::DoubleToString(this.TesterStatistics(STAT_RECOVERY_FACTOR), 2));
|
|
}
|
|
|
|
double CalcSwaps( const double &SwapShort, const double &SwapLong, const datetime &RolloverTime, const int &Rollover3Days )
|
|
{
|
|
double ChangeSwaps = 0;
|
|
|
|
for (int i = this.AmountHistoryOrders - 1; i >= 0; i--)
|
|
ChangeSwaps += this.HistoryOrders[i].SetSwap(SwapShort, SwapLong, RolloverTime, Rollover3Days);
|
|
|
|
this.InitStatistic();
|
|
|
|
return(ChangeSwaps);
|
|
}
|
|
|
|
void MoveHistory( HISTORYORDERS& pOrders )
|
|
{
|
|
for (int i = 0; i < this.AmountHistoryOrders; i++)
|
|
pOrders.AddHistoryOrder(this.HistoryOrders[i]);
|
|
|
|
this.AmountHistoryOrders = 0;
|
|
|
|
return;
|
|
}
|
|
};
|
|
|
|
#undef RESERVE_HISTORY_ORDERS
|