Podcasts about nachkommastellen

Exakte Planetenpositionen, Next-Level Features & die Zukunft von Codes of Life®.In dieser Folge sprechen @christianbrakmann & ich über die Technik hinter unserem Chart-Generator – und warum Präzision hier alles ist.Was dich erwartet:✔️ Wie wir mit 14 Nachkommastellen & NASA-Daten exakte Berechnungen erstellen✔️ Warum unser System Returns & Oppositionen mit höchster Genauigkeit abbildet✔️ Welche Upgrades im Tool kommen: Below the Line (bis auf Torebene) & die neue Bibliothek

Die Kreiszahl Pi (π) ist eine mathematische Konstante, die das Verhältnis des Umfangs eines Kreises zu seinem Durchmesser angibt. Diese Zahl zu berechnen ist gar nicht so einfach, insbesondere, wenn man sie genau bestimmen will, sie hat nämlich unendlich viele Nachkommastellen. Schon Archimedes hat sich mit der Berechnung von Pi beschäftigt.Heute ist es ein regelrechter Sport geworden möglichst viele Stellen von Pi in kürzester Zeit von einem Computer berechnen zu lassen oder auch möglichst viele Stellen auswendig aufsagen zu können. Den deutschen Rekord erzielte am 14. März 2024 die Frankfurter Gedächtniskünstlerin Susanne Hippauf mit 18 026 Nachkommastellen. Sie hat drei Stunden und fünf Minuten gebraucht, um sie aufzusagen. Natürlich ist die Zahl Pi auch von naturwissenschaftlicher Bedeutung für die Geometrie, für die Mathematik, aber auch für die Physik.Naturwissenschaftliche Weisheit hilft, Zusammenhänge zu verstehen und Dinge zu berechnen, um damit etwas vorhersagen oder konstruieren zu können. Sie bietet uns aber keinen Zugang zu Informationen über Gott und die nichtsichtbare Wirklichkeit. Mit unserer menschlichen Weisheit können wir Gott nicht erkennen. In der Schöpfung kann man sehr viel Weisheit entdecken und damit zu dem Rückschluss auf einen Schöpfer kommen. Wenn wir aber etwas über Gott wissen wollen, muss er selbst uns das offenbaren. Genau das hat er getan. In höchstem Maße in seinem Sohn Jesus Christus, der auf die Erde kam. Durch ihn ist er für uns erfahrbar geworden, und in seinem Wort, der Bibel, hat er sich uns umfassend mitgeteilt. Hier ist die Quelle des Wissens, das wirklich von Bedeutung ist, denn sie weist uns den Weg hinaus aus unserer Verlorenheit und Vergänglichkeit zu ewigem Leben mit Gott.Bernhard VolkmannDiese und viele weitere Andachten online lesenWeitere Informationen zu »Leben ist mehr« erhalten Sie unter www.lebenistmehr.deAudioaufnahmen: Radio Segenswelle

In diesem Video geht es um das Schließen von allen geöffneten Positionen. Hier ist das beispielsweise passiert. Es handelt sich um einen einfachen Expert Advisor, der immer dann alle Positionen schließt, wenn wir uns hier mit der Equity oberhalb der Balance, also der Bruttobilanz befinden. Das bedeutet, sobald dieser Wert hier über 300016 Euro steigt, werden hier oben die Positionen geschlossen. Wie können wir jetzt einen Expert Advisor in MQL5 erstellen, der in der Lage ist, diese Testpositionen hier alle auf einmal zu schließen? Um das zu tun, klicken Sie bitte im MetaTrader5 hier oben auf diesen kleinen Button oder drücken die F4-Taste. Das ruft dann hier den Meta Editor auf, und hier klicken wir auf Datei, neu, Expert Advisor aus Vorlage, weiter. Ich vergebe hier mal den Namen Simpler Position Close EA, klicke auf weiter, weiter, und fertigstellen. Und jetzt kann alles oberhalb der On-Tick-Funktion hier entfernt werden. Das gilt auch für die zwei Kommentarzeilen. Im ersten Schritt müssen wir die Trading-Bibliothek mit den vereinfachten Funktionen importieren. Das geht mittels Include-Befehl, und wir benötigen die in MQL5 enthaltene Datei Trade.MQH. Sie enthält vereinfachte Handelsfunktionen, und wir erstellen uns jetzt eine Instanz von der Klasse CTrade, die wird den Namen Trade bekommen. In MQL5 geht das so, und in unserer On-Tick-Funktion, die bei jeder Preisänderung aufgerufen wird, holen wir uns zunächst einmal den Ask-Preis. Das geht mit der Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart. Und wir nutzen die Konstante Symbol_Ask, um hier den Ask-Preis zu ermitteln. Und mit NormalizeDouble und _Digits sorgen wir dafür, dass wir je nach Währungspaar entweder drei oder fünf Nachkommastellen berechnen, denn wie Sie sehen, gibt es da durchaus Unterschiede. Im nächsten Schritt ermitteln wir den Bruttokontostand. Der Bruttokontostand ist das, was Sie hier vorne als ersten Wert im Strategietester sehen. Man bezeichnet ihn auch als AccountBalance, und der wird ermittelt über die Funktion AccountInfoDouble in Verbindung mit der Konstante Account_Balance. Neben der Account Balance gibt es auch noch die sogenannte Account Equity. Die Equity ist der Nettokontostand. Die Ermittlung ist ziemlich gleich, aber in diesem Fall nutzen wir die Konstante Account_Equity. Die Equity ist dieser Wert hier, und sie errechnet sich aus dem Bruttoguthaben abzüglich der Kosten für die offenen Positionen. Und damit wir etwas haben, was wir gleichzeitig schließen können, öffnen wir jetzt einige Testpositionen. Immer, wenn die Funktion PositionsTotal einen Rückgabewert kleiner fünf hat, dann nutzen wir die hier oben erstellte Trade-Instanz, um mit Trade.Buy zu kaufen. Ich ändere das hier mal auf zehn Micro Lot, das hier ist die Positionsgröße. Wir kaufen auf dem aktuellen Chart zum Ask-Preis. Wenn Sie einen Doppelklick hier auf ein Währungspaar durchführen, dann sehen Sie, dass der Ask-Preis, diese rote Linie, immer über dem Bid-Preis, der blauen Linie, liegt. Das hier ist das, was wir zahlen, wenn wir etwas kaufen, und das ist das, was wir erhalten, wenn wir etwas verkaufen. Da wir in diesem Fall kaufen, müssen wir zum aktuellen Ask-Preis kaufen. Wir haben hier keinen Stop Loss definiert. Unser Profitziel wird 100 Punkte über dem aktuellen Ask-Preis liegen, und da wir keinen Kommentar verwenden, nutzen wir hier die Konstante null. Und immer, wenn wir im Profit sind, wenn also unser Nettoguthaben das Bruttoguthaben übersteigt, dann möchten wir eine Funktion aufrufen mit dem Namen SchliesseallePositionen. Die gibt es aber noch gar nicht, also schreiben wir die jetzt. Und diese Funktion werden wir jetzt erstellen.

In diesem Video wollen wir uns einmal diesen Oszillator hier anschauen. Das ist der Commodity Channel Index. Der wird normalerweise als Filter genutzt. Wir wollen jetzt aber mal schauen, wie man den in MQL5 als Signal programmieren kann. Um das zu tun, klicken Sie bitte im Metaeditor bitte auf dieses kleine Symbol hier oben oder drücken Sie die F4 Taste. Das ruft dann hier den Metaeditor auf. Und hier klicken wir auf Datei, Neue Datei, Expert Advisor aus Vorlage, Weiter. Ich vergebe hier einmal den Namen SimplerCommodityChannelIndexEA, klicke auf Weiter, Weiter und Fertigstellen. Jetzt kann alles oberhalb der OnTick Funktion hier gelöscht werden. Und wir entfernen auch die zwei Kommentarzeilen. Wie so oft starten wir hier mit einem include Statement für die Datei Trade.mqh. Danach erstellen wir eine Instanz von der Klasse CTrade. Die bekommt den Namen trade. Und wir werden sie verwenden, um Positionen zu eröffnen. In der OnTick Funktion ermitteln wir zunächst den Ask Preise. Das übernimmt die Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart. Mit SYMBOL_ASK, alles in Großbuchstaben bitte, lässt sich hier der Ask Preis ermitteln. Und zusätzlich nutze ich noch NormalizeDouble und _Digits, um die richtige Anzahl von Nachkommastellen zu ermitteln. Das können je nach Währungspaar drei oder fünf Nachkommastellen sein. Das gleiche wiederholen wir jetzt nochmal für den Bid Preis. Hier unterscheidet der Name der Variable und der Parameter hier heißt SIMBOL_BID. Ansonsten sind diese beiden Zeilen nahezu identisch. Mit MqlRates erstellen wir uns ein Array für die Preisinformationen. Das wird im Anschluss mit ArraySetAsSeries von der aktuellen Kerze an abwärts sortiert. Und mit CopyRates füllen wir unser Preis Array mit Preisdaten für drei Kerzen. Dieser Ausdruck für das aktuelle Währungspaar kann auch so geschrieben werden. Seit einiger Zeit wurde die Sprache entsprechend angepasst. Wenn man das hier mal markiert und die F1 Taste drückt, dann wird das in der Hilfe hier auch so beschrieben. Im nächsten Schritt erstellen wir uns eine leere Variable mit dem Namen signal. Die ist vom Typ string, hat hier aber noch keinen Wert. Um den zu ermitteln erstellen wir uns ein weiteres Array für den Expert Advisor. Und mit der eingebauten MQL5 Funktion iCCI können wir jetzt für das aktuelle Währungspaar und die auf dem Chart ausgewählte Zeiteinheit den Commodity Channel Index für 14 Kerzen aufgrund der Schlusskurse berechnen. Die 14 taucht auch hier in Klammern auf. Und wenn man einmal mit der rechten Maustaste auf den Oszillator klickt und Eigenschaften auswählt, dann sieht man, dass das hier die Standardwerte sind. Auch dieses Array sortieren wir von der aktuellen Kerze an abwärts. Und im Anschluss nutzen wie CopyBuffer, um anhand der Definition, die wir hier oben getroffen haben, für Buffer null, das ist diese Linie hier, von der aktuellen Kerze null an für drei Kerzen unser Array mit Daten zu füllen. Und das ermöglicht es uns, den aktuellen Wert für den Commodity Channel Index zu berechnen, indem wir auf Kerze null in unserem Array zugreifen. Wenn sich der Wert oberhalb der Einhunderter-Linie befindet, das wäre hier die obere gestrichelte Linie, dann möchten wir gerne verkaufen. Darum weisen wir den Wert Verkaufen unsere signal Variable hier zu. Im umgekehrten Fall, wenn der Wert kleiner ist und sich unter der unteren gestrichelten Linie befindet, das wäre hier diese minus einhundert Linie, dann möchten wir gerne kaufen und weisen diesen Wert der signal Variable zu. Und wenn unser signal auf Verkaufen steht und die Funktion PositionsTo...

Mon, 08 Jul 2024 08:17:00 +0000 https://boersenradio-marktbericht.podigee.io/1387-borsenradio-live-blick-mo-8-7-24-dax-etwas-fester-in-die-kw28-dt-telekom-mit-high-lust-und-was-christian-drastil-nicht-wusste a9ab89878206bdaa86d7dc4b1aeaa711 Christian Drastil mit dem Live-Blick aus dem Studio des Börsenradio-Partners audio-cd.at in Wien wieder intraday mit Kurslisten, Statistiken und News aus Frankfurt und Wien. Es ist der Podcast, der das Gefühl für den DAX bringt, es ist Montag, der 8. Juli 2024 und so sieht es im Frühgeschäft aus. - DAX im Frühgeschäft etwas fester - Porsche im Frühgeschäft gesucht - Deutsche Bank im Frühgeschäft schwächer - Serien : Deutsche Post (+), Fresenius (+), Airbus (+) - Deutsche Telekom mit All-time-High Serie - News-Roundup der Baader Bank: Airbus - ATX etwas leichter - Pierer Mobility, AT&S stark - bzgl. Nachkommastellen werde ich mich bemühen, in Wien sagt man das anders - 1 kg Gold kostet 70.630 Euro, mitgeteilt von Gold &Co: goldundco.at - All-time-High-Jingle: https://audio-cd.at/page/playlist/5438  - Wiener Börse Party: https://www.audio-cd.at/wienerboerseplausch Bleiben Sie informiert und hören Sie jetzt rein für tiefere Einblicke und Analysen unter: www.boersenradio.de . Mehr Österreich-Content von Christian unter www.audio-cd.at/wienerboerseplausch bzw. www.audio-cd.at/spotify . Feedback? christian.drastil@boerse-social.com Du möchtest deine Werbung in diesem und vielen anderen Podcasts schalten? Kein Problem!Für deinen Zugang zu zielgerichteter Podcast-Werbung, klicke hier.Audiomarktplatz.de - Geschichten, die bleiben - überall und jederzeit! 1387 full no

Jeder Schritt zählt!

Wieso können sich manche Leute 18.026 Nachkommastellen merken und wir verlieren täglich unsere Schlüssel? Was macht man mit 10 Gramm Ketamin? Bringt das neue EM Trikot das Alman-Fass endgültig zum Überlaufen und wie gehts eigentlich unserem Charlie? Das alles und noch mehr in Folge 189.

Das hier ist der sogenannte Bulls Power Indikator. Es handelt sich hierbei einen Oszillator, der anzeigen soll, wie stark die Bullen sind. Man sagt ja, dass im Trading jeden Tag die Bullen gegen die Bären kämpfen und bei maximalen Ausschlägen kann man davon ausgehen, dass hier nach den höchsten Werten der Preis erst mal in den Keller geht. Im Umkehrschluss, wenn diese Linie hier überschritten wird, dann geht es in der Regel erst mal aufwärts. Dieser Oszillator hier wurde erstellt von einem professionellen Trader mit dem Namen Alexander Elder. Er sagt hier, dass ein fallender Wert über null ein Signal zum Verkauf ist. Der Oszillator wird auf 13 Kerzen berechnet. Man nutzt einen exponentiellen Moving Average und es wird empfohlen, den Bulls Power Indikator zusammen mit einem anderen Trend Indikator, wie zum Beispiel den Moving Average, zu nutzen. Wie also können wir jetzt für diesen diesen Bulls Power Indikator einen ExpertAdvisor in MQL5 erstellen? Um das zu tun, klicken wir hier im MetaTrader zunächst auf diesen kleinen Knopf hier oben oder drücken die F4-Taste. Das ruft hier den Metaeditor auf und hier klicken wir auf „Datei neu, „ExpertAdvisor von Vorlage, „Weiter, vergeben hier den Namen „Simple Bulls Power EA, klicken auf „Weiter, „Weiter, „Fertigstellen und löschen alles oberhalb dieser OnTick-Funktion und die beiden Kommentarzeilen. Und im ersten Schritt erstellen wir, wie so oft, ein Array für unsere Preisdaten vom Typ „Double und vergeben den Namen „My Price Array. Danach definieren wir die Eigenschaften für den Bulls Power EA, indem wir die in MQL5 eingebaute Funktion „i Bulls Power nutzen, und zwar für das aktuelle Währungspaar auf dem Chart und die dort eingestellte Zeiteinheit, zum Beispiel das Minuten-Chart oder das 60-Minuten-Chart. Und die Berechnung wird auf die letzten 13 Kerzen erfolgen, denn das ist der Zeitraum, der von Herrn Elder definiert wurde. Und im nächsten Schritt sortieren wir die Preise wieder abwärts von der aktuellen Kerze an, indem wir die Funktion „Array Set as Series nutzen. Das Ganze machen wir mit unserem Price-Array, das wir hier oben definiert haben. So, jetzt füllen wir Wir haben hier unseren Expert-Advisor noch mit Daten. Dazu nutzen wir hier die Definition aus dieser Zeile, die Funktion „Copy Buffer. Diese Null hier steht für den Indikator. Diese Null hier beschreibt die aktuelle Kerze und die drei bedeutet, dass wir die Preise von der aktuellen Kerze für drei Kerzen kopieren möchten und danach speichern wir das Resultat in unserem Price Array. Und aus diesem Price-Array hier holen wir uns jetzt aus der Kerze 0 den aktuellen Bulls Power-Wert und wir machen das mit einer Float-Variable. Normalerweise würde das hier eine Double-Variable sein. Das sind mir aber zu viele Nachkommastellen und außerdem braucht die Float-Variable gegenüber der Double-Variable nur 4 Byte statt 8 Byte im Speicher. In einem letzten Schritt lassen wir uns jetzt auf dem Chart noch unseren Wert und den Text Bulls Power-Wert ausgeben. Das machen wir mit der Comment-Funktion und nach diesem Text wird der Wert ausgegeben, den wir in der Zeile hier ermittelt haben. Kompilieren wir das Ganze, dann bekommen wir hier unten die Warnung, es gibt einen möglichen Datenverlust, weil wir hier einen Float statt einen Double-Wert berechnen. Trotzdem war der Compiler-Vorgang mit null Fehlern erfolgreich. Also klicken wir hier oben auf diesen kleinen Knopf oder drücken die F4-Taste, zurückzuwechseln in den MetaTrader. Im MetaTrader selbst klicken wir auf „Ansicht, „Strategietester oder drücken die Steuerung und die R-Taste. Das ruft dann hier unten den „Strategietester auf und hier wählen wir d...

Dieses farbenfrohe Lichterspiel hier im Hintergrund ist der Market Facilitation Index. Auch der ist im MetaTrader 5 enthalten, und in diesem Video möchten wir uns einmal anschauen, wie man den BWMFI-Wert hier auf dem Chart ausgeben kann. Falls Sie sich fragen, was diese unterschiedlich gefärbten Balken hier bedeuten: Wikipedia bietet hier in englischer Sprache für den Market Facilitation Index die Erklärungen für die vier unterschiedlichen Darstellungen, die es gibt. Grundsätzlich geht es darum, eine Verbindung zwischen dem Indikator und dem Marktvolumen herzustellen. Ich selbst bin bei der Signalwirkung von diesem Indikator eher skeptisch, aber wir wollen uns jetzt einmal anschauen, wie man den BWMFI-Wert von Bill Williams in MQL5 programmieren kann. Um das zu tun, klicken Sie bitte hier oben auf diesen kleinen Button im MetaTrader, und jetzt sollten Sie den Meta-Editor sehen. Und hier wählen wir „Datei/ Neu/ Expert Advisor (Vorlage)/ Weiter“. Ich vergebe hier einmal den Namen „SimplerBWMFI“, klicke auf „Weiter/ Weiter/ Fertigstellen“. Und jetzt können Sie alles oberhalb der „onTick“-Funktion entfernen und auch diese beiden Kommentarzeilen löschen. Innerhalb der „onTick“-Funktion erstellen wir uns zunächst einmal ein Array für den Expert Advisor. Das ist vom Typ „Double“ und bekommt den Namen „BWMFIArray“, das steht für „Bill Williams Market Facilitation Index“. Danach definieren wir den Expert Advisor, indem wir die eingebaute MQL5-Funktion iBWMFI nutzen. Die benötigt als Parameter das aktuell auf dem Chart ausgewählte Währungspaar, die auf dem Chart eingestellte Zeiteinheit, und als 3. Parameter wird das Tick-Volumen übergeben. Denn wenn man sich hier einmal die Eigenschaften mit der rechten Maustaste anzeigen lässt, dann sieht man hier unten, dass als Standardwert-Volumen „Tick“ eingestellt ist. Im Anschluss sortieren wir unser Array von der aktuellen Kerze abwärts. Das kann die Funktion „ArraySetAsSeries“ übernehmen, die ebenfalls in MQL5 eingebaut ist. Die sortiert unser Array, welches wir hier oben erstellt haben, von der aktuellen Kerze 0 –das ist diese Kerze- abwärts für 3 Kerzen. Und danach können wir mit „CopyBuffer“ unser Array hier mit Daten füllen. Wir möchten das gerne anhand der von uns getroffenen Definition aus dieser Zeile hier machen, für jeweils einen Buffer oder eine Linie, darum nutzen wir hier den Wert 0. Wir brauchen von der aktuellen Kerze für 3 Kerzen die Daten. Da die aktuelle Kerze den Index 0 hat, nutzen wir hier die 0, und diese 3 sorgt dafür, dass wir auch für die nächsten 2 Kerzen Daten erhalten. Und alle diese Daten möchten wir im Array speichern, darum geben wir als letzten Parameter hier unser BWMFIArray an. Um den aktuellen Wert berechnen zu können, greifen wir auf die Kerze 0, also auf die aktuelle Kerze in unserem BWMFIArray, zu und weisen das Ergebnis der Variable „BWMFIWert“ zu. Die ist vom Typ „Double“, kann also Dezimalzahlen mit Nachkommastellen verarbeiten. Fehlt noch die Ausgabe auf dem Chart, und das übernimmt für uns die MQL5-Funktion „Comment“. Die wird uns den Text „BWMFIWert“, gefolgt von dem hier berechneten Wert ausgeben. Das war's auch schon. Sie können jetzt hier oben auf „Kompilieren“ klicken, oder F7 auf Ihrer Tastatur drücken; dann sollten Sie hier unten keine Fehler oder Warnungen erhalten. Und wenn das bei Ihnen auch so ist, dann klicken Sie bitte hier oben auf diesen kleinen Button, oder drücken die F4-Taste auf Ihrer Tastatur, um in den MetaTrader zurückzukehren. Und im MetaTrader klicken wir auf „Ansicht/ Strategietester“, oder drücken die Tastenkombination Stgr+R. Das ruft dann hier dieses StrategietesterPanel auf,

  Analyse des Williams Prozent Range Indikators (00:17 – 01:04) Analyse des Indikators anhand von Chartbeispielen, die zeigen, wie Spitzen im Indikator vor Kursänderungen auftreten und wie diese Spitzen auf bevorstehende Richtungswechsel hinweisen. Erstellung eines Expert Advisors für den Williams Prozent Range Indikator (01:04 – 03:06) Anleitung zur Erstellung eines Expert Advisors im MetaEditor, der den Williams Prozent Range Indikator berechnet, inklusive der Einrichtung des MetaEditors und der Definition des Arrays und der Indikator-Eigenschaften. Berechnung und Ausgabe des Williams Prozent Range Werts (03:06 – 03:46) Schritt-für-Schritt-Anleitung zur Berechnung des Williams Prozent Range Werts und zur Ausgabe dieses Werts auf dem Chart. Kompilieren und Testen des Expert Advisors im MetaTrader (03:46 – 04:23) Anleitung zum Kompilieren des Expert Advisors und zum Testen im MetaTrader mit dem Strategie-Tester. Demonstration des Expert Advisors im MetaTrader (04:23 – 05:38) Demonstration des Expert Advisors im MetaTrader, Anzeige des Williams Prozent Range Werts und Interpretation der Signale, inklusive der Verbesserung des Indikators durch Anpassung der Kerzenanzahl. Zusammenfassung und Anwendungsmöglichkeiten (05:38 – 05:49) Zusammenfassung des Gelernten über den Williams Prozent Range Indikator und Anleitung zur Programmierung des Indikators in einem Expert Advisor in MQL5.   Heute möchten wir uns einmal den Williams PerCent Range Indikator ansehen. Dabei handelt es sich um ein Hilfsmittel, um festzustellen, ob ein Markt über- oder unterverkauft ist. Dieser Indikator besteht aus einer Linie. Und wenn diese Linie eine dieser beiden gestrichelten Werte überschreitet, dann wird es interessant. Der Williams ProzentRange Indikator oder auch Prozentr Indikator wurde 1966 von Larry Williams entwickelt, um überkaufte oder überverkaufte Situationen anzuzeigen. Wenn man sich unsere Situation hier anschaut, dann sieht man, dass die höchsten Spitzen hier immer auftreten, bevor der Kurs in den Keller geht und andersherum. Diese Spitzen hier unten deuten darauf hin, dass es wieder in die andere Richtung gehen wird. Hier kann man ganz gut erkennen, dass das etwas vor dem eigentlichen Kursabfall angezeigt wird. Und auch diese Spitze ist ein wenig vor dieser Kerze hier entstanden. Derzeit arbeiten wir hier mit 14 Kerzen. Wir werden das aber gleich im Verlauf dieses Videos noch auf 100 Kerzen verändern. Wie erstellt man also jetzt einen Expert Advisor, der den Wert für diesen Indikator messen kann? Dazu klicken wir im Metatrader zunächst hier oben auf dieses kleine Icon oder drücken die F4 Taste. Das ruft den Metaeditor auf und hier klicken wir auf Datei neu Expert Advisor von Vorlage erstellen. Weiter. Wir vergeben hier den Namen Simple Williams Prozentrange und klicken auf weiter. Weiter fertigstellen. Und jetzt löschen wir alles oberhalb dieser Ontick Funktion und entfernen diese beiden Kommentarzeilen. Im ersten Schritt benötigen wir ein Array. Es ist vom Typ Double, da es NachKommastellen für unsere Preisdaten aufnehmen soll und trägt den Namen WPR Array. Jetzt definieren wir noch die Einstellungen für den Williams ProzentRange Indikator. Laut unserer Definition möchten wir die Funktion iWPR nutzen, die in MQL5 eingebaut ist. Und wir möchten den Indikator gerne für das aktuelle Währungspaar auf dem Chart berechnen, und zwar für die auf dem Chart ausgewählte Zeiteinheit, wie beispielsweise das Minuten Chart. Und als Berechnungsgrundlage nutzen wir die letzten 14 Kerzen. Danach nutzen wir die Funktion ArraySetAsSeries für unser Array, um die Preisdaten abwärts von der aktuellen Kerze auszusor...

Eine Zahl mit ein paar Nachkommastellen hat unzählige Träume auf dem Gewissen. Die Zinsen für Immobilienkredite sind seit Anfang vergangenen Jahres rapide gestiegen, von einem auf nun über vier Prozent. Eine wahre Kostenexplosion: Wer heute ein Haus finanzieren will, muss schnell eine doppelt so hohe Rate stemmen wie noch vor kurzer Zeit. Die gesunkenen Immobilienpreise kompensieren die Zinsexplosion kaum. Ist der Traum vom eigenen Haus nun endgültig ausgeträumt? Darum ging es in einem BörsenWoche-Livestream bei LinkedIn, den ihr nun als Sonderfolge hören könnt. Dort sprechen Philipp und Mirjam Mohr, Vorständin für das Privatkundengeschäft beim Kreditvermittler Interhyp darüber, wie teuer der Hauskauf jetzt ist, an welchen Stellschrauben Verbraucher drehen können, um die Kosten zu reduzieren – und ob sich die Lage am Häusermarkt bald beruhigen dürfte. Lesen Sie hier mehr darüber, wie der Hauskauf jetzt noch gelingt: www.wiwo.de/29505326.html Disclaimer: Dieser Podcast ist keine Anlageberatung, sondern dient lediglich der Information und Unterhaltung. Die Hosts oder der Verlag übernehmen keine Haftung für Anlageentscheidungen, die ihr aufgrund der im Podcast gehörten Informationen trefft. Mitarbeit: Alexander Voß *** Exklusiv für WirtschaftsWoche BörsenWoche-Hörerinnen und -Hörer gibt es außerdem hier ein besonderes Abo-Angebot: www.wiwo.de/neu Helft uns, unsere Podcasts weiter zu verbessern. Eure Meinung ist uns wichtig: www.wiwo.de/zufriedenheit In der WiWo BörsenWoche bekommt ihr jeden Montag konkrete Anlagetipps, profunde Analysen und Einschätzungen von Trends. Herzstück der BörsenWoche sind zwei Musterdepots, bei denen die Geldanlage auf eigene Faust im Vordergrund steht: https://www.wiwo.de/boersenwoche/ [Mehr über die Angebote unserer Werbepartnerinnen und -partner findest du HIER](https://cmk.wiwo.de/cms/articles/15602/anzeige/podcast-werbepartnerinnen/hier-gibt-s-weitere-infos-zu-den-angeboten-unserer-werbepartner-innen)

Mit MQL5 und Metatrader 5 wird der Standard Deviation Indikator geliefert, der dazu genutzt werden kann, mögliche Kursänderungen im Forex Trading auf dem Chart vorauszusagen, denn er berechnet die durchschnittliche Kursbewegung der letzten X Kerzen und schlägt aus, sobald sich der Kurs überdurchschnittlich stark bewegt… Das was hier im Hintergrund läuft, ist der so genannte Standard Deviation Indikator. Der vergleicht aktuelle mit historischen Kursbewegungen und soll helfen, eine Wahrscheinlichkeit zu berechnen, die Auskunft darüber gibt, ob der Kurs jetzt steigen oder fallen wird. Die grundsätzliche Idee dabei ist, über einen Zeitraum in diesem Fall von 20 Kerzen zu messen wie stark sich der Kurs entwickelt und je höher der Indikatorwert ist, desto höher ist die Wahrscheinlichkeit einer Kursumkehr. In diesem Fall hat das gepasst. Wie können wir jetzt einen solchen Indikator als Expert Advisor in MQL programmieren? Dazu klicken wir zunächst hier oben auf diesen Button oder drücken die F4-Taste. Das ruft den Metaeditor auf und hier klicken wir auf Datei, Neu, Expert Advisor von Vorlage, Weiter und vergeben hier den Namen SimplerStandardDeviationEA, klicken auf Weiter, Weiter, Fertigstellen und löschen jetzt alles oberhalb der Ontick-Funktion und diese beiden Kommentarzeilen hier. Gut, das erste was wir jetzt benötigen ist ein Array f+r unsere Preisdaten. Das ist vom Wert double, damit es Nachkommastellen verarbeiten kann und trägt den Namen STDDEVArray. Im nächsten Schritt definieren wir jetzt die Eigenschaften für unseren Indikator. Die wird uns für das aktuelle Währungspaar auf dem Chart und die aktuell eingestellte Zeitperiode also beispielsweise für das Minutenchart, auf einer Basis von 20 Kerzen ohne eine Verschiebung nach rechts oder links zu benutzen für den SMA die Werte für die Schlusskurse berechnen. Danach benutzen wir die Funktion ArraySetAsSeries um unser STDDEV-Array abwärts von der aktuellen Kerze zu sortieren. Und dann füllen wir mit CopyBuffer, laut unserer Definition die wir hier oben getroffen haben, unser Array für die einzige benötigte Linie die wir brauchen von der aktuellen Kerze abwärts für drei Kerzen. Und nachdem wir die Preisdaten mit CopyBuffer in unser Array kopiert haben, berechnen wir für die aktuelle Kerze, das ist hier diese Kerze 0, aus unserem Array den entsprechenden Wert. Und im letzten Schritt fehlt natürlich noch die Chartausgabe, die wird den Text STDDEVWert und den von uns berechneten Wert direkt links oben auf dem Chart ausgeben. Okay, kompilieren wir unseren Expert Advisor. Das hat ohne Fehler und Warnungen funktioniert, also können wir mit diesem kleinen Button hier oben oder mit der F4 Taste in den Metatrader wechseln. Im Metatrader selbst klicken wir auf Ansicht, Strategietester oder drücken die STRG und die R-Taste. Danach wächlen wir hier die Datei SimplerStandardDeviationEA.ex5 aus und starten unseren Test. Und so sieht das ganze aus. Wie man sieht stimmt der Wert hier unten mit dem von uns berechneten Wert hier oben überein. Okay, Sie haben gelernt, wie man in weniger als 5 Minuten einen Expert Advisor für die Standard Deviation berechnet, den man mit anderen Indikatoren für die Ermittlung eines Einstiegssignals nutzen kann. Und Sie haben das mit wenigen Programmzeilen in MQL5 selber programmiert! Nicht sicher was Sie tun sollen? Klicken Sie auf den automatischen Trading Assistenten unten

Diesmal widmen wir uns dem Money Flow Index. Diese blaue Linie hier, dieser Indikator hier, kann uns sagen, ob ein Wert überverkauft oder überkauft ist. Wikipedia sagt, dass der Money Flow Index bei einem Wert von 80 oder mehr zeigt, dass der Markt überkauft ist, wohingegen ein Wert von 20 oder weniger bedeutet, dass der Markt überverkauft ist. Im Klartext bedeutet das, wenn hier ein Wert von 83,12% steht, dann würden wir hier einen Sell Trade eröffnen, weil wir erwarten, dass der Preis wieder runtergeht. Und wenn diese blaue Linie sich unterhalb der unteren gestrichelten Linie, die hier bei 20% liegt, befindet, dann würden wir davon ausgehen, dass der Markt überverkauft ist, und würden einen Long Trade in die andere Richtung aufmachen. Gut, wie erstellen wir uns jetzt einen Expert Advisor, der den Money Flow Index Indikator in MQL5 nutzen kann? Um das zu tun, klicken wir im Metatrader hier oben auf den kleinen Knopf oder drücken die F4-Taste, das startet den sogenannten Meta-Editor. Und hier wählen wir Datei, Neu, Expert Advisor aus Vorlage, Weiter. Ich nenne das Programm an der Stelle „Simpler Money Flow Index“, wir klicken auf Weiter, Weiter, Fertigstellen. Und jetzt kann alles oberhalb dieser OnTick-Funktion hier gelöscht werden, und auch die Kommentarzeilen entfernen wir. Als erstes brauchen wir ein Array für unsere Preisdaten, das bekommt den Namen „PreisArray“ und ist vom Typ Double, damit es auch Nachkommastellen verarbeiten kann. Und danach erstellen wir eine MFIDefinition für unseren Money Flow Index, indem wir die in MQL5 integrierte Funktion IMFI nutzen, um für das aktuelle Chart und die auf diesem Chart aktuell eingestellte Zeiteinheit, den MFI Wert basierend auf 14 Kerzen aufgrund des Tick-Volumens zu berechnen. Denn wenn Sie im Metatrader auf Einfügen, Indikatoren, Volumen, Money Flow Index klicken, dann sehen Sie die 14 Kerzen und das Tick-Volumen auch in den Standardeinstellungen. Nach der Definition sortieren wir die Preise abwärts von der aktuellen Kerze, indem wir die MQL5-Funktion ArraySetAsSeries benutzen und auf unser PreisArray anwenden. Und mit CopyBuffer füllen wir unser PreisArray hier mit Daten, die laut der MFIDefinition, die wir hier oben getroffen haben, für die erste Linie unseres Indikators, das ist diese Linie Null, von der aktuellen Kerze, das ist Kerze Null, für drei Kerzen, das ist diese 3. Und das Resultat speichern wir in unserem PreisArray. Jetzt berechnen wir den Wert für unseren MFI Expert Advisor für die aktuelle Kerze, das ist Kerze Null in diesem PreisArray, wir nutzen NormalizeDouble und diese 2, da uns hier oben zwei Nachkommastellen reichen. Denn wenn wir prüfen, ob wir oberhalb von 80 oder unterhalb von 20 sind, dann brauchen wir nicht die fünf Nachkommastellen zu berechnen, die der MFI-Indikator in der Ursprungsversion anzeigt. Und das Ergebnis speichern wir in einer Variable mit dem Namen MFIWert. Jetzt fehlt uns natürlich noch je nach Wert die passende Ausgabe auf unserem Chart, denn wenn unser berechneter MFIWert größer ist als 80, dann möchten wir mit der MQL5-Funktion Comment den Text „ÜBERKAUFT“ und den berechneten MFI-Wert aus dieser Zeile ausgeben. Im andern Fall, wenn der MFI-Wert kleiner ist als 20, nutzen wir Comment, um den Text auszugeben „ÜBERVERKAUFT“, natürlich auch gefolgt von dem berechneten Wert. Und sollte unser MFI-Wert größer sein als 20 und kleiner als 80, das bedeutet, die blaue Linie befindet sich zwischen diesen beiden gestrichelten Linien hier, dann geben wir gar keinen Text aus. Denn wir haben kein Signal, und in dem Fall reicht uns zur Überprüfung der berechnete MFIWert. So, das war's auch schon, wir klicken auf Kompilieren,

Das hier ist der RVI Indikator, der ist im Metatrader enthalten, wir haben hier einen kleinen Aufwärtstrend und das zeigt uns unser Indikator hier auch an. Und in dem Moment wo sich hier oben eine Korrektur im Aufwärtstrend entwickelt, wird das hier ebenfalls angezeigt. Liegen beide Linien unterhalb dieser gestrichelte Linie hier, dann befinden wir uns in einem Abwärtstrend und sobald hier eine Überkreuzung stattfindet, deutet das auf eine Korrektur im Abwärtstrend hin. Dieser RVI Indikator lässt es also zu, dass man immer ziemlich genau erkennen kann, in was für einer aktuellen Trendphase man sich befindet. Wie können wir jetzt mit MQL5 einen Expert Advisor erstellen der den RVI Indikator nutzt? Dazu klicken wir Metatrader hier oben auf diesen kleinen Knopf oder drücken die F4 Taste, das ruft dann hier den Meta Editor auf und dort klicken wir auf Datei – Neu – Expert Advisor aus Vorlage – Weiter. Ich vergebe hier mal den Namen simpler RVI, klicke auf Weiter – Weiter – Fertigstellen und jetzt kann alles oberhalb dieser OnTick Funktion gelöscht werden, genau wie die beiden Kommentarzeilen. Im ersten Schritt beginnen wir mit einer leeren Ausgabe auf unserem Chart und da unser Indikator in diesem Fall mit zwei Linien arbeitet die einen unterschiedlichen Wert haben, benötigen wir auch für dieses Beispiel zwei unterschiedliche PreiseArrays. Die erhalten den Namen Preisarray 0 und Preisarray 1 und jetzt definieren wir die Eigenschaften für den RVI Expert Advisor, indem wir die MQL5 Funktion iRVI aufrufen, und zwar für das aktuelle Chart und die auf dem Chart aktuell dargestellte Zeiteinheit. Unsere Berechnung soll aufgrund der letzten 10 Kerzen erfolgen, denn das ist doch das, was man bekommt, wenn man auf einfügen – Indikatoren – Oszillatoren – Relative Vigor Index klickt, dann sehen wir hier unsere 10 Kerzen für den RVI. Im nächsten Schritt sortieren wir die Preise abwärts von der aktuellen Kerze, das machen wir sowohl für unser PreisArray 0, als auch für unser PreisArray 1. Jetzt nutzen wir copy Buffer für unsere erste und für unsere zweite Indikator Linie, um aufgrund unserer iRVI Definition die wir hier oben getroffen haben, von der aktuellen Kerze für 3 Kerzen die Preis Daten in unserem PreisArray 0 bzw. für die andere Indikatorlinie unserem PreisArray 1 abzuspeichern. Und jetzt berechnen wir uns den Expert Advisor für die aktuelle Kerze aus dem Preisarray 0, holen wir von der aktuellen Kerze 0 den RVI Wert 0 mit drei Nachkommastellen und aus dem PreisArray 1 machen wir das gleiche, aber diesmal holen wir uns den RVI Wert 1 für unsere zweite Indikator Linie hier. Gut, kommen wir zur Chart Ausgabe. Zunächst berechnen wir hier die Werte für unseren Trend und wenn unser RVI Wert 0 kleiner ist als der RVI Wert 1 und der RVI Wert 1 unterhalb unserer gestrichelte 0 Linie liegt, also wir uns hier in diesem unteren Bereich befinden, dann haben wir einen Abwärtstrend. Im anderen Fall, wenn der RVI Wert 0 größer ist als der Wert 1 und sich der RVI Wert 0 oberhalb von unserer Nulllinie befindet, dann haben wir einen Aufwärtstrend und geben das mit Comment auf unserem Chart aus. Für die Korrekturen gilt in etwa die gleiche Formel, allerdings sind hier die Größer und Kleiner Zeichen umgekehrt, denn was oberhalb der gestrichelten Linie als Aufwärtstrend erkannt wird, wäre unterhalb der gestrichelten Linie hier eine Korrektur. Gut, das war es mit unserem Expert Advisor, wir klicken also jetzt hier auf kompilieren oder drücken die F7 Taste und dann sollte der Compiler keine Fehler und keine Warnungen auswerfen. Wenn das alles geklappt hat, klicken wir hier oben auf den kleinen Button oder drücken die F4 Taste um zurückzuk...

Mql5 ist ja eine objektorientierte Sprache und in diesem Beispiel möchten wir einmal ein solches Objekt erstellen. Das hier oben ist ein Label oder in unserem Fall haben wir es Textobjekt genannt und es zeigt uns in einer bestimmten Schriftgröße und einer bestimmten Schriftart den aktuellen Ask Preis an. Solche Objekte zu erstellen ist gar nicht schwer. Neben den Textobjekten gibt es auch Linien, Pfeile oder sonstige Dinge, die man direkt auf dem Chart ausgeben kann. Wie aber lässt sich ein solches Objekt erstellen damit wir es in unseren Expert Advisor einsetzen können? Dazu klicken wir hier oben auf diesem kleinen Button oder drücken die F4 Taste. Das ruft dann hier den MetaEditor auf und im MetaEditor klicken wir auf Datei –Neu – Expert Advisor aus Vorlage – weiter. Hier vergeben wir den Namen SimplesObjektLabel, klicken auf weiter – weiter – fertig stellen und jetzt kann alles oberhalb der Ontick Funktion hier gelöscht werden. Auch die Kommentarzeilen werden entfernt und da wir ja etwas brauchen, dass unser Label anzeigen kann, holen wir uns im ersten Schritt den Ask Preis. Der Ask Preis ist der Preis, der gefordert wird wenn wir eine Position kaufen wollen. Wir holen uns den aktuellen Ask Preis über SymbolInfoDouble. Das liest für das aktuelle Währungspaar mit dieser Konstante SYMBOL ASK den aktuellen Preis aus und mit dieser Konstante hier – digits – bekommen wir die passende Anzahl von Nachkommastellen, denn wie man hier sieht, gibt es Währungspaare mit drei Nachkommastellen und hier gibt es welche mit 5 Nachkommastellen. Und jetzt setzen wir die Objekteigenschaften für unser Textobjekt ein. Wir erstellen also ein Objekt mit ObjectCreate für das aktuelle Währungspaar, es soll den Namen TextObjekt bekommen. Und mit OBJ_LABEL sagen wir Mql5, dass wir gerne einen Text bearbeiten möchten. Wenn wir an dieser Stelle F1 drücken dann sieht man, dass es auch massenweise andere Objekttypen gibt. Das hier beispielsweise wäre ein Pfeil nach oben, das hier ist unser Label und das hier wäre beispielsweise ein Button und die Arrow Funktion hier kann einen Pfeil nach oben oder unten erzeugen. Wir benötigen kein separates Fenster, also nehmen wir für diesen Parameter eine 0, wir sind auch nicht zeitbezogen und unser Objekt muss auch nicht an einer bestimmten Stelle für einen Preis angezeigt werden. Also stellen wir auch das auf Null und danach wählen wir uns eine entsprechende Schriftart aus. Das geht mit der Funktion ObjectSetString, für das aktuelle Währungspaar und unser TextObjekt und mit OBJPROP_FONT setzen wir die Schriftart auf Arial. Danach setzen wir die Schriftgröße ein mit der Funktion ObjectSetInteger für das aktuelle Währungspaar und für unser TextObjekt nutzen wir die konstante OBJPROP_FONTSIZE und entscheiden uns für eine Schriftgröße von 24. Damit unser Label was anzeigen kann, setzen wir jetzt noch den Text ein. Das geht wieder mit ObjectSetString für das aktuelle Währungspaar und für unser TextObjekt nutzen wir die konstante OBJPROP_TEXT und geben hier den Text Ask Preis und den Ask Wert aus den wir hier oben in der Variable berechnet haben. Jetzt bestimmen wir noch die Position, die Distanz vom linken Rand soll 5 sein, das setzen wir mit ObjectSetInteger für das aktuelle Währungspaar und unser TextObjekt mit OBJPROP_XDISTANCE auf den Wert 5. Und die Distanz von oben setzen wir genauso, nur in diesem Fall nutzen wir OBJPROP_YDISTANCE für die y-Achse und hier verwenden wir mal den Wert 10. So, das war‘s auch schon. Jetzt kompilieren wir unseren Expert Advisor indem wir hier oben auf den kleinen Button oder auf die F7 Taste drücken und der Compiler warnt uns,

Diesmal geht es einen Indikator, den die meisten Trader lieben. Man bezeichnet ihn als Parabolischen SAR Indikator, und er zeichnet solche Punkte. Erfunden wurde er von jemandem mit dem Namen J. W. Wilder Junior. Und potentiell soll er Umkehrpunkte in der Preisentwicklung des Marktes darstellen können. Tatsächlich sieht das ganz beeindruckend aus. Man sieht hier, dass es aufwärts ging bis zu dieser Stelle. Dann hat sich die Richtung plötzlich geändert. Die Punkte erscheinen oberhalb des Kurses und es geht die ganze Zeit abwärts mit der Preisentwicklung, bis sich plötzlich hier die Preisrichtung dreht. Und jetzt befinden wir uns in einem Aufwärtstrend. Wenn man mit der Maus über diesen letzten Punkt geht, dann sieht man, dass dort ein Wert von 1.505 1994 angezeigt wird. Das ist auch der berechnete Wert hier oben links in der Ecke. Und jetzt geht es um die Frage, wie kann man sich mit MQL5 einen Expert Advisor erstellen, der genau diesen Wert hier ausrechnet? Und man könnte dann im eigenen System schauen, ob dieser Wert unterhalb des Kurses liegt, das würde für einen Aufwärtstrend sprechen. Und wenn die Punkte oberhalb des aktuellen Preises liegen, dann ist es ein Abwärtstrend. Um einen solchen Indikator beziehungsweise Expert Advisor zu erstellen, klicken wir erst einmal hier oben auf diesen kleinen Button oder drücken die F4 Taste. Das ruft den MetaEditor auf, mit dem wir ein MQL5 Programm erstellen können. Hier klicken wir jetzt auf Datei, neu, wählen Expert Advisor aus Vorlage aus, klicken auf weiter und nennen unser Programm an der Stelle Simpler SAR. Jetzt klicken wir auf weiter, weiter fertigstellen und löschen alle Inhalte oberhalb der OnTick Funktion und diese beiden Kommentar Zeilen hier. Und wie so oft brauchen wir zuerst ein Array für unsere Preis Daten. Also erstellen wir ein Array vom Typ Double mit dem Namen MySAR Array. Danach nutzen wir die Funktion ISAR, die in MQL5 eingebaut ist, für das aktuelle Symbol, also das Währungspaar, was wir gerade auf dem Chart haben und die aktuell eingestellte Periode, also die Zeiteinheit, wie zum Beispiel das Minuten-Chart, unseren SAR-Indikator zu definieren. Diese beiden Werte erkläre ich auch noch kurz. Wenn wir mit F4 zurück wechseln in den MetaTrader, können wir über Einfügen, Indikatoren, Tendenz den Parabolic SAR Indicator auswählen und der hat hier einen Schritt und einen Maximumwert. Und wir möchten die Standardwerte für den Schritt 0.02 und für das Maximum 0.2 benutzen. Und das sieht dann in unserem Quelltext so aus. Jetzt sortieren wir unser Array absteigend von der aktuellen Kerze 0 abwärts. Dazu nutzen wir die Funktion Array set as series und im nächsten Schritt füllen wir mit der Funktion Copy Buffer unser erstelltes MySAR Array für die erste Linie des Indikators, da er nur eine Linie hat, von der aktuellen Kerze abwärts für drei Kerzen nach der von uns hier oben erstellten Definition mit Daten. Im nächsten Schritt möchten wir den SR-Wert für die aktuelle Kerze berechnen. Das machen wir, indem wir uns aus dem My SAR Array von der Kerze null den benötigten Wert holen. Wir möchten hier aber fünf Nachkommastellen haben. Diese Funktion normalize Double ermöglicht uns für den vor dem Komma stehenden Wert die nach dem Komma stehende Anzahl von Kommastellen für die Ausgabe zu wählen. Würde ich hier eine zwei nehmen, dann hätten wir nur zwei Nachkommastellen. Wir benötigen in diesem Fall fünf. Gut, im letzten Schritt geht es noch darum, unsere berechneten Werte mit dem Text MySAR-Wert und einem Doppelpunkt mit der Funktion Commen direkt auf dem Chart anzuzeigen. Kompilieren wir also unseren Expert Advisor einmal. Da ist ein Fehler.

In diesem Video schauen wir uns einmal diesen Indikator hier an. Es handelt sich um einen Oszillator. Es ist der Commodity Channel Index. Und wir möchten uns einmal ansehen, wie man für diesen Indikator, für den Metatrader 5 in MQL5 einen Expert Advisor programmieren kann, der in der Lage ist, nicht nur die Signale auf dem Chart auszugeben, sondern auch selbständig Positionen zu eröffnen und zu schließen. Um das zu tun, klicken Sie bitte auf den kleinen Button hier oben links oder drücken sie die F4 Taste im Metatrader. Das öffnet dann hier das Meta Editor Fenster. Und hier klicken wir auf Datei, Neu, Expert Advisor aus Vorlage, Weiter. Ich vergebe hier mal den Namen SimplerICCIStandaloneEA. Klicke auf Weiter, Weiter und Fertigstellen. Jetzt kann alles oberhalb der On Tick Funktion gelöscht werden. Auch die zwei Kommentarzeilen werden entfernt. Wir starten hier oben damit, dass wir die Datei Trade.mqh importieren. Das geht mit dem include Befehl. Diese Datei gehört zum Umfang von MQL5 dazu. Diese Datei ermöglicht uns eine Instanz von der Klasse CTrade zu bilden. Die bekommt den Namen trade. Und wir werden sie später verwenden, um Positionen zu eröffnen. Vorher müssen wir ein paar Dinge berechnen. Zunächst brauchen wir den Ask und den Bid Preis. Die liefert uns die Funktion SymboInfoDouble für das aktuelle Währungspaar auf dem Chart. Mit SYMBOL_ASK kriegen wir den Ask Preis. Und SYMBOL_BID wird uns den Bid Preis liefern. Wir formatieren das Ganze mit NormalizeDouble und Unterstrich Digits. Denn manche Währungspaare haben drei Nachkommastellen, während andere fünf Nachkommastellen haben. Und diese Funktion stellt sicher, dass die richtige Anzahl von Nachkommastellen berechnet wird. Jetzt wo wir die zwei Preise haben, erstellen wir uns ein Preis-Array. Das machen wir mit der Funktion MqlRates und nennen es PriceInfo. Dieses Array wird die Preise für die Kerzen auf dem Chart aufnehmen. Zunächst sortieren wir es mit ArrySetAsSeries von der aktuellen Kerze an abwärts. Danach nutzen wir CopyRates um es mit Preisdaten zu füllen. Und zwar für das aktuelle Symbol, also Währungspaar auf dem Chart, die auf dem Chart ausgewählte Zeiteinheit. Wir starten von der aktuellen Kerze null und kopieren uns die Preisdaten für drei Kerzen in unser PriceInfo Array. Außerdem brauchen wir eine string Variable für unser Signal. Die nennen wir auch Signal. Den wert ermitteln wir später. Zunächst weisen wir hier noch keinen Wert zu. Jetzt brauchen wir noch ein Array. Das bekommt den Namen myPriceArray. Und das wird dieses Mal die Daten für unseren Expert Advisor aufnehmen. Wir definieren jetzt den Commodity Channel Index Expert Advisor indem wir die Funktion ICCI benutzen. Die wird mit MQL5 mitgeliefert. Und als Parameter nutzen wir das aktuelle Währungspaar, die aus dem Chart ausgewählte Zeiteinheit. Und wenn Sie sich fragen, was diese 14 hier bedeutet, dann klicken Sie doch einmal auf Einfügen, Indikatoren, Oszillatoren, Commodity Channel Index. Dann werden Sie sehen, dass hier die Periode auf 14 eingestellt ist. Das sind 14 Kerzen und genau das, was wir hier verwenden. Als letzten Parameter übergeben wir PRICE_CLOSE, damit die Ergebnisse anhand der Schlusskurse berechnet werden. Auch dieses Array wird mit ArraySetAsSeries wieder von der aktuellen Kerze an abwärts sortiert. Und dieses Mal nutzen wir CopyBuffer um anhand der von uns getroffenen Definition, die wir hier oben erstellt haben für Buffer null, also das erste Puffer, im Klartext diese blaue Linie hier, von der aktuellen Kerze null für drei Kerzen die Preisdaten in unser PriceArray zu kopieren. Und jetzt erhalten wir den aktuellen ICCIWert für die Kerze,

  In diesem Video wollen wir uns einmal anschauen, wie man eine Lotgröße basierend auf dem Kontostand berechnen kann und wie man das Ergebnis so auf oder abrundet, dass das auch passt. Also lassen Sie uns mal schauen, wie man das mit MQL5 realisieren kann. Um das zu tun, klicken Sie im MetaTrader bitte hier oben auf das Icon oder drücken Sie die F4 Taste. Dann sollten Sie im MetaEditor landen. Und hier klicken wir auf Datei, Neu Expert Advisor aus Vorlage, weiter, vergeben hier einen Namen. Ich habe das schon getan.   Meine Datei heißt Simple Lotgrößenrundung und wir haben das hier schon mal vorprogrammiert. Wir starten mit der On Tick Funktion. Dort wollen wir zunächst einmal das Konto Guthaben, also die Balance errechnen. Das geht mithilfe der Funktion Account Info Double, Account Balance und basierend auf dem Kontostand möchten wir die Positionsgröße berechnen. In unserem Fall nutzen wir dafür den Brutto Guthaben Wert und teilen diesen durch 100.000. Außerdem erstellen wir zwei Variablen für die gerundeten Werte einmal aufgerundet und einmal abgerundet. Diese ermitteln wir mithilfe der jeweiligen Funktion, die wir selbst programmieren. Die erste Funktion heißt Round up, die zweite Round down und wir übergeben jeweils als Parameter die berechnete Lotgröße und den Wert für die Kommastellen Rundung. Wir möchten das hier auf eine Kommastelle runden. Mit Normalize Double kann man die Endergebnisse noch etwas formatierter ausgeben. Obwohl wir hier jeweils zwei NachKommastellen angegeben haben, sehen wir, dass unsere Ergebnisse nach der ersten Stelle abgeschnitten werden. Und mithilfe der Comment Funktion geben wir das Ganze auf dem Chart aus. Kommen wir zu den eigentlichen Funktionen.   Um aufzurunden, übergeben wir unseren Eingabewert. Das ist die Positionsgröße, die wir oben übergeben haben und unseren Rundungswert. Das ist der zweite Parameter hier für die NachKommastellen. Und um das Resultat zu ermitteln, multiplizieren wir den Rundungswert mit dem Ergebnis dieser Funktion. Wenn Sie einmal F1 drücken und sich das in der Hilfe aufrufen, dann sehen Sie, dass da ein ganzzahliger Wert zurückgeliefert wird. Und als Parameter übergeben wir der Funktion MathCeil den Eingabewert und den Rundungswert. Anschließend nutzen wir Return, um unser Resultat wieder an die Funktion zurückzugeben. Die zweite Funktion zum Abrunden des Wertes funktioniert ähnlich. Hier nutzen wir allerdings nicht MathCeil, sondern MathFloor. Und auch hier geben wir das Resultat zurück an unsere Hauptfunktion.   Und das führt dann dazu, dass bei einer ermittelten Lotgröße von 0,25 Loth der aufgerundete Wert 0,3 und der abgerundete Wert 0,2 erscheint. Je nachdem, welchen Konten-Typ Sie haben, können Sie das entsprechend anpassen und so die richtigen Werte übergeben, damit eine Position auch korrekt eröffnet werden kann. Denn nicht alle Content Typen unterstützen die Staffelung in Mikrolotgrößen bis auf die zweite NachKommastelle. Das hier war übrigens wieder eine Anfrage von einem Premiumkunden. Und wenn Sie Premiumkunde sind und eine Idee für ein solches Video haben, dann schicken Sie mir einfach ein Email. Andernfalls finden Sie den Premiumkurs auf unserer Website. Und in diesem Video haben Sie gelernt, wie Sie Lotgrößen einfach auf- oder abrunden können, damit das zu Ihrem Kontotyp passt. Und Sie haben das selbst programmiert mit diesen paar Zeilen hier in MQL5. Nicht sicher was Sie tun sollen? Klicken Sie auf den automatischen Trading Assis...

In diesem Video geht es darum, diesen Indikator hier zu handeln. Es handelt sich um den variable Index Dynamic Average Indikator. Der wird hier automatisch gehandelt. Wir haben bereits eine erste eröffnete Position. Und wir wollen uns einmal anschauen, wie man in MQL5 einen eigenständig handelsfähigen Expert Advisor in wenigen Minuten programmieren kann. Um das zu tun, klicken Sie bitte im Meta Trader hier oben auf diesen kleinen Button oder drücken die F4 Taste. Das ruft dann hier den Meta Editor auf. Und hier wählen wir Datei, Neu, Expert Advisor aus Vorlage, Weiter. Ich vergebe hier einmal den Namen SimplerIcidyaStandAloneEA, klicke auf Weiter, Weiter und Fertigstellen. Jetzt kann alles gelöscht, was sich hier oberhalb der On Tick Funktion befindet. Auch die beiden Kommentarzeilen können entfernt werden. Wir beginnen damit, dass wir hier oben mit dem Include Befehl die Datei Trade.mqh importieren. Die gehört zum Lieferumfang von MQL5 dazu. Danach erstellen wir uns eine Instanz von der Klasse CTrade. Die bekommt den Namen Trade und wird uns einige Handelsfunktionen zur Verfügung stellen, die wir später nutzen, um Positionen zu eröffnen. Dafür brauchen wir erst einmal den Ask- und den Bid-Preis. Die ermitteln wir mit der Funktion SymbolInfoDouble. Die kann den Wert für diverse Eigenschaften eines Währungspaars zurückliefern. Und hier sehen wir SYMBOL_BID ist für den Bid-Preis und SYMBOL_ASK ist für den Ask-Preis. Wenn sie einmal ein Währungspaar anklicken, dann sehen sie hier, wir haben zwei Preislevel. Der rote Preis hier, ist der Ask-Preis, der blaue Preis hier, ist der Bid-Preis. Das dazwischen ist der spread an dem der Broker verdient. Wenn wir etwas kaufen, bekommen wir immer den etwas teureren Ask-Preis berechnet. Und wenn wir etwas verkaufen, erzielen wir nur den etwas niedrigeren Bid-Preis. Wir ermitteln mit _SYMBOL den Ask-Preis für das aktuelle Währungspaar auf dem Chart. Und mit NormalizeDouble und _Digits sorgen wir dafür, dass wir entweder fünf oder drei Nachkommastellen berechnen. Je nachdem, welches Währungspaar auf dem Chart sich gerade befindet. Das gleiche machen wir unten nochmal für den Bid-Preis. Außerdem benötigen wir noch eine String Variable für unser Signal. Wir vergeben auch den Namen Signal. Der Wert ist hier noch leer, denn der wird noch ermittelt. Jetzt brauchen wir noch ein Price Array. Das soll unsere Preisdaten aufnehmen. Und wir erstellen das mit der Funktion MQLRates. Die hat die Information über Preise, Volumen und Spread für uns. Mit der Funktion ArraySetAsSeries sortieren wir unser Price Array von der aktuellen Kerze an abwärts. Und mit CopyRates füllen wir unser Price Array mit Daten. Für das aktuelle Währungspaar und die aus dem Chart aktuell ausgewählte Zeiteinheit. Wir starten mit der aktuellen Kerze 0. Und brauchen Daten für drei Kerzen. Das reicht uns. Danach brauchen wir noch ein EA Array für die Werte von unserem Expert Advisor. Auch das sortieren wir mit ArraySetAsSeries. Und jetzt kommt die eigentliche Definition: Die erstellen wir mit dieser eingebauten Funktion iVIDyA. Die liefert uns den Wert für den Variable Index Dynamic Average Indikator zurück. Wenn man sich das einmal kurz anschaut, dann gibt es für jeden Punkt auf dieser roten Linie einen Wert, hier zu sehen als Value. Und alle diese Werte zusammen ergeben dann die Linie. Das ermittelt diese Funktion. Die braucht noch ein paar Parameter. Auch hier wieder das aktuelle Währungspaar auf dem Chart. Die aktuell ausgewählte Zeiteinheit und hier haben wir eine 9, eine 12 und eine 0. Und wenn wir auf Einfügen, Indikatoren, Tendenz, Variable Index Dynamic Average klicken,

15.637 Nachkommastellen von Pi in zwei Stunden und 42 Minuten aufsagen – das schaffte Gedächtniskünstlerin Susanne Hippauf. Damit hält sie den Weltrekord der Frauen im Pi-Aufsagen. 100 Milliarden Nachkommastellen sind bekannt, und auch in der Musik inspiriert Pi.

Mit 15.637 auswendig aufgezählten Nachkommastellen der Zahl Pi hat die Frankfurter Polizistin Susanne Hippauf einen neuen deutschen Rekord aufgestellt…

In diesem Video möchten wir uns einmal zufällige Einstiege ansehen. Die werden hier am laufenden Band produziert. Die ganze Zeit gibt es hier oben kaufen oder verkaufen Signale. Die werden anhand eines Zufallsgenerators produziert. Und wir wollen uns einmal anschauen, wie man einen Expert Advisor in MQL5 programmieren kann, der in der Lage ist, mit solchen zufälligen Einstiegen hier Positionen zu eröffnen. Um das zu tun klicken wir im Meta Trader auf diesen kleinen Button hier oder drücken die F4 Taste. Das ruft dann hier den Meta Editor auf und hier klicken wir auf Datei, Neu, Expert Advisor aus Vorlage. Weiter. Ich vergebe hier einmal den Namen SimplerStandaloneRandomEA. Klicke auf Weiter, Weiter und Fertigstellen. Jetzt kann alles oberhalb dieser On Tick Funktion gelöscht werden. Auch die zwei Kommentarzeilen werden entfernt. Zunächst importieren wir mit dem include Befehl eine Datei mit dem Namen Trade.mqh. Die gehört zum Lieferumfang vom MQL5 dazu und stellt Handelsfunktionen bereit. Und die ermöglicht uns, von der Klasse CTrade eine Instanz zu erstellen. Die nennen wir in diesem Fall trade und wir werden sie später benutzen, um damit Positionen zu eröffnen. Innerhalb der On Tick Funktion berechnen wir jetzt zunächst einmal den Ask Preis und den Bid Preis. Die brauchen wir, um Positionen eröffnen zu können. Ermittelt werden die mit dem Befehl SymbolInfoDouble für das aktuelle Währungspaar. SYMBOL_ASK liefert uns den Ask Preis. SYMBOL_BID liefert uns den Bid Preis. Und mit NormalizeDouble und Unterstrich Digits stellen wir sicher, dass wir die richtige Anzahl von Nachkommastellen für das entsprechende Währungspaar berechnen. Wenn man sich das hier einmal anschaut, da gibt es drei oder fünf Nachkommastellen. Das hier wäre der Ask und das hier wäre der Bid Preis. Und wir brauchen in diesem Fall beides. Außerdem brauchen wir eine String Variable für unser Signal. Hier weisen wir aber noch keinen Wert zu, denn den ermitteln wir gleich noch. Zunächst brauchen wir erst einmal ein paar Preisdaten. Dazu nutzen wir den Befehl MqlRates um ein Preis Array zu erstellen, das die Daten für die letzten Kerzen aufnehmen kann. Unser Preis Array wird zunächst mit ArraySetAsSeries von der aktuellen Kerze an abwärts sortiert. Danach nutzen wir CapyRates um unser Preis Array mit Daten zu füllen und zwar für das aktuelle Währungspaar auf dem Chart, die auf dem Chart eingestellte Zeiteinheit. Wir starten mit der aktuellen Kerze null und kopieren uns die Daten aus drei Kerzen. Damit haben wir unsere Preisdaten. Jetzt brauchen wir noch den Zufallsgenerator. Wir nutzen MathSrand und GetTickCount um diesen Zufallsgenerator zu initialisieren. GetTickCount liefert uns immer die Zahl der Millisekunden, die seit dem Systemstart vorbei sind. Damit ist das immer eine andere Zahl. Und die brauchen wir, weil MathSrand pseudozufällige Ganzzahlen produziert. Wäre dieser Wert immer gleich, würden wir auch immer die gleichen Zahlen erhalten und genau das wollen wir ja nicht. Berechnen wir also eine Zufallszahl. Dazu nutzen wir einen Befehl der ähnlich klingt MathRand. Und mit Prozent zwei bekommen wir entweder eine null oder eins zurück. Der Befehl an sich würde aber bis zu 32.767 Zahlen bereitstellen können. Da wir aber nur entweder kaufen oder verkaufen Signale benötigen, reichen uns hier zwei Zahlen. Und immer, wenn die Zufallszahl null ist, dann möchten wir gerne kaufen. Also weisen wir das Wort kaufen unserer Signal Variable zu. Im anderen Fall, wenn unser Zufallsgenerator eine eins ausspuckt, dann möchten wir verkaufen. Darum setzen wir unser Signal an der Stelle auf verkaufen.

In diesem Video geht es um den MACD. Das ist dieser Indikator hier unten. Und wir möchten uns in MQL5 einmal eine eigenständig handelsfähige Version für den Meta Trader5 programmieren. Immer, wenn wir hier eine Überschneidung der Signallinie von unten nach oben haben, dann ist das ein Kaufen Signal. Im umgekehrten Fall, wenn die rote Linie von oben nach unten überkreuzt, dann ist es ein Verkaufen Signal. Wie können wir uns jetzt in MQL5 einen solchen eigenständig handelsfähigen und automatisierten Expert Advisor erstellen? Um das zu tun, klicken Sie bitte im Meta Trader hier oben auf diesen kleinen Button oder drücken die F4 Taste. Das ruft dann hier den Meta Editor auf und hier klicken wir auf Datei, Neu, Expert Advisor aus Vorlage, Weiter. Ich vergebe hier einmal den Namen SimplerMACDStandAloneEA. Klicke auf Weiter, Weiter und Fertigstellen. Und jetzt kann alles oberhalb dieser On Tick Funktion hier gelöscht werden. Auch die zwei Kommentarzeilen werden entfernt. Zunächst einmal nutzen wir den Include Befehl um uns die Datei Trade.mgh zu importieren. Die stellt Handelsfunktionen bereit. Darum erstellen wir uns eine Instanz von der Klasse CTrade. Die bekommt den Namen Trade. Und wir werden sie gleich benutzen, um damit Positionen zu eröffnen. Zuerst erstellen wir uns eine String Variable für das Signal. Die bekommt auch den Namen Signal. Wir weisen aber zunächst noch keinen Wert zu, denn der muss noch ermittelt werden. Jetzt berechnen wir zunächst den AskPrice. Das ist der Preis, den wir bezahlen müssen, wenn wir etwas kaufen. Berechnen können wir das mit SymbolInfoDouble. Für das aktuelle Währungspaar benutzen wir SYMBOL_ASK für den AskPrice. Und mit normolize double und Unterstrich Digits stellen wir sicher, dass wir die richtige Anzahl von Nachkommastellen bekommen. Denn es gibt Währungspaare mit 3 und andere mit 5 Nachkommastellen. Das gleiche machen wir dann nochmal für den BitPrice. Das ist der Preis, den wir erhalten, wenn wir etwas verkaufen. Den bekommen wir mit Symbol_Bid. Ansonsten sind diese beiden Zeilen hier nahezu identisch. Wir brauchen auch noch ein Array für Preisdaten. Das bekommt den Namen PriceArray. Und jetzt kommen wir zur eigentlichen Definition für den MACD. Dazu nutzen wir die in MQL5 integrierte Funktion iMACD für das aktuelle Währungspaar auf dem Chart und die dort ausgewählte Zeiteinheit. Und falls Sie sich fragen, woher diese Werte kommen, die finden Sie auch hier wieder, in Klammern stehen sie hinter dem Indikator. Und wenn man sich mit der rechten Maustasche einmal die Eigenschaften von MACD ansieht, dann sieht man, hier wird ein schneller EMA mit dem Wert 12, ein langsamer EMA mit dem Wert 26 und ein MACD-SMA mit dem Wert 9 aufgeführt. 12, 26, 9 haben wir auch hier im Quelltext. Und unser Ergebnis wird ermittelt basierend auf den Schlusskursen. Jetzt sortieren wir unsere Preise noch abwärts von der aktuellen Kerze. Das machen wir mit ArraySetAsSeries und mit CopyBuffer füllen wir unser PreisArray anhand der MACD Definition, die wir hier oben getroffen haben von der aktuellen Kerze für 3 Kerzen mit Daten. Diese 0 hier steht für den Buffer Wert. Der MACD liefert uns hier mehrere Werte. Und wir interessieren uns für den Wert im Buffer 0. Jetzt sind wir in der Lage, den EA für die aktuelle Kerze zu berechnen. Indem wir auf Kerze 0 in unserem PreisArray zugreifen. Und das Ergebnis der Variable MACDWert zuweisen. Das Ganze tun wir dann nochmal für die Kerze davor. Das wäre Kerze 1. Und das Ergebnis von Kerze 1 weisen wir der Variable letzterMACDWert zu. Jetzt können wir ein Kauf Signal ermitteln. Das haben wir, wenn der aktuelle MACDWerts sich oberhalb der Nu...

In diesem Video möchten wir uns einmal den Relativen Vigor Index anschauen. Es handelt sich hier um einen Stand Alone Expert Advisor, der in der Lage ist, die Signale, die der LVI Indikator generiert., auch tatsächlich auf dem Chart zu handeln. Wie man sieht, haben wir hier unten auch schon einen offenen Trade. Und wir möchten uns einmal anschauen, wie man dieses Programm hier in MQL5 erstellen kann. Um das zu tun, klicken Sie bitte hier oben auf diesen kleinen Button oder drücken die F4 Taste im Meta Trader. Das ruft dann hier den Meta Editor auf und hier klicken wir auf Datei, Neu, Expert Advisor aus Vorlage, Weiter. Ich vergebe hier einmal den Namen SimplerRVIStandaloneIA. Klicke auf Weiter, Weiter und Fertigstellen. Jetzt kann alles oberhalb der On Tick Funktion hier gelöscht werden. Auch die zwei Kommentarzeilen können entfernt werden. Im ersten Schritt nutzen wir den Include Befehl hier, um die Datei Trade.mqh zu importieren. Die stellt uns eine Handelsklasse mit dem Namen CTrade zur Verfügung. Und wir erstellen eine Instanz von CTrade mit dem Namen Trade. Die werden wir gleich nutzen, um Positionen auch zu eröffnen. In der On Tick Funktion benötigen wir zunächst eine String Variable für das Signal. Die bekommt auch den Namen Signal aber zunächst keinen Wert zugewiesen. Danach ermitteln wir den AskPrice und den BidPrice. Das geht mit der Funktion SymbolInfoDouble. Wenn Sie auf ein Währungspaar klicken, dann sehen Sie hier das Sie zwei unterschiedliche Preise haben. Der AskPrice ist das, was wir zahlen, wenn wir etwas kaufen. Und der BidPrice ist das, was wir bekommen, wenn wir etwas verkaufen. Dazwischen ist eine Lücke, der sog. Spread. Daran verdient der Broker. Und mit Normalize Double und Unterstrich Digits ermitteln wir die Anzahl der Nachkommastellen. Die können hier nach Währungspaar drei- oder fünfstellig sein. Und Unterstrich Digits ermittelt das für uns automatisch. Wir brauchen noch zwei Arrays, die bekommen den Namen myPriceArray0 und myPriceArray1. Denn unser Indikator hier hat zwei Linien. Darum müssen wir auch zwei Signale berechnen. Dazu nutzen wir die eingebaute MQL5 Funktion iLVI für das aktuelle Symbol auf dem Chart. Und hier auf dem Chart ausgewählte Zeiteinheit. Diese 10 hier sehen wir auch hier in Klammern, wenn wir uns den Indikator genauer anschauen. Und wenn wir im Meta Trader einmal auf Einfügen, Indikatoren, Oszillatoren, Relative Vigor Index klicken, dann sehen wir auch hier eine Periode von zehn Kerzen. Das ist die Voreinstellung. Darum nutzen wir das auch hier im Quellcode. Gut, sortieren wir unsere beiden Arrays von der aktuellen Kerze an abwärts. Das machen wir für das PriceArray0 und für das PriceArray1, indem wir die Funktion ArraySetAsSeries anwenden. Und mit der Funktion CopyBuffer füllen wir unsere Array Daten. Wir tun das anhand der Definition, die wir hier oben getroffen haben. Einmal für Buffer 0 und einmal für Buffer 1, weil wir zwei Signale haben. Jeweils von der aktuellen Kerze 0 für drei Kerzen. Und speichern das Ergebnis in myPriceArray0 oder myPriceArray1. Danach holen wir uns aus dem jeweiligen PriceArray den Wert für die Kerze 0. Das ist immer die aktuelle Kerze. Und mit NormalizeDouble und dieser 3 hier, sorgen wir dafür, dass die Werte auch mit drei Nachkommastellen ausgegeben werden. Jetzt haben wir eigentlich alles zusammen. Ermitteln wir doch mal ein Kaufsignal. Immer wenn der RVI Value 0 kleiner ist als der RVI Value 1 und wenn beide Linien unterhalb der Nulllinie liegen, das ist hier diese gestrichelte Linie, dann erzeugt das ein Kaufen Signal. Darum weißen wir das Wort Kaufen unserer Signalvariable zu.

In diesem Video möchten wir uns einmal anschauen, wie man diesen Indikator, den parabolischen SAR mit Metatrader 5 automatisch handeln kann. Wir werden hier diesen Expert Advisor so programmieren, dass er in der Lage ist, eigenständig Positionen zu eröffnen. Man sieht hier diese Punkte. Immer wenn die sich unterhalb des Preises befinden, dann ist das ein Kaufen Signal. Und wenn die Punkte oberhalb der Kerzen gezeichnet werden, ist das ein Verkaufen Signal. Hier unten haben wir bereits eine erste Position eröffnet. Und wir werden uns jetzt einmal anschauen, wie man das mit dem Meta Editor programmieren kann. Um das zu tun klicken Sie bitte im Metatrader hier oben auf diesen kleinen Button oder drücken die F4 Taste. Das ruft dann hier den Meta Editor auf. Und hier klicken wir auf Datei, Neu, Expert Advisor aus Vorlage. Weiter. Ich vergebe hier einmal den Namen SimplerSARStandaloneEA. Klicke auf Weiter, Weiter, Fertigstellen. Jetzt kann alles oberhalb der On Tick Funktion gelöscht werden. Und wir entfernen auch die zwei Kommentarzeilen. Zunächst einmal nutzen wir den include Befehl, um die Datei Trade.mqh zu importieren. Die bietet uns Handelsfunktionen. Und damit können wir jetzt von der Klasse CTrade eine Instanz mit dem Namen trade erstellen. Die brauchen wir gleich für die Eröffnung der Positionen. In der On Tick Funktion erstellen wir uns zunächst ein Preis-Array mit dem Namen PreisArray. Das übernimmt für uns die Funktion MqlRates. Hier oben passen wir noch den Kommentar an. Danach nutzen wir ArraySetAsSeries, um unser Array von der aktuellen Kerze an abwärts zu sortieren. Und mit CopyRates füllen wir es mit Preisdaten für das aktuelle Währungspaar auf dem Chart und die auf dem Chart ausgewählte Zeiteinheit. Wir tun das von der aktuellen Kerze null für drei Kerzen und speichern das Ergebnis in unserem PreisArray. Außerdem brauchen wir noch einen String für unsere Signal Variable. Die bekommt den Namen Signal. Der Wert wird später zugewiesen, denn den müssen wir erst noch ermitteln. Zuvor berechnen wir erst mal den Ask und den Bid Preis. Diese Informationen gibt uns die Funktion SymbolInfoDouble für das aktuelle Symbol auf dem Chart. Mit SYMBOL_ASK bekommen wir den Ask Preis. Mit SYMBOL_BID den Bid Preis. Und NormalizeDouble und Unterstrich Digits nutzen wir, um die richtige Anzahl der Nachkommastellen zu ermitteln. Hier hätten wir drei Nachkommastellen. Und hier fünf. Und mit diesem Ausdruck hier wird das für jedes Währungspaar entsprechend angepasst. Jetzt brauchen wir noch ein Array für den SAR Indikator. Die Definition dieses Indikators geht über die iSAR Funktion, die in MQL5 eingebaut ist. Auch hier nutzen wir das aktuelle Währungspaar auf dem Chart und die auf dem Chart ausgewählte Zeiteinheit. Und wenn Sie sich fragen, was diese beiden Werte hier bedeuten, die sehen Sie auch, wenn Sie hier auf Einfügen, Indikatoren, Tendenz, Parabolic SAR klicken. Dann sehen wir eine Schrittweite von 0,02 und ein Maximum von 0,2. Und genau das nutzen wir hier auch. Auch dieses Array sortieren wir wieder abwärts von der aktuellen Kerze, indem wir ArraySetAsSeries verwenden. Und im Anschluss nutzen wir CopyBuffer um unser SARArray anhand der SAR Definition, die wir hier oben getroffen haben für Buffer null, also den ersten Signalwert, von der aktuellen Kerze null für drei Kerzen mit Daten zu füllen. Und jetzt können wir die Werte für die letzte Kerze berechnen. Dazu schauen wir uns einfach die Kerze eins in unserem Array an. Und kürzen mit NormalizeDouble und dieser fünf den gemessenen Wert auf fünf Nachkommastellen. Denn wenn Sie hier mal die Maus über einen dieser Punkte halten, dann sehen Sie,

In diesem Video möchten wir einen Expert Adviser erstellen, der in der Lage ist, den Stochastic Indicator eigenständig zu handeln. Es handelt sich hier um einen Oszillator. Immer wenn wir eine Überkreuzung dieser beiden Signallinien oberhalb der gestichelten oberen Linie habe, wäre das ein Verkaufen. Und unterhalb wäre es ein Kaufen Signal. Die Signale werden nicht nur hier auf dem Chart ausgegeben. Sondern wir haben hier unten auch schon eine erste geöffnete Position, die automatisch gehandelt wurde. Und wir möchten uns jetzt einmal anschauen, wie man so etwas in MQL5 programmieren kann. Um das zu tun, klicken Sie bitte hier oben auf diesen kleinen Button oder drücken die F4 Taste. Das ruft dann hier den Meta Editor auf. Und hier klicken wir auf Datei, Neu, Expert Advisor aus Vorlage. Weiter. Ich vergebe hier mal den Namen SimplerStochasticStandaloneEA, klicke auf Weiter, Weiter und Fertigstellen. Jetzt kann alles oberhalb dieser On Tick Funktion hier gelöscht werden. Auch die zwei Kommentarzeilen kommen weg. Hier oben nutzen wir den include Befehl, um die Datei Trade.mqh zu importieren. Die ermöglicht uns eine Instanz von der Klasse CTrade zu erstellen. Damit lassen sich dann später die Positionen eröffnen. In der On Tick Funktion, die bei jeder Preisänderung aufgerufen wird, erstellen wir erst einmal eine Signal Variable. Die ist vom Typ String, damit sie Textketten aufnehmen kann, bekommt aber hier noch keinen Wert zugewiesen. Der wird gleich noch ermittelt. Dazu benötigen wir erst einmal ein paar Dinge. Zum Beispiel den Ask und den Bid Preis. Hier oben kann man sehen, dass wir einen roten und einen blauen Preisverlauf haben. Der blaue Preis ist der Ask Preis. Den müssen wir zahlen, wenn wir etwas kaufen. Und der rote ist der Bid Preis. Den erhalten wir, wenn wir etwas verkaufen. Ermitteln können wir das mit der Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart. Mit SYMBOL_ASK bekommen wir den Ask Preis. Und mit SYMBOL_BID bekommen wir den Bid Preis. Und diese NormalizeDouble Funktion in Kombination mit _Digits sorgt dafür, dass wir entweder drei oder fünf Nachkommastellen haben, je nachdem, welches Währungspaar auf dem Chart ist. Jetzt brauchen wir noch zwei Arrays. Das eine heißt KArray und das andere heißt DArray. Wenn man im Metatrader auf Einfügen, Indikatoren, Oszillatoren, Stochastic Oszillator klickt, sieht man auch hier eine K Periode und eine D Periode. Zunächst einmal sortieren wir mit ArraySeAsSeries beide Arrays von der aktuellen Kerze an abwärts. Jetzt können wir unsere StochasticDefinition mit Hilfe der Funktion iStochastic umsetzen. Wir tun das für das aktuelle Währungspaar auf dem Chart und die auf dem Chart ausgewählte Zeiteinheit. Auch diese Parameter hier finden wir in den Standardeinstellungen für den Stochastic Oszillator wieder. Wir haben hier 5,3,3, MODE_SMA und STO_LOWHIGH. Und auch hier sehen wir eine Fünf für die K Periode, eine Drei für die D Periode. Die Verlangsamung ist drei. Die Methode steht auf Simple. Das ist gleich zu setzten mit MODE SMA. Der Preisbereich steht auf Low/High. Das entspricht hier diesem letzten Parameter. STO_LOWHIGH. Mit der Funktion CopyBuffer füllen wir jetzt unser KArray und unser DArray mit Preisdaten. Das erste Array für den Buffer null. Das ist die erste Signallinie. Das zweite Array ist Buffer eins. Das ist die zweite Signallinie. Wir brauchen jeweils von der aktuellen Kerze für drei Kerzen die Preisdaten laut unserer Definition, die wir hier oben getroffen haben. Und speichern sie in den jeweiligen Arrays. Und mit diesen Daten können wir jetzt die aktuellen Werte,

  In diesem Video, wo wir uns mal anschauen, wie man einen Expert Advisor programmieren kann, der in der Lage ist die Bollinger Bänder zu nutzen, um Einstiegs-Signale zu produzieren. Und wir verwenden hier auch den RSI Oszillator als Filter. Also lassen Sie uns mal schauen, wie man so etwas programmieren kann. Um das zu tun, klicken Sie im Metatrader bitte hier oben auf diesen kleinen Button  oder Sie drücken F4 Taste. Es ruft dann hier den MetaEditor auf und hier haben wir bereits eine vorprogrammierte Version. Die hat den Namen Stand Alone Bollinger RSI und wir verwenden hier einen Einstieg und einen Filter. Zunächst einmal nutzen wir den Include Befehl, um die zu MQL5 zugehörige Datei Trade.mqh zu importieren. Die stellt uns vereinfachte Handelsfunktion bereit und danach nutzen wir wieder include und importieren die zwei Module, die wir noch programmieren müssen. Das eine wird das Einstiegs-Signal für die Bollinger Bänder ermitteln und das andere den Filter für den RSI Oszillator. Danach berechnen wir den Ask Preis und den Bid Preis. Das funktioniert mit der Funktion Symbol Info Double für das aktuelle Währungspaar auf dem Chart.   Wir nutzen entweder Symbol Ask oder Symbol Bid. Und mit Normalize double und Unterstrich Digits stellen wir sicher, dass wir die richtige Anzahl von Nachkommastellen hinter dem Komma berechnen. Danach erstellen wir uns eine Instanz von der Klasse CTrade, der wir den Namen Trade verpassen. Und mit MQLRates erstellen wir uns für ein  Preis Info Array. Wir machen das außerhalb der OnTick Funktion, da wir das auch in dem Bollinger Bands Modul nutzen wollen. Mit Array set as series sortieren wir dann unser Preis Info Array von der aktuellen Kerze an abwärts. Und mit Copy Rates füllen wir unser Preis Info Array für das aktuelle Währungspaar auf dem Chart und die auf dem Chart ausgewählte Zeiteinheit von der aktuellen Kerze 0 für drei Kerzen. Das ermöglicht uns dann anhand der aktuellen Kerze 0 den Schlusskurs zu ermitteln, der in unserem Preis Info Array gespeichert ist und diesen der Variable CurrentPrice zuzuordnen. Um das Trading Signal zu ermitteln, öffnen wir jetzt eine Funktion mit dem Namen Check Entry Bollinger. Die finden wir hier in dem Modul. Unsere Funktion bekommt keine Parameter und ist vom Typ String, da sie einen Text zurückgeben wird.   Zunächst erstellen wir eine Signal Variable, die ist auch vom Typ String. Außerdem brauchen wir drei Arrays für die drei Bollinger Bänder. Auch diese werden mit Array set as series von der aktuellen Kerze an abwärts sortiert. Und mit der integrierten Funktion Ibands können wir für das aktuelle Währungspaar auf dem Chart und die dort ausgewählte Zeiteinheit die Bollinger Bänder für 20 Kerzen berechnen. Wir benötigen keinen Shift Wert und wir nutzen den Standardwert zwei für Deviation um anhand der Schlusspreise unsere Werte zu ermitteln. Mit Copy Buffer füllen wir jetzt unsere drei Arrays für das mittlere, das obere und das untere Band, das mittlere Band hat Buffer 0, das obere Buffer 1 und das untere Band Buffer 2. Und jetzt können wir die jeweils aktuellen Werte ermitteln, indem wir uns die Werte in unserem Array anschauen. Diesmal für die Kerze 0. Und dann wiederholen wir das Ganze noch mal für die Kerze davor. Dazu schauen wir uns die Werte für Kerze eins im Array an. Und wenn der Schlusskurs von Kerze 1 kleiner war als unser unteres Band und der Schlusskurs für Kerze 0 über unseren unteren Band liegt dann wäre das ein Kaufen-Signal. Im Umkehrschluss, wenn für Kerze eins der Schlusskurs größer war als unser oberes Band und der Schlusskurs für die aktuelle Kerze...

In diesem Video wollen wir uns einmal anschauen, wie man einen Expert Advisor programmieren kann, der zwei gleitende Durchschnitte und den MACD als Filter benutzt. Also schauen wir mal, wie das mit MQL5 geht. Um das zu tun, klicken Sie bitte im MetaTrader auf diesen kleinen IDE Button hier oben oder drücken Sie die F4 Taste. Das ruft dann den MetaEditor auf und ich habe hier schon eine vorprogrammierte Version. Die startet damit, dass wir mit dem Include Befehl hier oben die Datei Trade.MQH importieren.   Die ist Bestandteil von MQL5 und gehört zum Sprach-Umfang. Als nächstes nutzen wir wieder den Include Befehl und importieren uns zwei selbst programmierte Module. Die werden den gleitenden Durchschnitt und den MACD jeweils nutzen, um ein Einstiegs- und ein Filter Signal zu ermitteln. Anschließend berechnen wir den Ask Preis und den Bid preis. Das machen wir mit der Funktion Symbol Info Double für das aktuelle Währungspaar auf dem Chart und wir nutzen Symbol Unterstrich Ask oder Symbol Unterstrich Bid. Und mit Unterstrich Digits und Normalize double stellen wir sicher, dass wir die richtige Anzahl von NachKommastellen für das jeweilige Währungspaar ermitteln. Je nach Währung kann das nämlich unterschiedlich sein. Danach erstellen wir eine Instanz von der Klasse CTrade, die wir Trade nennen. Die stellt vereinfachte Handels-Funktionen bereit, die wir nutzen, um Positionen zu eröffnen. Weiter geht es mit der OnTick Funktion.   Hier nutzen wir MQL4Rates, um uns ein Informations Array für Preisdaten zu erstellen. Das wird dann mit Array set as series im Anschluss von der aktuellen Kerze an abwärts sortiert. Und mit Copy Rates füllen wir unser Array mit Preis Daten für das aktuelle Währungspaar auf dem Chart und die auf dem Chart ausgewählte Zeiteinheit. Wir starten bei der aktuellen Kerze Null und kopieren uns die Daten für drei Kerzen in unser Preis Info Array. Das ermöglicht uns, den aktuellen Preis zu ermitteln, indem wir uns den Schluss Preis für die aktuelle Kerze im Preis Info Array ausgeben lassen. Weiter geht es mit zwei String Variablen. Die eine ist für das Trading Signal und die andere ist für das Filter Signal. Dazu rufen wir eine Funktion auf. Die Check Entry EMA heißt. Und die befindet sich in diesem Modul. Und für den Filter rufen wir eine Funktion mit dem Namen Check Entry Macd auf. Die finden wir in diesem Modul.   Denn wenn das Trading Signal auf kaufen steht und der Filter ebenfalls auf kaufen steht und uns die Funktion Positions total einen Wert von Null zurückliefert, dann haben wir zwei Kauf Signale und keine offenen Positionen und dann nutzen wir Trade.Buy, um eine Position für zehn Mike zu eröffnen. Im anderen Fall, wenn das Trading Signal auf Sell steht, also wir ein Verkaufen Signal haben und auch der Filter sagt wir sollen verkaufen, dann prüfen wir ebenfalls, ob wir keine offenen Positionen haben. Und wenn das alles zutrifft, dann nutzen wir Trade.Sell um einer Verkaufs-Position über zehn Microlot zu eröffnen. Zum Schluss nutzen wir noch das Comment Signal, um uns das Signal für die gleitenden Durchschnitte und für den MACD auf dem Bildschirm ausgeben zu lassen. Diese beiden Module hier gibt es aber noch nicht. Die müssen wir also programmieren.   Das hier ist das erste. Die Funktion heißt Check entry EMA, um den exponentiellen gleitenden Durchschnitt zu ermitteln. Zunächst erstellen wir eine String Variable mit dem Namen Entry. Der weisen wir hier aber noch keinen Wert zu. Und dann erstellen wir uns zwei Arrays, eins für den Moving Average für 20 Kerzen und eins für den Moving Average für 50 Kerzen.

Gibt es „übertriebene Präzision“? Vor allem Fachleute dürften sich über die Bezeichnung wundern – denn sollten Informationen nicht so präzise sein wie möglich? Na ja – sofern die Nachkommastellen keine Rolle spielen, gibt es keinen Grund, „2,0 + 2,0 = 4,0“ zu sagen. Präzision ordnet sich der Relevanz unter: Wie präzise wir uns ausdrücken, hängt [...] Der Beitrag 143 Klartext-Podcast: Übertriebene Präzision erschien zuerst auf Thilo Baum.

  In diesem Video wollen wir uns einmal anschauen, wie man eine Langzeittrend ermitteln kann mit Hilfe von diesen gleitenden Durchschnitten. Und wir wollen uns einmal anschauen, wie man das nutzen kann, um Positionen entsprechend zu eröffnen. Um das zu tun, klicken Sie bitte hier oben auf dieses neue Symbol. Das heißt jetzt DIE. Danach klicken wir auf Datei, Neue Datei, Expert Advisor aus Vorlage, Weiter. Ich vergebe hier mal den Namen SimplerLongTermTrend, klicke auf Weiter, Weiter und Fertigstellen. Jetzt kann alles oberhalb der OnTick Funktion gelöscht werden. Auch die zwei Kommentarzeilen werden entfernt.   Wir starten mit einem Import für die Datei Trade.mqh, die Bestandteil von MQL5 ist. Sie enthält die Klasse CTrade, von der wir uns hier eine Instanz mit dem Namen trade erstellen. In der OnTick Funktion benötigen wir eine Signal Variable. Der weisen wir hier aber noch keinen Wert zu, denn, den möchten wir gleich ermitteln. Danach berechnen wir den Ask und den Bid Preis. Das geht über SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart. Wir nutzen entweder SYMBOL_ASK oder SYMBOL_BID und mit NormalizeDouble und _Digits ermitteln wir automatisch, ob das jeweilige Währungspaar drei oder fünf Nachkommastellen hat.   Für unsere Trendermittlung benötigen wir zwei Arrays. Eins soll für 950 und eins für 1.000 Kerzen sein. Für die Berechnung nutzen wir die integrierte Funktion iMA für das aktuelle Währungspaar auf dem Chart und die auf dem Chart ausgewählte Zeiteinheit, in diesem Fall für 950 Kerzen. Wir benötigen keinen Shift, also Verschiebungsmodus, nutzen MODE_EMA, um einen exponentiellen Moving Average zu berechnen. Und das Ergebnis soll ermittelt werden anhand der Schlusspreise. Das Ganze wiederholen wir jetzt nochmal für tausend Kerzen. Bis auf die Anzahl der Kerzen und die Bezeichnung ist alles identisch. Im Anschluss nutzen wir ArraySetAsSeries, um unsere beides Arrays von der aktuellen Kerze an abwärts zu sortieren. Und mit Hilfe von CopyBuffer füllen wir jetzt unsere Moving Average Arrays anhand der Definitionen, die wir hier oben getroffen haben. Und zwar tun wir das für Buffer null von der aktuellen Kerze null und wir kopieren die Werte für drei Kerzen und speichern sie in unseren Arrays.   Denn dadurch sind wir jetzt in der Lage die jeweilige Richtung zu ermitteln. Und wenn der Moving Average Array für 950 Kerzen aktuell größer ist als der Wert für den Moving Average Array für tausend Kerzen, dann wäre das für uns ein Kaufen Signal, also weisen wir den Begriff Buy unserer Einstiegsvariable zu. Im anderen Fall, wenn der 950er Moving Average unter dem 1.000er Moving Average liegt, dann wäre das für uns ein Verkaufen Signal und in dem Fall weisen wir den Begriff Sell unserer Einstiegsvariable zu. Denn, wenn unser Einstiegssignal auf Sell steht und wir keine geöffneten Positionen haben, wenn also die Funktion PositionsTotal einen Wert kleiner eins zurückliefert, dann nutzen wir trade.Sell, um eine Position zu verkaufen. Im umgekehrten Fall, wenn wir ein Kaufsignal und ebenfalls keine geöffnetes Positionen haben, dann nutzen wir trade.Buy, um eine Position zu kaufen. Und dieser Bereich hier stellt den Stop Loss und den Take Profit Wert dar.   Wenn Sie mit diesen Werten einmal experimentieren und viele Tests machen, dann werden Sie herausfinden, was Ihnen wirklich weiter hilft, um Ihre Ergebnisse zu verbessern. Das war es auch schon so weit. Wenn alles funktioniert und Sie hier auf Kompilieren klicken, dann sollten Sie keine Fehler bekommen. In meinem Fall ist das so. Wenn Ihnen das hier aber zu schnell ging oder wenn Sie keine Ahnung haben, was alle diese Codezeilen hier bewirken sollen,...

In diesem Video möchten wir uns einmal den Indikator Envelopes anschauen. Der produziert so eine blaue und eine rote Linie. Und wir wollen einmal schauen, wie man sich einen Expert Advisor in MQL5 erstellen kann, der in der Lage ist, Kaufen und Verkaufen Signale hier auf dem Chart auszugeben und eigenständig Positionen automatisch zu öffnen. Um das zu tun, klicken wir im Mata Trader auf diesen kleinen Button oder drücken die F4 Taste. Das ruft dann den Meta Editor auf. Und hier klicken wir auf Datei, Neu, Expert Advisor aus Vorlage, Weiter. Ich vergebe hier einmal den Namen SimplerEnvelopesStandAloneEA. Klicke auf Weiter, Weiter und Fertigstellen. Jetzt kann alles oberhalb der On Tick Funktion gelöscht werden. Und auch die zwei Kommentarzeilen kommen weg. Wir starten, indem wir uns eine Instanz von CTrade erstellen. Dazu nutzen wir den Include Befehl und importieren die Datei Trade.mqh. Die ist in MQL5 enthalten und stellt Handelsfunktionen bereit. Unsere Instanz bekommt den Namen Trade. Und damit werden wir gleich Positionen eröffenen. Vorher müssen wir noch ein paar Dinge berechnen. Fangen wir an mit dem Ask Preis und dem Bid Preis. Die Berechnung erfolgt mit der Funktion SymbolInfoDouble für das aktuelle Symbol auf dem Chart, also das Währungspaar. Benutzen SYMPBOL_ASK um den Ask Preis zu berechnen. Und SYMBOL_BID um den Bid Preis zu berechnen. Mit NormalizeDouble_Digits stellen wir sicher, dass die Berechnung von drei oder fünf Nachkommastellen automatisch erfolgt, je nachdem, welches Währungspaar wir traden. Jetzt brauchen wir noch eine leere String Variable. Die bekommt den Namen Signal, denn die soll später unser Handelssignal aufnehmen. Und mit MQL Rates erstellen wir uns ein Array für Preisinformationen. Das wird mittels ArraySetAsSeries von der aktuellen Kerze an abwärts sortiert. Jetzt nutzen wir die Funktion CopyRates um unser Preisinformations Array für das aktuelle Währungspaar und die auf dem Chart aktuelle ausgewählte Zeiteinheit von der Kerze 0, dass ist die aktuelle Kerze ganz rechts, die gerade erstellt wird, für drei Kerzen zu kopieren. Die Daten landen dann hier in unserem PriceArray. Für den Envelopes Indikator brauchen wir zwei Arrays. Eins für das obere und eins für das untere Band. Auch diese Arrays sortieren wir mit ArraySetAsSeries von der aktuellen Kerze an abwärts. Danach nutzen wir die Funktion iEnvelopes um den Expert Advisor zu definieren. iEnvelopes ist in MQL5 enthalten und benötigt als Parameter das aktuelle Währungspaar, die auf dem Chart ausgewählte Zeiteinheit. Diese 14 hier steht für 14 Kerzen. Man sieht das auch, wenn man einmal im Meta Trader auf Einfügen, Indikatoren, Tendenz Envelopes klickt. Hier sind 14 Kerzen als Standardwert vorgelegt, die Abweichung beträgt 0.100. Die Verschiebung ist 0 und berechnet wird das Ganze auf die Close Preise, also auf die Schlusskurse. Genau das sind auch die Paramter, die wir hier verwenden. Mittels CopyBuffer füllen wir jetzt unsere Arrays mit Daten. Und zwar anhand der Envelopes Definition, die wir hier oben getroffen haben. Das obere Array hat das Buffer 0. Das untere das Buffer 1. Wir starten von der jeweils aktuellen Kerze 0 und kopieren uns die Daten für drei Kerzen jeweils in das ober oder in das untere Array. Das ermöglicht uns, den Expert Advisor für die jeweils aktuelle Kerze zu berechnen. Der Wert für das obere Band wird ermittelt, indem man sich die Kerze 0 im jeweiligen Array anschaut. Und mit NormolizeDouble und dieser 6 kürzen wir dieses Ergebnis auf sechs Nachkommastellen ab. Das Gleiche machen wir hier nochmal für das untere Band. Und wenn die letzte Kerze unter dem unteren Band geschlossen wur...

Sagen wir es, wie es ist: Gretel hat ihren Business-Plan eigentlich nur für den Gründungszuschuss geschrieben - und ihn seitdem auch nicht mehr aus der Schublade geholt. Dass ein Businessplan - wenn er richtig genutzt wird - aber ein 1A-Planungstool fürs Business sein kann, war deswegen ein ziemliches Aha-Erlebnis für sie. Und das bescherte ihr Michaela Schächner, Business Coach mit einer Vorliebe für Zahlen und Mentorin für werteorientierte Unternehmerinnen. In diesem Schnack besprechen Michaela und Gretel ➡️ Wozu es überhaupt einen Businessplan braucht ➡️ Wie du herausfindest, welches Leben du führen willst ➡️ Wie du einen entspannten Zugang zum Businessplan kriegst Immer pragmatisch und getreu dem Motto „Deine Business-Strategie braucht kein Denken in Nachkommastellen.“

  In diesem Video wollen wir uns einmal anschauen, wie man für den Average True Range Indikator einen Sell Trailing Stop programmieren kann, der nachgezogen wird, wenn der der Wert für diesen Indikator hier sinkt. Also lassen Sie uns einmal schauen, wie man so etwas mit MQL5 programmieren kann. Um das zu tun, klicken Sie im MetaTrader bitte hier oben auf dieses kleine Symbol oder drücken Sie die F4-Taste. Das ruft dann hier den Metaeditor auf und hier klicken wir auf Datei, neue Datei, Expert Advisor aus Vorlage, weiter. Ich vergebe hier einmal den Namen SimplerAverageTrueRangeSellStop, klicke auf weiter, weiter und fertigstellen. Jetzt kann alles oberhalb dieser OnTick-Funktion hier entfernt werden und auch die zwei Kommentarzeilen werden gelöscht. Wir starten mit einer include-Funktion für die Datei Trade.mqh.   Diese Datei ist im Umfang von MQL5 enthalten und sie enthält die Klasse CTrade von der wir uns hier eine Instanz mit dem Namen trade erstellen. Außerdem benötigen wir einige Variablen. Die Erste ist für den Basis Stop Point Wert, die Zweite ist für den berechneten Stop Point Wert und die dritte Variable ist der Bid Preis. Den nutzen wir diesmal als globale Variable. Alle Variablen, die außerhalb einer Funktion deklariert werden stehen für alle Funktionen zur Verfügung. Innerhalb der OnTick-Funktion erstellen wir uns jetzt eine Signal-Variable. Die ist vom Typ string, aber wir weisen hier noch keinen Wert zu. Danach berechnen wir den Bid Preis. Das übernimmt die Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart.   Wir nutzen SYMBOL_BID und mit NormalizeDouble und _Digits stellen wir sicher, dass die richtige Anzahl von Nachkommastellen für das jeweilige Währungspaar ermittelt werden. Als nächstes erstellen wir ein PriceArray für unsere Preisdaten und für die Definition unseres Average True Range Indikators nutzen wir die eingebaute Funktion iATR. Die benötigt einige Parameter. Der erste Parameter ist das aktuelle Währungspaar. Der zweite Parameter die auf diesem Währungspaar ausgewählte Zeiteinheit und wir möchten das Ergebnis anhand von 14 Kerzen berechnen. Mit der Funktion ArraySetAsSeries sortieren wir unser PriceArray jetzt von der aktuellen Kerze an abwärts. Und mit der Funktion CopyBuffer füllen wir unser PriceArray mit Daten. Anhand der Definition, die wir hier oben getroffen haben, möchten wir für Buffer 0, das ist die Signallinie, von der aktuellen Kerze 0 für drei Kerzen die Daten in unserem PriceArray speichern.   Jetzt können wir den aktuellen Average True Range Wert berechnen, in dem wir auf Kerze 0 in unserem PriceArray zugreifen und mit NormalizeDouble und fünf Nachkommastellen stellen wir sicher, dass die Darstellung so ist wie auch auf dem Chart zu sehen. Denn hier wird für den Indikator auch das Ergebnis mit fünf Nachkommastellen angezeigt. Wir benötigen auch eine statische Variable vom Typ double für den alten Wert. Und wenn der aktuelle Average True Range Wert kleiner ist als der alte Wert, dann haben wir ein Verkaufssignal und dann setzen wir unser Signal auf sell und wenn wir ein Verkaufssignal haben und die Anzahl der Positionen kleiner ist als 1, dann bedeutet das, wir haben keine offenen Positionen, aber ein Verkaufssignal und dann nutzen wir trade.Sell, um eine Testposition von 10 Microlot zu eröffnen. Das hier machen wir auf einem Demokonto, und zwar deshalb damit wir sehen können, ob unser Trailing Stop funktioniert, denn dazu benötigen wir eine geöffnete Position. Wir ermitteln den Wert für den Trailing Stop in dem wir hier eine benutzerdefinierte Funktion mit dem Namen CheckATRSellTrailingStop aufrufen und ihr den Parameter...

  In diesem Video wollen wir einmal herausfinden, wie man die Zeit für die Schließung von bereits abgeschlossenen Positionen ermitteln kann. Also lassen Sie uns einmal schauen, wie man so etwas mit MQL5 programmiert. Um das zu tun, klicken Sie bitte im Metatrader hier oben auf dieses kleine Symbol oder drücken Sie die F4 Taste. Das ruft dann hier den Metaeditor auf. Und hier klicken wir auf Datei, Neue Datei, Expert Advisor aus Vorlage, Weiter. Ich vergebe hier einmal den Namen SimplerOderCloseZeit, klicke auf Weiter, Weiter und Fertigstellen. Jetzt kann alles oberhalb der OnTick Funktion hier gelöscht werden. Und auch die zwei Kommentarzeilen werden entfernt. Wir starten damit, dass wir die Datei Trade.mqh importieren. Die ist Bestandteil von MQL5 und sie ermöglicht uns hier eine Instanz der Klasse CTrade zuz erstellen. Innerhalb der OnTick Funktion ermitteln wir zunächst den Ask Preis und den Bid Preis. Das übernimmt die Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart. Wir nutzen entweder SYMBOL_ASK oder SYMBOL_BID. Und mit NormalizeDouble und _Digits stellen wir sicher, dass die richtige Anzahl von Nachkommastellen berechnet wird. Im Anschluss möchten wir gerne prüfen, ob wir keine offenen Positionen haben. Das wäre der Fall, wenn PositionsTotal keiner ist als eins. Und wenn dem so ist, dann möchten wir hier Testpositionen eröffnen. Das würde man natürlich auf einem Echtgeldkonto nicht tun. Aber dafür sind Demo-Konten ja geeignet. Und wenn wir keine Positionen eröffnen, dann können wir natürlich auch kein Datum für die Zeit der Schließung ermitteln. Das möchten wir mit einer separaten Funktion erledigen. Die bekommt den Namen GetCloseTime, aber existiert noch nicht. Also müssen wir die jetzt programmieren. Unsere benutzerdefinierte Funktion hat keinen Rückgabewert. Darum nutzen wir hier void. Wir übergeben auch keine Parameter. Wir brauchen für die Berechnung einige Variablen. Ich habe diese hier auch in einem anderen Video verwendet. Eventuell benötigen Sie nicht alle davon. Für unsere Berechnung greifen wir hier auf die Order Historie zu. Und mit einer for-Schleife gehen wir alle Positionen durch. Danach möchten wir gerne mit Hilfe von HistoryDealGetTicket die Ticket Nummer der jeweiligen geschlossenen Position ermitteln, sofern diese größer ist null. Denn dann können wir uns einige Eigenschaften zur jeweiligen Position holen. Der Order Profit wird mit Hilfe der Funktion HistoryDealGetDouble für das aktuelle Ticket berechnet. Hier nutzen wir als Parameter DEAL_PROFIT. Für den Order Typ funktioniert das ganz ähnlich. Das machen wir mit HistoryDealGetInteger für die Ticket Nummer. Und hier nutzen wir DEAL_TYPE. Außerdem möchten wir gerne wissen, ob das Währungspaar zum Chart passt. Darum ermitteln wir hier mit HistoryDealGetString für die Ticket Nummer noch das aktuelle Symbol. Das geht mit DEAL_SYMBOL. Jeder Deal hat auch einen Entry Wert. Den ermitteln wir mit HistoryDealGetInteger für die Ticket Nummer und nutzen DEAL_ENTRY. Jetzt kommen wir zum interessanten Teil. Die DealTime ermitteln wir mit HistoryDealGetInteger für die Ticket Nummer und nutzen DEAL_TIME. Da das aber einen Integer Wert zurückliefert, der für Menschen schlecht zu lesen ist, konvertieren wir das Ganze mit TimeToString in ein lesbares Format für die DealTime. Dazu nutzen wir hier TIME_DATE und TIME_SECONDS. Weiter geht es mit der Überprüfung, ob unsere Position auch zum aktuellen Währungspaar auf dem Chart passt. Außerdem möchten wir noch wissen, ob der OrderType entweder ORDER_TYPE_BUY oder ORDER_TYPE_SELL ist. Denn, es gibt auch sogenannte Pending Orders, also noch nicht ausgeführte Order Typen.

  In diesem Video wollen wir uns einmal anschauen, wie man einen Expert Advisor erstellen kann der in der Lage ist, bei einem RSI-Wert von über 70 eine Verkaufsposition zu eröffnen, die dann beim unterschreiten eines Wertes von 30 wieder geschlossen wird. Um das zu tun, klicken Sie im MetaTrader bitte hier oben auf dieses kleine Symbol oder drücken sie die F4-Taste. Das ruft dann hier den Metaeditor auf und hier klicken auf Datei, neue Datei, Expert Advisor aus Vorlage, weiter. Ich vergebe hier einmal den Namen SimplerRSISellStop, klicke auf weiter, weiter und fertigstellen. Jetzt kann alles oberhalb dieser OnTick-Funktion hier gelöscht werden und auch die zwei Kommentarzeilen werden entfernt. Wir starten mit einem include-Statement. Damit importieren wir diese Datei. Trade.mqh ist ein Bestandteil von MQL5 und das ermöglicht es uns eine Instanz der Klasse C-Trade zu erstellen. Die heißt trade und wir werden sie gleich nutzen, um eine Position zu eröffnen. Innerhalb der OnTick-Funktion berechnen wir zunächst den Ask-Preis und den Bid-Preis. Das übernimmt die Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart. Wir nutzen entweder SYMBOL_ASK oder SYMBOL_BID und mit NormalizeDouble und _Digits stellen wir sicher, dass wir die richtige Anzahl von Nachkommastellen für das jeweilige Währungspaar automatisch berechnen. Im nächsten Schritt erstellen wir uns ein Array. Das wird dann im Anschluss mit Hilfe der Funktion ArraySetAsSeries von der aktuellen Kerze an abwärts sortiert. Und mit Hilfe, der in MQL5 enthaltenen Funktion iRSI können wir jetzt für das aktuelle Währungspaar auf dem Chart und die dort eingestellte Zeiteinheit für 14 Kerzen den Wert ermitteln, und zwar anhand der Schlusspreise. Mit Hilfe von CopyBuffer füllen wir jetzt unser RSIArray mit Daten für den Buffer 0. Angefangen von der aktuellen Kerze 0. Für drei Kerzen möchten wir die Daten anhand der Definition, die wir hier oben getroffen haben, in unserem Array speichern. Und jetzt können wir den Wert ermitteln, in dem wir uns einfach den Wert für Kerze 0 in unserem RSIArray holen und dieser Variable hier zuweisen. Denn diesen Wert brauchen wir jetzt, um zu überprüfen, ob PositionTotal 0 ist, das bedeutet, wir hätten keine geöffnete Position und ob der RSI-Wert größer ist als 70. Wenn beide Bedingungen erfüllt sind, dann nutzen wir trade.Sell, um eine Position für 10 Microlot zu eröffnen. Das ist eine Verkaufsposition. Und natürlich machen wir das nur auf einem Demokonto. Denn um unseren Stop zu testen, brauche wir ja eine geöffnete Position. Diese Funktion hier CheckRSISellStop die soll dann die Verkaufsposition wieder schließen. Wir übergeben hier den RSI-Wert. Zum Schluss unserer Hauptfunktion möchten wir noch einen Comment-Statement dazu nutzen, damit der RSI-Wert auch auf unserem Chart ausgegeben wird. Und das war´s soweit mit der OnTick-Funktion. Diese Funktion hier gibt es aber noch nicht. Die müssen wir jetzt erstellen. Unsere benutzerdefinierte Funktion soll den Namen CheckRSISellStop haben. Wir übergeben hier den RSI-Wert als Parameter. Mit Hilfe einer Vorschleife gehen wir alle offenen Positionen durch. Dann holen wir uns mittels der Funktion PositionGetSymbol für den aktuellen Schleifenzählerwert das Währungspaar für die Position. Außerdem brauchen wir noch die Ticketnummer. Die bekommen wir mit PositionGetInteger, POSITION_TICKET und den Positionstyp bekommen wir mit PositionGetInteger, POSITION_TYPE. Das ermöglicht uns zu prüfen, ob der Positionstyp den Wert POSITION_TYPE_SELL hat. Wenn das der Fall ist, dann handelt es sich um eine Verkaufsposition. In dem Fall prüfen wir hier noch,

  In diesem Video wollen wir uns einmal anschauen, wie man einen RSI Indikator erstellt, der eine Position eröffnet, wenn der Wert unter dreißig liegt und diese Position wieder schließen, sobald der Wert über siebzig steigt. Also lassen Sie uns einmal schauen, wie man so etwas mit MQL5 programmieren kann. Um das zu tun, klicken Sie bitte im Metatrader hier oben auf dieses kleine Symbol oder drücken Sie die F4 Taste. Das ruft dann hier den Meta Editor auf. Und hier klicken wir auf Datei, Neue Datei, Expert Advisor aus Vorlage, Weiter. Ich vergebe hier einmal den Namen SimplerRSIBuyStop, klicke auf Weiter, Weiter und Fertigstellen. Jetzt kann alles oberhalb der OnTick Funktion gelöscht werden. Und wir entfernen auch die zwei Kommentarzeilen. Wir starten mit einer include Anweisung. Die wird uns die Datei Trade.mqh importieren. Die stellt uns dann wiederum die Klasse CTrade zur Verfügung, von der wir hier eine Instanz erstellen. Die bekommt den Namen trade. Innerhalb der OnTick Funktion nutzen wir SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart, um uns den Ask Preis oder den Bid Preis zu ermitteln. Dazu übergeben wir als Parameter SYMBOL_ASK beziehungsweise SYMBOL_BID. Und mit NormalizeDouble und _Digits stellen wir sicher, dass wir automatisch die richtige Anzahl der Nachkommastellen für das jeweilige Währungspaar berechnen.   Im Anschluss erstellen wir uns hier ein Array vom Typ double. Mit ArraySetAsSeries wird unser Array dann von der aktuellen Kerze an abwärts sortiert. Und jetzt können wir die in MQL5 eingebaute Funktion iRSI nutzen, um für das aktuelle Währungspaar auf dem Chart und die auf dem Chart ausgewählte Zeiteinheit für 14 Kerzen den Wert anhand der Schlusskurse zu ermitteln. Wir nutzen CopyBuffer, um anhand der Definition die wir gerade getroffen haben für das aktuelle Buffer null, angefangen von der aktuellen Kerze Nummer null, für drei Kerzen die Daten in unser RSI Array zu kopieren. Und jetzt berechnen wir den aktuellen Wert, indem wir einfach den Wert für Kerze null aus unserem RSI Array ermitteln. Mit NormalizeDouble und zwei stellen wir sicher, dass der Wert auf zwei Nachkommastellen gekürzt wird. Denn so wird er auch von unserem Indikator auf dem Chart angezeigt. Sofern wir keine geöffnete Position haben, ist der Rückgabewert für PositionsTotal null. Und wir möchten gleichzeitig ermitteln, ob der RSI Wert unter dreißig liegt. Das wäre dann für uns ein Kaufsignal. Und dann nutzen wir trade.Buy, um eine Kaufposition für zehn Mikrolot zu eröffnen. Es handelt sich hier um eine Testposition. Und die möchten wir danach über eine selbsterstellte Funktion mit dem Namen CheckRSIBuyStop schließen. Dazu übergeben wir hier den aktuellen RSI Wert als Parameter.   Damit wir auch was sehen nutzen wir die Comment Ausgabe, um auf dem Chart den aktuellen RSI Wert auszugeben. Diese Klammer hier schließt unsere Hauptfunktion. Aber damit wir diese Funktion hier auch nutzen können, müssen wir die jetzt noch programmieren. Unsere benutzerdefinierte Funktion soll den Namen CheckRSIBuyStop erhalten. Und wir übergeben hier den aktuellen RSI Wert. Mit Hilfe einer For-Schleife gehen wir alle offenen Positionen durch und holen uns für jede Position das aktuelle Währungspaar. Das geht mit der Funktion PositionsGetSymbol für den aktuellen Schleifenzähler. Außerdem ermitteln wir das Ticket der jeweiligen Position mit dem Befehl PositionGetInteger. Hier verwenden wir als Parameter POSITION_TICKET. Bitte alles in Großbuchstaben. Für den Positionstypen erfolgt die Ermittlung ähnlich. Auch hier nutzen wir PositionGetInteger und diesmal ist der Parameter POSITION_TYPE. Denn damit können wir prüfen,

  In diesem Video wollen wir uns einmal anschauen, wie man einen Expert Advisor erstellen kann, der in der Lage ist, die Richtung der letzten geschlossenen Position zu ermitteln. Also lassen Sie uns einmal schauen, wie man so etwas mit MQL5 programmieren kann. Ich hoffe, dass ich dieses Video aufnehmen kann, bevor der Baulärm wieder losgeht. Um zu starten, klicken Sie bitte im Metatrader auf dieses kleine Symbol hier oben oder drücken Sie die F4-Taste. Das ruft dann hier den Metaeditor auf und hier klicken wir auf Datei, Neue Datei, Expert Advisor aus Vorlage, weiter. Ich vergebe hier mal den Namen SimplerLastOrderTyp, klicke auf weiter, weiter und fertigstellen. Jetzt kann alles oberhalb der OnTick-Funktion hier gelöscht werden und auch die zwei Kommentarzeilen werden entfernt. Wir starten hier oben mit einer include-Anweisung für die Datei trade.mqh. Die enthält die Klasse CTrade von der wir uns hier eine Instanz mit dem Namen trade erstellen. In der OnTick-Funktion berechnen wir zunächst den Ask-Preis. Das übernimmt die Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart.   Wir nutzen SYMBOL_ASK und mit NormalizeDouble und _Digits stellen wir sicher, dass wir die richtige Anzahl von Nachkommastellen für das jeweilige Währungspaar ermitteln. Das wiederholen wir dann nochmal für den Bid-Preis. Diesmal nutzen wir SYMBOL_BID. Natürlich brauchen wir zur Ermittlung einer Positionsrichtung auch Positionen, also machen wir hier eine Position auf. Jeweils trade.Buy für einen Buy-Trade und trade.Sell für einen Sell-Trade. Natürlich würden man das hier nicht auf einem Echtgeldkonto machen, aber dafür sind Demokonten ja da. Zur Ermittlung der letzten Position möchten wir eine Funktion aufrufen. Die hat den Namen GetLastOrderType, existiert aber momentan noch nicht, denn die müssen wir gleich noch programmieren. Und das Ergebnis lassen wir uns dann mit einem Comment-Befehl auf dem Chart ausgeben. Dort wird dann stehen „Meine letzte Position war: “ und die ermittelte Positionsrichtung. Kommen wir jetzt aber zum interessanten Teil und das ist diese Funktion hier. Unsere selbsterstellte Funktion soll einen string, also eine Textkette zurückgeben und den Namen GetLastOrderType haben. Wir benötigen hier einige Variablen zur Ermittlung der Positionsdetails. Mit HistorySelect suchen wir uns jetzt einen Bereich heraus, den wir ermitteln möchten. Wir starten am Anfang bis zur aktuellen Zeit. Danach gehen wir mit Hilfe einer Vorschleife alle Deals durch. Innerhalb der Schleife ermitteln wir zunächst die Ticketnummer. Das geht mit HistoryDealGetTicket für den aktuellen Schleifenzähler. Gleichzeitig prüfen wir hier, ob diese Nummer größer ist als 0.   Wenn das der Fall ist, ermitteln wir den OrderProfit. Das übernimmt die Funktion HistoryDealGetDouble für die aktuelle Ticketnummer und als Parameter nutzen wir hier DEAL_PROFIT. Des Weiteren benötigen wir den Order-Typen. Der wird ermittelt mit Hilfe von HistoryDealGetInteger für die Ticketnummer und hier nutzen wir als Parameter DEAL_TYPE. Weiter geht es mit dem Währungspaar. Das bekommen wir über HistoryDealGetString für die aktuelle Ticketnummer und diesmal nutzen wir DEAL_SYMBOL. Außerdem brauchen wir den Typ für die Schließung. Den bekommen wir mit HistoryDealGetInteger für die Ticketnummer und diesmal nutzen wir DEAL_ENTRY. Jetzt prüfen wir noch, ob das Währungspaar zu unserem Währungspaar auf dem Chart passt und wir möchten noch wissen, ob der DealEntry den Wert 1 entspricht. Das ist nämlich der Fall, wenn eine Position geschlossen wurde. Wenn das der Fall war und die Schließung den Order-Typ ORDER_TYPE_BUY hatte, dann handelt es sich bei der ursprünglichen Position um einen Sell-Trade. War der Typ bei der Schließung aber ORDER_TYPE_SELL, dann wurde eine Buy-Position geschlossen. Jetzt weisen wir unserem Resultat hier noch die Ergebnisse für den OrderProfit, die Ticketnummer und die Richtung der Position zu.   Danach schließen wir unsere ganzen Schleifen und schlussendl...

  In diesem Video wollen wir uns einmal anschauen, wie man einen Sell Trailing Stop für diesen Indikator hier programmieren kann. Es handelt sich um den Envelopes-Indikator. Also lassen Sie einmal schauen, wie man so etwas mit MQL5 programmieren kann. Um das zu tun, klicken Sie bitte im Metatrader hier oben auf dieses kleine Symbol oder drücken Sie die F4-Taste. Das ruft dann hier den Metaeditor auf und hier klicken wir auf Datei, Neue Datei, Expert Advisor aus Vorlage, weiter. Ich vergebe hier einmal den Namen SimplerEnvelopesSellTrailingStop, klicke auf weiter, weiter und fertigstellen. Jetzt kann alles oberhalb der OnTick-Funktion gelöscht werden und auch die zwei Kommentarzeilen werden entfernt.   Wir starten hier mit einem include-Befehl für die Datei trade.mqh. Die ist Bestandteil von MQL5 und wir können darin von der Klasse CTrade eine Instanz mit dem Namen trade erstellen. Diese Instanz werden wir später nutzen, um eine Testposition zu eröffnen. Innerhalb der OnTick-Funktion starten wir damit, dass wir uns eine statische Variable vom Typ double erstellen. Die soll uns den letzten Stop Loss-Wert wieder zur Verfügung stellen, wenn die Funktion das nächste Mal aufgerufen wird. Danach berechnen wir den Ask Preis und Bid Preis. Das geht mit der Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart. Wir nutzen entweder SYMBOL_ASK oder SYMBOL_BID und mit NormalizeDouble und _Digits stellen wir sicher, dass jeweils die richtige Anzahl von Nachkommastellen hinter den Komma berechnet wird. Damit wir eine Trailing Stop auch anpassen können brauchen wir auch eine Position. Wir prüfen also im nächsten Schritt ob PositionsTotal uns einen Wert von kleiner 1 liefert. Wenn das der Fall ist, dann setzten wir hier unseren letzten Wert für den Stop Loss auf 0.   Danach eröffnen wir eine Testposition mit trade.Sell. Die Position soll 10 Microlot groß sein. Natürlich würden man diesen Schritt auf einem Echtgeldkonto überspringen, aber dafür sind Demokonto ja da. Weiter geht es. Wir benötigen jetzt jeweils ein Array für das obere und für das untere Band des Indikators. Danach nutzen wir ArraySetAsSeries, um das Array für das obere und für das untere Band von der aktuellen Kerze an abwärts zu sortieren und jetzt können wir die in MQL5 enthaltene Funktion iEnvelopes nutzen, um für das aktuelle Währungspaar und die auf dem Chat aktuell ausgewählte Zeiteinheit für 14 Kerzen den Wert des Indikators zu berechnen. Wir nutzen hier keinen Verschiebungswert. Dieser Parameter hier, MODE_SMA, steht für Simple Moving Average. Die Ergebnisse sollen anhand der Schlusskurse berechnet werden.   Und dieser Wert 0.100 den sieht man auch, wenn man auf einem leeren Chartfenster einmal auf Einfügen, Indikatoren, Tendenz, Envelopes klickt. Da ist der Wert. Es handelt sich um den Abweichungswert oder auf Englisch Deviation-Wert. Bitte übernehmen Sie hier alle grundlegenden Einstellungen, klicken auf OK. Jetzt erscheint der Indikator auf dem Chart und jetzt klicken wir mit der rechten Maustaste, wählen Vorlagen, Vorlage speichern und speichern das Ganze unter den Namen tester.tpl. Den alten Wert können Sie hier ersetzen. Tester.tpl ist die Schablone, die angezeigt wird, wenn wir einen Strategietest starten, aber zurück zum Programm. Mit CopyBuffer können wir uns jetzt anhand der Envelopes-Definition, die wir hier oben getroffen haben, entweder für Buffer 0 oder Buffer 1, das steht für das jeweilige Band, von der aktuellen Kerze 0 für drei Kerzen die Daten ins obere bzw. untere Band-Array kopieren. Das ermöglicht uns dann die Werte für die aktuelle Kerze zu ermitteln. Das hab ich hier aber mal auskommentiert, denn in diesem Fall interessiert uns eher die Kerze davor.   Das ist Kerze 1 und den Wert dafür erhalten wir, indem wir auf Kerze 1 im jeweiligen Array zugreifen. Ich hab hier noch NormalizeDouble und die Sechs genutzt, um die Wert auf sechs Nachkommastellen zu kürzen. Das ist nämlich auch das was wir angezeigt bekommen,

Leute, Ted Bundy. Einfach f*cking Ted Bundy ist von irgendwelchen Hipster Gen-Z Alternativo Spinnern ein Crush. Check ich nicht, werde ich nicht checken und werde ich auch nicht versuchen zu verstehen. Bevor ich das verstehe, lerne ich alle Nachkommastellen von π auswendig. Liebe, immer! Winston

Schweizer Forscher haben nach eigenen Angaben die mathematische Kreiszahl Pi so genau wie noch nie berechnet. Wie die Fachhochschule Graubünden mitteilte, legten sie mit 62,8 Billionen Stellen hinter dem Koma die bislang exakteste Berechnung vor. Sie übertrafen damit den bestehenden Rekord um 12,8 Billionen Stellen.

  In diesem Video wollen wir einmal anhand dieses Indikators hier einen Buy Trailing Stop programmieren. Der vom Envelopes-Indikator gesteuert wird. Also lassen Sie uns einmal schauen, wie man so etwas mit MQL5 programmieren kann. Um das zu tun, klicken Sie bitte hier oben auf dieses kleine Symbol oder drücken Sie die F4-Taste im Metatrader. Das ruft dann hier den Metaeditor auf und hier klicken wir auf Datei, neue Datei, Expert Advisor aus Vorlage, weiter. Ich vergebe hier einmal den Namen SimplerEnvelopesBuyTrailingStop, klicke auf weiter, weiter und fertigstellen. Jetzt kann alles oberhalb der OnTick-Funktion hier gelöscht werden und auch die zwei Kommentarzeilen werden entfernt. Wir starten hier mit einem include-Befehl.   Der wird uns die Datei trade.mph importieren. Die ermöglicht es uns von der Klasse C-Trade eine Instanz mit dem Namen trade zu erstellen und die werden wir gleich nutzen, um eine Testposition zu eröffnen. In der OnTick-Funktion starten wir mit einer statischen Variable vom Typ double. Die soll den Wert für den letzten Stop-Loss speichern. Danach ermitteln wir den Ask-Preis und den Bid-Preis. Das geht über die Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart. Wir nutzen entweder SYMBOL_ASK oder SYMBOL_BID und mit NormalizeDouble und _Digits ermitteln wir automatisch wie viele Nachkommastellen das jeweilige Währungspaar hat. Damit wir einen Stop-Loss testen können müssen wir eine Testposition eröffnen.   Das macht man natürlich nur auf einem Demokonto und immer, wenn PositionsTotal uns einen Rückgabewert von kleiner 1 zurückgibt, dann bedeutet das, dass wir keine geöffnete Position haben. Und dann eröffnen wir hier mit trade.Buy eine Testposition über 10 Microlot. Direkt im Anschluss setzen wir den letzten Stop-Loss-Wert zurück, denn mit einer neuen Position muss der Stop-Loss natürlich auch neu berechnet werden. Für unseren Envelopes-Indikator brauchen wir zwei Arrays. Die erstellen wir hier und im Anschluss nutzen wir ArraySetAsSeries, um diese beiden Arrays von der aktuellen Kerze an abwärts zu sortieren. Danach nutzen wir die in MQL5 eingebaute Funktion iEnvelopes für das aktuelle Währungspaar auf dem Chart und die auf dem Chart ausgewählte Zeiteinheit, um den Indikatorwert für 14 Kerzen zu berechnen. Den Verschiebungswert setzen wir auf 0.   Wir nutzen MODE_SMA für Simple Moving Average. Das Ergebnis soll anhand der Schlusskurse berechnet werden und dieser letzte Parameter hier ist der sogenannte Diviation-Wert. Wenn Sie einmal ein leeres Chart öffnen und auf Einfügen, Indikatoren, Tendenz, Envelopes klicken, dann sehen Sie auch hier diesen Wert als Abweichung von 0.100. Wir übernehmen hier mal die Standardwerte, klicken auf OK, klicken mit der rechten Maustaste in das Chart, speichern diese Vorlage unter dem Namen tester.tpl, denn das ist die Vorlage, die wir gleich im Strategietester sehen werden. Den alten Wert können Sie hier getrost ersetzen. Weiter geht´s im Metaeditor mit dem Befehl CopyBuffer. Der wird uns anhand der Envelopes-Definition, die wir hier oben getroffen haben, die Daten für Buffer 0 und für Buffer 1 in das obere beziehungsweise in das untere Band kopieren. Wir starten jeweils mit Kerze 0 und kopieren uns Preisdaten für drei Kerzen. Um den aktuellen Wert zu berechnen, brauchen wir nur in Kerze  des jeweiligen Arrays hineinzuschauen. Mit NormalizeDouble und ,6 kürze ich das Ganze hier auf sechs Nachkommastellen.   Uns interessiert in diesem Fall eher die Kerze davor. Die Werte lassen sich ähnlich ermitteln. Hier schauen wir einfach auf den Wert von Kerze 1 und natürlich müssen wir auch den Namen der Variablen entsprechend anpassen. Weiter geht´s mit den Prüfkonditionen, denn wir möchten gerne wissen, ob der letzte Wert für das untere Band kleiner ist als der Bid-Preis. Als nächstes überprüfen wir, ob der Wert für das letzte untere Band größer ist als der Wert für unseren letzten Stop-Loss und wenn beide Bedingungen zutreffen,

  In diesem Video wollen wir uns einmal anschauen, wie man einen Expert Advisor erstellen kann, der in der Lage ist, anhand von Preisdaten auf einem Line-Chart zu handeln. Also lassen Sie uns einmal schauen, wie man so etwas mit MQL5 programmieren kann. Um das zu tun, klicken Sie im Metatrader bitte auf dieses kleine Symbol hier oben oder drücken Sie die F4-Taste. Das ruft dann hier den Metaeditor auf und hier klicken wir auf Datei, neue Datei, Expert Advisor aus Vorlage, weiter. Ich vergebe hier einmal den Namen SimplerShiftedPriceEA, klicke auf weiter, weiter und fertigstellen. Jetzt kann hier alles oberhalb der OnTick-Funktion gelöscht werden und auch die zwei Kommentarzeilen werden entfernt. Wir starten mit einem include-Befehl für die Datei trade.mqh.   Die ist Teil von MQL5 und stellt vereinfachte Handelsfunktionen zur Verfügung. Um diese Funktionen nutzen zu können erstellen wir uns hier eine Instanz von der Klasse CTrade. Die bekommt den Namen trade. Innerhalb der OnTick-Funktion berechnen wir uns jetzt den Ask-Preis und den Bid-Preis. Das geht mit der Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart. SYMBOL_ASK oder SYMBOL_BID liefert uns den jeweiligen Preis und mit NormalizeDouble und _Digits stellen wir sicher, dass die richtige Anzahl von Nachkommastellen für das jeweilige Währungspaar auch berechnet wird. Außerdem brauchen wir noch eine Variable für unser Signal. Hier weisen wir aber noch keinen Wert zu, denn den möchten wir gleich noch ermitteln. Mit der Funktion MqlRates erstellen wir uns jetzt ein Preis-Array für Preisinformationen.   Das wird mit der Funktion ArraySetAsSeries im Anschluss von der aktuellen Kerze an abwärts sortiert und mit CopyRates füllen wir unser Array für das aktuelle Währungspaar auf dem Chart und die aktuell ausgewählte Zeiteinheit, von der aktuellen Kerze 0, für drei Kerzen mit Daten, die wir hier im PriceInformation-Array speichern. Wir brauchen aber noch ein zweites Array und zwar für unseren MovingAverage. Und hier nutzen wir die Funktion iMA. Für das aktuelle Währungspaar auf dem Chart und die auf dem Chart ausgewählte Zeiteinheit möchte ich gerne einen SimpleMovingAverage für eine Kerze berechnen und die Ausgabe soll 20 Kerzen in die Zukunft verschoben werden. Wir nutzen MODE_SMA, das steht für SimpleMovingAverage und die Ergebnisse sollen anhand der Schlusskurse berechnet werden. Auch in diesem Fall nutzen wir ArraySetAsSeries, um unser Array von der aktuellen Kerze an abwärts zu sortieren. Mit CopyBuffer können wir jetzt unser Array mit Daten füllen.   Anhand der Definition, die wir hier oben getroffen haben, kopieren wir uns für Buffer 0, von der aktuellen Kerze 0, für drei Kerzen, die Daten und speichern sie uns in unserem Array. Und jetzt sind wir in der Lage, den aktuellen Wert für unser Array zu ermitteln. Dazu greifen wir einfach auf Kerze 0 in unserem MovingAverageArray zu und wenn der Wert den wir da ermitteln haben unter dem aktuellen Schlusskurs für Kerze 0 in unserem Preisinformations-Array liegt, dann ist das für uns ein Buy-Signal und dann weisen wir den Begriff Buy unserer Signalvariable zu. Andernfalls, wenn der aktuelle MovingAverage-Wert größer ist als der Schlusskurs für Kerze 0 in unserem Preisinformations-Array, dann wäre das ein Verkaufen-Signal und dann weisen wir den Begriff Sell unsere Signalvariable zu. Und wenn unser Signal auf Verkaufen steht und uns der Rückgabewert für PositionsTotal einen Wert kleiner 1 liefert, dann haben wir keine geöffneten Positionen, aber ein Sell-Signal. Und jetzt nutzen wir trade.Sell, um 10 Microlot zu verkaufen. Umgekehrt, wenn unser Signal auf Kaufen steht und wir ebenfalls keine geöffneten Positionen haben, dann nutzen wir hier trade.Buy, um 10 Microlot zu kaufen.   Zum Schluss gönnen wir uns noch mit dem Comment-Befehl eine Chartausgabe. Die wird uns den Text „Das aktuelle Signal ist jetzt:“ gefolgt von dem ermittelten Signal ausgeben. Das war´s soweit.

  In diesem Video wollen wir uns einmal anschauen, wie man einen Expert Advisor programmieren kann, der Verkaufspositionen bei einem bestimmten, vom Benutzer definierten Wert, schließt. Also lassen Sie uns einmal schauen, wie man so etwas mit MQL programmiert.   Um das zu tun, klicken Sie bitte im Metatrader hier oben auf dieses kleine Symbol oder drücken Sie die F4-Taste. Das öffnet dann hier den Metaeditor und hier klicken wir auf Datei, Neue Datei, Expert Advisor aus Vorlage, weiter. Ich vergebe hier mal den Namen SimplesSellPercentageRisiko, klicke auf weiter, weiter und fertigstellen. Jetzt kann hier alles oberhalb der OnTick-Funktion gelöscht werden und auch die zwei Kommentarzeilen werden entfernt. Wir starten hier mit einem include-Befehl. Die in MQL5 enthaltene Datei trade.mqh ermöglicht es uns vereinfachte Trading-Funktionen zu nutzen. Dazu erstellen wir uns zunächst einmal eine Instanz von der Klasse C-Trade. Die bekommt den Namen trade und wir werden sie später verwenden, um Testpositionen zu eröffnen. Außerdem hätte ich gerne eine input-Variable. Wenn man diesen input-Begriff einmal mit der Maus markiert und die F1-Taste drückt, dann sieht man, dass es sich um eine sogenannte Eingabevariable handelt.   Die können dann vom Benutzer im Fenster für die Eigenschaften des Expert Advisor geändert werden ohne dass man neu kompilieren muss. Die Variable ist vom Typ double, damit sie auch Nachkommastellen verarbeiten kann, und der Startwert sind 0,5 Prozent. Außerdem benötigen wir eine weitere Variable für den maximalen Verlust, den wir akzeptieren werden. Auch die ist vom Typ double. Innerhalb der OnTick-Funktion starten wir damit, dass wir den Bid-Preis berechnen. Das geht mit der Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart. Wir nutzen hier SYMBOL_BID, da wir den Bid-Preis benötigen. Und mit NormalizeDouble und _Digits stellen wir sicher, dass wir die richtige Anzahl von Nachkommastellen für das jeweilige Währungspaar automatisch berechnen. Jetzt holen wir uns noch die Account Balance. Das geht mit Hilfe der Funktion AccountInfoDouble. Als Parameter übergeben wir hier ACCOUNT_BALANCE. Wenn Sie das markieren und die F1-Taste drücken, dann werden Sie feststellen, dass man sich noch sehr viele andere Eigenschaften vom Konto anzeigen lassen kann. Uns interessiert hier aber nur das Bruttoguthaben.   Und damit wir eine Position schließen können, müsse wir Testpositionen eröffnen. Dazu prüfen wir, ob PositionsTotal einen Wert kleiner eins zurückliefert. Das würde bedeuten, wir haben keine geöffnete Position. Und dann nutzen wir hier trade.Sell, um eine Testposition für zehn Microlot zu eröffnen. Natürlich würden wir das nicht auf einem Echtgeldkonto machen, aber dafür sind Demokonten ja gut und ohne Positionseröffnung können wir auch nichts schließen. Auf dem Echtgeldkonto könnten Sie aber mehrere Positionen haben, darum gehen wir mit einer Vorschleife alle diese Positionen durch. Mit Hilfe von PositionGetTicket für den aktuellen Schleifenzähler ermitteln wir die Ticketnummer für die aktuelle Position. Den Profit kann man ermitteln, indem man PositionGetDouble nutzt. Hier übergeben wir POSITION_PROFIT. Auch da gibt es diverse Informationen, die man sich so ermitteln lassen kann. Wenn Sie es richtig machen wollen, dann müssen Sie den SWAP, also die Zinsen für das Halten von Positionen über Nacht auch mit im Profit ermitteln, aber für dieses einfache Beispiel soll uns das hier so reichen. Weiter geht's mit der Berechnung für den maximalen Verlust, den wir erlauben möchten. Und um das zu berechnen, nehmen wir die Balance, also das Bruttoguthaben, teilen es durch 100, dann haben wir ein Prozent vom Bruttoguthaben. Dieses Prozent können wir dann mit dem benutzerdefinierten Wert multiplizieren, den der Expert Advisor vom Benutzer übergeben bekommt. Und falls Sie sich über diesen Teil hier wundern, damit kehren wir das Ganze ins Negative um, denn ein maximaler Positionsverlust ist ein negativer Wert.

  In diesem Video wollen wir uns einmal anschauen, wie man einen Expert Advisor programmieren kann, der in der Lage ist, aufgrund von prozentuellen Verlustwerten Positionen zu schließen. Also lassen Sie uns einmal schauen, wie man so etwas in MQL5 programmieren kann. Um das zu tun, klicken Sie bitte im Metatrader hier oben auf dieses kleine Symbol oder drücken Sie die F4-Taste. Das ruft dann hier den Metaeditor auf und hier klicken wir auf Datei, Neue Datei, Expert Advisor aus Vorlage, weiter. Ich vergebe hier mal den Namen SimplesBuyPercentageRisiko, klicke auf weiter, weiter und fertigstellen. Jetzt kann hier alles oberhalb der OnTick-Funktion gelöscht werden und auch die zwei Kommentarzeilen werden entfernt.   Wir starten mit einem include-Befehl für die Datei trade.mqh. Die enthält die Klasse CTrade von der wir uns hier eine Instanz erstellen. Außerdem benötigen wir noch eine input-Variable vom Typ double für den Risikoprozentwert. Dieser Zusatz input wird es ermöglich, dass das der Benutzer ohne Neukompilierung verändern kann. Und wir brauchen noch eine Variable vom Typ double für den maximalen Positionsverlust, den wir erlauben. Innerhalb der OnTick-Funktion starten wir damit, dass wir zunächst den Ask-Preis berechnen. Das übernimmt die Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart und wir nutzen hier SYMBOL_ASK mit Hilfe von NormalizeDouble und _Digits stellen wir sicher, dass wir die richtige Anzahl von Nachkommastellen für das jeweilige Währungspaar automatisch berechnen. Im nächsten Schritt berechnen wir hier die Balance, also das Bruttoguthaben. Das übernimmt die Funktion AccountInfoDouble und hier übergeben wir als Parameter ACCOUNT_BALANCE.   Damit wir auch prüfen können, ob unser Expert Advisor funktioniert benötigen wir eine Testposition. Das macht man natürlich nur auf einem Demokonto. Falls wir also keine offene Position haben, dann nutzen wir hier trade.Buy um eine Testposition für zehn Microlot zu eröffnen. Es handelt sich hier um eine buy, also eine Kauf-Position. Kommen wir zum eigentlichen interessanten Teil. Wir gehen hier mit einer Vorschleife alle offenen Positionen durch. Für jede dieser gefundenen Positionen benutzen wir PositionGetTicket für den aktuellen Schleifenzähler, um die Ticketnummer für unsere Position zu ermitteln. Danach ermitteln wir mit PositionGetDouble den Profit der Position. Wenn man das einmal markiert und die F1-Taste drückt, dann sieht man, dass der Profit nicht den SWAP, also die Gebühren für das Halten einer Position über Nacht enthält. Falls sie längerfristig Positionen halten, sollten Sie das auch berücksichtigen. Für unser einfaches Beispiel soll das aber so reichen.   Jetzt berechnen wir den maximalen Positionsverlust. Wir nehmen unser Bruttoguthaben, also die Balance und teilen es durch 100. Das multiplizieren wir dann mit dem Wert den der Benutzer als Risiko eingegeben hat. Und falls Sie sich hier vorne über den Teil wundern, wir müssen das Ganze als negativen Wert berechnen, denn ein Verlust ist negativ. Danach baue ich hier noch zwei Print-Ausgaben ein. Die werden uns im Journal den Positionsprofit und den Wert für den maximalen Positionsverlust angeben. Denn immer, wenn der Positionsprofit niedriger ist als das was wir als maximalen Positionsverlust erlauben, dann nutzen wir trade.PositionClose, um unser jeweiliges Ticket zu schließen. Bitte vergessen Sie nicht die schließende Klammer hier für den Vorloop einzusetzen. Und zum Schluss gönnen wir uns noch eine Comment-Ausgabe. Die wird uns auf dem Chart den Wert für die Balance, den maximalen Positionsverlust und den prozentualen Risikowert ausgeben.   Das wars auch schon so weit. Wenn Ihnen das hier zu schnell ging oder wenn Sie keine Ahnung haben, was alle diese Codezeilen hier bedeuten, dann möchten Sie sich vielleicht zunächst eines der Grundlagenvideos noch einmal anschauen. Vielleicht ist aber auch der Premiumkurs interessant für Sie. Den finden Sie auf unserer Webseite.

  In diesem Video wollen wir uns einmal anschauen, wie man für diesen Standard Deviation Indikator einen Expert Advisor erstellt, der in der Lage ist, anhand der letzten 200 Kerzen die Höchste und Niedrigste zu ermitteln. Also lassen Sie uns einmal schauen, wie man so etwas mit MQL5 programmieren kann. Um das zu tun, klicken Sie bitte im Metatrader hier oben auf dieses kleine Symbol oder drücken Sie die F4-Taste.   Das ruft dann hier den Metaeditor auf und hier klicken wir auf Datei, neue Datei, Expert Advisor aus Vorlage, weiter. Ich vergebe hier mal den Namen SimplerStandardDeviationEA, klicke auf weiter, weiter und fertigstellen. Jetzt kann hier alles oberhalb dieser OnTick-Funktion gelöscht werden und auch die zwei Kommentarzeilen werden entfernt. Wir starten mit einem include-Befehl. Damit können wir uns die Inhalte der Datei trade.mqh zu Nutze machen.   Die enthält auch die Klasse CTrade von der wir uns hier eine Instanz mit dem Namen trade erstellen. Die werden wir später nutzen, um Positionen zu eröffnen. Innerhalb der OnTick-Funktion starten wir damit, dass wir uns zunächst eine signal-Variable erstellen. Der weisen wir hier aber noch keinen Wert zu, denn den möchten wir gleich noch ermitteln. Dazu berechnen wir uns zunächst einmal den ask-Preis und den bid-Preis. Das übernimmt die Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart.   Wir nutzen entweder SYMBOL_ASK oder SYMBOL_BID und mit der Funktion NormalizeDouble und _Digits stellen wir sicher, dass wir die richtige Anzahl von Nachkommastellen berechnen. Je nach Währungspaar kann das dreistellig oder fünfstellig sein. Jetzt brauchen wir auch noch ein Array für unsere Preisdaten.   Das ist vom Typ double damit es auch Nachkommastellen aufnehmen kann und mit Hilfe der Funktion ArraySetAsSeries sortieren wir jetzt die Daten von der aktuellen Kerze an abwärts. Um unsere Werte zu ermitteln steht uns die Funktion iStdDev zur Verfügung. Die ist Bestandteil von MQL5 und benötigt einige Parameter. Und das sind das aktuelle Währungspaar auf dem Chart und die auf dem Chart eingestellte Zeiteinheit. Wir möchten das Ganze für 20 Kerzen berechnen, ohne einen Wert für die Verschiebung anzugeben.   Wir nutzen hier MODE_SMA für SimpleMovingAverage und die Ergebnisse sollen anhand er Schlusspreise berechnet werden. Mit Hilfe der Funktion CopyBuffer füllen wir jetzt unser Array anhand er Definition, die wir hier oben getroffen haben und zwar für Buffer 0. Angefangen von Kerze 0 für 200 Kerzen mit Werten. Das ermöglicht uns herauszufinden, welches die Nummer der höchsten Kerze ist.   Dazu nutzen wir die Funktion ArrayMaximum. Die wird in unserem Array suchen. Angefangen von Kerze 0 wird das ganze Array durchsucht und die Nummer der höchsten Kerze landet dann in dieser Variable. Das Ganze gibt's natürlich dann auch noch in umgekehrter Form. Mit ArrayMinimum können wir die Nummer der niedrigsten Kerze ermitteln. Der Rest des Befehls ist hier identisch. Und damit wir den aktuellen Wert auf dem Chart ausgeben können, ermitteln wir den noch, indem wir uns den Wert von unserem Array für Kerze 0 holen. Der wird mit NormalizeDouble hier auf sechs Stellen verkürzt. Denn das ist auch das was uns der Indikator hier unten anzeigt.   Kommen wir zur Definition der Signale. Wenn unsere aktuelle Kerze 0 den niedrigsten Wert für unseren Indikator beinhaltet, dann ist das für uns ein Kaufen-Signal und dann setzen wir unser Signal hier auf buy. Andernfalls, wenn unsere aktuelle Kerze den höchsten Wert hat, dann ist das für uns ein Verkaufen-Signal und dann setzen wir unser Signal hier auf sell. Und so fern unser Signal auf verkaufen steht und uns der Rückgabewert von PositionsTotal einen Wert von

  In diesem Video wollen wir uns einmal anschauen, wie man diesen Indikator hier berechnen kann. Es handelt sich um sogenannte Fractale. Also lassen Sie uns einmal schauen, wie man das mit MQL5 automatisieren kann. Um das zu tun, klicken Sie bitte im Metatrader hier oben auf dieses kleine Symbol oder drücken Sie die F4 Taste. Das ruft hier dann den Metaeditor auf. Und hier klicken wir auf Datei, Neue Datei, Expert Advisor aus Vorlage, Weiter. Ich vergebe hier einmal den Namen SimplerFractalsEA, klicke auf Weiter, Weiter und Fertigstellen. Jetzt kann alles oberhalb dieser OnTick Funktion gelöscht werden.   Und auch die Kommentarzeilen werden entfernt. Wir starten damit, dass wir einen include Befehl nutzen, um die Datei Trade.mqh zu importieren. Das ermöglicht uns, von der Klasse CTrade eine Instanz mit dem Namen trade zu erstellen. Die werden wir gleich nutzen, um Positionen zu eröffnen. In der OnTick Funktion berechnen wir den Ask Preis und den Bid Preis. Das übernimmt die Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart. Wir nutzen entweder SYMBOL_ASK oder SYMBOL_BID. Und mit NormalizeDouble und _Digits stellen wir sicher, dass automatisch die richtige Anzahl von Nachkommastellen für das jeweilige Währungspaar berechnet wird. Außerdem brauchen wir noch eine Variable für das Signal. Die ist vom Typ string, nimmt hier also Textketten auf. Wir weisen aber noch keinen Wert zu, denn den möchten wir gleich berechnen. Dazu brauchen wir ein Preis Array für die Preis Daten. Das erstellen wir mit Hilfe von MqlRates. Mit Hilfe von ArraySetAsSeries sortieren wir unser Preis Array jetzt von der aktuellen Kerze an abwärts.   Und mit CopyRates füllen wir es für das aktuelle Währungspaar auf dem Chart und die aktuelle Zeiteinheit auf diesem Chart. Wir sollten das aber immer gleich schreiben. Deswegen verwenden wir hier _Symbol und _Period. Wenn man das aber mal markiert und die F1 Taste drückt, dann sieht man, dass man das auch mit Klammern verwenden kann. Wir benötigen die Kerzen von Kerze null bis Kerze drei. Und speichern die Werte in unserem Preis Array ab. Wir starten mit Kerze null und benötigen die Daten für drei Kerzen, die wir in unserem Preis Array speichern. Jetzt brauchen wir noch zwei Arrays. Eins für das obere und eins für das untere Fractal. Und um die Werte zu ermitteln nutzen wir die Funktion iFractals für das aktuelle Währungspaar auf dem Chart und die aktuell auf dem Chart ausgewählte Zeiteinheit. Auch diese beiden Arrays sortieren wir wieder mit Hilfe von ArraySetAsSeries von der aktuellen Kerze an abwärts. Und jetzt füllen wir sie mit Werten.   Das geht mit der Funktion CopyBuffer. Anhand der Fractals Definition die wir hier oben getroffen haben, füllen wir für die obere Linie, angefangen von Kerze eins für drei Kerzen unser Fractal Array. Das gleiche wiederholen wir hier nochmal für das untere Fractal Array. Das ist ziemlich ähnlich, aber diesmal nutzen wir LOWER_LINE. Und auch der Name von unserem Array wird entsprechend angepasst. Das alles ermöglicht und jetzt, den Wert für die letzte Kerze zu ermitteln. Das bedeutet, wir schauen uns den Wert für Kerze eins in unserem UpperFractalsArray an. Um den oberen Wert zu berechnen beziehungsweise den Wert für Kerze eins in unserem LowerFractalsArray für den unteren Wert. Jetzt kommt eine kleine Besonderheit. Und zwar müssen wir unsere ermittelten Werte jetzt daraufhin prüfen, ob sie dem Wert EMPTY-VALUE entsprechen. Wenn das der Fall ist, dann setzen wir die jeweilige Variable hier auf null. Das machen wir hier auch für den unteren Wert. Denn, wenn das das der Fall ist, dann würden Sie auf dem Chart exponentielle Werte sehen. EMPTY-VALUE steht hier für einen leeren Wert im Indikatorpuffer. Jetzt können wir prüfen, ob unsere Einstiegsbedingungen erfüllt sind.   Denn wenn der Wert für das untere Fractal ungleich null ist und dieser Wert kleiner ist, als der niedrigste Preis für Kerze eins in unserem Preis Array, dann wäre das für uns ein buy Signal,

  In diesem Video wollen wir uns einmal anschauen, wie man einen Expert Advisor erstellen kann, der in der Lage ist, aufgrund von maximalen oder minimalen Werten eines Oszillators Positionen zu eröffnen. Um das zu tun, klicken Sie im Metatrader bitte hier oben auf dieses kleine Symbol oder drücken Sie die F4 Taste. Das ruft hier dann den Metaeditor auf. Und hier klicken wir auf Datei, Neue Datei, Expert Advisor aus Vorlage, Weiter. Ich vergebe hier einmal den Namen SimplerIOBVEA, klicke auf Weiter, Weiter und Fertigstellen. Jetzt kann alles oberhalb dieser OnTick Funktion hier gelöscht werden. Und wir entfernen auch die Kommentarzeilen. Wir beginnen, indem wir mit Hilfe des include Befehles hier die Datei Trade.mqh importieren.   Die werden wir gleichen nutzen, um Positionen zu eröffnen. In der OnTick Funktion erstellen wir uns zunächst eine String Variable für das Signal. Und damit wir Positionen eröffnen können, benötigen wir noch den Ask Preise und den Bid Preis. Die berechnen wir mit Hilfe von SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart. Wir nutzen SYMBOL_ASK beziehungsweise SYMBOL_BID und mit Hilfe von NormalizeDouble und _Digits stellen wir sicher, dass wir die richtige Anzahl von Nachkommastellen je nach Währungspaar automatisch berechnen. Außerdem brauchen wir für unseren Expert Advisor ein Array für die Preisdaten. Das sortieren wir dann mit Hilfe von ArraySetAsSeries von der aktuellen Kerze an abwärts. Jetzt definieren wir unseren Oszillator. In unserem Fall nutzen wir den Oszillator On Balance Volume für das aktuelle Währungspaar auf dem Chart und die aktuell eingestellte Zeiteinheit. Der dritte Parameter hier VOLUME_TICK soll uns das Tickvolumen anzeigen. Danach nutzen wir CopyBuffer, um anhand der Definition die wir hier oben getroffen haben, für das Oszillatoren Signal, angefangen von Kerze null für 100 Kerzen, die Daten in unser Array kopieren zu können.   Und das ermöglicht es uns, den aktuellen Wert zu ermitteln, indem wir einfach auf den Wert Kerze null in unseren Array zugreifen. Jetzt brauchen wir noch den maximalen und den minimalen Wert. Dazu ermitteln wir mit Hilfe von ArrayMaximum zunächst die Nummer der Kerze, die in unserem EAArray, angefangen von Kerze null für das komplette Array den höchsten Wert hat. Entsprechend lässt sich mit ArrayMinimum auch die Nummer der Kerze ermitteln, die den minimalsten Wert in unserem Array hat. Und jetzt sind wir in der Lage, den tatsächlich maximalen Wert zu ermitteln, indem wir in unserem Array den Wert von der eben ermittelten Kerze auslesen. Das gleiche wiederholen wir dann nochmal und ermitteln den Wert für die minimale Kerze. Wie gesagt, es handelt sich immer um die letzten 100 Kerzen. Und wenn die aktuelle Kerze größer oder gleich ist zu dem bisher ermittelten Maximalwert in unserem Array, dann sehen wir das als Kaufen Signal und setzen unser Signal hier auf buy. Im anderen Fall, wenn der aktuelle Wert für Kerze null kleiner oder gleich ist zu bis jetzt minimal gemessenen Wert, dann ist das für uns ein Verkaufen Signal. Also setzen wir unser Signal hier auf sell.   Und wenn unser Signal auf Verkaufen steht und wir keine geöffneten Positionen haben, wenn also der Rückgabewert von PositionsTotal kleiner ist als eins, dann nutzen wir trade.sell um zehn Mikrolot zu verkaufen. Andernfalls, wenn unser Signal hier auf Kaufen steht und wir ebenfalls keine geöffnete Position haben, dann nutzen wir trade.buy um zehn Mikrolot zu kaufen. Zum Schluss erstellen wir uns noch eine Chartausgabe. Das macht der Comment Befehl. Der wird uns den aktuellen, den maximalen und den minimalen Wert auch auf unserem Chart anzeigen. Hier unten versteckt sich noch irgendwo die schließende Klammer. Und das war es im Großen und Ganzen. Wenn Ihnen das hier zu schnell ging oder wenn Sie keine Ahnung haben, was alle diese Codezeilen hier bewirken sollen, dann möchten Sie sich vielleicht zunächst ein anderes Video aus der Grundlagenserie noch einmal anschauen.

  In diesem Video wollen wir uns einmal anschauen, wie man einen Expert Advisor erstellen kann, der in der Lage ist, bei absteigenden Trends alle fünfzig Punkte einen neuen Sell Trade zu eröffnen. Also lassen Sie uns einmal schauen, wie man so etwas mit MQL5 realisieren kann. Um das zu tun, klicken Sie im Metatrader bitte hier oben auf dieses kleine Symbol oder drücken Sie die F4 Taste. Das ruft dann hier den Metaeditor auf. Und hier klicken wir auf Datei, Neue Datei, Expert Advisor aus Vorlage, Weiter. Ich vergebe hier einmal den Namen SimplesSellGridSystem, klicke auf Weiter, Weiter und Fertigstellen. Jetzt kann alles oberhalb der OnTick Funktion hier gelöscht werden. Und wir entfernen auch die zwei Kommentarzeilen. Im ersten Schritt nutzen wir den include Befehl, um die Datei Trade.mqh zu importieren. Die stellt uns vereinfachte Handelsfunktionen bereit. Und um die zu nutzen erstellen wir hier eine Instanz von der Klasse CTrade mit dem Namen trade. Außerdem nutzen wir  MqlRates für ein Array mit dem Namen PriceInfo, das unsere Preisdaten aufnehmen wird. Und im Anschluss erstellen wir uns eine Signal Variable vom Typ string. Der weisen wir hier aber noch keinen Wert zu, denn der wird gleich ermittelt. In der OnTick Funktion nutzen wir eine statische Variable vom Typ double. Die bekommt den Namen NextSellPrice. Und die werden wir verwenden, um den nächsten Sell Preis zu definieren. Und damit wir etwas verkaufen können brauchen wir den Bid Preis. Den ermitteln wir mit der Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart.   Wir nutzen SYMBOL_BID. Und mit NormalizeDouble und _Digits lassen wir uns automatisch die richtige Anzahl von Nachkommastellen für das jeweilige Währungspaar ermitteln. Mit Hilfe der Funktion ArraySetAsSeries sortieren wir unser PriceInfo Array jetzt von der aktuellen Kerze an abwärts. Danach füllen wir es mit Daten. Das übernimmt die Funktion CopyRates für das aktuelle Währungspaar auf dem Chart und die auf dem Chart ausgewählte Zeiteinheit, möchten wir von der aktuellen Kerze null die Werte für drei Kerzen in unserem PriceInfo Array speichern. Sofern wir keine offenen Positionen haben, liefert uns die Funktion PositionsTotal einen Wert von null zurück. Dann setzen wir unseren NextSellPrice hier ebenfalls auf null. Um das Signal zu ermitteln möchten wir eine Funktion mit dem Namen CheckEntrySignal nutzen. Die existiert noch nicht.   Also müssen wir die gleich noch programmieren. Für die Einstiegsbedingungen möchten wir prüfen, ob unser Bid Preis kleiner ist als der NextSellPrice den wir definiert haben. Oder, ob unser NextSellPrice den Wert null hat. Die nächste Bedingung wäre zu prüfen, ob unser Signal auf sell steht. Und wenn beides zutrifft, dann nutzen wir hier trade.Sell, um zehn Mikrolot zu verkaufen. Danach setzen wir sofort den Level für den nächsten Sell Preis auf einen Wert, fünfzig Punkte unterhalb des aktuellen Bid Preises. Damit wir auch was sehen, nutzen wir hier die Comment Funktion. So weit, so gut. Aber da diese Funktion hier nicht existiert, müssen wir die jetzt noch programmieren. Unsere Funktion soll den Namen CheckEntrySignal bekommen und uns einen string Wert, also eine Textkette zurückliefern. Wir prüfen hier, ob der Schlusskurs für Kerze eins in unserem PriceInfoArray größer ist, als der Eröffnungskurs für Kerze eins im gleichen Array.   Wenn das so ist, ist das für uns ein Verkaufssignal. Und dann setzen wir hier unsere Signal Variable auf Buy. Im umgekehrten Fall, wenn der Schlusskurs für Kerze eins niedriger war, als der Eröffnungskurs für Kerze eins, dann wäre das ein Verkaufen Signal. Und dann setzen wir unsere Variable hier auf sell. Zum Schluss nutzen wir noch den return Befehl, um unser Signal an das Hauptmodul zurückzuliefern. Das war es soweit. Wenn Ihnen das zu schnell ging oder wenn Sie keine Ahnung haben, was diese Code Zeilen hier bewirken sollen, dann möchten Sie sich vielleicht zunächst eines der anderen Videos anschauen.

  In diesem Video wollen wir einmal einen Expert Advisor erstellen, der bei sich überschneidenden gleitenden Durchschnitten in der Lage ist, Sell Position automatisch zu schließen. Das ist jetzt grade passiert. Also lassen Sie uns einmal schauen, wie man so etwas in MQL5 programmieren kann. Um das zu tun klicken Sie im Metatrader bitte hier oben auf dieses kleine Symbol oder drücken Sie die F4 Taste. Das ruft dann hier den Metaeditor auf. Und hier klicken wir auf Datei, Neue Datei, Expert Advisor aus Vorlage, Weiter. Ich vergebe hier den Namen SimplerSellCrossoverStopLoss, klicke auf Weiter, Weiter und Fertigstellen. Jetzt kann alles oberhalb der OnTick Funktion gelöscht werden.   Und auch die zwei Kommentarzeilen werden entfernt. Wir starten mit einem include Befehl. Der wird uns die Inhalte der Datei Trade.mqh zur Verfügung stellen. Die enthält vereinfachte Handelsfunktionen. Und um die zu nutzen, erstellen wir uns jetzt von der Klasse CTrade eine Instanz mit dem Namen trade. Innerhalb der OnTick Funktion möchten wir den Ask Preis ermitteln. Das geht mit der Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart. Wir nutzen SYMBOL_ASK. Und mit NormalizeDouble und _Digits stellen wir sicher, dass die richtige Anzahl von Nachkommastellen für das jeweilige Währungspaar ermittelt wird. Das Ganze wiederholen wir dann noch einmal für den Bid Preis. Da ist eigentlich nur der Name der Variable anders und wir nutzen hier SYMBOL_BID.   Außerdem brauchen wir eine Variable für unser Signal. Die nennen wir auch signal, weisen hier aber noch keinen Wert zu, denn der wird gleich noch ermittelt. Für die Preisdaten brauchen wir zwei Arrays, ein SmalMovingAverageArray und ein BigMovingAverageArray. Und die Definition für den SmallMovingAverageArray ersten wir mit Hilfe der Funktion iMA für das aktuelle Währungspaar auf dem Chart und die auf dem Chart ausgewählte Zeiteinheit möchten wir für zwanzig Kerzen einen Wert ermitteln. Wir nutzen hier keine Verschiebung. Dieser Parameter steht für SMA, also Smal Moving Average.   Sie könnten hier auch MODE_EMA für eine exponentiellen gleitenden Durchschnitt nutzen. Und das Ergebnis soll ermittelt werden anhand der Schlusspreise der Kerzen. Für den BigMovingAverage sieht das ganz ähnlich aus. Diesmal ermitteln wir hier den Wert für fünfzig Kerzen. Mit Hilfe von CopyBuffer können wir jetzt anhand der Definition die wir hier oben getroffen haben für Buffer null, also die einzige Signallinie von der aktuellen Kerze null für drei Kerzen die Daten kopieren und in unserem SmallMovingAveragerArray speichern. Für den BigMovingAverageArray wiederholen wir das Ganze nochmal. Und nachdem wir das alles durchgeführt haben sind wir in der Lage, herauszufinden, ob der Wert für Kerze eins in unserem BigMovingAverageArray kleiner ist, als der Wert für Kerze eins in unserem SmallMovingAverageArray. Falls das zutrifft, setzen wir hier unser Signal auf buy, also kaufen.   Im anderen Fall, wenn der Wert für Kerze eins im BigMovingAverageArray größer ist, als der Wert für Kerze eins im SmallMovingAverageArray, dann wäre das ein Verkaufssignal und dann setzen wir unsere Signalvariable hier auf sell. Und wenn wir ein kaufen Signal haben und die Anzahl unserer Positionen größer ist als null, dann möchten wir gerne alles Verkaufspositionen schließen, weil sich der Trend gedreht hat. Im anderen Fall, wenn unser Signal auf verkaufen steht und wir keine offene Position haben, dann eröffnen wir hier mit trade.sell eine Testposition für zehn Mikrolot. Wie gesagt, das hier ist nur für den Test. Man würde das auf einem Echtgeldkonto natürlich nicht machen. Damit wir sehen, wie das aktuelle Signal aussieht, fügen wir hier eine Comment Ausgabe für das Chart hinzu. Die wird uns den Text anzeigen: Das Signal ist jetzt… gefolgt von dem ermittelten Signal. Damit wir diese Position hier nutzen können, müssen wir die jetzt aber noch programmieren, denn die existiert noch nicht.

  In diesem Video wollen wir uns einmal anschauen, wie man ein Buy Grid System in MQL5 programmieren kann. Hier werden Buy Positionen eröffnet, immer dann, wenn der Preis fünfzig Punkte steigt. Also lassen Sie uns einmal schauen, wie man so etwas in MQL5 programmieren kann. Um das zu tun, klicken Sie bitte im Metatrader auf dieses kleine Symbol hier oben oder drücken Sie die F4 Taste. Das ruft dann hier den Metaeditor auf. Und hier klicken wir auf Datei, Neue Datei, Expert Advisor aus Vorlage, Weiter. Ich vergebe hier einmal den Namen SimplesBuyGridSystem, klicke auf Weiter, Weiter und Fertigstellen. Jetzt kann alles oberhalb der OnTick Funktion gelöscht werden. Und wir entfernen auch die zwei Kommentarzeilen.   Zunächst importieren wir uns die Datei Trade.mqh. Die ist Bestandteil von MQL5 und stellt vereinfachte Handelsfunktionen bereit. Dazu erstellen wir uns eine Instanz von der Klasse CTrade. Die bekommt den Namen trade. Außerdem benötigen wir ein Array für Preisdaten. Das erzeugen wir mit MqlRates und der Name ist PriceInfo. Und für unser Signal erzeugen wir uns noch eine string Variable. Die bekommt den Namen Signal, aber noch keinen Wert zugewiesen. Innerhalb der OnTick Funktion erstellen wir uns eine statische Variable vom Typ double. Die hat den Namen NextBuyPrice und soll den Level für den nächste Kaufpreisaktion festlegen. Dieser Zusatz static, der sorgt dafür, dass diese Variable ihren Wert während der Laufzeit des Expert Advisors behält.   Im nächsten Schritt berechnen wir den Ask Preis. Das übernimmt die Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart. Wir nutzen SYMBOL_ASK als Parameter. Und mit NormalizeDouble und _Digits stellen wir sicher, dass die richtige Anzahl von Nachkommastellen für das jeweilige Währungspaar automatisch berechnet wird. Mit Hilfe von ArraySetAsSeries sortieren wir unser PriceInfo Array jetzt von der aktuellen Kerze an abwärts. Und mit CopyRates füllen wir unser PriceInfo Array für das aktuelle Währungspaar und die aktuell ausgewählte Zeiteinheit. Wir starten mit Kerze null und kopieren die Preisinformationen für drei Kerzen in unser PriceInfo Array. Immer wenn wir keine geöffnete Position haben, das wäre der Fall, wenn PositionsTotal den Wert null zurückliefert, dann setzen wir den Preislevel für den nächsten Kauf auf null.   Um das Signal zu ermitteln rufen wir eine Funktion mit dem Namen CheckEntrySignal auf. Die existiert zu diesem Zeitpunkt noch nicht. Also müssen wir die gleich noch programmieren. Als Einstiegskonditionen prüfen wir hier, ob der Ask Preis größer oder gleich dem NextBuyPrice Level ist. Zweite Kondition ist, dass wir prüfen, ob unser Signal auf buy, also auf kaufen steht. Und wenn das der Fall ist, dann nutzen wir trade.Buy, um eine Position für zehn Mikrolot zu kaufen. Die ist gleichzeitig dann der Basiswert für unseren nächsten Kaufpreis. Den setzen wir jetzt nämlich auf den aktuellen Ask Preis plus fünfzig Punkte. Und damit wir auch was sehen, nutzen wir eine Comment Ausgabe. Die wird uns auf dem Chart den aktuellen Ask Preis und den NextBuyPrice anzeigen.   Soweit war es das mit der Hauptfunktion. Damit wir diese Funktion hier nutzen können, müssen wir die jetzt noch programmieren. Unsere Funktion soll CheckEntrySignal heißen und eine string Variable, also einen Text Wert zurückgeben. Dazu nutzen wir in unserem Beispiel eine ganz einfache Überprüfung. Und zwar prüfen wir, ob der Schlusskurs der letzten Kerze höher lag, als der Eröffnungskurs. Dann wäre die Kerze bullish und dann setzen wir unser Signal auf buy, also auf Kaufen. Im anderen Fall, wenn der Schlusskurs unter dem Eröffnungspreis liegt, dann wäre das ein Verkaufssignal. Und dann setzen wir unsere Signal Variable hier auf sell. Zum Schluss nutzen wir den return Befehl, um unser ermitteltes Signal an das Hauptmodul zurückzugeben. Das war es soweit. Wenn Ihnen das zu schnell ging oder wenn Sie nicht wissen, was alle diese Code Zeilen hier bewirken sollen,

RTW-Fahrer Nils nennt Corona-Demonstrierende “Spinner”, Robin bekommt ein zeitreisendes Paket und grillt Grafikkarten, LEGO blockiert den Import von Klemmbausteinen und eine Mutter aus Pennsylvania nutzt Deepfakes gegen Vereinskolleginnen ihrer Tochter. Was kann da noch schief gehen?

  In diesem Video wollen wir uns einmal anschauen, wie man einen Expert Advisor erstellen kann, der in der Lage ist, für jede Position die Trade Richtung umzukehren. Also lassen Sie uns einmal schauen, wie man so etwas mit MQL5 programmieren kann. Um das zu tun, klicken Sie bitte im Metatrader hier oben auf dieses kleine Symbol oder drücken Sie die F4 Taste. Das ruft dann hier den Metaeditor auf. Und hier klicken wir auf Datei, Neue Datei, Expert Advisor aus Vorlage, Weiter. Ich vergebe hier einmal den Namen SimpleReversePosition, Klicke auf Weiter, Weiter und Fertigstellen. Jetzt kann alles oberhalb dieser OnTick Funktion hier gelöscht werden. Und wir entfernen auch direkt die zwei Kommentarzeilen. Wir starten mit einer include Anweisung. Damit importieren wir die Datei Trade.mqh. Die gehört mit zu MQL5 und stellt vereinfachte Funktionen für Positionseröffnungen und Positionsbehandlung bereit.   Dazu erstellen wir uns aus der Klasse CTrade hier eine Instanz mit dem Namen Trade. Wir brauchen auch ein paar Variablen. Die erste Variable ist vom Typ string, hat den Namen direction, für Richtung und bekommt von uns den initialen Wert buy zugewiesen. Die nächste Variable hat einen Zusatz, der heißt input. Das sorgt dafür, dass man die Werte dieser Variable ohne Neukompilierung auch während der Laufzeit als Benutzer verändern kann, indem man einfach die Eigenschaften im Expert Advisor einstellt.   Diese Variable ist vom Typ integer und hat den Namen TakeProfitPoints. Der initiale Wert ist hier fünfzig. Jetzt wiederholen wir das Ganze nochmal für die StopLoss Punkte. Auch hier nutzen wir den input Zusatz. Und der initiale Wert für den StopLoss wird hier dreißig Punkte sein. Innerhalb der OnTick Funktion möchten wir zunächst einmal den Ask Preis berechnen. Das übernimmt die Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart.   Wir nutzen hier SYMBOL_ASK. Und mit NormalizeDouble und _Digits stellen wir sicher, dass die richtige Anzahl für die Nachkommastellen berechnet wird. Das ist abhängig von der genutzten Währung. Das Gleiche müssen wir hier nochmal für den Bid Preis machen. Im Großen und Ganzen ist die Zeile identisch, bis auf den Namen und den hier genutzten Parameter SYMBOL_BID. Und jetzt möchten wir gerne prüfen, ob wir keine geöffneten Positionen haben.   Das wäre der Fall, wenn die Funktion PositionsTotal einen Wert von null zurückliefert. Gleichzeitig möchten wir gerne wissen, ob die direction, also die Richtung, auf buy steht. Falls beides zutrifft, eröffnen wir eine buy Position. Das geht mit trade.Buy. Wir möchten gerne eine Position in der Höhe von zehn Mikrolot eröffnen für das aktuelle Währungspaar auf dem Chart zum Ask Preis. Dieser Ausdruck hier wird die gewünschte Anzahl von StopLoss Punkten für uns setzen. Der darauffolgende Parameter hier ist für den TakeProfit Wert. Auch hier werden die gewünschten Punkte eingesetzt. Und der letzte Parameter hier wäre für einen Kommentar. Der wird aber nicht benötigt, darum setzen wir den auf null. Nachdem wir die Position eröffnet haben möchten wir die Richtung umkehren, setzen also hier den Wert für die Variable direction auf sell. Für die sell Trades sieht das ähnlich aus.   Zunächst prüfen wir hier, ob wir geöffnete Positionen haben. Dann, ob die Richtung auf sell steht. Und wenn beides zutrifft, nutzen wir trade.Sell, um zehn Mikrolot zu verkaufen. In diesem Fall müssen wir den Bid Preis nutzen. Und natürlich sind bei einem sell Trade die StopLoss Punkte oberhalb des aktuellen Preises und der TakeProfit muss darunterliegen. Nachdem wir dann unsere sell Position eröffnet haben, setzen wir hier die Variable direction für die Richtung auf buy. Und jetzt fehlt uns eigentlich nur noch eine Chart Ausgabe. Das übernimmt der Comment Befehl. Der gibt uns hier den Text: die aktuelle Richtung ist… gefolgt von der Variable direction aus. Soweit so gut. Wenn Ihnen das hier zu schnell ging oder wenn Sie keine Ahnung haben,

In diesem Video wollen wir uns mal anschauen, wie man diesen Indikator hier programmieren kann, damit zumindest die Werte ausgegeben werden. Es handelt sich um den Alligator Indikator von Bill Williams. Also lassen Sie uns einmal schauen, wie man so etwas in MQL5 realisiert. Um das zu tun klicken Sie im Metatrader bitte hier oben auf dieses kleine Symbol oder drücken Sie die F4-Taste. Das ruft dann hier den Metaeditor auf und hier klicken wir auf Datei, neue Datei, Expert Advisor aus Vorlage, weiter. Ich vergeben hier mal den Namen SimplerAlligator, klicke auf weiter, weiter und fertigstellen. Jetzt kann hier alles oberhalb der OnTick-Funktion gelöscht werden und auch die zwei Kommentarzeilen werden entfernt. Da der Alligator Indikator drei unterschiedliche Werte hat, brauchen wir hier drei Arrays. Das Erste ist für den Jaw-Wert. Jaw steht für Kiefer. Das zweite Array für die Teeth, also für die Zähne. Und das dritte Array ist für die Lippen. Wenn man mal mit der rechten Maustaste auf die Eigenschaften des Alligator Indikators klickt, dann sehen wir hier, diese drei Werte. Im nächsten Schritt geht es darum die Definition für den Alligator Indikator durchzuführen. Das übernimmt die in MQL5 eingebaute Funktion iAlligator und die kommt mit einer ganzen Menge Parametern. Der erste Parameter ist für das aktuelle Währungspaar auf dem Chart, der zweite Parameter steht für die auf dem Chart gerade ausgewählte Zeiteinheit, der dritte Parameter ist die Anzahl der Kerzen für die Berechnung des Kiefers, also der Jaw Periode. In diesem Fall nutzen wir 13 Kerzen. Parameter Nummer vier steht für die Verschiebung. Wir nutzen hier keine Verschiebung. Im Original wird die Jaw Periode um 8 Kerzen verschoben berechnet. Das macht aber die Kontrolle für den aktuellen Wert schwierig. Darum machen wir das hier ohne Verschiebungswerte. Der nächste Parameter ist für die Zähne, also die Teeth Periode. Dieser Wert wird anhand von 8 Kerzen ermittelt. Auch hier setzen wir den Verschiebungswert wieder auf 0. Die dritte Linie ist die Lips Periode. Hier nutzen wir 5 Kerzen für die Berechnung. Auch das machen wir hier wieder ohne Verschiebung. Der nächste Parameter steht für die Wahl des gleitenden Durchschnittes. Ich hab jetzt hier MODE_SMA gewählt und wenn man da einmal F1 drückt, dann findet man heraus, dass es unterschiedliche Möglichkeiten gibt. Die Originalversion von Bill Williams nutzt hier eine geglättete Version. Man könnte auch einen exponentiellen Moving Average wählen. Und der letzte Parameter steht für den angewendeten Preis. Wir möchten das gerne anhand er Schlusspreise ermitteln. Machen wir noch die Klammer zu und setzen ein Semikolon. Dann ist die Definition soweit beendet. Im nächsten Schritt sortieren wir unsere drei Arrays, die wir hier oben erstellt haben, mit Hilfe der Funktion ArraySetSeries von der aktuellen Kerze an, abwärts. Und jetzt nutzen wir CopyBuffer, um anhand er Alligatordefinition, die wir hier oben getroffen haben, unser JawArray mit Werten zu füllen. Für den Jaw-Wert nutzen wir den ersten Buffer. Das ist Buffer 0. Der wird uns den Jaw-Wert ermitteln. Buffer 1 steht für Teeth, also für die Zähne und Buffer 2 liefert den Lips-Wert für die Lippen. Wir machen das in diesem Wert für den Jaw-Wert, also nutzen wir Buffer 0 und kopieren uns von der aktuellen Kerze 0 für 3 Kerzen die Werte, die wir dann in unserem JawArray speichern. Für das TeethArray, also für die Zähne, sieht das ganz ähnlich aus. Mit dem Unterschied, dass wir hier Buffer 1 benutzen. Und für die Lips, also für die Lippen, machen wir das Ganze nochmal mit Buffer 2. Danach können wir die jeweiligen Werte ermitteln, in dem wir einfach auf den Wert von Kerze 0 auf unserem JawArray zugreifen. Das gibt uns hier den AlligatorJaw-Wert. Ich nutze NormalizeDouble und fünf Nachkommastellen, um die Ausgabe entsprechend zu formatieren. Ähnlich sieht das aus, um den Wert für Teeth, also für die Zähne, zu ermitteln. Gleiches Verfahren,