Geldverwaltungsfunktionen in einem Expert Advisor

Einleitung

MQL5 bietet eine Möglichkeit zur Einholung einer großen Menge an Informationen über den aktuellen Zustand des Ausgabegerätes und des MQL5-Prgramms sowie über das Finanzinstrument und das Handelskonto. Um die Funktionen der Geldverwaltung zu ordnen, müssen wir die Eigenschaften der beiden zuletzt genannten Abschnitte studieren, und uns mit folgenden Funktionen vertraut machen:

• SymbolInfoInteger()
• SymbolInfoDouble()
• SymbolInfoString()
• AccountInfoInteger()
• AccountInfoDouble()
• AccountInfoString()

Obgleich in diesem Beitrag das Hauptaugenmerk auf der Verwendung von Funktionen in den Expert Advisors liegt, können all diese Beschreibungen auch auf Indikatoren und Skripte angewendet werden.

Abrufen von Informationen zu Ihrem Kontostand

Die beiden wichtigsten Eigenschaften eines Handelskontos sind Guthaben (Balance) und Reinvermögen (Equity). Verwenden Sie zum Abrufen dieser Werte die Funktion AccountInfoDouble(): 

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

Als Nächstes interessiert uns die Höhe der verfügbaren Mittel für offene Positionen sowie der gesamte nicht realisierte Gewinn oder Verlust auf dem Konto bei allen offenen Positionen.

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

Um neue Positionen eröffnen oder die vorhandenen stärken zu können, benötigen wir freie nicht an Anlagen gebundene Mittel.

   double free_margin=AccountInfoDouble(ACCOUNT_FREEMARGIN);

An dieser Stelle sei darauf hingewiesen, dass die vorgenannten Werte in Geldbeträgen ausgedrückt werden.

Die von der Funktion AccountInfoDouble() ausgegebenen Geldbeträge werden in der Einzahlungswährung für das Konto ausgedrückt. Um die Einzahlungswährung abzurufen, bedienen sie sich der Funktion AccountInfoString().

string account_currency=AccountInfoString(ACCOUNT_CURRENCY);

Der Eigenmittelbestand

Das Konto weist ein weiteres wichtiges Merkmal auf, den Mittelbestand, an dem ein Stop Out eintritt (das zwangsweise Schließen von Positionen aufgrund des Fehlens der zur Aufrechterhaltung der offenen Positionen benötigten eigenen Mittel). Verwenden Sie zum Abrufen dieser Werte die Funktion AccountInfoDouble():

double stopout_level=AccountInfoDouble(ACCOUNT_MARGIN_SO_SO);

Die Funktion gibt nur den Wert selbst aus, sie erläutert jedoch nicht, in welcher Art von Einheiten er ausgedrückt wird. Es gibt zwei Modelle für die Angabe des Mittelbestandes für einen Stop Out: in Prozent oder in Zahlungsmitteln. Um das herauszufinden, benutzen Sie die Funktion AccountInfoInteger():  

//--- 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);

Weitere Angaben zu dem Konto

Häufig ist es bei Berechnungen erforderlich, die Höhe der auf dem Handelskonto gebotenen Hebelwirkung zu kennen. Auch diese Information können Sie mithilfe der Funktion AccountInfoInteger() abrufen:

   int leverage=(int)AccountInfoInteger(ACCOUNT_LEVERAGE);

Um zu verhindern, dass versehentlich ein nicht zugelassener Expert Advisor auf einem echten Konto ausgeführt wird, müssen Sie wissen, um welche Art Konto es sich handelt. 

   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");
     }

Es kann nicht auf jedem Konto gehandelt werden, zum Beispiel können auf Wettbewerbskonten erst nach Beginn des Wettbewerbs Handelsvorgänge ausgeführt werden. Auch diese Information liefert die Funktion AccountInfoInteger():

   bool trade_allowed=(bool)AccountInfoInteger(ACCOUNT_TRADE_ALLOWED);
   if(trade_allowed)
      Print("Trade is allowed");
   else
      Print(com,"Trade is not allowed");

Aber auch wenn dieses Konto zum Handel zugelassen ist, bedeutet das nicht, dass der Expert Advisor zum Handel berechtigt ist. Um zu prüfen, ob der Expert Advisor zum Handel zugelassen ist, schreiben Sie:

   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");

Diese Beispiele finden Sie in dem angehängten Expert Advisor Account_Info.mq5 . Sie können in MQL5-Programmen jeder Komplexität verwendet werden.

Informationen über das Instrument

Jedes Finanzinstrument verfügt über seine eigene Beschreibung und befindet sich auf einem Pfad, den dieses Instrument beschreibt. Wenn wir an unserem Ausgabegerät das Eigenschaftenfenster zu EURUSD öffnen, sehen wir etwas wie das:

In diesem Fall lautet die Beschreibung für EURUSD: „EURUSD, Euro im Vergleich zu US Dollar“. Um diese Angabe abzurufen, verwenden wir die Funktion SymbolInfoString():

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

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

Zur Ermittlung des Umfangs eines üblichen Vertrages verwenden Sie die Funktion SymbolInfoDouble():

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

Es ist eine Eigenschaft von Devisenhandelsinstrumenten, eine Währung zu verkaufen und eine andere zu kaufen. Der Kontrakt wird in der Währung ausgewiesen, in der der Kauf abgewickelt werden muss. Das ist eine Basiswährung, die mithilfe der Funktion SymbolInfoString() abgerufen werden kann:

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

Preisänderungen bei dem Instrument führen zu einer Veränderung bei dem Preis erworbener Vermögenswerte und damit zu einer Änderung des Gewinns bei einer offenen Position (der Gewinn kann sogar negativ sein, wenn die Position an Wert verliert). So führt die Preisänderung zu in einer bestimmten Währung ausgedrückten Ertragsänderungen. Diese Währung wird als Notierungswährung bezeichnet. Bei dem Währungspaar EURUSD ist die Basiswährung üblicherweise der Euro und der US Dollar die Notierungswährung. Zum Abrufen der Notierungswährung können Sie sich ebenfalls der Funktion SymbolInfoString() bedienen:

   string profit_currency=SymbolInfoString(_Symbol,SYMBOL_CURRENCY_PROFIT);

   Print("Currency quotes: "+profit_currency);

Um eine Position in dem Instrument zu eröffnen, benötigen Sie Zahlungsmittel, und diese werden auch in einer bestimmten Währung ausgedrückt. Diese Währung wird als Margen- oder Einzahlungswährung bezeichnet. Bei den Devisenhandelsinstrumenten sind die Margen- und die Basiswährung in der Regel identisch. Verwenden Sie zum Abrufen der Einzahlungswährung die Funktion SymbolInfoString():

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

Alle dargestellten Funktionen finden sich im Programmcode des Expert Advisors Symbol_Info.mq5. Die Abbildung unten zeigt die mithilfe der Funktion Comment() ausgegebenen Informationen zu dem Kürzel EURUSD.

Berechnung der Höhe der Einlage

Die von Händlern am meisten benötigte Information über Finanzinstrumente ist die Höhe des zur Eröffnung einer Position in diesen erforderlichen Geldbetrages. Ohne zu wissen, wie viel Geld zum Kauf oder Verkauf einer vorgegebenen Anzahl Posten benötigt wird, kann die Kapitalverwaltungsfunktion des Expert Advisors nicht eingesetzt werden. Außerdem wird die Überwachung des Kontostandes ebenfalls schwierig.

Wenn Sie Schwierigkeiten haben, der weiteren Erörterung zu folgen, empfehle ich Ihnen die Lektüre des Artikels ABC des Devisenhandels. Die dort gegebenen Erläuterungen gelten auch für diesen Beitrag.

Wir müssen die Höhe der Marge der Währungseinlage berechnen, das heißt, die Einlage aus der Währung der Sicherheitsleistung in die Einzahlungswährung umrechnen, indem wir den erhaltenen Wert durch den Betrag der Hebelwirkung des jeweiligen Kontos dividieren. Dazu schreiben wir die Funktion GetMarginForOpening():

//+------------------------------------------------------------------+
//|  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);
  }

mit:

• Posten (lot) - Umfang der offenen Position;
• Kürzel (symbol) - Name des Finanzinstruments;
• als vermeintliche Richtung der Position.

Somit verfügen wir über folgende Informationen zur Berechnung der Margengröße (die Geldmittel zur Sicherung der offenen Position):

• die Einzahlungswährung
• die Währung der Sicherheitsleistung
• Währungsnotierungen (evtl. benötigt bei Kreuzwährungspaaren)
  
• die Kontraktmenge

Schreiben Sie das in MQL5:

//--- 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;

Die Variable „Art“ hat Auswirkungen darauf, wie wir die Kontraktmenge in der Einzahlungswährung berechnen. Berücksichtigen Sie das auf der Grundlage der Beispiele, in allen weiteren Fällen gehen wir davon aus, dass als Einzahlungswährung der US Dollar fungiert.

Die Währungspaare werden üblicherweise in drei Gruppen eingeteilt:

• Unmittelbare Währungspaare - der Wechselkurs des US Dollars zu einer bestimmten Währung. Beispiele: USDCHF, USDCAD, USDJPY, USDSEK;
• Umgekehrte Währungspaare - der Wechselkurs einer bestimmten Währung zum US Dollar. Beispiele: EURUSD, GBPUSD, AUDUSD, NZDUSD;
• Kreuzwährungspaare - Währungspaare ohne Beteiligung des US Dollars. Beispiele: AUDCAD, EURJPY, EURCAD. 
  

1. EURUSD - das umgekehrte Währungspaar

Wir bezeichnen die Währungspaare, in denen die Notierungswährung die Währung des Kontos ist, als umgekehrte Währungspaare. In unseren Beispielen ist als Kontowährung der US Dollar angegeben, somit fällt unsere Einordnung der Währungspaare mit der allgemein akzeptierten Klassifizierung zusammen. Wenn Ihr Handelskonto jedoch eine andere Währung verwendet (statt des US Dollars), deckt sich dies nicht mehr. In einem solchen Fall, berücksichtigen Sie stets die Kontowährung, um die weiteren Erläuterungen zu verstehen.

Die Kontraktmenge bei EURUSD beträgt 100.000 Euro. Wir müssen 100.000 Euro in der Einzahlungswährung ausdrücken, in US Dollar. Dazu müssen wir den Wechselkurs kennen, zu dem Euros in US Dollar umgerechnet werden. Wir führen den Begriff Rechenwährung ein, er bezeichnet die zur Umrechnung der Währung der Sicherheitsleistung in die Einzahlungswährung benötigte Währung.

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

Glücklicherweise gibt das Währungspaar EURUSD den Wechselkurs von Euro zu US Dollar wieder, und somit ist das Kürzel EURUSD, für das die Höhe der Sicherheitsleistung zu berechnen ist, in diesem Fall genau der Wechselkurs:

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

Wir haben den Wert der Variable Art als „true“ festgelegt, was bedeutet, dass wir zur Umrechnung von Euro in US Dollar (die Währung der Sicherheitsleistung ist konvertierbar in die Einzahlungswährung) den aktuellen EURUSD-Wechselkurs mit der Kontraktmenge multiplizieren. Ist die Variable Art  „false“, dividieren Sie die Kontraktmenge durch den Wechselkurs der Rechenwährung. Verwenden Sie zum Abrufen der aktuellen Preise zu dem Instrument die Funktion SymbolInfoTick().

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

Diese Funktion überträgt den aktuellen Preis sowie den Zeitpunkt der letzten Preisaktualisierung in die Variable des Typs MqlTick - dieser Aufbau wurde eigens zu diesem Zweck entwickelt. 

Deshalb reicht es, den letzten Preis zu diesem Kürzel zu ermitteln, ihn mit der Kontraktmenge sowie anschließend mit der Anzahl der Einzelposten zu multiplizieren. Aber welchen Preis sollen wir zur Berechnung verwenden, wenn man bedenkt, dass es für dieses Instrument sowohl einen Kauf- als auch einen Verkaufspreis gibt? Ganz naheliegend: wenn wir kaufen, entspricht der Berechnungspreis dem Briefkurs, und beim Verkaufen dem Geldkurs.

//--- 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;
        }
     }

Folglich ist in unserem Beispiel die Einzahlungswährung für das Kürzel EURUSD der Euro, die Kontraktmenge beläuft sich auf 100.000 und der letzte Briefkurs lag bei 1,2500. Die Kontowährung ist der US Dollar und die Kalkulationswährung ist dasselbe EURUD-Währungspaar. Durch Multiplikation von 100.000 mit 1,2500 erhalten wir 125.000 US Dollar; das ist exakt so viel wie der Standardkontrakt zum Kauf von einem Posten EURUSD bei einem Briefkurs von 1,2500. 

Wir können schlussfolgern, dass wir, wenn die Notierungswährung mit der Währung des Kontos identisch ist, einfach nur die Kontraktmenge mit dem entsprechenden Kurs, Geld- oder Brief-, je nach gewünschter Richtung der Position multiplizieren müssen, um den Wert eines Postens der Kontowährung zu ermitteln.

margin=lots*lot_size*rate/leverage;

2. USDCHF - unmittelbares Währungspaar

Die Währung der Sicherheitsleistung und die Kontowährung bei USDCHF decken sich, es ist der US Dollar. Die Währungspaare, bei denen die Währung der Sicherheitsleistung und die Kontowährung gleich sind, nennen wir unmittelbare Währungspaare. Kontraktmenge = 100.000. Das ist der einfachste Fall, man gibt einfach das Produkt an.

//--- 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);
     }

Fällt die Einzahlungswährung mit der Kontowährung zusammen, entspricht der Wert der Einlage in der Kontowährung dem Produkt von Standardkontrakt und der Anzahl der Einzelposten (Kontrakte) dividiert durch die Höhe der Hebelwirkung.

Marge = Posten * Postengröße / Hebelwirkung (margin=lots*lot_size/leverage);

3. CADCHF - Kreuzwährungspaar

Das Währungspaar CADCHF dient zur Veranschaulichung, es kann jedoch jedes Währungspaar verwendet werden, bei dem Einzahlungs- und Notierungswährung der Kontowährung entsprechen. Diese Währungspaare werden als „gekreuzt“ bezeichnet, weil zur Berechnung der Marge und des Ertrags in ihnen der Wechselkurs eines weiteren Währungspaares bekannt sein muss, der sich mit dem einer der Währungen schneidet.

Für gewöhnlich handelt es sich bei Kreuzwährungspaaren um solche, die nicht in US Dollar notiert sind. Wir werden jedoch alle Paare, bei denen die Kontowährung nicht in der Notierung enthalten ist, als Kreuzwährungspaare bezeichnen. Folglich handelt es sich, wenn die Kontowährung der Euro ist, bei dem Paar GBPUSD um ein Kreuzwährungspaar, da die Einzahlungswährung das Britische Pfund ist, während die Währungsnotierungen in US Dollar ausgeführt werden. In diesem Fall müssen wir zur Berechnung der Marge das Pfund (GBP) in Euro (EUR) ausdrücken.

Wir werden jedoch mit der Betrachtung eines Beispiels fortfahren, bei dem das Kürzel das Währungspaar CADCHF ist. Hier ist die Einzahlungswährung der Kanadische Dollar (CAD) und fällt nicht mit dem US Dollar (USD) zusammen. Die Notierungswährung ist der Schweizer Franken, der ebenfalls nicht dem US Dollar entspricht.

Wir können lediglich sagen, dass die Einlage zur Eröffnung einer Position in 1 Posten sich auf 100.000 Kanadische Dollar beläuft. Unsere Aufgabe besteht darin, die Einlage in die Kontowährung, den US Dollar, umzurechnen. Dazu müssen wir das Währungspaar finden, dessen Wechselkurs sowohl den US Dollar als auch die Einzahlungswährung, CAD, enthält. Es stehen insgesamt zwei Möglichkeiten zur Wahl:

• CADUSD
• USDCAD

Wir haben die Ausgabedaten für CADCHF:

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

Wir wissen vorher nicht, welches der Währungspaare in dem jeweiligen Ausgabegerät vorhanden ist, und für MQL5 sind beide Möglichkeiten gleichwertig. Deshalb schreiben wir die Funktion GetSymbolByCurrencies(), die uns für die gegebene Kombination von Währungen das erste passende Währungspaar für unsere Berechnungen liefert.

//+------------------------------------------------------------------+
//| 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);
  }

Wie aus dem Programmcode ersichtlich wird, beginnen wir mit der Aufzählung aller in der „Marktansicht“ verfügbaren Kürzel (Die Funktion SymbolsTotal() mit dem Parameterwert „true“ liefert uns diese Mengenangabe). Zum Abrufen der Namen aller Kürzel anhand ihrer Nummer in der Aufstellung der „Marktansicht“ verwenden wir die Funktion SymbolName() mit dem Parameterwert „true“!  Wenn wir den Parameter auf „false“ setzen, zählen wir alle Kürzel auf dem Handelsserver auf, und das sind in der Regel viel mehr als die in dem jeweiligen Ausgabegerät ausgewählten.

  Anschließend verwenden wir das Kürzel zur Abfrage der Einlage und der Notierungen und um sie mit denen zu vergleichen, die an die Funktion GetSymbolByCurrencies() weitergegeben wurden. Im Erfolgsfall geben wir die Bezeichnung des Kürzels ein, und die Arbeit der Funktion wird erfolgreich und vor der geplanten Zeit abgeschlossen. Nachdem der Zyklus vollständig durchlaufen wurde, und die letzte Zeile der Funktion ohne einen Treffer und ohne das Kürzel gefunden zu haben, erreicht ist, lautet die Ausgabe: NULL.

Jetzt, da wir die Kalkulationswährung für das Kreuzwährungspaar mithilfe der Funktion GetSymbolByCurrencies() abrufen können, unternehmen wir zwei Versuche: zunächst suchen wir nach dem Kürzel, dessen Einzahlungswährung die Währung der Marge (Die Einzahlungswährung bei CADCHF ist CAD), und dessen Notierungswährung die Währung des Kontos (USD) ist. Mit anderen Worten, wir suchen nach etwas, das mit dem Paar CADUSD vergleichbar ist.

//--- 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;
        }
     }

Sollte dieser Versuch fehlschlagen, müssen Sie versuchen eine andere Lösung zu finden: suchen Sie nach einem Kürzel, dessen Einzahlungswährung die Kontowährung (USD) und dessen Notierungswährung die Margenwährung (Die Einzahlungswährung bei CADCHF ist CAD) ist. Wir suchen nach etwas, das USDCAD ähnelt.

Da wir nun das Berechnungswährungspaar gefunden haben, gibt es zwei Möglichkeiten, wie es sein kann: unmittelbar oder umgekehrt. Die Variable „Art“ setzt den Wert „true“ für das umgekehrte Währungspaar an. Liegt ein unmittelbares Währungspaar vor, so ist der Wert „false“. Ist der Wert „true“, multiplizieren wir ihn mit dem Wechselkurs des Währungspaars, ist er „false“, teilen wir ihn durch den Einzahlungswert eines Standardkontrakts in der Kontowährung.

Es folgt die abschließende Berechnung der Höhe der Einzahlung in der Kontowährung für die gefundene Kalkulationswährung. Das eignet sich für beide Alternativen: unmittelbare wie umgekehrte Währungspaare.

//--- 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;
        }
     }

Ausgabe des erzielten Ergebnisses

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

Hier ist die Arbeit der Funktion GetMarginForOpening() getan. Was noch getan werden muss, ist die Division des erhaltenen Wertes durch die Höhe der verfügbaren Hebelwirkung, anschließend bekommen wir den Wert der Marge für offene Positionen mit dem angegebenen Umfang in der angenommenen Richtung. Vergessen Sie nicht, dass sich bei den Kürzeln, die für ein umgekehrtes oder ein Kreuzwährungspaar stehen, der Wert der Marge bei jeder Kursschwankung ändert.

Hier ist ein Teil des Codes des Expert Advisors SymbolInfo_Advanced.mq5. Der vollständige Code wird als Datei angehängt,

//+------------------------------------------------------------------+
//| 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);
  }

und das Ergebnis seiner Arbeit erscheint in dem Diagramm.

Fazit

Die gegebenen Beispiele zeigen, wie leicht und unkompliziert es ist, sich Informationen über die wichtigsten Eigenschaften eines Handelskontos sowie über die besonderen Merkmale von Finanzinstrumenten zu verschaffen.