Download MetaTrader 5

Functions for Money Management in an Expert Advisor

8 July 2010, 18:04
MetaQuotes Software Corp.
5
7 111

Introduction

The MQL5 language provides an opportunity to obtain a vast amounts of information about the current terminal conditions, of the mql5-program, as well as the financial instrument and the trading account. In order to organize the functions of capital management, we will need to study the properties from the last two listed sections, as well as acquaint ourselves with the following functions:

Although in this article, the main focus is kept on the use of functions in the Expert Advisors, all of these descriptions can be applied to indicators and scripts.

Obtaining information about your account balance

The first two important characteristics of a trading account - the balance and equity. To obtain these values, use the AccountInfoDouble() function

   double balance=AccountInfoDouble(ACCOUNT_BALANCE);
   double equity=AccountInfoDouble(ACCOUNT_EQUITY);

The next thing that interests us, is the size of the deposit funds for open positions, and the total floating profit or loss on the account, for all open positions.

   double margin=AccountInfoDouble(ACCOUNT_MARGIN);
   double float_profit=AccountInfoDouble(ACCOUNT_PROFIT);

In order to be able to open new positions or strengthen the existing ones, we need free resources, not participating in the deposit.

   double free_margin=AccountInfoDouble(ACCOUNT_FREEMARGIN);

Here it should be noted, that the above values are expressed in monetary terms.

Monetary values, returned by the AccountInfoDouble() function, are expressed in deposit currency. To find out the deposit currency, use the AccountInfoString() function.

string account_currency=AccountInfoString(ACCOUNT_CURRENCY);

The level of personal funds

The account has another important characteristic - the level at which the event Stop Out occurs (a mandatory closing of a positions due to a shortage of personal funds necessary for maintaining open positions). To obtain this value, re-use the AccountInfoDouble() function:

double stopout_level=AccountInfoDouble(ACCOUNT_MARGIN_SO_SO);

The function only returns the value itself, but it doesn't explain what type of units this value is expressed in. There are two modes of level specification for Stop Out: in percents and in currency. In order to find this out, use the AccountInfoInteger() function:  

//--- Get account currency
string account_currency=AccountInfoString(ACCOUNT_CURRENCY);

//--- Stop Out level
   double stopout_level=AccountInfoDouble(ACCOUNT_MARGIN_SO_SO);

//--- Stop Out mode
   ENUM_ACCOUNT_STOPOUT_MODE so_mode=(ENUM_ACCOUNT_STOPOUT_MODE)AccountInfoInteger(ACCOUNT_MARGIN_SO_MODE);
   if(so_mode==ACCOUNT_STOPOUT_MODE_PERCENT)

      PrintFormat("Stop Out level in percents %.2f%%",stopout_level);
   else
      PrintFormat("Stop Out level in currency %.2f %s",stopout_level,account_currency);


Additional information about the account

Often in calculations it required to know the size of the provided on the trading account leverage. You can obtain this information by using the AccountInfoInteger() function:

   int leverage=(int)AccountInfoInteger(ACCOUNT_LEVERAGE);
In order to avoid accidentally running the unregulated Expert Advisor on a real account, you need to know the type of the account. 
   ENUM_ACCOUNT_TRADE_MODE mode=(ENUM_ACCOUNT_TRADE_MODE)AccountInfoInteger(ACCOUNT_TRADE_MODE);
   switch(mode)
     {
      case ACCOUNT_TRADE_MODE_DEMO:    Comment("Account demo");               break;
      case ACCOUNT_TRADE_MODE_CONTEST: Comment(com,"Account Contest");        break;
      case ACCOUNT_TRADE_MODE_REAL:    Comment(com,"Account Real");           break;
      default:                         Comment(com,"Account unknown type");
     }
Trading is not possible on every account, for example, on competitive accounts, trading operations can only be done after the beginning of the competition. This information can also be obtained by the AccountInfoInteger() function:
   bool trade_allowed=(bool)AccountInfoInteger(ACCOUNT_TRADE_ALLOWED);
   if(trade_allowed)
      Print("Trade is allowed");
   else
      Print(com,"Trade is not allowed");

Even if trading on this account is permitted, it doesn't mean that the Expert Advisor has the right to trade. To check whether the Expert Advisor is permitted to trade, write:

   if(trade_allowed)
     {
      bool trade_expert=(bool)AccountInfoInteger(ACCOUNT_TRADE_EXPERT);
      if(trade_expert)
         Print("Experts are allowed to trade");

      else
         Print("Experts are not allowed to trade");

These examples can be found in the attached Expert Advisor Account_Info.mq5 . They can be used in MQL5 programs of any complexity.


Information about the instrument

Each financial instrument has its own descriptions and is placed on a path, which this instrument characterizes. If we open the EURUSD properties window in the terminal, we will see something like this:

In this case, the description for EURUSD is - "EURUSD, Euro vs US Dollar". To obtain this information, we use the SymbolInfoString() function:

   string symbol=SymbolInfoString(_Symbol,SYMBOL_DESCRIPTION);
   Print("Symbol: "+symbol);

   string symbol_path=SymbolInfoString(_Symbol,SYMBOL_PATH);
   Print("Path: "+symbol_path);

To find out the size of a standard contract, use the SymbolInfoDouble():

   double lot_size=SymbolInfoDouble(_Symbol,SYMBOL_TRADE_CONTRACT_SIZE);
   Print("Standard contract: "+DoubleToString(lot_size,2));

It is a characteristic of FOREX instruments to sell one currency while buying another. The contract is indicated in the currency, which is necessary to perform the purchase. This is a base currency, and it can be obtained using the SymbolInfoString() function:

   string base_currency=SymbolInfoString(_Symbol,SYMBOL_CURRENCY_BASE);
   Print("Base currency: "+base_currency);

Price changes in the instrument lead to a change in the price of a purchased assets, and therefore, to a profit variation for an open position (the profit can be negative if the position is losing). Thus, the price change leads to changes in income, expressed in a particular currency. This currency is called the quote currency. For a currency pair EURUSD the base currency is usually the Euro, and the quote currency is the U.S. dollar. To obtain the quote currency you can also use the SymbolInfoString() function:

   string profit_currency=SymbolInfoString(_Symbol,SYMBOL_CURRENCY_PROFIT);

   Print("Currency quotes: "+profit_currency);

To open a position on the instrument you need funds, and these funds are also expressed in a particular currency. This currency is called the currency margin or deposit. For the FOREX instruments the margin and the base currencies are usually the same. To obtain the value of the deposit currency, use the SymbolInfoString() function:

   string margin_currency=SymbolInfoString(_Symbol,SYMBOL_CURRENCY_MARGIN);
   Print("Currency deposit: "+margin_currency);

All of the described functions are given in the code of the Symbol_Info.mq5  Expert Advisor. The figure below demonstrates the output of information on the symbol EURUSD, using the Comment() function.


Calculating the size of the deposit

The information about financial instruments, most needed for traders, is the size of the funds, required for opening a position on it. Without knowing how much money is needed to buy or sell a specified number of lots, we can not implement the Expert Advisor's system for capital managing. In addition, controlling the account balance also becomes difficult.

If you have difficulties with understanding the further discussion, I recommend you to read the article Forex Trading ABC. The explanations described in it are also applicable to this article.

We need to calculate the size of the margin in the currency deposit, ie recalculate the deposit from the mortgage currency to the deposit currency, by dividing the obtained value by the amount of the given account leverage. To do this we write the GetMarginForOpening() function:
//+------------------------------------------------------------------+
//|  Return amount of equity needed to open position                 |
//+------------------------------------------------------------------+
double GetMarginForOpening(double lot,string symbol,ENUM_POSITION_TYPE direction)
  {
   double answer=0;
//--- 
    ...
//--- Return result - amount of equity in account currency, required to open position in specified volume
   return(answer);
  }

where:

  • lot - the volume of the open position;
  • symbol - the name of the financial instrument;
  • the alleged position direction.
So, we have the following information for calculating the size of the margin (monetary funds for mortgage of the open position):
  • deposit currency
  • mortgage currency
  • Currency quotes (may be needed for Cross Currency pairs)
  • the contract size

Write this in the MQL5 language:

//--- Get contract size
   double lot_size=SymbolInfoDouble(symbol,SYMBOL_TRADE_CONTRACT_SIZE);

//--- Get account currency
   string account_currency=AccountInfoString(ACCOUNT_CURRENCY);

//--- Margin currency
   string margin_currency=SymbolInfoString(_Symbol,SYMBOL_CURRENCY_MARGIN);

//--- Profit currency
   string profit_currency=SymbolInfoString(_Symbol,SYMBOL_CURRENCY_PROFIT);

//--- Calculation currency
   string calc_currency="";
//--- Reverse quote - true, Direct quote - false
   bool mode;

The mode variable affects how we will be calculating the size of the contract in the deposit currency. Consider this based on examples, in all further cases let's assume that the deposit currency is the US dollar.

The currency pairs are usually divided into three categories:

  • Direct Currency Pairs - the U.S. dollar exchange rate to a particular currency. Examples: USDCHF, USDCAD, USDJPY, USDSEK;
  • Reverse Currency Pair - the exchange rate of a particular currency to the U.S. dollar. Examples: EURUSD, GBPUSD, AUDUSD, NZDUSD;
  • Cross Currency Pairs - a currency pair, which does not involve the U.S. dollar. Examples: AUDCAD, EURJPY, EURCAD. 


1. EURUSD - the reverse currency pair

We will call the currency pairs, in which the quote currency is the account currency, reverse currency pairs. In our examples, the account currency is represented with the U.S. dollar, so our classification of the currency pairs will coincide with the generally accepted classification. But if your trading account uses a different currency (not USD), it will not coincide. In this case, take into consideration the account currency, in order to understand any further explanations.

The contract size for EURUSD - 100 000 euros. We need to express 100 000 euros in the currency of the deposit - U.S. dollars. To do this you need to know the exchange rate, according to which the euro can be counted into dollars. We introduce the concept computation currency , that is, the currency needed for converting the mortgage currency to the deposit currency.

//--- Calculation currency
   string calc_currency="";

Fortunately, the EURUSD currency pair displays the exchange rate of the euro against the dollar, and hence, for this case, the symbol of EURUSD, for which you need to calculate the mortgage size, is precisely the exchange rate:

//--- If profit currency and account currency are equal
   if(profit_currency==account_currency)
     {
      calc_currency=symbol;
      mode=true;
     }

We have established the value of the mode as true, which means that for transferring Euros to dollars (mortgaged currency is convertible into the deposit currency), we will multiply the current exchange rate of EURUSD by the size of the contract. If mode  = false, then we divide the contract size by the exchange rate of the computational currency. For obtaining the current prices on the instrument, use the SymbolInfoTick() function.

//--- We know calculation currency, let's get its last prices
   MqlTick tick;
   SymbolInfoTick(calc_currency,tick);

This function puts the current price and time of the last update of prices into the variable of the MqlTick type - this structure was specially designed for this purpose. 

Therefore it is sufficient enough to obtain the latest price on this symbol, multiply it by the size of the contract and then by the number of lots. But which calculation price should we take, considering that there is a purchase price and a sale price for this instrument? so logically: if we are buying, the price for calculations is equal to the Ask price, and if we are selling, will need to take the Bid price.

//--- Now we have everything for calculation 
   double calc_price;
//--- Calculate for Buy
   if(direction==POSITION_TYPE_BUY)
     {
      //--- Reverse quote
      if(mode)
        {
         //--- Calculate using Buy price for reverse quote
         calc_price=tick.ask;
         answer=lot*lot_size*calc_price;
        }
     }

//--- calculate for Sell
   if(direction==POSITION_TYPE_SELL)
     {
      //--- Reverse quote
      if(mode)
        {
         //--- Calculate using Sell price for reverse quote

         calc_price=tick.bid;
         answer=lot*lot_size*calc_price;
        }
     }

Thus, in our example, for the EURUSD symbol the deposit currency is Euro, the contract size is 100 000, and the last Ask price  = 1.2500. Account currency - U.S. dollar, and the calculation currency is the same EURUSD currency pair. Multiply 100 000 by 1.2500 and get 125 000 U.S. dollars - this is exactly how much a standard contract for purchasing 1 EURUSD lot is, if the Ask price =1.2500. 

We can conclude that if the quote currency is equal to the account currency, then to obtain the value of one lot of the account currency, we simply multiply the size of the contract by the appropriate price, Bid or Ask, depending on the intended direction of the position.

margin=lots*lot_size*rate/leverage;

2. USDCHF - direct currency pair

The mortgage currency and the account currency for USDCHF match - the U.S. dollar. The currency pairs, in which the mortgage currency and the account currency are the same, we will call direct currency pairs. Contract size - 100 000. This is the simplest situation, simply return the product.

//--- if the base currency symbol and the deposit currency are the same
   if(margin_currency==account_currency)
     {
      calc_currency=symbol;
      //--- Just return the contract value, multiplied by the number of lots
      return(lot*lot_size);
     }

If the deposit currency coincides with the account currency, then the value of the deposit in the account currency is equal to the product of the standard contract multiplied by the number of lots (contracts) divided by the size of the leverage.

margin=lots*lot_size/leverage;

3. CADCHF - cross- currency pair

The CADCHF currency pair is taken for illustrative purposes, and any other pair, in which the deposit currency and the quote currency coincide with the account currency, can be used. These currency pairs are called cross, because in order to calculate the margin and profit on them, we need to know the exchange rate of some other currency pair, which intersects with that one on one of the currencies.

Usually, a cross-currency pairs are the pairs, the quotes of which do not use the U.S. dollar. But we will call all pairs, which do not include the account currency in its quotes, cross-currency pairs. Thus, if the account currency is in Euro, then the pair GBPUSD will be a cross-currency pair, since the deposit currency is in British pounds, and currency quotes are in U.S. dollars. In this case, to calculate the margin, we will have to express the pound (GBP) in Euro (EUR).

But we will continue to consider an example in which the symbol is the currency pair CADCHF. The deposit currency is in Canadian Dollars (CAD) and does not coincide with the U.S. dollar (USD). The quote currency is in Swiss francs and also does not coincide with the American dollar.

We only can say that the deposit for opening a position in 1 lot equals to 100,000 Canadian dollars. Our task is to recalculate the deposit into the account currency, in U.S. dollars. To do this we need to find the currency pair, the exchange rate of which contains the U.S. dollar and the deposit currency - CAD. There are a total of two potential options:

  • CADUSD
  • USDCAD

We have the output data for the CADCHF:

margin_currency=CAD (Canadian dollar)
profit_currency=CHF (Swiss frank)

We do not know in advance which of the currency pairs exists in the terminal, and in terms of the MQL5 language, neither option is preferable. Therefore, we write the GetSymbolByCurrencies() function, which for the given set of currencies will give us the first matching currency pair for calculations.

//+------------------------------------------------------------------+
//| Return symbol with specified margin currency and profit currency |
//+------------------------------------------------------------------+
string GetSymbolByCurrencies(string margin_currency,string profit_currency)
  {
//--- In loop process all symbols, that are shown in Market Watch window
   for(int s=0;s<SymbolsTotal(true);s++)
     {
      //--- Get symbol name by number in Market Watch window
      string symbolname=SymbolName(s,true);

      //--- Get margin currency
      string m_cur=SymbolInfoString(symbolname,SYMBOL_CURRENCY_MARGIN);

      //--- Get profit currency (profit on price change)
      string p_cur=SymbolInfoString(symbolname,SYMBOL_CURRENCY_PROFIT);

      //--- if If symbol matches both currencies, return symbol name
      if(m_cur==margin_currency && p_cur==profit_currency) return(symbolname);
     }
   return(NULL);
  }

As can be seen from the code, we begin the enumeration of all symbols, available in the "Market View" window (SymbolsTotal() function with "true" parameter will give us this amount). In order to get the name of each symbol by the number in the list of the "Market View", we use the SymbolName() function with true parameter!  If we set the parameter to "false", then we will enumerate all of the symbols presented on the trading server, and this is usually much more than what is selected in the terminal.

  Next, we use the name of the symbol to obtain the currency deposit and the quotes, and to compare them with the ones that were passed to the GetSymbolByCurrencies() function. In case of success, we returns the name of the symbol, and the work of the function is completed successfully and ahead of schedule. If the loop is completed, and we reach the last line of the function, then nothing fit and the symbol was not found, - return NULL.

Now that we can obtain the calculation currency for the cross-currency pair, by using the GetSymbolByCurrencies() function, we will make two attempts: in the first attempt we'll search for the symbol, the deposit currency of which is the margin_currency (deposit currency CADCHF - CAD), and the quote currency is the currency of the account (USD). In other words, we are looking for something similar to the pair of CADUSD.

//--- If calculation currency is still not determined
//--- then we have cross currency
   if(calc_currency="")
     {
      calc_currency=GetSymbolByCurrencies(margin_currency,account_currency);
      mode=true;
      //--- If obtained value is equal to NULL, then this symbol is not found
      if(calc_currency==NULL)
        {
         //--- Lets try to do it reverse
         calc_currency=GetSymbolByCurrencies(account_currency,margin_currency);
         mode=false;
        }
     }

If the attempt fails, try to find another option: look for a symbol, the deposit currency of which is account_currency (USD), and the quote currency is margin_currency (deposit currency for CADCHF - CAD). We are looking for something similar to the USDCAD.

Now that we found the calculations currency pair, it can be one of two options - direct or reverse. The mode variable assumes the value "true" for the inverse currency pair. If we have a direct currency pair, then the value is equal to "false". For the "true" value, we multiply it by the exchange rate of the currency pair, for the false value- we divide it by the deposit value of a standard contract in the account currency.

Here is the final calculation of the deposit size in the account currency for the found calculation currency. It is fit for both options - the direct and the reverse currency pairs.

//--- We know calculation currency, let's get its last prices
   MqlTick tick;
   SymbolInfoTick(calc_currency,tick);

//--- Now we have everything for calculation
   double calc_price;
//--- Calculate for Buy
   if(direction==POSITION_TYPE_BUY)
     {
      //--- Reverse quote
      if(mode)
        {
         //--- Calculate using Buy price for reverse quote
         calc_price=tick.ask;
         answer=lot*lot_size*calc_price;
        }
      //--- Direct quote 
      else
        {
         //--- Calculate using Sell price for direct quote
         calc_price=tick.bid;
         answer=lot*lot_size/calc_price;
        }
     }

//--- Calculate for Sell
   if(direction==POSITION_TYPE_SELL)
     {
      //--- Reverse quote
      if(mode)
        {
         //--- Calculate using Sell price for reverse quote
         calc_price=tick.bid;
         answer=lot*lot_size*calc_price;
        }
      //--- Direct quote 
      else
        {
         //--- Calculate using Buy price for direct quote
         calc_price=tick.ask;
         answer=lot*lot_size/calc_price;
        }
     }

Return the obtained result

 //--- Return result - amount of equity in account currency, required to open position in specified volume
return  (Answer);

The GetMarginForOpening() function completes its work at this point. The last thing that needs to be done is to divide the obtained value by the size of the provided leverage - and then we will obtain the value of the margin for open positions with the specified volume in the assumed direction. Keep in mind, that for the symbols, representing the reverse or the cross-currency pair, the value of the margin will vary with each tick.

Here is a part of the SymbolInfo_Advanced.mq5  Expert Advisor code. The complete code is attached as a file.

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- String variable for comment
   string com="\r\n";
   StringAdd(com,Symbol());
   StringAdd(com,"\r\n");

//--- Size of standard contract
   double lot_size=SymbolInfoDouble(_Symbol,SYMBOL_TRADE_CONTRACT_SIZE);

//--- Margin currency
   string margin_currency=SymbolInfoString(_Symbol,SYMBOL_CURRENCY_MARGIN);
   StringAdd(com,StringFormat("Standard contract: %.2f %s",lot_size,margin_currency));
   StringAdd(com,"\r\n");

//--- Leverage
   int leverage=(int)AccountInfoInteger(ACCOUNT_LEVERAGE);
   StringAdd(com,StringFormat("Leverage: 1/%d",leverage));
   StringAdd(com,"\r\n");

//--- Calculate value of contract in account currency
   StringAdd(com,"Deposit for opening positions in 1 lot consists ");

//--- Calculate margin using leverage
   double margin=GetMarginForOpening(1,Symbol(),POSITION_TYPE_BUY)/leverage;
   StringAdd(com,DoubleToString(margin,2));
   StringAdd(com," "+AccountInfoString(ACCOUNT_CURRENCY));

   Comment(com);
  }

and the result of its work on the chart.


Conclusion

The provided examples demonstrate how easy and simple it is to obtain information about the most important characteristics of the trading account and about the properties of financial instruments.

Translated from Russian by MetaQuotes Software Corp.
Original article: https://www.mql5.com/ru/articles/113

Attached files |
Last comments | Go to discussion (5)
Roger Flatt
Roger Flatt | 1 Aug 2010 at 23:18

Hi, Rosh

Thanks greatly for your article, and all of your other articles - advice and guidance for us MQL/C++ n00bs is hugely appreciated. Spasiba.

I am currently working on my own Money Management code, to enforce trading discipline and remove emotionally damaging fear and greed.

My philosophy is a little different in terms of selecting lot size - everything begins and ends with Money Management (MM).

If I have an account balance of (e.g.) 10,000, and a 'maximum at risk per trade philosophy' of 5% then the most I can risk on one position is 500.

If I determine that my stop is 20 pips (because of Bollinger Lower or ATR, or whatever [adjusted for 'its gone bad, get out']) , then my lot size is 500/20, giving a 25 pip investment.

If Target (Limit/TKP) and 'Crash out' (Stop Loss/STP) are always in pips, it makes the calculation easier.

If the signal (buy/sell) is not strong, then adjust the risk downwards. If stronger (ADX 50+, or rising maybe), then increase the money at risk.

Allowing for leverage gives a formula of:

Lots=(Account*0.05)/Leverage/STP)*(RISKADJ); // Where RISKADJ is 1.00 normally, 0.50 for a 'poorer, riskier' trade, and maybe 2.0 for a 'green light' trade.

In short, this philosophy asks 'how many lots is this trade worth?' rather than 'have I the margin for a 2.0 lot trade?'.

 

Mathmatically, it is not too different from your code, but the philosophy begins and ends with managing risk and exposure, and protecting the money in the account.  

 

Buy/sell signals have tens of thousands of combinations, which provide an endless study for all of us.

Money management has very few parameters, and just one key parameter - 'how much of my account will I risk in this trade?'  

 

Hope this makes sense, and thanks again for everything.

Todge.  

Rashid Umarov
Rashid Umarov | 2 Aug 2010 at 18:28
Todge:

Hi, Rosh

Thanks greatly for your article, and all of your other articles - advice and guidance for us MQL/C++ n00bs is hugely appreciated. Spasiba.

I am currently working on my own Money Management code, to enforce trading discipline and remove emotionally damaging fear and greed.

My philosophy is a little different in terms of selecting lot size - everything begins and ends with Money Management (MM).


I absolutely agree with you. This article does not pretend to be comprehensive and just strives only educational purpose.
okwh
okwh | 9 Sep 2010 at 15:33

This is not  Money Management .

only how to get information about the most important characteristics of the trading account and about the properties of financial instruments.

these information can be used to Money Management.
 

Pawel Wojnarowski
Pawel Wojnarowski | 19 Sep 2010 at 14:01
DxdCn:

This is not  Money Management .

only how to get information about the most important characteristics of the trading account and about the properties of financial instruments.

these information can be used to Money Management.
 

Of course it isn't. As you can see, even the author of the article named it "Functions for Money Management (...)". So I don't see a point in you remark. 

okwh
okwh | 9 Oct 2010 at 09:33
Enigma71fx:

Of course it isn't. As you can see, even the author of the article named it "Functions for Money Management (...)". So I don't see a point in you remark. 

should changed to  "support Functions for Money Management  in MQL's library "
Step on New Rails: Custom Indicators in MQL5 Step on New Rails: Custom Indicators in MQL5

I will not list all of the new possibilities and features of the new terminal and language. They are numerous, and some novelties are worth the discussion in a separate article. Also there is no code here, written with object-oriented programming, it is a too serous topic to be simply mentioned in a context as additional advantages for developers. In this article we will consider the indicators, their structure, drawing, types and their programming details, as compared to MQL4. I hope that this article will be useful both for beginners and experienced developers, maybe some of them will find something new.

Here Comes the New MetaTrader 5 and MQL5 Here Comes the New MetaTrader 5 and MQL5

This is just a brief review of MetaTrader 5. I can't describe all the system's new features for such a short time period - the testing started on 2009.09.09. This is a symbolical date, and I am sure it will be a lucky number. A few days have passed since I got the beta version of the MetaTrader 5 terminal and MQL5. I haven't managed to try all its features, but I am already impressed.

False trigger protection for Trading Robot False trigger protection for Trading Robot

Profitability of trading systems is defined not only by logic and precision of analyzing the financial instrument dynamics, but also by the quality of the performance algorithm of this logic. False trigger is typical for low quality performance of the main logic of a trading robot. Ways of solving the specified problem are considered in this article.

Using text files for storing input parameters of Expert Advisors, indicators and scripts Using text files for storing input parameters of Expert Advisors, indicators and scripts

The article describes the application of text files for storing dynamic objects, arrays and other variables used as properties of Expert Advisors, indicators and scripts. The files serve as a convenient addition to the functionality of standard tools offered by MQL languages.