Kategorientheorie in MQL5 (Teil 17): Funktoren und Monoide

Einführung

Wir setzen unseren Blick auf die Kategorientheorie mit einem weiteren Blick auf die Funktorkategorie. Bisher haben wir Anwendungen der Kategorientheorie bei der Implementierung von nutzerdefinierten Instanzen der Expert-Trailing-Klasse und der Expert-Signal-Klasse gesehen, sodass wir in diesem Artikel Anwendungen bei der Verwendung der Expert-Money-Klasse betrachten werden. Alle diese Klassen werden mit der Meta Editor IDE geliefert und mit dem MQL5-Assistenten bei der Erstellung von Expertenberatern mit minimalem Programmieraufwand verwendet.

Die Positionsgröße ist eines der wichtigsten Themen, wenn es um die Entwicklung von Handelssystemen geht. Die Ergebnisse, die bei den ersten Tests eines Expertenberaters erzielt werden, reagieren sehr empfindlich darauf. Daher ist es oft ratsam, ihn ganz wegzulassen (feste Marge oder feste Losgröße verwenden) oder ihn erst ganz am Ende hinzuzufügen, wenn Sie bereits ein geeignetes Einstiegssignal haben, das gut mit Ihren Ausstiegsmethoden abgestimmt ist. Nichtsdestotrotz werden wir versuchen, eine ideale Positionsgröße auf der Grundlage eines prognostizierten Stop-Loss in einer nutzerdefinierten Instanz der Klasse CMoneyCT des Experten festzulegen.

Funktoren sind eine Brücke zwischen Kategorien, die nicht nur die Unterschiede zwischen den Objekten in jeder Kategorie, sondern auch die Unterschiede in ihren Morphismen erfassen. Wir konnten sehen, wie diese erfassten Informationen zur Vorhersage von Änderungen der Volatilität und Markttrends verwendet werden können, wenn wir Kategorien in Form von Diagrammen und linearen Reihenfolgen betrachten. Erinnerungsgraphen und lineare Ordnungen sind keine Kategorien an sich, wurden aber als solche angesehen, weil wichtige Kategorienaxiome vorhanden waren.

In den Artikeln 14 und 15 wurden Funktoren mit Hilfe einfacher linearer Gleichungen implementiert, wobei die Zuordnung lediglich einen Koeffizienten für die Steigung und einen y-Abschnitt zur Bestimmung der Objekte und Morphismen der Kodomänenkategorie erforderte. Seit Artikel 16 haben wir begonnen, Funktoren als ein einfaches neuronales Netz, ein so genanntes mehrschichtiges Perzeptron, zu betrachten. Dieses Netzwerk, das aus der Arbeit von Warren McCulloch und Walter Pitts hervorgegangen ist und nachweislich jede kontinuierliche Funktion von -1 bis +1 wiedergeben kann, ist seit einiger Zeit auch dafür bekannt, jede Kontravalenz XOR zu replizieren, wenn es mehrschichtig ist.

In diesem Artikel fassen wir unseren Blick auf Funktoren zusammen und untersuchen, wie wir in Verbindung mit Monoid und einer Vorbestellung von Wertpapierkursen ein System zur Festlegung von Positionsgrößen beim Handel mit einem Wertpapier, nämlich BTCUSD (Bitcoin), formulieren können. Als wir uns das letzte Mal mit Monoiden beschäftigt haben, bestand ihre Hauptanwendung für Händler in der Klassifizierung von Handelsschritten, sodass Entscheidungen durch die Operationen der einzelnen Monoide getroffen werden konnten. Ein Monoid ist eine Menge, eine binäre Operation und ein Identitätselement. Wir hatten daher Monoide für jeden der fiktiven Schritte erstellt, mit denen ein Händler konfrontiert wird, wenn er Entscheidungen zur Eröffnung einer Position trifft.

Verstehen von Funktoren und Monoiden im Handel

Wenn wir einige der bisher behandelten Grundlagen kurz rekapitulieren, sind Objekte (in früheren Artikeln als Domänen bezeichnet) die Zelle oder der Baustein von Kategorien. Innerhalb einer Kategorie haben Objekte Zuordnungen zueinander, die Morphismen genannt werden, und genauso wie Morphismen Objekte miteinander verbinden, verbinden Funktoren Kategorien.

Die Verbindung zwischen den Kategorien, die durch die Funktoren hergestellt wird, hat sich also als nützlich erwiesen, um Prognosen zu erstellen, da es sich bei der Codomain-Kategorie um eine Zeitreihe handelt, deren Prognose unser Thema ist. In unserem letzten Artikel ging es um die Entscheidung, ob wir beim S&P 500 kaufen oder verkaufen.

Anders als im letzten Artikel, wo Funktoren Graphen mit linearen Ordnungen verknüpften, werden wir jedoch Monoide als Domänenkategorie verwenden. Wie bereits erwähnt, haben wir bei jedem Handelsschritt Monoide als Entscheidungspunkte verwendet. Diese Schritte, die sich zwangsläufig von denjenigen unterscheiden, die andere Händler aufgrund unterschiedlicher Strategien verwenden, waren die Auswahl eines Zeitrahmens, die Auswahl eines Rückblickzeitraums, die Auswahl eines anzuwendenden Preises und die Auswahl eines Indikators, der den zuvor ausgewählten Zeitrahmen, Rückblick und den angewendeten Preis bei der Erstellung eines Messwertes berücksichtigt. Die letzte Auswahl betraf die Handelsaktion, d. h. ob wir angesichts des Indikatorwerts seinem Trend folgen oder uns entgegen seinem Wert positionieren. Die Monoide wurden also für jede dieser Entscheidungen kodiert, und die Binäroperation jedes Monoids war für die Auswahl des entsprechenden Wertes aus jeder Menge verantwortlich, nachdem alle Werte der Menge durchlaufen worden waren.

Funktoren als Multi-Layer Perceptrons (MLPs)

Die Rolle des mehrschichtigen Perceptrons im Handel kann nicht hoch genug eingeschätzt werden. Die schiere Menge an Artikeln über neuronale Netze ist ein klarer Beweis dafür, warum sie unverzichtbar geworden sind und immer mehr werden. Für die meisten Händler dienen sie jedoch dazu, die nächsten Preistrends eines Wertpapiers zu prognostizieren, was auch in Ordnung ist. Was jedoch meiner Meinung nach übersehen werden kann, ist die Auswahl (und vielleicht die Regularisierung) der Eingabedaten für das Netz. Ja, Sie wollen eine Zeitreihe prognostizieren, aber auf welchen Datenstrom wollen Sie Ihre Prognose stützen und warum? Dies mag trivial klingen, könnte aber unter anderem der Grund dafür sein, dass viele Netze, die mit großen Datenmengen trainiert wurden, bei Testläufen nicht die gleiche Leistung erbringen.

So wie wir in unserem sehr grundlegenden Handelssystem für Artikel 9 und einigen anderen, die darauf folgten, Monoide zur Entscheidungsfindung bei jedem der Schritte verwendet haben, werden wir dies auch für diesen Artikel tun, mit der einzigen Ausnahme, dass der letzte Schritt weggelassen wird und vier Schritte übrig bleiben. Der ausgelassene fünfte Schritt, dessen Monoid festlegt, ob man dem Trend folgt oder gegen den Trend handelt, ist hier nicht relevant. Unser mehrschichtiges Perzeptron (MLP) verwendet dann jeden der vier verbleibenden monoiden Ausgangswerte als Eingabe. Die Zielausgabe, für die unser MLP trainiert wird, sind die idealen Stop-Loss-Punkte für eine offene Position. Die Größe dieser Stop-Loss-Lücke ist umgekehrt proportional zu den in einer Position gehandelten Lots und dient daher als wichtige Kennzahl für unsere Positionsgröße.

Auf diese Weise werden wir also eine Positionsgröße auf der Grundlage der prognostizierten Stop-Loss-Lücke ermitteln:

         //output from MLP forecast
         double _stoploss_gap=_y_output[0];
         
         //printf(__FUNCSIG__+" ct call: "+DoubleToString(_stoploss_gap));
      
         sl=m_symbol.Ask()+fabs(_stoploss_gap);
         
         //--- select lot size
         double _ct_1_lot_loss=(_stoploss_gap/m_symbol.TickSize())*m_symbol.TickValue();
         double lot=((m_percent/100.0)*m_account.FreeMargin())/_ct_1_lot_loss;
         
         //--- calculate margin requirements for 1 lot
         if(m_account.FreeMarginCheck(m_symbol.Name(),ORDER_TYPE_SELL,lot,m_symbol.Bid())<0.0)
         {
            printf(__FUNCSIG__" insufficient margin for sl lot! ");
            lot=m_account.MaxLotCheck(m_symbol.Name(),ORDER_TYPE_SELL,m_symbol.Bid(),m_percent);
         }
         
         //--- return trading volume
         return(Optimize(lot));

Zunächst berechnen wir den Lot-Verlust oder den Dollarwert des Drawdowns, der entsteht, wenn eine Position von einem Lot über dem projizierten Stop-Loss-Abstand im roten Bereich geöffnet ist. Dies ist die Lücke geteilt durch die Tickgröße mal den Tickwert. Wenn wir „m_percent“, die prozentuale Zuteilung der Marge, die normalerweise einer neuen Position zugewiesen wird, als den maximal zulässigen prozentualen Drawdown für die zu eröffnende Position ansehen, dann sind unsere Lots dieser Prozentsatz geteilt durch 100, multipliziert mit unserer freien Marge und geteilt durch den Verlust per Lot. Mit anderen Worten: Wie viele Einzelverluste können wir mit unserem maximalen Drawdown-Betrag verkraften?

Monoide Operationen für die Positionsberechnung

Die Codierung für die Entscheidungsfindung jedes Monoids, wie in den vorangegangenen Artikeln beschrieben, wurde also von einer Funktion, der Funktion „Operate“, übernommen, die je nach der Operationsmethode für das Eingabemonoid eine Auswahl aus den Werten der Monoidmenge traf. Die in unserem Fall verwendeten Operationsmethoden waren sehr rudimentär. Wir haben 6 Operationen aufgelistet, von denen wir nur 4 verwendet haben, da Addition und Multiplikation voraussetzten, dass Null und Eins immer in den monoiden Mengen vorhanden sind, was in unserem Fall nicht möglich war. Unser Code, der diese Enumeration und die Funktion hervorhebt, lautet wie folgt:

//+------------------------------------------------------------------+
//| Enumeration for Monoid Operations                                |
//+------------------------------------------------------------------+
enum EOperations
  {
      OP_FURTHEST=5,
      OP_CLOSEST=4,
      OP_MOST=3,
      OP_LEAST=2,
      OP_MULTIPLY=1,
      OP_ADD=0
  };

//+------------------------------------------------------------------+
//|   Operate function for executing monoid binary operations        |
//+------------------------------------------------------------------+
void CMoneyCT::Operate(CMonoid<double> &M,EOperations &O,int IdenityIndex,int &OutputIndex)
   {
      OutputIndex=-1;
      //
      double _values[];
      ArrayResize(_values,M.Cardinality());ArrayInitialize(_values,0.0);
      //
      for(int i=0;i<M.Cardinality();i++)
      {
         m_element.Let();
         if(M.Get(i,m_element))
         {
            if(!m_element.Get(0,_values[i]))
            {
               printf(__FUNCSIG__+" Failed to get double for 1 at: "+IntegerToString(i+1));
            }
         }
         else{ printf(__FUNCSIG__+" Failed to get element for 1 at: "+IntegerToString(i+1)); }
      }
      
      //
      
      if(O==OP_LEAST)
      {
         ...
      }
      else if(O==OP_MOST)
      {
         ...
      }
      else if(O==OP_CLOSEST)
      {
         ...
      }
      else if(O==OP_FURTHEST)
      {
         ...
      }
   }

Da wir nun an der Positionsgröße und nicht an der Volatilität der Markttrendprognose interessiert sind, können das endgültige „Aktions“-Monoid und seine Entscheidung durch einen Funktor ersetzt werden. Die ersten vier Monoide werden also ausgeführt, um die Entscheidung über den Indikatorwert zu erleichtern, der für die Positionsbestimmung maßgeblich ist. Wir bleiben bei den Indikatoren RSI und Bollinger-Bänder, wobei letztere wie zuvor normalisiert werden, um einen Wert ähnlich dem RSI zu erhalten, der zwischen 0 und 100 liegt. Obwohl dieser Indikatorwert das Ergebnis von drei früheren Monoidergebnissen ist, wird er mit diesen gepaart, um eine Gruppe von vier Werten zu bilden, die die Eingaben unseres mehrschichtigen Perzeptrons darstellen. Die Eingaben für den Zeitrahmen und den angewandten Preis müssen daher wie im letzten Artikel in ein numerisches Format umgewandelt werden, das von der MLP verarbeitet werden kann.

Um es noch einmal zu sagen: Ein Monoid, das einfach eine Menge, eine binäre Operation und ein Identitätselement ist, erlaubt einfach die Auswahl eines Elements aus dieser Menge, wie sie durch die binäre Operation definiert ist. Durch die Auswahl eines Zeitrahmens, einer Rückblicksperiode und eines angewandten Preises erhalten wir die Eingaben für unseren Indikator, dessen normalisierter Wert (0-100) als vierte Eingabe im MLP dienen wird.

Die einzelnen Schritte zur Auswahl des Zeitrahmens, der Rückblickperiode, des angewandten Preises und des zu verwendenden Indikators wurden in einem früheren Artikel behandelt; der aktualisierte Code ist beigefügt. Im Folgenden wird jedoch dargestellt, wie die Ausgaben der einzelnen Funktionen zustande kommen:

         ENUM_TIMEFRAMES _timeframe_0=SetTimeframe(m_timeframe,0);
         int _lookback_0=SetLookback(m_lookback,_timeframe_0,0);
         ENUM_APPLIED_PRICE _appliedprice_0=SetAppliedprice(m_appliedprice,_timeframe_0,_lookback_0,0);
         double _indicator_0=SetIndicator(_timeframe_0,_lookback_0,_appliedprice_0,0);

Integration von Funktoren und Monoiden für eine umfassende Positionsbestimmung

Um unsere MLP richtig nutzen zu können, müssen wir sie entsprechend trainieren. Im letzten Artikel wurde das Training bei der Initialisierung durchgeführt und die profitabelsten Gewichte des Netzes, sofern für die gewählte Netzeinstellung verfügbar, wurden geladen und als Ausgangspunkt des Trainingsprozesses für die Anpassung der Gewichte verwendet. Für diesen Artikel wird kein Pre-Training vor oder bei der Initialisierung durchgeführt. Stattdessen wird das Netz mit jedem neuen Balken trainiert. Ein Balken nach dem anderen. Damit soll nicht gesagt werden, dass dies der richtige Ansatz ist, sondern es handelt sich lediglich um eine Form für die vielen Möglichkeiten, die man hat, wenn es um das Training eines MLP oder eines Netzwerks in diesem Sinne geht. Da die anfänglichen Gewichte immer zufällig sind, bedeutet dies, dass dieselben Experteneinstellungen bei verschiedenen Testläufen zwangsläufig zu sehr unterschiedlichen Ergebnissen führen. Um dies zu umgehen, werden die Gewichte eines profitablen Testlaufs in eine Datei geschrieben und beim Start des nächsten Laufs mit ähnlichen Netzwerkeinstellungen (Anzahl der Elemente in der versteckten Schicht) werden diese Gewichte geladen und dienen als Anfangsgewichte für einen Testlauf. Die Lese und -schreibfunktionen des Netzwers und bleiben proprietär und daher wird hier nur auf ihre Bibliothek verwiesen, da der Leser seine eigene implementieren soll.

Die Synergie von Monoiden und MLP ist also das, was hier wirklich vorgestellt wird, denn es kann argumentiert werden, dass beide allein in der Lage sind, Prognosen für die Haltestellenentfernung zu erstellen. Dies würde idealerweise eine Kontrolle zur Überprüfung erfordern, d. h. wir müssten getrennte Expertenberater haben, die nur Monoide und nur MLPs implementieren, und alle drei Ergebnismengen vergleichen. Dies ist in diesem Artikel leider nicht möglich, aber der Quellcode, der beide Ideen zeigt, ist beigefügt, sodass der Leser eingeladen ist, diese Idee der Synergie zu erforschen und zu verifizieren (oder zu widerlegen?).

Der Code, der die beiden integriert, ist also wie folgt:

      m_open.Refresh(-1);
      m_high.Refresh(-1);
      m_close.Refresh(-1);
      
      CMLPTrain _train;
      
      int _info=0;
      CMLPReport _report;
      CMatrixDouble _xy;_xy.Resize(1,__INPUTS+__OUTPUTS);
      
      _xy[0].Set(0,RegularizeTimeframe(_timeframe_1));
      _xy[0].Set(1,_lookback_1);
      _xy[0].Set(2,RegularizeAppliedprice(_appliedprice_1));
      _xy[0].Set(3,_indicator_1);
      //
      int _x=StartIndex()+1;
      
      double _sl_1=m_high.GetData(_x)-m_low.GetData(_x);
      
      if(m_open.GetData(_x)>m_close.GetData(_x))
      {
         _sl_1=m_high.GetData(_x)-m_open.GetData(_x);
      }
      
      double _stops=(2.0*(m_symbol.Ask()-m_symbol.Bid()))+((m_symbol.StopsLevel()+m_symbol.FreezeLevel())*m_symbol.Point());
      
      _xy[0].Set(__INPUTS,fmax(_stops,_sl_1));
      
      _train.MLPTrainLM(m_mlp,_xy,1,m_decay,m_restarts,_info,_report);

Fallstudie: Praktische Anwendung und Backtesting

Zur Analyse unserer Methode der zusammengesetzten Positionsgrößenbestimmung werden wir Bitcoin (BTCUSD) als Testwert verwenden. Die Optimierungstests werden vom 1. Januar 2020 bis zum1. August 2023 in einem täglichen Zeitrahmen durchgeführt. Neben der Optimierung der idealen Anzahl von Gewichten in der versteckten Schicht, da wir einen MLP mit nur einer versteckten Schicht verwenden, werden wir auch die Feinabstimmung der vier Monoide vornehmen, die wir zur Ermittlung der Positionsgröße verwenden. Das bedeutet, dass wir das ideale Identitätselement und den idealen Operationstyp für jedes der vier Monoide festlegen werden, die wir für die Bestimmung unserer Positionsgröße verwenden. Unsere Analyse konzentriert sich voll und ganz auf die Positionsbestimmung, was bedeutet, dass das verwendete Expertensignal eines der in der MQL5-Bibliothek bereitgestellten sein muss. Hierfür werden wir die Klasse des RSI-Signals verwenden. Es werden keine Trailing-Stops implementiert, und wie bei allen vorherigen Tests werden keine Take-Profit- oder Stop-Loss-Werte verwendet, sodass die Parameter für „Take-Level“ und „Stop-Level“ Null sind. Unser Experte ist jedoch offen für die Möglichkeit, schwebende Aufträge zu verwenden, und so wird auch der Parameter „price level“ wie bisher optimiert werden.

Wir führen Tests mit dem Funktor für Objekte und mit dem Funktor für Morphismen durch. Die Ergebnisse werden im Folgenden dargestellt:

Für beliebige Eingabewerte wie die aus dem obigen Lauf mit Objektmorphismen sind die Ergebnisse nicht unbedingt reproduzierbar, da bei der Initialisierung jedes MLP zufällige Gewichte zugewiesen werden. Es ist zwar hilfreich, dass wir bei der Initialisierung Gewichte aus einem früheren profitablen Durchlauf laden können, um zu vermeiden, dass wir jedes Mal bei Null anfangen, aber selbst dann würden Sie die Gewichte des profitablen MLP anpassen, was bedeutet, dass Sie keine identischen Ergebnisse erhalten würden, da das Training für jeden neuen Balken erfolgt. Der Leser ist daher aufgefordert, eine auf seine Strategie zugeschnittene Methode zu programmieren, die die Gewichte seiner besten Testläufe sorgfältig protokolliert und ausliest.

Wenn wir zur Kontrolle einen Expert Advisor mit demselben RSI-Signal und ohne Trailing-Stop, aber mit einer anderen Methode zur Positionsgrößenbestimmung, nämlich der Verwendung einer festen Margin, ausführen, erhalten wir die folgenden Ergebnisse:

Die Ergebnisse zeigen, dass unsere Systeme auch ohne ausführliche Testläufe tendenziell bessere Ergebnisse liefern. (Optimierungen wurden abgekürzt, da es nur darum ging, das Potenzial aufzuzeigen.) Wie jedoch bereits zu Beginn des Artikels erwähnt, sind es für die meisten Händler die Positionsgrößenaspekte des Systems, an denen man zuletzt bastelt, wenn überhaupt, da sie einen großen Einfluss auf die Ergebnisse des Testlaufs haben und streng genommen nichts bedeuten würden, wenn ein solides Einstiegssignal mit dem System verwendet wird.

Beschränkungen und Überlegungen

Potenzielle Herausforderungen und Einschränkungen unserer funktorbasierten Positionsgrößenbestimmung werden durch ein Kontinuum von Punkten abgedeckt, von denen wir versuchen, einige hervorzuheben. Zunächst müssen wir uns darüber im Klaren sein, dass jeder Händler eine steile Lernkurve durchlaufen muss, um Monoidsets zu erhalten, die mit seiner Strategie funktionieren, und um geeignete MLP-Trainingsmuster zu erstellen. Beides ist für die Umsetzung der hier vorgestellten Strategie von entscheidender Bedeutung und erfordert einen angemessenen Zeitaufwand, bevor man mit den Arbeiten beginnen kann.

Zweitens werden Kurslücken oder Wertpapiere, deren einminütige OHLC-Daten nicht mit den realen Tick-Daten übereinstimmen, keine zuverlässigen monoiden Einstellungen oder MLP-Gewichte ergeben, wenn sie auf einem Live-Konto gehandelt werden (bei einem Forward Walk). Die Gründe dafür liegen auf der Hand, aber dies ist ein wesentlicher Knackpunkt bei der Umsetzung der hier vorgestellten Ideen.

Drittens ist die übermäßige Anpassung und Verallgemeinerung ein weiteres Problem, das speziell MLPs plagt. Ich habe dies bereits angedeutet, indem ich auf die Bedeutung des Datensatzes für die Eingabeschicht hinwies, und meiner Meinung nach kann man dies durch die Verwendung aussagekräftiger, regularisierter Daten umgehen. „Aussagekräftig“ in dem Sinne, dass es glaubwürdige grundlegende Aspekte des Datensatzes der Eingabeschicht gibt, von denen man erwarten würde, dass sie die Vorhersage, an der wir interessiert sind, beeinflussen.

Und dann ist da noch das Problem der Parameterabstimmung, von dem manche sagen, dass es mit dem vorherigen Punkt zusammenhängt, aber ich würde behaupten, dass es darüber hinausgeht, wenn wir die Kosten der beteiligten CPU-Ressourcen und den Zeitaufwand für die Ermittlung unserer Zielparameter berücksichtigen, dann ist es eindeutig ein Problem, das über die Anpassung hinausgeht.

Eine weitere Hürde, der sich die Programmierer bewusst sein müssen, ist die schlechte Interpretierbarkeit und Transparenz von Systemen, die mit MLPs entwickelt wurden. Wenn Sie ein funktionierendes System haben und Investoren anlocken wollen, verlangen diese oft, dass Sie mehr darüber offenlegen, wie Ihr System dank MLP funktioniert. Je nach den Schichten Ihres Netzes und seiner Komplexität könnte dies eine Herausforderung darstellen, wenn es darum geht, Ihre potenziellen Kunden zu überzeugen. Es gibt auch noch andere Aspekte wie die Datenvorverarbeitung, die für MLPs gewissermaßen obligatorisch ist, da sie immer Gewichte laden müssen, Änderungen des Marktregimes, Modellaktualisierung und -pflege usw. All diese Faktoren müssen berücksichtigt werden, und es müssen geeignete Vorkehrungen getroffen werden, um sie zu bewältigen, sobald sie auftreten.

In der Tat könnte man argumentieren, dass die letzten Punkte zum Wandel des Marktverhaltens für traditionelle Handelsansätze wie den manuellen Handel sprechen. Meines Erachtens ist das noch nicht ausgemacht, da heute Systeme entwickelt und anhand umfangreicher historischer Datensätze getestet werden, die ein breites Spektrum von unterschiedlichen Marktverhaltens erfassen.

Schlussfolgerung und künftige Ausrichtung

Um unsere wichtigsten Erkenntnisse aus dieser Studie zusammenzufassen, haben wir gezeigt, wie eine andere Perspektive auf ein Monoid als Kategorie in der Sprache MQL5 implementiert werden kann. Wir sind weiter gegangen, um zu zeigen, dass diese Implementierung nützlich sein kann, um die Positionsgröße eines Handelssystems zu steuern, das sich in unserem Fall auf den RSI-Indikator für Ein- und Ausstiegssignale stützt.

Die Bedeutung von Funktoren und Monoiden als Werkzeuge zur Positionsgrößenbestimmung impliziert, dass dasselbe auch für andere Aspekte eines Handelssystems, wie z. B. Einstiegssignale oder, wie es in diesen Serien oft der Fall war, die Platzierung und Anpassung von Trailing Stops, getan werden kann.

Wie am Ende erwähnt, gibt es noch einige Arbeit und Hürden zu überwinden, bevor Händler die hier vorgestellten Ideen vollständig nutzen können. Die Leser sind daher eingeladen, bei der Entwicklung ihrer Handelssysteme mit funktorbasierten Ansätzen zu experimentieren.

Referenzen

Einschlägige Quellen stammen von Wikipedia, wie die im Artikel angegeben Hyperlinks.

Anhang: MQL5 Code-Schnipsel

Kopieren Sie die Dateien „MoneyCT_17_.mqh“ in den Ordner „MQL5\include\Expert\Money\“ ab, und „ct_9.mqh“ kann in den Include-Ordner.

Sie sollten diesen Leitfaden für die Zusammenstellung eines Expert Advisors mithilfe des Assistenten befolgen, da Sie diese als Teil eines Expert Advisors zusammenstellen müssen. Wie im Artikel erwähnt, habe ich den RSI-Oszillator als Einstiegssignal und keinen Trailing-Stop verwendet. Wie immer ist das Ziel dieses Artikels nicht, Ihnen einen Gral zu präsentieren, sondern vielmehr eine Idee, die Sie an Ihre eigene Strategie anpassen können. Die beigefügten *.mq5-Dateien wurden vom Assistenten zusammengestellt, Sie können sie kompilieren oder Ihre eigenen Dateien zusammenstellen. Die Datei mit dem Unterstrich „control“ wurde mit fester Losgröße zusammengestellt.