Bedingung nach Negativ-Trades
 

Hallo allerseits,

ich möchte, dass mein EA etwas anders macht, nachdem er 2 negativ-Trades gemacht hat.

Ich müsste also soetwas programieren wie:
wenn die letzten beiden Trades im Minus geschlossen wurden, dann......

Da ich mich erst seit wenigen Wochen mit der MQL4-Programmierung befasse, wäre es schön, wenn mir jemand die konkrete(n) Befehlszeile(n) schreiben könnte.

Danke!!

Hallo,

mit einer Zeile ist das nicht getan. Und es wäre schon ein Modul, was den Rahmen sprengen würde es hier kostenlos zu liefern.

Als Anregung jedoch um zwei Richtungen zu geben:

- Es müsste die Orderhistory ausgelesen und analysiert werden. Das wäre der fachmännische Weg.

- Als Übung für den Anfang, was auch funktioniert, eine Variable(Var1) setzen, wenn der Kurs die Höhe des Stops erreicht. Wird nicht das Stop erreicht (else), dann Var1 false.
Das zusätzlich mit einer zweiten Variable, wo die Funktion durchlaufen wird, wenn Var1 gesetzt wurde.
Der Rest halt einfach, ist Var1 und Var2 gesetzt, dann mache alles anders.
Zu beachten ist, wenn ein Trade positiv ausfällt, sollten die beiden Variablen zurückgesetzt werden.

Hallo Adlerauge,

ich habe mal etwas ähnliches programmiert, dass Dir als erster Hinweis weiterhelfen könnte:

//Auf einen Long- folgt immer ein Short-Trade und umgekehrt
int Zaehler_History=0;
if (LongShortWechsel==true)
{
for(Zaehler_History=OrdersHistoryTotal();Zaehler_H istory>=0;Zaehler_History--)//
{
OrderSelect(Zaehler_History,SELECT_BY_POS,MODE_HIS TORY);
if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=MagicNumber)
continue;

if(OrderSymbol()==Symbol() && OrderMagicNumber()==MagicNumber)
{
if(OrderType()==OP_BUY)
{
LastTradeLong=true;
LastTradeShort=false;
break;
}
if(OrderType()==OP_SELL)
{
LastTradeLong=false;
LastTradeShort=true;
break;
}

}
}
}

Dieser Code testet, ob der letzte! geschlossene Trade long oder short war.
Du mußt natürlich die Bedingung ändern und testen, ob er Gewinn oder Verlust
gemacht hat und auch noch den vorletzten Trade ebenfalls testen.

Dies geht somit in Richtung des 1. Ansatzes von Raul0.

Den 2. Ansatz von Raul0 kann ich nicht so recht nachvollziehen, meines
Wissens ändert sich der Wert einer Variablen wieder auf den Ausgangswert,
wenn der EA neu initialisiert wird. Du müsstest also beim Testen Deiner Funktion jedesmal wieder von vorne anfngen, sobals Du einen Wert in der Eingabebox änderst oder den MT 4 neu startest. Das könnte sehr mühsam
sein.

Ob man den Wert einer Variablen dauerhaft speichern kann, diese Möglichkeit
habe ich bei MQL leider noch nicht gefunden.

Vielleicht weiss da ja jemand Rat?

danke schonmal für die Antworten, da kann ich meine Frage schon präzisiere n:
ich dachte auch an das Auslesen der Orderhistory.
Ich finde in der MQL4 Hilfe aber nur den Befehl "OrderHistoryTotal", der mir aber so wie das sehe nur Auskunft über die Anzahl der geschlossenen Orders gibt, oder?
Meine Frage ist also, wie kann ich Informationen zu geschlossenen Orders abfragen, damit ich diese dann von meinem EA weiterbenutzen lassen kann.

Auf Stops kann ich mich leider nicht basieren, da in diesem EA keine Stops gesetzt werden. Die Orders werden auf Grund von MAs gesetzt und geschlossen.

Die Antwort findest Du in meinem obigen Code-Fragment.
OrdersHistoryTotal liefert dei Anzahl der geschlossenen Orders,
die hier in einer for-Schleife abwärts durchlaufen werden.
Für jede Order wird nun geprüft, ob sie die angegebenen Bedingungen
erfüllt (hier Währungspaar bzw. Symbol und Magic-Nummer stimmen
überein). Wenn ja, wird die Order ausgewählt und Du kannst die
entsprechenden Werte, z.B. Preis, Trade-Richtung, SL, TP oder in
Deinem Fall OrderProfit() auslesen und weiterverarbeiten.

So ist das Prinzip! So eine Schleifen-Konstruktion musst Du immer
verwenden, wenn Du auf Trades zugreifen willst. :)

ok, danke Dir, TLO. Ich werde versuchen, mir das mal auf diese Art zurechtzubasteln..))

Adlerauge, ich hatte gerade nichts zu tun und habe mal einen Code-Entwurf gemacht, wie Dein Programm aussehen könnte:

//Aktion nach 2 Verlusttrades umkehren
int Zaehler_History = 0; //Variable enthält den "Countdown" beim Durchlaufen der geschlossenen Trades
int AnzahlVerlustTrades = 0;//Variable zählt die letzten Verlusttrades
for(Zaehler_History=OrdersHistoryTotal();Zaehler_H istory>=0;Zaehler_History--)
{
OrderSelect(Zaehler_History,SELECT_BY_POS,MODE_HIS TORY);
if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=MagicNumber)
continue; //Order entspricht nicht den Kriterien, daher wird nach der nächsten Order gesucht.

if(OrderSymbol()==Symbol() && OrderMagicNumber()==MagicNumber) //Order entspricht den Kriterien.
{
{
if(OrderProfit() >= 0)
break; // Steigt aus der Schleife aus, wenn der gefundene Trade keinen Verlust gemacht hat
else if(OrderProfit()<0)
AnzahlVerlustTrades = AnzahlVerlustTrades + 1; //Die Zahl der letzten Verlusttrades wird um
//1 erhöht, wenn der letze Trade mit Verlust
//war.
}
if AnzahlVerlustTrades >= 2
SETZE SIGNAL FÜR NEUE AKTION; //Hier könnte dann eine Varible ihren Wert wechseln oder die
//neue Aktion auf andere Weise eingeleitet werden, wenn die
//Zahl der aufeinanderfolgenden Verlusttrades 2 erreicht.
}
}

Das ist so natürlich nicht lauffähig und nicht getestet, soll aber den Denkansatz verdeutlichen. Du musst wissen, MQL ist nicht gerade eine benutzerfreundliche Programmiersprache und "glänzt" durch einige Ungereimtheiten. Insbesondere der Editor lässt einen schnell den Überblick
verlieren.

Lass mich mal wissen, ob Du damit was anfangen konntest! :)

Cool!
Ich danke Dir, genau so einen Ansatz habe ich gesucht. Ich werde ein bißchen brauchen, um mich damit auseinanderzusetzen, ich geb Dir dann aber in jedem Fall eine Rückmeldung....

Hallo TLO,

ich habe zunächst einmal versucht, Deinen Order-Wechsel-Code umzusetzen.
Dazu habe ich einfach mal einen Indikator genommen, in diesem Fall den Momentum, und versucht den Code so zu schreiben, dass er long geht, wenn der Momentum über 100 geht, und dann short geht sobald der Momentum wieder und 100 fällt.

Leider funktioniert es noch nicht .....
hier ist der ganze Quellcode:

extern double HandelsLots = 0.01;
extern double StopLoss = 100;
extern double TakeProfit = 50;
extern int PeriodMomentum = 14;

double Momentum;

int MagicNumber;
int Zaehler_History;

bool LastTradeShort;
bool LastTradeLong;
bool LongShortWechsel;

//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int init()
{
Momentum = iCustom(NULL,0,"Momentum",PeriodMomentum,0,1);
return(0);
}

//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick ()

//Auf einen Long- folgt immer ein Short-Trade und umgekehrt
{
if (LongShortWechsel==true)
{
for(Zaehler_History=OrdersHistoryTotal();Zaehler_H istory>=0;Zaehler_History--)//
{
OrderSelect(Zaehler_History,SELECT_BY_POS,MODE_HIS TORY);
if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=MagicNumber)
continue;

if(OrderSymbol()==Symbol() && OrderMagicNumber()==MagicNumber)
{
if(OrderType()==OP_BUY)
{
LastTradeLong=true;
LastTradeShort=false;
break;
}
if(OrderType()==OP_SELL)
{
LastTradeLong=false;
LastTradeShort=true;
break;
}

}
}
}

// Erste Order

if (OrdersTotal() == 0)
if (Momentum > 100)
if (OrdersHistoryTotal()==0)
{
OrderSend(Symbol(),OP_BUY,HandelsLots,Ask,2,Ask-StopLoss*Point,Ask+TakeProfit*Point,NULL,0,0,Green );
}

if (OrdersTotal() == 0)
if (Momentum < 100)
if (OrdersHistoryTotal()==0)
{
OrderSend(Symbol(),OP_SELL,HandelsLots,Bid,2,Bid+S topLoss*Point,Bid-TakeProfit*Point,NULL,0,0,Red);
}

// Nachfolgende Orders

if (OrdersTotal() == 0)
if (Momentum > 100)
if (LastTradeLong=false)
if (LastTradeShort=true)
{
OrderSend(Symbol(),OP_BUY,HandelsLots,Ask,2,Ask-StopLoss*Point,Ask+TakeProfit*Point,NULL,0,0,Green );
}

if (OrdersTotal() == 0)
if (Momentum < 100)
if (LastTradeShort=false)
if (LastTradeLong=true)
{
OrderSend(Symbol(),OP_SELL,HandelsLots,Bid,2,Bid+S topLoss*Point,Bid-TakeProfit*Point,NULL,0,0,Red);
}
}

//..VG.... Adlerauge

OH, OH, wo fang ich da jetzt an? :)

Auf den ersten Blick nur mal das Gröbste, was ich so gesehen habe:

1. Ich würde der MagicNumber mal einen Wert zuweisen und sie gleich als
extern deklarieren, dann kannst Du den EA auch für verschiedene Paare/Timeframes verwenden.

2. iCustom ist für individuelle Indikatoren, iMomentum ist direkt integriert.
Nimm die in der Hilfe angegebenen Spezifikationen.

3. Der Indikator darf nicht bei int init() stehen, dann ändert er seinen Wert während des Programmablaufs nicht mehr!

4. Deine if-Konstruktionen können so nicht funktionieren,
wenn schon, muss es heissen:

if (OrdersTotal() = 0 && Momentum > 100 && OrdersHistoryTotal()=0)
...;

In diesem Fall würde Dein EA allerdings nur auf einem "jungfräulichen" Konto traden, auf dem es weder offene noch geschlossene Trades gibt.
Das kann irgendwie nicht der Sinn sein!!

Das nur fürs Erste, auf ein Neues! :)

...gut, danke für die Hausaufgaben ;-)

Mach Dir keine Sorgen, Adlerauge, das wird schon! :)

Allein um die Sache mit den Indikatoren herauszufinden, habe ich Tage gebraucht! Das kommt davon, wenn alles nur in Englisch und weit verstreut dokumentiert ist.

Als ich vor 20 Jahren das Programmieren mal mit dem vielgeschmähten Visual- bzw. Access-Basic angefangen habe, war das Alles viel einfacher!

Da konnte man solche Sachen noch mit ein paar Mausklicks machen, da gab es einen Editor, in dem jede Unterfunktion in einem separaten Fenster angezeigt werden konnte usw. usf.

Irgendwie sind wir wieder in der programmiertechnischen Steinzeit angekommen, aber was soll man machen? :rolleyes:

Hi TLO,

ich habe früher mal ein bisschen HTML programmiert, mehr aber auch nicht.

Letztendlich muss man ja die Logik der Programmiersprache verstehen, um damit arbeiten zu können.....

Bei Deinem Code zu den wechselnden Trades ist mir noch nicht klar, welche der Parameter ich als Kriterium für die zu öffnenden Trades nehmen muss.

Ich habe es nun nochmal mit (LastTradeLong==false && LastTradeShort==true) versucht, funktioniert aber nicht (macht gar keinen Trade auf).
Wenn ich nur (LastTradeLong==false) als Kriterium nehme, scheint er sich um den Code zu den wechselnden Trades nicht weiter zu scheren und macht nach Belieben Buys hinter Buys und Sells hinter Sells auf.

Hier ist der aktuelle Stand:

extern double HandelsLots = 0.01;
extern double StopLoss = 50;
extern double TakeProfit = 50;

int MagicNumber = 1500001;
int Zaehler_History;

bool LastTradeShort;
bool LastTradeLong;
bool LongShortWechsel;

//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int init()
{

}
//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick ()
{
double iMom=iMomentum(NULL,5,14,0,0);

//Auf einen Long- folgt immer ein Short-Trade und umgekehrt
if (LongShortWechsel==true)
{
for(Zaehler_History=OrdersHistoryTotal();Zaehler_H istory>=0;Zaehler_History--)
{
OrderSelect(Zaehler_History,SELECT_BY_POS,MODE_HIS TORY);
// if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=MagicNumber)
// continue;

if(OrderSymbol()==Symbol() && OrderMagicNumber()==MagicNumber)
{
if(OrderType()==OP_BUY)
{
LastTradeLong=true;
LastTradeShort=false;
break;
}
if(OrderType()==OP_SELL)
{
LastTradeLong=false;
LastTradeShort=true;
break;
}

}
}
}


if (OrdersTotal() == 0 && iMom > 100 && LastTradeLong==false)
{
OrderSend(Symbol(),OP_BUY,HandelsLots,Ask,2,Ask-StopLoss*Point,Ask+TakeProfit*Point,NULL,0,0,Green );
}

if (OrdersTotal() == 0 && iMom < 100 && LastTradeShort==false)
{
OrderSend(Symbol(),OP_SELL,HandelsLots,Bid,2,Bid+S topLoss*Point,Bid-TakeProfit*Point,NULL,0,0,Red);
}


}

Was meinst Du?

Hi Adlerauge,

benutze für Code bitte den Button oben in der Leiste, wo "php" draufsteht, dann kann man das ganze besser lesen. Versuch mal folgendes, habs nur kurz zusammengeschrieben, nicht getestet und nicht compiliert:

Hi Adlerauge,
ich habe Deinen Code jetzt mal getestet, und ich muss sagen, ich
weiss auch nicht, wo der Fehler liegt. MQL4 ist einfach programmiertechnischer Schrott, da musst Du in die Glaskugel schauen, ob das klappt oder nicht.

Und glaub mir, ich weiss, wovon ich rede! Mein EA hat inzwischen 2500 Zeilen, und er läuft (meistens). Manchmal tut er auch wieder nicht, was gestern noch funktionierte.

Darum bin ich auch bei jeder noch so kleinsten Änderung äusserst vorsichtig, mache jedesmal eine Sicherungskopie des alten Codes und
teste erst wieder (was lange Zeit in Anspruch nimmt), ob das auch funktioniert.

Z.B. die Funktion void OnTick() hat bei mir noch nie gemacht, was
sie sollte, die ignoriert sämtliche Folgecodes.

Ich empfehle Dir, nicht soviel Zeit in dieses MQL zu investieren, es ist
unausgereift und im Grunde für Anwender völlig unzumutbar! :mad:

Hi GoS, hi TLO,

danke für Eure Antworten. Morgen teste ich weiter, dann kommt mein feedback. Irgendwie muss diese Geschichte ja zum Laufen zu kriegen sein......))

Wenn nach der OnTick()-Funktion alle Folgecodes ignoriert werden, wie läuft denn dann bei Dir überhaupt ein EA?
In der Regel sitzt der Fehler vor dem Monitor. Auch ich habe manchmal schon lange gesucht, aber bisher immer!!! den Fehler gefunden, der durch mich induziert wurde.
Deine Einschätzung über die Programmqualität ist maßlos übertrieben und ungerechtfertigt und reflektiert ein völlig falsches Bild. Sicherlich gibt es das Eine oder Andere zu verbessern. Aber wo ist das nicht der Fall.

Und ich!! weiss ganz genau, wovon ich hier rede.

traderdoc

Hi Adlerauge,
nachdem sich meine "Wut" wieder etwas gelegt hat, habe ich noch ein wenig probiert. Hier der lauffähige EA, ist nicht ausgefeilt und ich habe alle "Krücken" dringelassen, denn Du willst ja was lernen :), aber er tut was er soll, immer einen Long- und dann einen Short-Trade eröffnen und umgekehrt.

Der EA arbeitet übrigens ohne OnTick(), bin ich so gewohnt und funktioniert auch. ;) Verbesserungsvorschläge sind aber gerne willkommen.

P.S.: Ich habe festgestellt, dass hier beim Einfügen von Text manchmal Leerzeichen hinzugefügt werden, wo keine hingehören, da musst Du evtl. drauf achten. Diesmal scheint aber auf den ersten Blick alles o.k., wo ich die Funktion zum Codeeinfügen benutzt habe. Man ist ja lernfähig. ;)

Ja gut, dann hast Du die alte Struktur genommen mit start().

Diese Zeile sollte dann doch besser so lauten:
for(Zaehler_History=OrdersHistoryTotal()-1;Zaehler_History>=0;Zaehler_History--)

und hier steckt ein typisches Fehlerchen drin:

OrderSend(Symbol(),OP_BUY,HandelsLots,Ask,2,Ask-StopLoss*Point,Ask+TakeProfit*Point,EAName,MagicNumber,0,Green);

adäquat hier:

OrderSend(Symbol(),OP_SELL,HandelsLots,Bid,2,Bid+StopLoss*Point,Bid-TakeProfit*Point,EAName,MagicNumber,0,Red);

Wenn da nicht vorher unter init() entschieden wird, ob es sich um einen 4-oder 5-Digitbroker handelt, dann würden jetzt bei 5-Digitbroker aus den 50 Pips StopLoss in den Variablen plötzlich 5 Pips werden, was verdammt knapp sein kann. (und aus der Slippage 0,2 Pips)

Daher sollte immer in init() stehen:

und dann entsprechend:

OrderSend(Symbol(),OP_BUY,HandelsLots,Ask,Slippage ,NormalizeDouble(Ask-StopLoss*Pt, Digits),NormalizeDouble(Ask+TakeProfit*Pt, Digits),EAName,MagicNumber,0,Green);

Zusätzlich Slippage angepaßt und die SL- und TP-Werte zur Sicherheit auf entsprechende Kommastellen normiert (da kann sonst einiges in die Hose gehen und den berühmten Fehler 130 produzieren).

traderdoc

Hi Gos, hi TLO,

eure Wechsel-Trade Codes funktionieren beide..... ich bin begeistert!!..)))

Damit kann man arbeiten ;-)

GoS, danke für den php - Tipp!

TLO, ein bisschen über die "Maschine" zu fluchen ist schon ok.... wenn man nicht zwischendurch mal Dampf abläst, kommt es einem wahrscheinlich früher oder später zu den Ohren raus ;-)..... und dem Computer tut es ja nicht weh, wenn er mal beschipft wird ...

hi traderdoc,

danke für den wertvollen Tip. Ich legs mir mal in die (virtuelle) Schublade. Ich habe zwar keinen vier-stelligen Broker und habe auch nicht vor, einen zu haben.... aber man weiss ja nie ;-)

Hi Adlerauge,

danke für Dein Lob, dass ich Dir einen lauffähigen EA kostenlos geliefert habe! :D Aber Du bist Anfänger, da helfe ich gern!

Der EA hat sogar gestern Abend bei der Zinsentscheidung, der FED einen
kleinen Demogewinn gemacht! Ein sensationelles Teil! ;)

Bei dem Code von GoS musst Du natürlich berücksichtigen, dass der sofort nicht mehr funktioniert, sobald der EA neu initalisiert wird und auch nicht, wenn der EA mehr als einmal auf einem Account installiert wird, für verschiedene Währunspaare zum Beispiel!

Den Einwurf von traderdoc bgl. der 4- oder 5-Stellen-Konten, Digits und
Points und Allem, was damit zusammenhängt, verstehe ich natürlich zur Genüge.

Von der Problematik kann ich ein Lied singen, das wird für Dich aber erst relevant, wenn Du ein wenig fortgeschritten bist!

Ich wünsch Dir viel Erfolg! :cool:

@Adlerauge, ne dann hast Du mein Post nicht verstanden. Also nix mit virtueller Schublade! Gerade wenn Du einen 5-Digitbroker hast, mußt!! Du den Code so benutzen, wie er in meinem Post steht, sonst gibt es evtl. Probleme mit einer zu kleinen Slippage, aber auf jeden Fall mit zu kleinen SL und TP. Die in den Variablen stehenden 50 Pips werden zu realen 5Pips!! Und das willst Du doch bestimmt nicht, oder?

@TLO Trader, wie sind hier nicht im Sangesverein und singen Lieder, sondern programmieren einen sauberen Code! Und der sog. Einwurf hat nichts mit Fortgeschrittensein zu tun, sondern sind Basics, die unverzichtbar sind. Wenn Du das nicht im Code Deines "lauffähigen" EAs berücksichtigst, dann kannst Du das sensationelle Teil in die "Tonne treten".

traderdoc

traderdoc, du bist aber humorlos! :D

Bitte lies den Thread mal von Anfang an, Adlerauge hat vor 2 Wochen mit der MQL4-Programmierung begonnen und wollte etwas Hilfestellung. Hier geht es nicht um die Entwicklung eines verkaufsfähigen EA, in dem alle Eventualitäten berücksichtigt werden müssen, sondern darum, einem Anfänger in der Materie etwas unter die Arme zu greifen!

Und das mit den 5 Pips SL und TP funktioniert doch, also was gibt´s zu meckern? Hier geht die Diskussion doch schon los: Was ist eigentlich ein Pip? Für mich immer noch die 4. Stelle hinter dem Komma, für manche aber auch die 5. Stelle. Das hängt auch vom Broker ab. Aber ich denke, das hat Adlerauge schon gesehen, er möchte ja einen EA für seine Strategie selber programmieren und nicht die "eierlegende Wollmilchsau" erschaffen. :D

Also halte Dich bitte ein bisschen zurück mit Deinen herablassenden Kommentaren, hier geht es ja in erster Linie um Trading und nicht um die perfekte C++-Programmierung! ;)

hi traderdoc,

dass 50 Punkte bei einem 5-stelligem Broker 5 Pips sind, weiss ich... damit komme ich klar ;-)

Ich habe aber eine andere Frage an Dich:

du hast geschrieben, dass die Zaehler_History so gezählt werden sollte:

for(Zaehler_History=OrdersHistoryTotal()-1;Zaehler_History>=0;Zaehler_History--)

Warum -1 ?
Wie funktioniert die Zählweise genau? Mir erschliesst sich die Logik dahinter noch nicht....

Ich danke Dir!

lol TLO,
noch ein bisschen Feintuning und der EA läuft bei jeder Grossbank.... :D:D:D

Ich werde nun versuchen mich um mein Ausgangsproblem zu kümmern, was da lautete:

if (der EA 2 Negativ-Trades in Folge gemacht hat)
{
dann...
}

...mal sehen, ob ich mir das jetzt zurechtbasteln kann....

@TLO Trader, Du bist aber dünnhäutig!
Genau! Gerade weil er ein Anfänger baut man nicht solche Fehler ein, sondern stellt ihn gleich auf das richtige Gleis. Und es geht auch nicht um die Frage, ob das ein verkaufsfähiger EA werden soll, sondern darum hier einen sauberen Code abzuliefern.
Was ein Pip ist, ist klar definiert, unabhängig vom Broker!
Meine Kommentare sind zielgerichtet! Und wer keinen ordentlich funktionierenden EA hat, der sollte sich bemühen einen zu haben oder sollte händisch traden. denn der Markt verzeiht keine Fehler, weder händische noch programmtechnische.

@Adlerauge, mittels OrdersHistoryTotal() wird die Gesamtzahl der in der Historie liegenden Orders ermittelt, z.B. 10. Da die Orders die Indizierung 0 bis 9 bekommen, kann dieses Datenfeld nur bis zum Element mit dem Index 9 gehen und nicht 10 - also muß da OrdersHistoryTotal() - 1 stehen!
Dasselbe würde für OrdersTotal() gelten.
Zusätzlich solltest Du Dir angewöhnen, double-Variablen, die v.a. in Orderfunktionen einfließen, immer mit NormalizeDouble() zu normieren. Häufig genug droht sonst der Fehler 130.

traderdoc

Erlaube mir mal, anstelle von traderdoc zu antworten. :)
Die Logik erschliesst sich eigentlich keinem, da habe ich auch lange drüber gebrütet! :D Im Prinzip zählt man vom (Höchstwert -1) auf 0 runter, man könnte natürlich (was logischer wäre) vom Höchstwert auf 1 runterzählen. Ich habe aber noch nie festgestellt, das da was nicht funktioniert. Im Prinzip geht es immer nur darum, ob Du von unten nach oben oder von oben nach unten zählst.

Aber vielleicht weiss traderdoc ja noch was dazu. ;)

P.S.: Hab den EA mal gestern Abend bei den zu erwartenden schnellen Kursausbrüchen bei der Bekanntgabe der Fed-Zinsentscheidung beobachtet, und er blieb doch tatsächlich im Gewinn! Kann am Momentum-Indikator liegen, den man jetzt noch mt einem 2. Indikator
"puffern" müsste.

Ich werde mal an dieser Strategie arbeiten! :D

Die Logik erschließt sich jedem, der sauber programmiert. Denn ein Array mit der Arraygröße 10 wird nun mal von 0 bis 9 (also 10 - 1) indiziert. Da die Orders in der Historie auch in einem Array liegen, welches von 0 bis OrdersHistorieTotal()-1 geht, schreibt man rückwärtszählend eben dann:
for (int i = OrdersHistoryTotal()-1; i >= 0; i--)
oder vorwärtszählend:
for (int i = 0; i < OrdersHistoryTotal(); i++) {

Definitv muß das Feld mit dem Index 0 mit in die for-Schleife, sonst fehlt eine Order!
Ich spreche hier wieder vom sauberen Programmieren, weil der Zugriff auf das Element mit dem Index 10, bei einem selbst definierten Array mit der Arraygröße 10, unweigerlich zu einer Fehlermeldung: "array out of range in ..." führt, mit der Folge, dass der EA nicht mehr weiterarbeitet, solange dieser Fehler im Code enthalten ist.
MetaQuotes war beim Überschreiten des Index im Falle des OrdersHistoryTotal() so gnädig, den Fehler vorher abzufangen!

Und damit sich u.a. @Adlerauge, den sauberen Zugriff auf ein Array von vornherein angewöhnt, steht da eben:
for (int i = OrdersHistoryTotal()-1; i >= 0; i--)

Das sollte aber nun zur Erklärung reichen.

traderdoc

Sauber Erklärt;
 

Hallo,

@traderdock das haste sauber Erklärt, das habe so ja ich verstanden...:D

Gruß Franz

_____________________
Erfolg bedeutet die Umwandlung von Wissen in positives Handeln.

Das hat traderdoc wirklich schön erklärt! Das ist eben der Unterschied zwischen Programmiererlogik und Menschenlogik. Der Mensch fängt bei 1 an zu zählen und der Programmier bei 0. :D

Wer hat dieses Desaster eigentlich erfunden, ohne das Alles viel einfacher wäre? War das Bill Gates? Oder gar der Weihnachtsmann?

Wie auch immer, ich wünsche Euch Allen schon mal frohe Festtage!

http://cloud.directupload.net/plugin...qd&/xanta1.gif

Immer sauber poggen!
 

Hallo TLO Trader,
- Der Mensch fängt bei 1 an zu zählen und der Programmier bei 0. -
Diese Aussage ist nicht ganz richtig. Auch der Programmierer ist ein Mensch und fängt bei 1 an zu zählen wenn er die Werte in einen Array zählt, nur der Index (also der Name des Index) fängt bei einen Array bei 0 an. (ich weiss nicht ob es bei allen Programmiersprachen so ist, aber das wird es wohl). Das ist einfach eine Regel der Programmiersprache MQL4 bei einen Array.
Überall gibt es Regeln, im Strassenverkehr, in der Mathematik (Punkt vor Strichrechnung, z.B) sonst gibt es Caos, oder ein falsches Ergebnis.
Aber kurz und Bündig: was ich hier mit sagen möchte ist das es ein fach von größter wichtigkeit ist das man als Neuling von vorne rein die Regeln der Programmierung ein hält und sauber pogget.
Wir können glaube ich froh sein das die Profis uns Neulingen immer so Tatkräftig unter die Arme greifen, auch wenn Sie es mal mit kräftiger Stimme sagen.
Ist wie bei den Kind mit der Herdplatte!
An der Börse werden Fehler mit Geld bezahlt und bei einen EA das er nicht läuft. (oder falsch läuft)
In diesen Sinne,
Gruß Franz :)
_______________________________
Wo das Chaos auf die Ordnung trifft, gewinnt meist das Chaos, weil es besser organisiert ist. Friedrich Nietzsche