Forex_Strategy_Builder.Backtester.CalculateAccountStats C# (CSharp) Method

        public static void CalculateAccountStats()
        {
            maxBalance = 0;
            minBalance = 0;
            maxEquity  = 0;
            minEquity  = 0;
            maxEquityDrawdown = 0;
            maxDrawdown       = 0;

            maxMoneyBalance = Configs.InitialAccount;
            minMoneyBalance = Configs.InitialAccount;
            maxMoneyEquity  = Configs.InitialAccount;
            minMoneyEquity  = Configs.InitialAccount;
            maxMoneyEquityDrawdown = 0;
            maxMoneyDrawdown       = 0;

            barsInPosition    = 0;
            grossProfit       = 0;
            grossLoss         = 0;
            grossMoneyProfit  = 0;
            grossMoneyLoss    = 0;
            chargedSpread     = 0;
            chargedRollOver   = 0;
            chargedCommission = 0;
            chargedSlippage   = 0;
            moneyChargedSpread     = 0;
            moneyChargedRollOver   = 0;
            moneyChargedCommission = 0;
            moneyChargedSlippage   = 0;
            ambiguousBars     = 0;
            unknownBars       = 0;
            balanceDrawdown  = new int[Bars];
            equityDrawdown   = new int[Bars];

            maxBalanceDate       = Time[0];
            minBalanceDate       = Time[0];
            maxMoneyBalanceDate  = Time[0];
            minMoneyBalanceDate  = Time[0];
            maxDrawdownDate      = Time[0];
            maxMoneyDrawdownDate = Time[0];

            equityPercentDrawdown      = 100;
            maxMoneyDrawdownPercent    = 0;
            moneyEquityPercentDrawdown = 0;
            winLossRatio               = 0;

            winningTrades = 0;
            losingTrades  = 0;
            totalTrades   = 0;
            testedDays    = 0;

            for (int bar = FirstBar; bar < Bars; bar++)
            {
                double accountExchangeRate = AccountExchangeRate(Close[bar]);
                double pipsToMoney = InstrProperties.Point * InstrProperties.LotSize / accountExchangeRate;

                // Balance
                double balance = session[bar].Summary.Balance;
                if (balance > maxBalance)
                {
                    maxBalance = balance;
                    maxBalanceDate = Time[bar];
                }
                if (balance < minBalance)
                {
                    minBalance = balance;
                    minBalanceDate = Time[bar];
                }

                // Money Balance
                double moneyBalance = session[bar].Summary.MoneyBalance;
                if (moneyBalance > maxMoneyBalance)
                {
                    maxMoneyBalance = moneyBalance;
                    maxMoneyBalanceDate = Time[bar];
                }
                if (moneyBalance < minMoneyBalance)
                {
                    minMoneyBalance = moneyBalance;
                    minMoneyBalanceDate = Time[bar];
                }

                // Equity
                double equity = session[bar].Summary.Equity;
                if (equity > maxEquity) maxEquity = equity;
                if (equity < minEquity) minEquity = equity;

                // Money Equity
                double moneyEquity = session[bar].Summary.MoneyEquity;
                if (moneyEquity > maxMoneyEquity) maxMoneyEquity = moneyEquity;
                if (moneyEquity < minMoneyEquity) minMoneyEquity = moneyEquity;

                // Maximum Drawdown
                if (maxBalance - balance > maxDrawdown)
                {
                    maxDrawdown = maxBalance - balance;
                    maxDrawdownDate = Time[bar];
                }

                // Maximum Equity Drawdown
                if (maxEquity - equity > maxEquityDrawdown)
                {
                    maxEquityDrawdown = maxEquity - equity;

                    // In percents
                    if (maxEquity > 0)
                        equityPercentDrawdown = 100 * (maxEquityDrawdown / maxEquity);
                }

                // Maximum Money Drawdown
                if (maxMoneyBalance - MoneyBalance(bar) > maxMoneyDrawdown)
                {
                    maxMoneyDrawdown        = maxMoneyBalance - MoneyBalance(bar);
                    maxMoneyDrawdownPercent = 100 * (maxMoneyDrawdown / maxMoneyBalance);
                    maxMoneyDrawdownDate    = Time[bar];
                }

                // Maximum Money Equity Drawdown
                if (maxMoneyEquity - MoneyEquity(bar) > maxMoneyEquityDrawdown)
                {
                    maxMoneyEquityDrawdown = maxMoneyEquity - MoneyEquity(bar);

                    // Maximum Money Equity Drawdown in percents
                    if (100 * maxMoneyEquityDrawdown / maxMoneyEquity > moneyEquityPercentDrawdown)
                        moneyEquityPercentDrawdown = 100 * (maxMoneyEquityDrawdown / maxMoneyEquity);
                }

                // Drawdown
                balanceDrawdown[bar] = (int)Math.Round((maxBalance - balance));
                equityDrawdown[bar]  = (int)Math.Round((maxEquity  - equity));

                // Bars in position
                if (session[bar].Positions > 0)
                    barsInPosition++;

                // Bar interpolation evaluation
                if (session[bar].BacktestEval == BacktestEval.Ambiguous)
                {
                    ambiguousBars++;
                }
                else if (session[bar].BacktestEval == BacktestEval.Unknown)
                {
                    unknownBars++;
                }

                // Margin Call bar
                if (!Configs.TradeUntilMarginCall && marginCallBar == 0 && session[bar].Summary.FreeMargin < 0)
                    marginCallBar = bar;
            }

            for (int pos = 0; pos < PositionsTotal; pos++)
            {   // Charged fees
                Position position = Backtester.PosFromNumb(pos);
                chargedSpread          += position.Spread;
                chargedRollOver        += position.Rollover;
                chargedCommission      += position.Commission;
                chargedSlippage        += position.Slippage;
                moneyChargedSpread     += position.MoneySpread;
                moneyChargedRollOver   += position.MoneyRollover;
                moneyChargedCommission += position.MoneyCommission;
                moneyChargedSlippage   += position.MoneySlippage;

                // Winning losing trades.
                if (position.Transaction == Transaction.Close  ||
                    position.Transaction == Transaction.Reduce ||
                    position.Transaction == Transaction.Reverse)
                {
                    if (position.ProfitLoss > 0)
                    {
                        grossProfit      += position.ProfitLoss;
                        grossMoneyProfit += position.MoneyProfitLoss;
                        winningTrades++;
                    }
                    else if (position.ProfitLoss < 0)
                    {
                        grossLoss      += position.ProfitLoss;
                        grossMoneyLoss += position.MoneyProfitLoss;
                        losingTrades++;
                    }
                    totalTrades++;
                }
            }

            winLossRatio = (double)winningTrades / Math.Max((losingTrades + winningTrades), 1.0);

            executedOrders = 0;
            tradedLots = 0;
            for (int ord = 0; ord < totalOrders; ord++)
            {
                if (OrdFromNumb(ord).OrdStatus == OrderStatus.Executed)
                {
                    executedOrders++;
                    tradedLots += OrdFromNumb(ord).OrdLots;
                }
            }

            testedDays = (Time[Bars - 1] - Time[FirstBar]).Days;
            if (testedDays < 1)
                testedDays = 1;

            if (Configs.AccountInMoney)
                GenerateAccountStatsInMoney();
            else
                GenerateAccountStats();

            if (Configs.AdditionalStatistics)
            {
                CalculateAdditionalStats();

                if (Configs.AccountInMoney)
                    SetAdditioanlMoneyStats();
                else
                    SetAdditioanlStats();
            }

            return;
        }

        /// <summary>
        /// Calculates the strategy.
        /// </summary>
        /// <param name="recalcIndicators">true - to recalculate all the indicators.</param>
        void Calculate(bool recalcIndicators)
        {
            bool isUPBVChanged = Data.Strategy.AdjustUsePreviousBarValue();

            // Calculates the indicators by slots if it's necessary
            if (recalcIndicators)
            {
                foreach (IndicatorSlot indSlot in Data.Strategy.Slot)
                {
                    string    indicatorName = indSlot.IndicatorName;
                    SlotTypes slotType      = indSlot.SlotType;
                    Indicator indicator     = Indicator_Store.ConstructIndicator(indicatorName, slotType);

                    indicator.IndParam = indSlot.IndParam;

                    indicator.Calculate(slotType);

                    indSlot.IndicatorName  = indicator.IndicatorName;
                    indSlot.IndParam       = indicator.IndParam;
                    indSlot.Component      = indicator.Component;
                    indSlot.SeparatedChart = indicator.SeparatedChart;
                    indSlot.SpecValue      = indicator.SpecialValues;
                    indSlot.MinValue       = indicator.SeparatedChartMinValue;
                    indSlot.MaxValue       = indicator.SeparatedChartMaxValue;
                    indSlot.IsDefined      = true;
                }
            }

            // Searches the indicators' components to determine the Data.FirstBar
            Data.FirstBar = Data.Strategy.SetFirstBar();

            // Logging
            Data.Log("Calculate the strategy");

            // Calculates the backtest
            Backtester.Calculate();
            Backtester.CalculateAccountStats();

            Data.IsResult = true;
            if (isUPBVChanged)
            {
                RebuildStrategyLayout();
            }
            smallIndicatorChart.InitChart();
            smallIndicatorChart.Invalidate();
            smallBalanceChart.SetChartData();
            smallBalanceChart.InitChart();
            smallBalanceChart.Invalidate();
            SetupJournal();
            infpnlAccountStatistics.Update(
                Backtester.AccountStatsParam,
                Backtester.AccountStatsValue,
                Backtester.AccountStatsFlags,
                Language.T("Account Statistics"));

            return;
        }