Das MQL5-Kochbuch: Die Eigenschaften offener Hedge-Positionen abfragen

15 Oktober 2018, 09:37
Denis Kirichenko
0
127

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:

  1. datetime                   Time(void);
  2. ulong                        TimeMsc(void);
  3. datetime                   TimeUpdate(void);
  4. ulong                        TimeUpdateMsc(void);
  5. 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:

  1.    double            Volume(double &_buy_volume,double &_sell_volume);
  2.    double            PriceOpen(void);
  3.    double            StopLoss(void);
  4.    double            TakeProfit(void);
  5.    double            PriceCurrent(void);
  6.    double            Commission(void);
  7.    double            Swap(void);
  8.    double            Profit(void);
  9.    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:

  1. für das ungedeckte Volumen
  2. für das abgesicherte (gedeckte) Volumen (wenn die Größe der abgesicherten Marge angegeben ist).
  3. 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:

  1. Kontowährung. Konten werden in der Regel in folgenden Währungen geführt: USD, EUR, GBP, CHF.
  2. 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).
  3. 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:

  1. Wenn die Kontowährung im Symbol der Hedge-Position als Basiswährung vorhanden ist. Nehmen wir an, Sie handeln USDCHF auf einem Dollar-Konto.
  2. 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.
  3. 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.

Das Panel der Eigenschaften einer Hedge-Position

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 Software Corp.
Originalartikel: https://www.mql5.com/ru/articles/4830

Beigefügte Dateien |
Hedge.zip (15.37 KB)
Elder-Ray (Bulls Power und Bears Power) Elder-Ray (Bulls Power und Bears Power)

Der Artikel beschäftigt sich mit dem Handelssystem von Elder-Ray, das auf den Indikatoren Bulls Power, Bears Power und einem gleitenden Durchschnitt (EMA — exponentiellen gleitenden Durchschnitt) basiert. Dieses System wurde von Alexander Elder in seinem Buch "Trading for a Living" beschrieben.

Kombinieren der Strategien von Trend- und Seitwärtsbewegung Kombinieren der Strategien von Trend- und Seitwärtsbewegung

Es gibt viele Handelsstrategien 'da draußen'. Einige suchen nach Trends, andere definieren Preisspannen von Preisbewegungen und handeln dann diese. Ist es möglich beide Ansätze zu kombinieren, um die Profitabilität zu erhöhen?

Verwendung von Indikatoren zur Optimierung von Expert Advisors in Echtzeit Verwendung von Indikatoren zur Optimierung von Expert Advisors in Echtzeit

Die Effizienz eines jeden Handelsroboters hängt von der richtigen Auswahl seiner Parameter ab (Stichwort Optimierung). Jedoch können Parameter, die sich für ein Zeitintervall als optimal erwiesen, ihre Wirksamkeit in einer anderen Zeitspanne der Handelshistorie nicht bestätigen. Außerdem erweisen sich EAs, die während der Tests Gewinne zeigen, als verlustbringend in Echtzeit. Damit rückt das Thema der kontinuierlichen Optimierung in den Vordergrund. Bei vielen Routinearbeiten suchen Menschen immer nach Möglichkeiten, diese zu automatisieren. In diesem Artikel schlage ich einen nicht standardisierten Ansatz zur Lösung dieses Problems vor.

Automatisierte Optimierung eines EAs mit dem MetaTrader 5 Automatisierte Optimierung eines EAs mit dem MetaTrader 5

Der Artikel beschreibt die Implementation eines selbst-optimierenden Mechanismus unter dem MetaTrader 5.