Code für eine Art Ausbruchstrading nach Faktor Pips und Zeit
Ich würde mal unter Stichwort 'Momentum' suchen.
Oder ATR
Danke für die Infos. Werde mich mal durch die Artikel und Codes lesen, ob ich etwas paasendes finde.
Danke für die Infos. Werde mich mal durch die Artikel und Codes lesen, ob ich etwas paasendes finde.
Nachdem ich schon länger einen Schutz vor Breakouts, oder ein System das Breakouts handelt suche, bin ich am überlegen und proggen.
Ich hab einen Spreadfilter der sich automatisch auf die Spreads eines Instruments einstellt. Ist ja ein großer Unterschied zwischen zB: EURUSD, BTCUSD, Gold, DAX usw.
Es werden die Spreads des Vortages zwischen zwei einstellbaren Zeiten (zB 8:00 bis 20:00) untersucht, ein Mittelwert gebildet und ein Faktor dazugerechnet. Das ist dann der maximal erlaubte Spread. Funktioniert prächtig.
Sehr ähnlich könnte ich mir das für Breakouts vorstellen. Also zwischen zwei Zeiträumen die mittlere Barsize (oder delta Hig bzw delta Low) feststellen, Faktor dazurechnen
und die Stops im errechneten Abstand auf die letzte fertige Bar setzen.
Der Kerzenchart ist ja eigendlich schon ein Indikator, der die Zeit gerücksichtigt. (im Gegensatz zum Renko-Chart, der nur Kursbewegungen darstellt)
Auch der Donchian-Channel scheint mir zum 'abgreifen' der Hochs und Tiefs, über eine Periode, geeignet. Das geht aber auch ohne Indikator in einem EA (mit MqlRates).
Das alles wäre reine Preisaction, wenn ich diesen Begriff recht verstanden habe.
Ich bin zwar selbst kein Fan von Kerzencharts und mache mittlerweile fast alles mit range bars, dennoch zu Breakouts von klassischen Kerzen eine Anmerkung:
(1) die zeitliche Stückelung in die Perioden-Längen wird nicht annähernd deckungsgleich sein mit den Zeitpunkten zu denen plötzliche Kursausbrüche tatsächlich beginnen oder enden; den entscheidenden Moment wird man daher oft verpassen
(2) es kann z.B. innerhalb einer Kerze lange recht wenig passieren kann.. und dann kommt doch noch der plötzliche Spike am Kerzenende und wird anteilig in der endenden und der folgenden Kerze abgebildet, so dass die tatsächliche Bewegung durch die Verteilung auf zwei Kerzen mehr oder weniger untergehen kann
was man daher alternativ tun kann, ist ein tickbasiertes rollierendes Zeit"fenster" hinter dem Kurs zu herzuschleppen und davon stets den maximalen positiven und negativen Preisausschlag der letzten x Sekunden (oder Millisekunden) ableiten - denn "breakout" bedeutet ja letztlich viel Bewegung pro wenig Zeit, viel Y-Achse pro wenig X-Achse; das hier habe ich in dem Kontext noch aus einem früheren EA "rumliegen":
struct TICK_ARRAY { long time_msc; double price; }; TICK_ARRAY tick_array[]; MqlTick tick; // -------------------------------------------------------------------------------- void OnTick() { SymbolInfoTick(_Symbol,tick); // update tick array while (ArraySize(tick_array)!=0 && tick.time_msc-tick_array[0].time_msc>max_msc) { ArrayRemove(tick_array,0,1); } int stored_ticks=ArraySize(tick_array)+1; ArrayResize(tick_array,stored_ticks,1000); tick_array[stored_ticks-1].price=tick.bid; tick_array[stored_ticks-1].time_msc=tick.time_msc; double max_price=0;double min_price=DBL_MAX; for (int n=0;n<stored_ticks;n++) { max_price=MathMax(max_price,tick_array[n].price); min_price=MathMin(min_price,tick_array[n].price); } .. .. }
max_msc wäre dann eine input-Variable für die Breite des Zeitfensters in Millisec.
aus dem "max_price" und "min_price" innerhalb des definierten Zeitfensters, der Breite des Zeitfensters sowie dem aktuellen Kurs lässt sich stets tick-aktuell ein breakout-Momentum ableiten
Edit: Der Vorteil gegenüber dem weiter oben genannten Vorschlag der Verwendung der Average True Range ist weniger zeitliche Verzögerung des Signals (und bei Ausbrüchen kommt es ja sehr auf Schnelligkeit an).
Geht das nicht mit:
MqlTick TickArray[]; // array of ticks int loaded=CopyTicks(_Symbol,TickArray); // load ticks from cache
um vieles einfacher?
und dann mit ArrayMinimum() und ArrayMaximum() die Höhen und Tiefen ermitteln?
Geht das nicht mit:
um vieles einfacher?
und dann mit ArrayMinimum() und ArrayMaximum() die Höhen und Tiefen ermitteln?
Klar, mit CopyTicks geht das natürlich auch. Allerdings - das ist der Hintergedanke - werden damit viele unnötige Daten geschrieben (tick.volume, tick.flags, tick.last...) die für die eigentliche Frage nicht interessieren. Im Grunde will man ja nur Preis und Zeit wissen.
Ich könnte mir vorstellen, dass das obige Vorgehen daher minimal schneller ist. Außerdem ist die Frage, ob tatsächlich jedes Mal ALLE Ticks neu ausgelesen werden müssen und ob es stattdessen nicht genügt, nur die paar jeweils zu alten Ticks zu löschen und den EINEN neuen Tick anzufügen. Ständige neue Speicherallokationen trotz variabler Arraygröße sollten durch die großzügig angegebene Reserve in ArrayResize vermieden werden. Kommt wohl auf den Versuch an, was effizienter ist.
Das, was hingegen im obigen Beispiel durchaus etwas Resourcen verbrauchen wird ist eher die for-Schleife. Und ich denke das lässt sich eben NICHT mit ArrayMinimum()/ArrayMaximum() umgehen, denn MqlTick ist ja ebenfalls eine Struktur
und sowas wie ArrayMaximum(tick_array[].bid), also der Zugriff auf die index-lose Gesamtheit der einzelnen Unterelemente eines bestimmten Typs innerhalb eines struct-Arrays (hier .bid) funktioniert ja nicht; dann beschwert sich der Compiler mit "Array required".
Danke dür die Infos. Ich habe bei den Codes nicht wirklich was passendes gefunden und da ich keine Ahnung vom programieren habe frage ich mal ganz doof. Muss ich den oben geschriebenen Code einfach so in die mq5 mit einfügen und gut ist oder wie verhält sich das?
Danke dür die Infos. Ich habe bei den Codes nicht wirklich was passendes gefunden und da ich keine Ahnung vom programieren habe frage ich mal ganz doof. Muss ich den oben geschriebenen Code einfach so in die mq5 mit einfügen und gut ist oder wie verhält sich das?
Nee, die Bedingungen was der EA auf Basis irgendwelcher errechneter Werte (wie z.B. Momentum) dann machen soll müssen natürlich definiert werden, genau wie man solche Regeln ja auch im manuellen Handel festlegen würde - das kann Dir niemand abnehmen.
Wenn Du nicht selbst programmierst gibt es aber auch zig Indikatoren in dem Bereich, die sich manuell handeln lassen; ATR, Momentum, Volatility, ADX... schlagen alle bei schnellen Bewegungen stärker aus als in Seitwärtsphasen. Und nicht zuletzt natürlich die simple Länge der aktuellen Kerze selber - auch wenn das kein "Indikator" ist, dafür aber mit dem Vorteil dass es keine wirkliche Verzögerung ("lagging") gibt.
Du wirst das Rad aber nicht neu erfinden müssen. Die Suchfunktion ("breakout", "momentum","news trading"...) wird Dir hunderte von nützlichen Links liefern, sowohl zur Theorie als auch zu fertigen EAs und Indikatoren in der Codebase oder dem Marktplatz.
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.
Hallo zusammen
Hat einer von euch schon einen Code in der Codebase hinterlegt oder gefunden, der auf eine Art Ausbruch reagiert, indem er permanent misst ob ein Kurs innerhalb einer bestimmten Zeit (einstellbar) eine bestimmte Pipsstrecke (einstellbar) zurückgelegt hat und daraufhin in die entsprechende Richtung eine Kauf/ Verkauforder auslöst?
Wenn nein was würde das kosten (MT5).