Das MQL5-Kochbuch: Die Eigenschaften offener Hedge-Positionen abfragen
1 031
0
Einführung
Eine der kürzlich hinzugefügten Terminalfunktionen des MetaTrader 5 ist die Möglichkeit, bidirektionale Positionen zu öffnen. Dieses Kontensystem der Positionen wird als Hedging bezeichnet. Die Unterstützung dieses Systems ermöglicht eine einfache Übertragung von Handelsalgorithmen von MetaTrader 4 auf die fünfte Plattformversion und nutzt gleichzeitig die Vorteile der erweiterten MetaTrader 5 Funktionalität. Für weitere Details zu den Optionen des Hedging-Systems in MetaTrader 5 lesen Sie bitte den Artikel "Hedging-System zur Verrechnung von Positionen in MetaTrader 5 verfügbar".
In diesem Artikel werden wir die Eigenschaften der Gesamtposition, die Gegenstand des Hedging-System ist, besprechen.
1. Hedge-Position. Typen
Eine (aggregierte) Hedge-Position ist eine Marktposition, die aus mehreren Orders im Markt gebildet wird. Eine Hedge-Position beinhaltet im engeren Sinne Orders in verschiedene Richtungen (Kauf und Verkauf). Ich schlage jedoch vor, "Hedge" auch im weiteren Sinne zu nutzen. Hier kann eine Hedge-Position auch Aufträge in die gleiche Richtung umfassen. Dieser Ansatz ist mit den Terminalfunktionen des MetaTrader 5 verbunden: Wir können Orders in eine Richtung öffnen, aber auch in der anderen.
Es gibt mehrere Möglichkeiten, eine aggregierte Position zu klassifizieren. Das vielleicht beliebteste Kriterium ist die Unterscheidung von Positionen nach der Art der offenen Positionen, die die Gesamtposition bilden. Welche Orders können also eine solche Position bilden? Tabelle 1 unten zeigt verschiedene Kombinationen.
| Nr | Typ | Beschreibung |
|---|---|---|
| 1 | Hedge buy | Nur Kauf |
| 2 | Hedge netting buy | Netto Kauf |
| 3 | Hedge sell | Nur Verkauf |
| 4 | Hedge netting sell | Netto Verkauf |
| 5 | Hedge locked | Geschlossen (der gesamte Hedge) |
Tabelle 1. Hedge-Typen
Lassen Sie uns diese Typen kurz erläutern. Wenn die Gesamtposition nur Kauf- oder nur Verkaufsaufträge hat (im Sinne von MetaTrader 4), wird diese Position entweder als Hedge-Buy oder Hedge-Sell betrachtet. Wenn die Position unterschiedliche Orders hat (sowohl Kauf als auch Verkauf), werden wir feststellen, welche Orders vorherrschen. Wenn es mehr Kaufpositionen gibt, wird die Position als 'hedge netting buy' bezeichnet. Wenn es mehr Verkaufspositionen gibt, handelt es sich um eine 'hedge netting sell'. Um genauer zu sein, müssen wir uns mit dem Positionsvolumina und nicht mit deren Anzahl befassen. Angenommen, eine Hedge-Position hat 1 Kaufposition von 1,25 Lots und zwei Verkaufspositionen von 0,5 und 0,6 Lots. Die Gesamtposition ist 'hedge netting buy' mit dem Volumen von 0,15 Lots:
1.25 – (0.5 + 0.6) = 0.15.
Eine besondere Art der gemischten Position ist das Locking (Schließen), bei dem sich Kauf und Verkauf volumenmäßig ausgleichen.
Lassen Sie uns diese beschriebenen Hedge-Typen in der folgenden Aufzählung formalisieren:
//+------------------------------------------------------------------+ //| Hedge-Type | //+------------------------------------------------------------------+ enum ENUM_HEDGE_TYPE { HEDGE_BUY=0, // Kauf HEDGE_SELL=1, // Verkauf HEDGE_NETTING_BUY=2, // Netto-Kauf HEDGE_NETTING_SELL=3, // Netto-Verkauf HEDGE_LOCKED=4, // Geschlossen };
Eine Position im Netting-System, die ebenfalls aggregiert ist, kann nur von einer der beiden Arten sein: Kauf oder Verkauf. Die Typenkennung ist einer der Werte der Enumeration ENUM_POSITION_TYPE:
1) POSITION_TYPE_BUY;
2) POSITION_TYPE_SELL.
Im Hedging-System gibt es fünf Arten von aggregierten Positionen.
Im nächsten Abschnitt werden wir eine Klasse erstellen, die die Eigenschaften der Hedge-Position behandelt.
2. Die Klasse CHedgePositionInfo
Die Standardbibliothek stellt die Klasse CPositionInfo zur Verfügung, die den Zugriff auf die Eigenschaften einer offenen Marktposition ermöglicht. Wir werden diese Klasse teilweise für unseren Fall verwenden, da die von der Klasse behandelte Position als separate Marktorder (im Sinne von MetaTrader 4) dargestellt wird. Wir benötigen eine Klasse, die alle Positionen innerhalb der aggregierten Position (Hedge) verarbeitet.
Verwenden wir OOP-Hilfsmittel und erstellen wir die Klasse CHedgePositionInfo:
//+------------------------------------------------------------------+ //| Class CHedgePositionInfo | //| Purpose: Class for access to a hedge position info. | //| Derives from class CObject. | //+------------------------------------------------------------------+ class CHedgePositionInfo : public CObject { //--- === Data members === --- private: ENUM_HEDGE_TYPE m_type; double m_volume; double m_price; double m_stop_loss; double m_take_profit; ulong m_magic; //--- Objekte CArrayLong m_tickets; CSymbolInfo m_symbol; CPositionInfo m_pos_info; //--- === Methods === --- public: //--- Constructor/Destructor void CHedgePositionInfo(void){}; void ~CHedgePositionInfo(void){}; //--- Initialisierung bool Init(const string _symbol,const ulong _magic=0); //--- get methods CSymbolInfo *Symbol(void) {return GetPointer(m_symbol);}; CArrayLong *HedgeTickets(void) {return GetPointer(m_tickets);}; CPositionInfo *PositionInfo(void) {return GetPointer(m_pos_info);}; ulong Magic(void) const {return m_magic;}; //--- fast access methods to the integer hedge properties datetime Time(void); ulong TimeMsc(void); datetime TimeUpdate(void); ulong TimeUpdateMsc(void); ENUM_HEDGE_TYPE HedgeType(void); //--- fast access methods to the double hedge properties double Volume(double &_buy_volume,double &_sell_volume); double PriceOpen(const ENUM_TRADE_TYPE_DIR _dir_type=TRADE_TYPE_ALL); double StopLoss(const ENUM_TRADE_TYPE_DIR _dir_type=TRADE_TYPE_ALL); double TakeProfit(const ENUM_TRADE_TYPE_DIR _dir_type=TRADE_TYPE_ALL); double PriceCurrent(const ENUM_TRADE_TYPE_DIR _dir_type=TRADE_TYPE_ALL); double Commission(const bool _full=false); double Swap(void); double Profit(void); double Margin(void); //--- fast access methods to the string hedge properties string TypeDescription(void); //--- info methods string FormatType(string &_str,const uint _type) const; //--- select bool Select(void); //--- Status void StoreState(void); bool CheckState(void); private: //--- calculation methods bool AveragePrice( const SPositionParams &_pos_params, double &_avg_pr, double &_base_volume, double &_quote_volume ); int CheckLoadHistory(ENUM_TIMEFRAMES period,datetime start_date); }; //+------------------------------------------------------------------+
Ein paar Worte zu den Mitgliedern der Klassendaten.
Erstens gibt es ein eindeutiges Symbol. D.h. eine Hedge-Position kann beliebige Positionen desselben Symbols beinhalten. Das Symbol wird basierend auf dem Feld m_symbol bestimmt, das das Klassenbeispiel CSymbolInfo repräsentiert.
Zweitens kann die Magicnummer (m_magic) verwendet werden, um Aufträge zu filtern. Der Filter ermöglicht die Erstellung einer Position, die von einem handelnden Expert Advisor verwaltet wird. Dadurch können mehrere Hedge-Positionen mit demselben Symbol erstellt werden.
Es gibt auch ein dynamisches Array für die Abrechnung von Aufträgen (m_tickets). Die Tickets der Hedge-Position werden zu diesem Array hinzugefügt.
Die Funktionen zum Erhalten der Eigenschaften einer beliebigen ausgewählten Position (d.h. einer Market Order im Sinne von MetaTrader 4) werden von der Klasseninstanz CPositionInfo (m_pos_info) ausgeführt.
Andere Hedge-Eigenschaften werden zur Beurteilung des Zustands herangezogen:
- Typ (m_type);
- Volumen (m_volume);
- Eröffnungspreis (m_price);
- Preis des Stop-Loss (m_stop_loss);
- Preis des Take-Profit (m_take_profit).
Die Klassenkonstruktion basiert hier auf der Klassenlogik CPositionInfo. Das ist ganz natürlich. Deshalb hat die neue Klasse Methoden, die ganze Zahlen, Dezimalzahlen etc. zurückgeben. Und es wird natürlich auch spezifische Methoden geben.
2.1 Initialisierungsverfahren
Bevor wir die Klassenmerkmale verwenden können, müssen wir die entsprechende Instanz initialisieren. Das Verfahren prüft, ob der EA unter den Systembedingungen "Hedging" arbeitet und ob das gewünschte Symbol ausgewählt und/oder die Magicnummer bestimmt wurde.
//+------------------------------------------------------------------+ //| Initialization | //+------------------------------------------------------------------+ bool CHedgePositionInfo::Init(const string _symbol,const ulong _magic=0) { //--- account margin mode ENUM_ACCOUNT_MARGIN_MODE margin_mode=(ENUM_ACCOUNT_MARGIN_MODE)AccountInfoInteger(ACCOUNT_MARGIN_MODE); if(margin_mode!=ACCOUNT_MARGIN_MODE_RETAIL_HEDGING) { Print(__FUNCTION__+": no retail hedging!"); return false; } if(!m_symbol.Name(_symbol)) { Print(__FUNCTION__+": a symbol not selected!"); return false; } ENUM_SYMBOL_CALC_MODE symbol_calc_mode=(ENUM_SYMBOL_CALC_MODE)SymbolInfoInteger(_symbol,SYMBOL_TRADE_CALC_MODE); if(symbol_calc_mode!=SYMBOL_CALC_MODE_FOREX) { Print(__FUNCTION__+": only for Forex mode!"); return false; } m_magic=_magic; //--- return true; } //+------------------------------------------------------------------+
Diese Methode ist für die spätere Verwendung der Merkmale der Hedge-Klasse zwingend erforderlich. Beachten Sie, dass der Modus zur Berechnung der Marge in der Methode überprüft wird. Wenn es nicht mit "Hedging" übereinstimmt, gibt die Methode false zurück. Außerdem wird die Berechnungsmethode der Kontraktwerte geprüft. Wir werden nur mit Forex-Verträgen arbeiten.
2.2 Eigenschaften mit ganzen Zahlen
Ganze Zahlen werden von folgenden Methoden zurückgegeben:
- datetime Time(void);
- ulong TimeMsc(void);
- datetime TimeUpdate(void);
- ulong TimeUpdateMsc(void);
- ENUM_HEDGE_TYPE HedgeType(void).
Hier ist der Code der Methode CHedgePositionInfo::Time():
//+------------------------------------------------------------------+ //| Get the hedge open time | //+------------------------------------------------------------------+ datetime CHedgePositionInfo::Time(void) { datetime hedge_time=WRONG_VALUE; int hedge_pos_num=m_tickets.Total(); //--- if any positions if(hedge_pos_num>0) { //--- find the first opened position for(int pos_idx=0;pos_idx<hedge_pos_num;pos_idx++) { ulong curr_pos_ticket=m_tickets.At(pos_idx); if(curr_pos_ticket<LONG_MAX) if(m_pos_info.SelectByTicket(curr_pos_ticket)) { datetime curr_pos_time=m_pos_info.Time(); if(curr_pos_time>0) { if(hedge_time==0) hedge_time=curr_pos_time; else { if(curr_pos_time<hedge_time) hedge_time=curr_pos_time; } } } } } //--- return hedge_time; } //+------------------------------------------------------------------+
Um die Eröffnungszeit des Hedges zu erhalten, die eigentlich die Zeit der ersten Position innerhalb des Hedges ist, müssen wir alle Positionen durchgehen und die früheste finden.
Um die Änderungszeit des Hedge, d.h. die der letzten geänderten Position, zu erhalten, müssen wir die vorherige Methode leicht modifizieren:
//+------------------------------------------------------------------+ //| Get the hedge update time | //+------------------------------------------------------------------+ datetime CHedgePositionInfo::TimeUpdate(void) { datetime hedge_time_update=0; int hedge_pos_num=m_tickets.Total(); //--- if any positions if(hedge_pos_num>0) { //--- find the first opened position for(int pos_idx=0;pos_idx<hedge_pos_num;pos_idx++) { ulong curr_pos_ticket=m_tickets.At(pos_idx); if(curr_pos_ticket<LONG_MAX) if(m_pos_info.SelectByTicket(curr_pos_ticket)) { //--- get the current position update time datetime curr_pos_time_update=m_pos_info.TimeUpdate(); if(curr_pos_time_update>0) if(curr_pos_time_update>hedge_time_update) hedge_time_update=curr_pos_time_update; } } } //--- return hedge_time_update; } //+------------------------------------------------------------------+
Hier ist der Code der Methode zur Bestimmung des Hedge-Typs:
//+------------------------------------------------------------------+ //| Get the hedge type | //+------------------------------------------------------------------+ ENUM_HEDGE_TYPE CHedgePositionInfo::HedgeType(void) { ENUM_HEDGE_TYPE curr_hedge_type=WRONG_VALUE; int hedge_pos_num=m_tickets.Total(); //--- if any positions if(hedge_pos_num>0) { //--- get the volumes double total_vol,buy_volume,sell_volume; buy_volume=sell_volume=0.; total_vol=this.Volume(buy_volume,sell_volume); //--- define a hedge type if(buy_volume>0. && sell_volume>0.) { if(buy_volume>sell_volume) curr_hedge_type=HEDGE_NETTING_BUY; else if(buy_volume<sell_volume) curr_hedge_type=HEDGE_NETTING_SELL; else curr_hedge_type=HEDGE_LOCKED; } else if(buy_volume>0. && sell_volume==0.) curr_hedge_type=HEDGE_BUY; else if(buy_volume==0. && sell_volume>0.) curr_hedge_type=HEDGE_SELL; } //--- return curr_hedge_type; }; //+------------------------------------------------------------------+
Der Hedge-Typ ist abhängig von der Differenz zwischen Kauf- und Verkaufsvolumen. Erst prüfen wir, ob es sich bei der Position um eine Hedge-Position im engeren Sinne handelt. Wenn das Kauf- und Verkaufsvolumen gleich sind, ist dies ein vollständiger Hedge. Wenn sie nicht gleich sind, ist dies ein Zeichen für ein teilweisen Hedge.
Dann prüfen wir, ob der Hedge Volumen verschiedener Richtungen beinhaltet und nicht nur Kauf und Verkauf.
2.3 Eigenschaften mit Dezimalzahlen
Folgenden Methoden geben Dezimalzahlen zurück:
- double Volume(double &_buy_volume,double &_sell_volume);
- double PriceOpen(void);
- double StopLoss(void);
- double TakeProfit(void);
- double PriceCurrent(void);
- double Commission(void);
- double Swap(void);
- double Profit(void);
- double Margin(void).
Die Methode zur Bestimmung des Hedge-Volumens hat Referenzen auf Variablen. Diese Implementierung ermöglicht es uns, sowohl das Volumen der Hedge-Position als auch das Volumen seiner Komponenten (Kauf- und Verkaufsorders) sofort zu erhalten.
//+------------------------------------------------------------------+ //| Get the hedge volume | //+------------------------------------------------------------------+ double CHedgePositionInfo::Volume(double &_buy_volume,double &_sell_volume) { double total_vol=0.; int hedge_pos_num=m_tickets.Total(); //--- if any positions if(hedge_pos_num>0) { _buy_volume=_sell_volume=0.; //--- get the buy\sell volumes for(int pos_idx=0;pos_idx<hedge_pos_num;pos_idx++) { ulong curr_pos_ticket=m_tickets.At(pos_idx); if(curr_pos_ticket<LONG_MAX) if(m_pos_info.SelectByTicket(curr_pos_ticket)) { ENUM_POSITION_TYPE curr_pos_type=m_pos_info.PositionType(); double curr_pos_vol=m_pos_info.Volume(); if(curr_pos_vol>0.) { //--- for a buy position if(curr_pos_type==POSITION_TYPE_BUY) _buy_volume+=curr_pos_vol; //--- else for a sell position else if(curr_pos_type==POSITION_TYPE_SELL) _sell_volume+=curr_pos_vol; } } } total_vol=_buy_volume-_sell_volume; } //--- return total_vol; } //+------------------------------------------------------------------+
Für die Arbeit mit den Preiseigenschaften wurde eine Hilfsmethode CHedgePositionInfo::AveragePrice() erstellt. Hier ist der Codeblock zur Berechnung des durchschnittlichen Hedge-Preises in Abhängigkeit von den Typen der Preislevel:
//--- if the hedge volumes calculated if(hedge_base_volume!=0. && hedge_quote_volume!=0.) { _avg_pr=fabs(hedge_quote_volume/hedge_base_volume); _base_volume=hedge_base_volume; _quote_volume=hedge_quote_volume; return true; }
Hierfür wird der Wert-Ansatz verwendet: das Verhältnis des endgültigen Hedge-Wertes in der Kurswährung zum endgültigen Hedge-Wert in der Depotwährung.
Später werden wir diese Berechnung anhand eines separaten Beispiels analysieren.
Swap- und Gewinnmethoden summieren die entsprechenden Variablen jeder einzelnen Position innerhalb einer Hedge-Position und liefern den resultierenden Wert zurück. Die Methode zur Abfrage der Kommission analysiert Deals, die an der Positionseröffnung beteiligt waren. Hier ermöglicht der Parameter die Auswahl, wie die Kommissionshöhe berechnet werden soll. Verwenden Sie den Standardwert, um Kommissionen nur auf der Grundlage von Eröffnungsgeschäften zu berechnen. Setzen Sie den Parameter auf true, wenn Sie Kommissionen sowohl bei der Eröffnung wie beim Schließen berechnen müssen. Beachten Sie jedoch, dass die letztgenannte Option aus mehreren Gründen einen ungefähren Charakter hat. Erstens können ausgewählte Positionen durch entgegengesetzte geschlossen werden. Es wird also Deals vom Typ DEAL_ENTRY_OUT_BY geben. Die Kommission wird bei solchen Geschäften nicht belastet. Zweitens, wenn die Kontowährung nicht mit der Basiswährung übereinstimmt, können die Ein- und Ausgangskosten unterschiedlich sein, wenn sich die Kurse ändern.
//+------------------------------------------------------------------+ //| Get the hedge commission | //+------------------------------------------------------------------+ double CHedgePositionInfo::Commission(const bool _full=false) { double hedge_commission=0.; int hedge_pos_num=m_tickets.Total(); //--- if any positions if(hedge_pos_num>0) for(int pos_idx=0;pos_idx<hedge_pos_num;pos_idx++) { ulong curr_pos_ticket=m_tickets.At(pos_idx); if(curr_pos_ticket<LONG_MAX) if(m_pos_info.SelectByTicket(curr_pos_ticket)) { long curr_pos_id=m_pos_info.Identifier(); if(curr_pos_id>0) //--- retrieve the history of deals associated with the selected position if(HistorySelectByPosition(curr_pos_id)) { CDealInfo curr_deal; int deals_num=HistoryDealsTotal(); for(int deal_idx=0;deal_idx<deals_num;deal_idx++) if(curr_deal.SelectByIndex(deal_idx)) { ENUM_DEAL_ENTRY curr_deal_entry=curr_deal.Entry(); if(curr_deal_entry==DEAL_ENTRY_IN) { double curr_deal_commission=NormalizeDouble(curr_deal.Commission(),2); if(curr_deal_commission!=0.) { double fac=1.; if(_full) fac=2.; hedge_commission+=(fac*curr_deal_commission); } } } } } } //--- return hedge_commission; } //+------------------------------------------------------------------+
Die Klasse enthält die Methode CHedgePositionInfo::Margin(), die es ermöglicht, die Marge für eine Hedge-Position zu bestimmen. Diese Methode war eigentlich die am schwierigsten zu programmierende. Man könnte einen eigenen Artikel darüber schreiben, wie man die Marge für offene Positionen und offene Aufträge korrekt bestimmt.
2.3.1 Marge von Hedge-Positionen
Wie vom Entwickler beschrieben, gibt es zwei Methoden zur Berechnung der Marge für bidirektionale Positionen. Die verwendete Art wird vom Broker festgelegt. Die erste Methode verwendet eine "Grundberechnung", und die zweite basiert dem "größeren Leg".
Ich bin der zweiten Berechnungsart noch nie begegnet. Trotzdem ist sie im Code implementiert. Lassen Sie uns aber zuerst die erste Methode betrachten. Sie wird einen komplexeren Algorithmus haben, der die Berechnung der Marge beinhaltet:
- für das ungedeckte Volumen
- für das abgesicherte (gedeckte) Volumen (wenn die Größe der abgesicherten Marge angegeben ist).
- für Pending-Orders
In diesem Artikel wird die Marge für das Retail Forex, Futures-Modell berechnet. Die Berechnung der Marge für Pending-Orders wird nicht berücksichtigt.
Für eine vollständige Berechnung der Marge der Hedge-Position sind Angaben zu den folgenden Parametern erforderlich:
- Kontowährung. Konten werden in der Regel in folgenden Währungen geführt: USD, EUR, GBP, CHF.
- Währung der Marge. In der Regel entspricht dies der Basiswährung. So ist beispielsweise die Währung der Marge für EURUSD der Euro (EUR) und für das AUDNZD-Kreuzpaar der Australische Dollar (AUD).
- Die Hebel (leverage).
Beachten Sie auch, dass die Marge in der Saldenzeile der Registerkarte Handel des Terminals in der Depotwährung angegeben wird. Das Berechnungsergebnis sollte daher den Wert der Marge in der Depotwährung sein.
Da die Margenwährung von der Kontowährung abweichen kann, gibt es mehrere Berechnungsmöglichkeiten:
- Wenn die Kontowährung im Symbol der Hedge-Position als Basiswährung vorhanden ist. Nehmen wir an, Sie handeln USDCHF auf einem Dollar-Konto.
- Wenn die Kontowährung im Symbol der Hedge-Position als notierte Währung vorhanden ist. Zum Beispiel, wenn Sie EURUSD auf einem Dollar-Konto handeln.
- Wenn das Symbol der Hedge-Position nicht die Depotwährung enthält. Zum Beispiel, wenn Sie AUDNZD auf einem Dollar-Konto handeln.
Die erste Variante ist die am einfachsten zu berechnende und die letzte die schwierigste. Betrachten wir nun Berechnungsbeispiele für jede Option.
Variante 1
Angenommen, es gibt ein Dollarkonto (Einlage) mit fünf offenen USDCHF-Positionen (Abb.1).
Abb.1 Marktpositionen für das Paar USDCHF
Basisparameter:
Kontowährung - USD.
Währung der Marge - USD.
Hebel (leverage) - 1:100.
Drei sind Kaufpositionen. Das Gesamtvolumen der Positionen beträgt 5,55 Lots, was $555.000 entspricht. Die anderen beiden sind Verkaufspositionen. Das Gesamtvolumen dieser Positionen beträgt 7,5 Lose, was $750.000 entspricht.
A) Berechnung für das ungedeckte Volumen
Das ungedeckte Volumen entspricht 1,95 Losen, d.h. $195.000. Es handelt sich um ein Verkaufsvolumen, da mehr ver- als gekauft wurde. Der Kauf oder Verkauf selbst spielt in unserem Fall jedoch keine Rolle, da wir den Durchschnitt der gewichteten Preise nicht berechnen müssen.
Die Marge für diesen Betrag wird unter Berücksichtigung des Hebels berechnet:
$195.000 / 100 = $1.950,00.
B) Berechnung der abgesicherten Volumina
Das abgesicherte Volumen entspricht 5,55 Losen, d.h. 555.000 $.
Die Marge für diesen Betrag wird unter Berücksichtigung des Hebels berechnet:
$555.000 / 100 = $5.550,00.
Der berechnete Wert der Marge ergibt sich aus der Summe der Margen der gedeckten und der ungedeckten Volumina.
$1.950 + $5.550 = $7.500.
Dies ist der Wert, der im Trading Terminal als "Margin" angezeigt wird.
Variante 2
Jetzt gibt es ein Dollar-Konto (Einlage) mit fünf offenen EURUSD-Positionen (Abb.2).
Abb.2 Marktposition EURUSD
Basisparameter:
- Kontowährung - USD.
- Währung der Marge - EUR.
- Hebel (leverage) - 1:300.
Drei sind Kaufpositionen. Das Gesamtvolumen der Positionen beträgt 5,55 Lots, was €555.000 oder $645.617,20 entspricht. Der Durchschnitt der gewichteten Preise der Kaufpositionen beträgt $1,163274.
Wieder gibt es zwei Verkaufspositionen. Das Gesamtvolumen dieser Positionen beträgt 7,5 Lots, was €750.000 oder $872.409 entspricht. Der Durchschnitt der gewichteten Verkaufspreise beträgt $1,163212.
Alle Positionen sind in Tabelle 2 dargestellt.
| Typ | Volumen | Preis | Value, $ |
|---|---|---|---|
| Kauf | 1,75 | 1,16329 | 203.575,75 |
| Kauf | 2,55 | 1,16329 | 296.638,95 |
| Kauf | 1,25 | 1,16322 | 145.402,50 |
| Verkauf | 3,00 | 1,16323 | 348.969,00 |
| Verkauf | 4,50 | 1,16320 | 523.440,00 |
| Gesamt | 13,05 | 1,1632385 | 1.518.026,20 |
Tabelle 2. Marktposition EURUSD
Es gibt insgesamt 5 Positionen. Das Gesamtvolumen der Positionen beträgt 13,05 Lots, welches €1.305.000 oder $1.518.026,20 entspricht Der Durchschnitt der gewichteten Preise beträgt $1.16324.
A) Berechnung für das ungedeckte Volumen
Das ungedeckte Volumen entspricht 1,95 Lots, d.h. $195.000. Es handelt sich um ein Verkaufsvolumen, da mehr ver- als gekauft wurde. Daher verwenden wir den Durchschnitt der gewichteten Preise, um die die Geldbeträge der Volumina zu berechnen.
$1,163212 * €195.000 = $226.826,34.
Die Marge für diesen Betrag wird unter Berücksichtigung des Hebels berechnet:
$226.826,34 / 300 = $756,09.
B) Berechnung der abgesicherten Volumina
Das Hedge-Volumen beträgt 5,55 Lots, d.h. €555.000. Verwenden wir den Durchschnitt der gewichteten Preise aller Position, um den Wert dieses Volumens zu bestimmen:
$1,1632385 * €555.000 = $645.597,35.
Die Marge für diesen Betrag wird unter Berücksichtigung des Hebels berechnet:
$645.597,35 / 300 = $2.151,99.
Jetzt, theoretisch, die gesamte Bruttomarge sollte gleich dem Folgenden sein:
$756,09 + $2.151,99 = $2.908,08.
Der im Terminal angezeigte Wert ist jedoch $1.832,08.
Der Grund dafür ist, dass der Parameter "Hedged Margin" aus der Symbolspezifikation für das abgedeckte (abgesicherte) Volumen berücksichtigt wird. Wenn er kleiner als die Vertragsgröße ist, erhalten wir einen Multiplikator. Dieser Parameter in unserer Symbolspezifikation ist gleich 50.000. Dann:
Wert des Hedge-Volumen = $1,1632385 * €555.000 / (100.000 / 50.000) = $322.798,67.
Marge für das Hedge-Volumen = 322.798,67 $ / 300 = $1.076,00.
Berechnung der Summe: $756,09 + $1.076,00 = $1.832,08. Dies ist der im Terminal angezeigte Wert.
Variante 3
Diesmal gehen wir von einem Dollar-Konto (Einlage) aus, auf dem fünf Positionen AUDNZD sind (Abb.3).
Abb.3 Marktpositionen für das Paar AUDNZD
Basisparameter:
- Kontowährung - USD.
- Währung der Marge - AUD.
- Hebel (leverage) - 1:300.
Drei sind Kaufpositionen. Das Gesamtvolumen der Positionen beträgt 5,55 Lots, welches A$555.000 oder $400.442,35 entspricht. Der Durchschnitt der gewichteten Preise der Kaufpositionen beträgt $0,7215178.
Wieder gibt es zwei Verkaufspositionen. Das Gesamtvolumen der Positionen beträgt 5,55 Lots, was A$750.000 oder $541.035,00 entspricht. Der Durchschnitt der gewichteten Verkaufspreise beträgt $0,72138.
Alle Positionen sind in Tabelle 3 dargestellt.
| Typ | Volumen | Preis | Value, $ |
|---|---|---|---|
| Kauf | 1,75 | 0,72152 | 126.266,00 |
| Kauf | 2,55 | 0,72152 | 183.987,60 |
| Kauf | 1,25 | 0,72151 | 90.188,75 |
| Verkauf | 3,00 | 0,72144 | 216.432,00 |
| Verkauf | 4,50 | 0,72134 | 324.603,00 |
| Gesamt | 13,05 | 0,72144 | 941.477,35 |
Tabelle 3. Marktpositionen für das Paar AUDNZD
Die Spalte Preis enthält die Eröffnungspreise der Positionen nicht für AUDNZD, sondern für das AUDUSD. Dies ermöglicht die Auswertung des gehandelten Volumens in der Kontowährung. Hier müssen wir uns auf die Tick- und Kurs-Historie des Paares beziehen, die die Kontowährung und die Marginwährung beinhaltet. Daher können die berechneten Werte leicht von den tatsächlichen abweichen.
Es gibt insgesamt 5 Positionen. Das Gesamtvolumen der Positionen beträgt 13,05 Lots, was A$1.305.000 oder $941.477,35 entspricht. Der Durchschnitt der gewichteten Preise der Positionen beträgt $0,72144.
A) Berechnung für das ungedeckte Volumen
Das ungedeckte Volumen entspricht 1,95 Lots, d.h. A$195.000. Es handelt sich um ein Verkaufsvolumen, da mehr ver- als gekauft wurde. Daher verwenden wir den Durchschnitt der gewichteten Preise, um die die Geldbeträge der Volumina zu berechnen.
$0,72138 * A$195.000 = $140.669,10.
Die Marge für diesen Betrag wird unter Berücksichtigung des Hebels berechnet:
$140.669,10 / 300 = $468,90.
B) Berechnung der abgesicherten Volumina
Das Hedge-Volumen entspricht 5,55 Lots, d.h. A$555.000. Verwenden wir den Durchschnitt der gewichteten Preise aller Positionen unter Berücksichtigung des Parameters "Hedged Margin", um den Wert für dieses Volumen zu bestimmen:
$0,72144 * A$555.000 / (100.000 / 50.000) = $200.199,21.
Die Marge für diesen Betrag wird unter Berücksichtigung des Hebels berechnet:
$200.199,21 / 300 = $667,33.
Berechnung der Summe: $468,90 + $667,33 = $1.136,23. Vergleichen wir das Ergebnis mit der Abb.3: Es entspricht dem im Terminal angezeigten Wert.
2.4 Sonstige Eigenschaften
Die Klasse enthält Methoden für das Arbeiten mit einer Hedge-Position: StoreState() und CheckState(). Ähnlich wie bei einer einzigen gemeinsamen Position umfasst eine Hedge-Position die Preise für Art, Volumen, Eröffnungspreis, Stop-Loss und Take-Profit.
Die einzige Texteigenschaftsmethode TypeDescription() gibt den Hedge-Typ als Zeichenkette zurück.
Von besonderer Bedeutung ist die Select()-Methode, die es ermöglicht, eine Hedge-Position auszuwählen. Hier ist der Code der Methode:
//+------------------------------------------------------------------+ //| Selects hedge positions | //+------------------------------------------------------------------+ bool CHedgePositionInfo::Select(void) { string hedge_symbol=m_symbol.Name(); //--- clear all positions m_tickets.Shutdown(); //--- collect positions int pos_num=PositionsTotal(); for(int pos_idx=0;pos_idx<pos_num;pos_idx++) if(m_pos_info.SelectByIndex(pos_idx)) { string curr_pos_symbol=m_pos_info.Symbol(); //--- select by symbol if(!StringCompare(hedge_symbol,curr_pos_symbol)) { //--- if to select by magic bool is_the_same_magic=true; if(m_magic>0) { long curr_pos_magic=m_pos_info.Magic(); if(m_magic!=curr_pos_magic) is_the_same_magic=false; } if(is_the_same_magic) { ulong curr_pos_ticket=m_pos_info.Ticket(); if(curr_pos_ticket>0) if(!m_tickets.Add(curr_pos_ticket)) { PrintFormat(__FUNCTION__+": failed to add #%d ticket!",curr_pos_ticket); return false; } } } } //--- return m_tickets.Total()>0; } //+------------------------------------------------------------------+
Der Hauptzweck der Methode ist die Aktualisierung der Ticketnummern der Positionen, aus denen sich die Hedge-Position zusammensetzt. Es geht um offene Positionen im Markt, die das Symbol gemein haben mit der des Hedge-Symbols. Die Auswahl kann zusätzlich durch die Magic gefiltert werden.
3. Beispiele
Wir haben eine Klasse geschaffen, die mit den Eigenschaften der Hedge-Position arbeitet. In diesem Abschnitt werden wir uns mit praktischen Beispielen beschäftigen. Beginnen wir mit einem einfachen Skript.
3.1 Ein Testskript
Zu Trainingszwecken habe ich das Skript Test_hedge_properties.mq5 erstellt, das Hedge-Eigenschaften im Journal auf der Registerkarte "Experten" anzeigt.
In der ersten Variante der Margenberechnung hatten wir fünf USDCHF-Positionen (Abb.1). Starte das Skript. Die folgenden Informationen werden im Journal angezeigt:
2018.09.03 18:51:37.078 Test_hedge_properties (AUDNZD,H1) ---== Hedge properties==--- 2018.09.03 18:51:37.078 Test_hedge_properties (AUDNZD,H1) Symbol: USDCHF 2018.09.03 18:51:37.078 Test_hedge_properties (AUDNZD,H1) Positions total = 5 2018.09.03 18:51:37.078 Test_hedge_properties (AUDNZD,H1) 1) #293972991 buy 1.75 USDCHF 0.97160000 2018.09.03 18:51:37.078 Test_hedge_properties (AUDNZD,H1) 2) #293974150 buy 2.55 USDCHF 0.97142000 2018.09.03 18:51:37.078 Test_hedge_properties (AUDNZD,H1) 3) #293974889 sell 3.00 USDCHF 0.97157000 2018.09.03 18:51:37.078 Test_hedge_properties (AUDNZD,H1) 4) #293975329 sell 4.50 USDCHF 0.97164000 2018.09.03 18:51:37.078 Test_hedge_properties (AUDNZD,H1) 5) #293976289 buy 1.25 USDCHF 0.97205000 2018.09.03 18:51:37.078 Test_hedge_properties (AUDNZD,H1) Magic: 0 2018.09.03 18:51:37.078 Test_hedge_properties (AUDNZD,H1) Time: 2018.08.29 17:15:44 2018.09.03 18:51:37.078 Test_hedge_properties (AUDNZD,H1) Time in msc: 1535562944628 2018.09.03 18:51:37.078 Test_hedge_properties (AUDNZD,H1) Update time: 2018.08.29 17:20:35 2018.09.03 18:51:37.078 Test_hedge_properties (AUDNZD,H1) Update time in msc: 1535563235034 2018.09.03 18:51:37.078 Test_hedge_properties (AUDNZD,H1) Type: HEDGE_NETTING_SELL 2018.09.03 18:51:37.078 Test_hedge_properties (AUDNZD,H1) Type description: hedge netting sell 2018.09.03 18:51:37.078 Test_hedge_properties (AUDNZD,H1) Volume: -1.95 2018.09.03 18:51:37.078 Test_hedge_properties (AUDNZD,H1) Buy volume: 5.55 2018.09.03 18:51:37.078 Test_hedge_properties (AUDNZD,H1) Sell volume: 7.50 2018.09.03 18:51:37.078 Test_hedge_properties (AUDNZD,H1) Open price: 0.97159 2018.09.03 18:51:37.078 Test_hedge_properties (AUDNZD,H1) Sl-price: -1.00000 2018.09.03 18:51:37.078 Test_hedge_properties (AUDNZD,H1) Tp-price: -1.00000 2018.09.03 18:51:37.078 Test_hedge_properties (AUDNZD,H1) Current price: 0.96956 2018.09.03 18:51:37.078 Test_hedge_properties (AUDNZD,H1) Commission: 0.00 2018.09.03 18:51:37.078 Test_hedge_properties (AUDNZD,H1) Swap: -35.79 2018.09.03 18:51:37.078 Test_hedge_properties (AUDNZD,H1) Profit: 409.77 2018.09.03 18:51:37.078 Test_hedge_properties (AUDNZD,H1) Margin: 7500.00
In der Variante 2 hatten wir es mit den Eigenschaften einer EURUSD-Position zu tun (Abb.2) Durch das Skript wurden folgende Informationen ausgewiesen:
2018.09.03 18:55:09.469 Test_hedge_properties (AUDNZD,H1) ---== Hedge properties==--- 2018.09.03 18:55:09.469 Test_hedge_properties (AUDNZD,H1) Symbol: EURUSD 2018.09.03 18:55:09.469 Test_hedge_properties (AUDNZD,H1) Positions total = 5 2018.09.03 18:55:09.469 Test_hedge_properties (AUDNZD,H1) 1) #119213986 buy 1.75 EURUSD 1.16329000 2018.09.03 18:55:09.469 Test_hedge_properties (AUDNZD,H1) 2) #119214003 buy 2.55 EURUSD 1.16329000 2018.09.03 18:55:09.469 Test_hedge_properties (AUDNZD,H1) 3) #119214004 buy 1.25 EURUSD 1.16322000 2018.09.03 18:55:09.469 Test_hedge_properties (AUDNZD,H1) 4) #119214011 sell 3.00 EURUSD 1.16323000 2018.09.03 18:55:09.469 Test_hedge_properties (AUDNZD,H1) 5) #119214021 sell 4.50 EURUSD 1.16320000 2018.09.03 18:55:09.469 Test_hedge_properties (AUDNZD,H1) Magic: 0 2018.09.03 18:55:09.469 Test_hedge_properties (AUDNZD,H1) Time: 2018.08.31 16:38:10 2018.09.03 18:55:09.469 Test_hedge_properties (AUDNZD,H1) Time in msc: 1535733490531 2018.09.03 18:55:09.469 Test_hedge_properties (AUDNZD,H1) Update time: 2018.08.31 16:38:49 2018.09.03 18:55:09.469 Test_hedge_properties (AUDNZD,H1) Update time in msc: 1535733529678 2018.09.03 18:55:09.469 Test_hedge_properties (AUDNZD,H1) Type: HEDGE_NETTING_SELL 2018.09.03 18:55:09.469 Test_hedge_properties (AUDNZD,H1) Type description: hedge netting sell 2018.09.03 18:55:09.469 Test_hedge_properties (AUDNZD,H1) Volume: -1.95 2018.09.03 18:55:09.469 Test_hedge_properties (AUDNZD,H1) Buy volume: 5.55 2018.09.03 18:55:09.469 Test_hedge_properties (AUDNZD,H1) Sell volume: 7.50 2018.09.03 18:55:09.469 Test_hedge_properties (AUDNZD,H1) Open price: 1.16303 2018.09.03 18:55:09.469 Test_hedge_properties (AUDNZD,H1) Sl-price: -1.00000 2018.09.03 18:55:09.469 Test_hedge_properties (AUDNZD,H1) Tp-price: -1.00000 2018.09.03 18:55:09.469 Test_hedge_properties (AUDNZD,H1) Current price: 1.16198 2018.09.03 18:55:09.469 Test_hedge_properties (AUDNZD,H1) Commission: 0.00 2018.09.03 18:55:09.469 Test_hedge_properties (AUDNZD,H1) Swap: -37.20 2018.09.03 18:55:09.469 Test_hedge_properties (AUDNZD,H1) Profit: 206.60 2018.09.03 18:55:09.469 Test_hedge_properties (AUDNZD,H1) Margin: 1832.08
In der dritten Variante hatten wir Positionen in AUDNZD (Abb.3). Das Skript druckt die folgende Informationen in das Journal:
2018.09.03 18:47:25.369 Test_hedge_properties (EURUSD,H1) ---== Hedge properties==--- 2018.09.03 18:47:25.369 Test_hedge_properties (EURUSD,H1) Symbol: AUDNZD 2018.09.03 18:47:25.369 Test_hedge_properties (EURUSD,H1) Positions total = 5 2018.09.03 18:47:25.369 Test_hedge_properties (EURUSD,H1) 1) #119214062 buy 1.75 AUDNZD 1.08781000 2018.09.03 18:47:25.369 Test_hedge_properties (EURUSD,H1) 2) #119214068 buy 2.55 AUDNZD 1.08783000 2018.09.03 18:47:25.369 Test_hedge_properties (EURUSD,H1) 3) #119214071 buy 1.25 AUDNZD 1.08785000 2018.09.03 18:47:25.369 Test_hedge_properties (EURUSD,H1) 4) #119214083 sell 3.00 AUDNZD 1.08773000 2018.09.03 18:47:25.369 Test_hedge_properties (EURUSD,H1) 5) #119214092 sell 4.50 AUDNZD 1.08757000 2018.09.03 18:47:25.369 Test_hedge_properties (EURUSD,H1) Magic: 0 2018.09.03 18:47:25.369 Test_hedge_properties (EURUSD,H1) Time: 2018.08.31 16:39:41 2018.09.03 18:47:25.369 Test_hedge_properties (EURUSD,H1) Time in msc: 1535733581113 2018.09.03 18:47:25.369 Test_hedge_properties (EURUSD,H1) Update time: 2018.08.31 16:40:07 2018.09.03 18:47:25.369 Test_hedge_properties (EURUSD,H1) Update time in msc: 1535733607241 2018.09.03 18:47:25.369 Test_hedge_properties (EURUSD,H1) Type: HEDGE_NETTING_SELL 2018.09.03 18:47:25.369 Test_hedge_properties (EURUSD,H1) Type description: hedge netting sell 2018.09.03 18:47:25.369 Test_hedge_properties (EURUSD,H1) Volume: -1.95 2018.09.03 18:47:25.369 Test_hedge_properties (EURUSD,H1) Buy volume: 5.55 2018.09.03 18:47:25.369 Test_hedge_properties (EURUSD,H1) Sell volume: 7.50 2018.09.03 18:47:25.369 Test_hedge_properties (EURUSD,H1) Open price: 1.08708 2018.09.03 18:47:25.369 Test_hedge_properties (EURUSD,H1) Sl-price: -1.00000 2018.09.03 18:47:25.369 Test_hedge_properties (EURUSD,H1) Tp-price: -1.00000 2018.09.03 18:47:25.369 Test_hedge_properties (EURUSD,H1) Current price: 1.09314 2018.09.03 18:47:25.369 Test_hedge_properties (EURUSD,H1) Commission: 0.00 2018.09.03 18:47:25.369 Test_hedge_properties (EURUSD,H1) Swap: -21.06 2018.09.03 18:47:25.369 Test_hedge_properties (EURUSD,H1) Profit: -779.45 2018.09.03 18:47:25.369 Test_hedge_properties (EURUSD,H1) Margin: 1136.23
Das Skript Test_hedge_properties.mq5 befindet sich im Zip-Archiv und kann heruntergeladen werden.
3.1 Das Panel der Eigenschaften einer Hedge-Position
Jetzt werden wir die Aufgabe komplizieren. Mit Hilfe der Standardbibliothek erstellen wir den Expert Advisor HedgePropertiesEA.mq5, der ein Panel auf dem Chart zeichnet, das die Eigenschaften der ausgewählten Hedge-Position anzeigt.
Zu diesem Zweck erstellen wir die Klasse CHedgeDialog, die von der Standardklasse CAppDialog abgeleitet ist. Diese Klasse wird uns helfen, die Notwendigkeit zu vermeiden, typische Aufgaben zu programmieren, wie z.B. das Minimieren und Maximieren des Panelfensters, das Behandeln von Änderungen an den Panel-Elementen, etc.
//+------------------------------------------------------------------+ //| Class CHedgeDialog | //| Purpose: Class for displaying a hedge position info. | //| Derives from class CAppDialog. | //+------------------------------------------------------------------+ class CHedgeDialog : private CAppDialog { //--- === Data members === --- private: CArrayString m_symbols_arr; //--- controls CLabel m_labels[FIELDS_NUM+1]; CEdit m_edits[FIELDS_NUM]; CComboBox m_combo; bool m_to_refresh; //--- === Methods === --- public: //--- Constructor/Destructor void CHedgeDialog(void) {}; void ~CHedgeDialog(void) {}; //--- Initialisierung bool Init(void); void Deinit(const int _reason); //--- Verarbeitung void OnChartEvent(const int _id, const long &_lparam, const double &_dparam, const string &_sparam); void OnTradeEvent(void); //--- private: int HedgeSymbols(void); void RefreshPanel(void); }; //+------------------------------------------------------------------+
Die Klasseninstanz im EA-Code ruft Initialisierungs- und Deinitialisierungsereignisse, Diagrammereignisse sowie Ereignisse im Zusammenhang mit Handelsgeschäften auf und verarbeitet sie.
Das Panel für die Eigenschaften der Hedge-Position ist in Abb.4 dargestellt.
Abb.4 Das Panel der Eigenschaften einer Hedge-Position
Eine der wichtigsten Methoden ist CHedgeDialog::RefreshPanel(). Bei Bedarf werden die Informationsfelder des Panels aktualisiert. Einige Schwierigkeiten bei der Programmierung und beim Testen wurden durch Situationen verursacht, die eine Änderung der Anzahl der Hedges zur Folge hatten. In diesem Fall ist es notwendig, die eindeutigen Symbole in der Auswahlliste zu ändern und eine Endlosschleife der OnChartEvent()-Handler-Aufrufe zu vermeiden. Zu diesem Zweck wird limit verwendet, um die aufeinanderfolgende Handler-Aufrufe auf längstens 1 Sekunde zu begrenzen.
//--- check the limit for refreshing if(!m_to_refresh) { uint last_cnt=GetTickCount(); static uint prev_cnt=0; uint msc_elapsed=last_cnt-prev_cnt; prev_cnt=last_cnt; if(msc_elapsed>1000) m_to_refresh=true; else return; }
Der ganze Code des Expert Advisors HedgePropertiesEA.mq5 ist in der beigefügten Zip-Datei verfügbar.
Schlussfolgerungen
Zusätzlich zu den Fähigkeit eine multi-asset Handelsterminals unterstützt MetaTrader 5 unterschiedliche Positionssysteme. Diese Möglichkeiten bieten deutlich erweiterte Möglichkeiten für die Umsetzung und Formalisierung von Handelsideen.
Ich hoffe dieser Artikel interessiert all jene, die ihre Strategie vom MetaTrader 4 auf den MetaTrader 5 übertragen möchten.
Übersetzt aus dem Russischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/ru/articles/4830
Verwendung von Indikatoren zur Optimierung von Expert Advisors in Echtzeit
Elder-Ray (Bulls Power und Bears Power)
Automatisierte Optimierung eines EAs mit dem MetaTrader 5
Kombinieren der Strategien von Trend- und Seitwärtsbewegung
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.