Berechnung der richtigen Lotgrösse - Money Management mit MQL4

 

Mit MQL4 MarketInfo() ist es möglich alle Informationen unseres Broker's zu erhalten, die wir benötigen um die richtige Lotgrösse auto. für den nächsten Handel zu berechnen.

 

Ich habe gelesen.

Successful Traders is to risk less than 2% of available Capital (FreeMargin) on a single trade and ensure that you never leave a trade open without setting the stop loss.

Also sind unsere Input Daten, wir riskieren nicht mehr als 2% unseres verfügbaren Kapitals(FreeMargin) pro Handel und wir benutzen immer einen StopLoss.

Die Formel lautet: Lots = ( Risk Capital / StopLoss ) / (10 / exchange rate)

 

Doch welche Art von Konto haben wir?

mini, standart, micro?

Wie hoch ist unser Leverage?

In welcher Währung führen wir unser Konto? in EUR, USD, GBP...?

Welche ist die kleinstmögliche Lotgröße unseres Brokers usw...?

 

Bei diesen Fragen kommt MQL4 MarketInfo() zum Einsatz.

 

Wir benötigen für die Berechnung folgene Informationen unseres Broker's

• schrittweise Änderung der Lotgrösse
  
• kleinstmögliche Lotgrösse
  
• Lotgrösse basierend auf unsere Kontowährung
  
• benötigte freie Margin für das öffnen eines Lots
  
• Wert eines Ticks basierend auf unsere Kontowährung*
  
• Tickgröße basierend auf unsere Kontowährung*
  
• Pointgröße
  *Die Werte von MarketInfo rechnen auto. mit der Kontowährung die wir benutzen.( in EUR, GBP, ...)
  

In MQL4 sieht das ganze dann so aus.

MarketInfo(Symbol(), MODE_LOTSTEP);
MarketInfo(Symbol(), MODE_MINLOT);
MarketInfo(Symbol(), MODE_LOTSIZE);
MarketInfo(Symbol(), MODE_MARGINREQUIRED);
MarketInfo(Symbol(), MODE_TICKVALUE);
MarketInfo(Symbol(), MODE_TICKSIZE);
MarketInfo(Symbol(), MODE_POINT);

 

Jetzt wird mit diesen Daten das mögliche Minimum vom Margin, Tick und Point berechnet.

double MinMargin = MarketInfo(Symbol(), MODE_MARGINREQUIRED)*MarketInfo(Symbol(), MODE_MINLOT);
double MinTick  = MarketInfo(Symbol(), MODE_TICKVALUE)*MarketInfo(Symbol(), MODE_MINLOT);
double MinPoint  =  MarketInfo(Symbol(), MODE_TICKVALUE)*MarketInfo(Symbol(), MODE_POINT)/MarketInfo(Symbol(), MODE_TICKSIZE);

 

Fortsetzung folgt...

Berechnung der richtigen Lotgrösse - Money Management mit MQL4

 

Fortsetzung folgt...

 

Gab es mal eine Fortsetzung? Ich suche eine allgemeine Formel für den Metatrader die z.B. auch den Hebel des Kontos mit einbezieht.

 

Gegeben ist also das Instrument, der Abstand bis zum Stop, das verfügbare Kapital und das gewünschte Risiko, gesucht wird die jeweilige Lotgrösse für ein konkretes Konto.

 

Für eure Tips dankt

 

Lutz

Gab es mal eine Fortsetzung?

 

AFAIK nicht, aber wir könnens ja selber mal versuchen ;) am Besten gemeinsam, lernt man am meisten.

 

Du meinst das der Hebel eine Rolle spielt, inwiefern? Wenn ich sage ich riskiere 1% vom Kapital, dann bedeutet das doch, das man im Verlustfall genau 1% des Kapitals verloren hat.

Nicht das man für den Trade 1% der Margin verwendet etc. oder lieg ich falsch?

 

Der Hebel und die freie Margin spielt eine Rolle, wenn ich wissen will ob ich den Trade überhaupt eröffnen darf. Wenn ich zB sage um Margincall zu verhindern will ich maximal 30% Marginlevel etc.

AFAIK nicht, aber wir könnens ja selber mal versuchen ;) am Besten gemeinsam, lernt man am meisten.

 

Gern, brauche so etwas für einen EA.

 

Du meinst das der Hebel eine Rolle spielt, inwiefern? Wenn ich sage ich riskiere 1% vom Kapital, dann bedeutet das doch, das man im Verlustfall genau 1% des Kapitals verloren hat.

Nicht das man für den Trade 1% der Margin verwendet etc. oder lieg ich falsch?

 

Durch den Hebel verändert sich IMHO aber auch meine Bewegung im Konto wenn sich das Basisinstrument um z.B. 0.001% bewegt oder liege ich da falsch?

Ich habe hier Konten mit Hebel 200 und mit Hebel 400, wenn ich da jeweils 0.1 Lot kaufe müsste sich das eine soppelt so stark verändern wie das andere.

 

Wenn ich nun auf jedem mit 1000 Euro Kapital starte müsste ich bei dem mit Hebel 400 nur die halbe Position nehmen damit die nach Tradeende gleich stehen.

 

Korrigiert mich.

 

Ich fange mal mit einer früher mal grob ermittelten Formel für EUR/USD an, wir können die ja dann schrittweise verallgemeinern:

 

 

double Risikobetrag = Kapital*risiko/100;
if (Ask>SL) double abstandstop = Ask-SL; else abstandstop = SL-Ask;
double lots = (Risikobetrag/(abstandstop*100*7.3));
lots = MathCeil(MathRound(lots))/100;
if (lots < 0.01) lots = 0.01;

 

Lutz

Ich habe hier Konten mit Hebel 200 und mit Hebel 400, wenn ich da jeweils 0.1 Lot kaufe müsste sich das eine soppelt so stark verändern wie das andere.

Also AFAIK ist die Bewegung pro Punkt unabhängig vom Hebel. Bewegung pro Punkt kriegst du über die Tick_value bzw. Pointvalue.

Mit einem Hebel 400 Konto kannst du nur mit dem gleichen Kapital doppelt soviele Positionen aufmachen wie mit einem Hebel 200 Konto. Weil du eben pro Lot nur 1/400 des Wertes als Margin hinterlegen musst anstatt einem 1/200.

 

Wollte es eigentlich gerade testen, aber der nette Alpari-Server ignoriert die Angabe des hebels ganz fröhlich.

Bei 1:500 Hebel hat man 1 USD Wertänderung pro 0.00001 Bewegung pro Lot und eine nötige Margin von 282.50

Rechnet man jetzt 282,50 * 500 = 141250. Und bei einem Kurs von 1.4125 sind 100000 Euro genau 141250 Wert. Und eine Änderung des Wechselkurs in der 5. Kommastelle ändert den Wert von 100000 Euro um genau 1 Dollar.

Passt alles wunderbar zusammen.

 

 

zum Code:

warum immer SL-Ask oder Ask-SL? Wenn du SELL eröffnest, verkaufst du beim Bid.

Würde es der einfachheitshalber eher

double stopdiff= MathAbs(entry-stop);

machen.

 

woher kommen die 7.3? ;)

 

Ich versuch mal eine allgemeine Formel herzuleiten:

Wenn die Position geschlossen wird haben wir (im Longfall) folgenden Gewinn/Verlust:

 risk= ((exit-entry)*value_change_per_point*lots

Aber wir kenne das risk bereits und wollen die lots wissen. Also formen wir um

 risk/((exit-entry)*value_change_per_point) = lots

 

Was jetzt noch "fraglich" ist, ist das (value_change_per_point), also die Wertänderung pro vollen Punkt (also von 1.0000 auf 2.0000). Ich arbeite am liebsten mit tick_value und ticksize (vor allem weil man die Werte von MarketInfo direkt kriegt ;).

An der Forex ist es natürlich immer so eine Frage wenn man zB mit einem EUR Konto GBP/JPY handelt... Dann ist der Tick_value nämlich nicht konstant, aber nehmen wirs einfach mal an.

Bei EUR/USD und einem USD Konto ist zB bei Alpari:

TICK_SIZE= 0.00001

TICK_VALUE= 1

Wenn wir die Wertänderung pro vollen Punkt (nicht Point!) wollen, müssen wir umrechnen. Wir wissen das die Wertänderung pro Tick (also wenn man die Wertänderung pro Punkt auf Ticks runterbricht) genau tick_value ist:

value_change_per_point*tick_size=tick_value

Also folgt

value_change_per_point=tick_value/tick_size

 

eingefügt in das oben folgt:

lots= risk/((exit-entry)*(tick_value/tick_size)) = (risk*tick_size)/((exit-entry)*tick_value)

 

So, ich lass das mal kurz so stehen. Kann ja sein das sich wo ein Fehler eingeschlichen hat ;)

Fortsetzung folgt (diesmal wirklich ;)

Also AFAIK ist die Bewegung pro Punkt unabhängig vom Hebel. Bewegung pro Punkt kriegst du über die Tick_value bzw. Pointvalue.

Mit einem Hebel 400 Konto kannst du nur mit dem gleichen Kapital doppelt soviele Positionen aufmachen wie mit einem Hebel 200 Konto. Weil du eben pro Lot nur 1/400 des Wertes als Margin hinterlegen musst anstatt einem 1/200.

 

Wollte es eigentlich gerade testen, aber der nette Alpari-Server ignoriert die Angabe des hebels ganz fröhlich.

Bei 1:500 Hebel hat man 1 USD Wertänderung pro 0.00001 Bewegung pro Lot und eine nötige Margin von 282.50

Rechnet man jetzt 282,50 * 500 = 141250. Und bei einem Kurs von 1.4125 sind 100000 Euro genau 141250 Wert. Und eine Änderung des Wechselkurs in der 5. Kommastelle ändert den Wert von 100000 Euro um genau 1 Dollar.

Passt alles wunderbar zusammen.

 

Ja, war ein Denkfehler von mir.

 

zum Code:

warum immer SL-Ask oder Ask-SL? Wenn du SELL eröffnest, verkaufst du beim Bid.

Korrekt, Bid wäre dort richtig.

 

Würde es der einfachheitshalber eher

double stopdiff= MathAbs(entry-stop);

machen.

woher kommen die 7.3? ;)

 

Korrekturfaktor, das war ein Eurokonto beim EURUSD Kurs von ca. 1,37.

 

Den Rest muss ich erst mal in Ruhe nachvollziehen

 

Lutz

Den Rest muss ich erst mal in Ruhe nachvollziehen

 

So, habe das Schritt für Schritt nachvollzogen, und im Metatrader mal nachgebaut.

 

Mit

 

double lots=(risk*MarketInfo(Symbol(),MODE_TICKSIZE))/(MathAbs(Entry-SL)*MarketInfo(Symbol(),MODE_TICKVALUE));

 

kommen erst mal plausible Werte raus.

 

Bei einem Demokonto mit 16200 Euro und 0,5% Risiko bei 20 Pips Abstand EURUSD ergibt das 80 Euro Risiko für den Trade und 0.5748 Lot.

 

Es ist sicher sinnvoll die je nach Plattform und Instrument noch auf Vielfache von 0.1 oder 0.01 zu runden?

 

Lutz

Genau,

 

da du den Einsatz von MarketInfo schon vorweg genommen hast, mach ich gleich weiter ;)

 

ich würds in eine solche Funktion packen:

double calcLotSize(double stopdiff,double riskPercent) {
 double risk= AccountEquity()*riskPercent/100;
 double lots=(risk*MarketInfo(Symbol(),MODE_TICKSIZE))/(stopdiff*MarketInfo(Symbol(),MODE_TICKVALUE));

 //producing a valid lotsize
 double lot_step= MarketInfo(symbol,MODE_LOTSTEP);
 double minlot= MarketInfo(symbol,MODE_MINLOT);
 double maxlot= MarketInfo(symbol,MODE_MAXLOT);
 lots= MathFloor(lots/lot_step)*lot_step;
 lots= MathMin(maxlot,MathMax(minlot,lots)); // no empty orders, not trading too much ;)
 
 return(lots);
}

 

was jetzt noch fehlt ist die Überprüfung ob man überhaupt genug Margin für diese Position hat, aber das sollte man nicht hier machen. Außer man überprüft außerhalb ob lots= 0 und sendet die Order dann nicht. Dann sollte man aber auch nicht auf MinLot aufrunden.

Also diese Funktion hier versucht eine Lotgröße zu bestimmen die möglichst nahe an dem gewünschten Risiko (im Zweifelsfall darunter) liegt aber dennoch eine gültige Lotgröße für OrderSend ist.

 

Hoffe ich hab mich nirgends vertan ;)

Hoffe ich hab mich nirgends vertan ;)

 

Das sieht nicht so aus, werde ich aber noch testen.

 

Ich muss noch zwei Ergänzungen vornehmen (vielleicht etwas speziell für meine Anwendung):

 

- zum einen muss ich der Funktion das Symbol übergeben, da ich aus einem EA Positionen in ganz verschiedenen Instrumenten öffnen möchte

 

- zum anderen gehe ich mitunter Positionen mit recht hohem Risiko ein, deshalb möchte ich den niedrigeren Wert aus Balance oder Equity als verfügbares Kapital heranziehen um zumindest hier dann etwas vorsichtiger zu agieren

 

Ganz korrekt müsste man dazu auch die SL aller offenen Positionen als offenes Risiko mit heranziehen, das ist dann aber etwas aufwendig. Andererseits habe ich im Moment nicht viele Positionen gleichzeitig offen so dass das so schon einigermassen passt.

 

Lutz

Stimmt, mit symbol als Parameter wärs ganz allgemein, dann kann man die Funktion schon schön in eine lib dazupacken ;)

 

Ganz korrekt müsste man dazu auch die SL aller offenen Positionen als offenes Risiko mit heranziehen, das ist dann aber etwas aufwendig. Andererseits habe ich im Moment nicht viele Positionen gleichzeitig offen so dass das so schon einigermassen passt.

Wieso? Das Eröffnungsrisiko bezieht sich ja immer auf eine Position, weils darum geht das jede Position das gleiche R hat (also "gleichberechtigt" ist).

Was du meinst wär dann eher eine Art Risikopool wo du sagst das maximal X Prozent in Summe gleichzeitig riskiert werden dürfen. Das sollte dann aber ein anderer Wert sein. zB 2-3% pro Position und in Summe nicht mehr als 30% gleichzeitig...

Wieso? Das Eröffnungsrisiko bezieht sich ja immer auf eine Position, weils darum geht das jede Position das gleiche R hat (also "gleichberechtigt" ist).

Was du meinst wär dann eher eine Art Risikopool wo du sagst das maximal X Prozent in Summe gleichzeitig riskiert werden dürfen. Das sollte dann aber ein anderer Wert sein. zB 2-3% pro Position und in Summe nicht mehr als 30% gleichzeitig...

 

Ich möchte einfach berücksichtigen wenn eine offene Position schon im Minus ist und dann lieber etwas weniger riskieren. Die Drawdowns werden dann einfach kleiner, wenn der Gewinn dadurch mal etwas langsamer wächst habe ich damit kein Problem.

 

Lutz

Ich möchte einfach berücksichtigen wenn eine offene Position schon im Minus ist und dann lieber etwas weniger riskieren. Die Drawdowns werden dann einfach kleiner, wenn der Gewinn dadurch mal etwas langsamer wächst habe ich damit kein Problem.

 

Ok, das ist dann vor allem der Punkt mit Min(Balance,Equity) oder? Weil du da offener Gewinner nicht berücksichtigst, offene Verlierer aber das Risiko reduzieren.

Wenn du das aktuelle Risiko der offenen Positionen mit berücksichtigst, geht das aber nicht nur auf deine offenen Verlierer oder? ZB eine Order offen aktuell 20 Punkte im Gewinn, StopLoss steht bei 20 Punkte unter Einstieg... Init-Risiko 20 Punkte, "offenes Risk" sogar 40 Punkte. soll jetzt das Risiko für eine neue Position um diese 20 Punkte reduziert werden? Oder gar um 40?

 

nicht falsch verstehen, kann alles Sinn machen und hängt natürlich von der jeweiligen Strategie hab, will nur sichergehen das du nichts übersiehst ;)

 

bzgl. Risikopool könnte man ja noch eine Funktion "vorschalten" die dir das freie Risiko gibt, das kann man dann in die calcLots(...) reingeben und die gibt ggf lots= 0 zurück. Bin derzeit nicht bei meinem Coding-PC, aber wenns wen interessiert könnt ichs bei Gelegenheit implementieren.

 

lg

Ja, war ein Denkfehler von mir.

 

Der Vollständigkeit halber: habe das eben mit zwei Konten überprüft:

 

Bei Änderung des Hebels ändert sich lediglich die Marginanforderung entsprechend, das Ergebnis des Trades ist bei gleicher Lotgrösse identisch.

Eigentlich logisch, aber manchmal hat man einen Knoten im Hirn.

 

Danke für den Denkanstoss

 

Lutz

Also,

ich hab mal ein bissl gebastelt. Und die Funktionen sollten jetzt folgendes tun:

calcPossibleRisk() berechnet wieviel Risiko noch frei ist sodass in Summe nicht mehr als x Prozent vom angegeben balance riskiert werden. Wobei man wählen kann ob das offene Risiko genommen wird oder nur das Eröffnungsrisiko. Wenn das übergebene maximale Risiko pro Position kleiner ist als das noch freie wird natürlich das pro pos zurückgegeben.

Der Rückgabewert ist also genau der Betrag den eine neue Position riskieren sollte.

 

Dieser Wert kann jetzt ins calcLots übergeben werden das dann die passende Lotsize ausrechnet. Das neue calcLots kann auch 0 zurückgeben was man außerhalb überprüfen muss und ggf. keine Order senden.

 

ich hoffe wie immer das ich mich nirgends vertan hab, vielleicht hilfts dem einen oder anderen.

double calcPossibleRisk(int magicnumber,double maxPosRiskPerc,double maxPoolRiskPerc,double equity,bool useOpenRisk) {
 double openRisk= 0;
 double pointRisk= 0;
 double curPrice= 0;
 for(int idx= OrdersTotal()-1;idx >= 0;idx--) {
   if(!OrderSelect(idx,SELECT_BY_POS,MODE_TRADES))
     continue;
   if(OrderMagicNumber() != magicnumber && magicnumber != 0)
     continue;
   if(OrderType() == OP_BUY)
     curPrice= MarketInfo(OrderSymbol(),MODE_BID); //Buy close on Bid
   if(OrderType() == OP_SELL)
     curPrice= MarketInfo(OrderSymbol(),MODE_ASK); //Sell close on Ask
   if(useOpenRisk && (OrderType() == OP_BUY || OrderType() == OP_SELL))
     pointRisk= MathAbs(curPrice - OrderStopLoss());
   else
     pointRisk= MathAbs(OrderOpenPrice() - OrderStopLoss());
   //calc risk in Currency
   openRisk+= pointRisk*MarketInfo(OrderSymbol(),MODE_TICKVALUE)/MarketInfo(OrderSymbol(),MODE_TICKSIZE);
 }
 double maxPoolRisk= equity*maxPoolRiskPerc/100;
 if(openRisk > maxPoolRisk)
   return(0);
 
 double freeRisk= maxPoolRisk - openRisk;
 freeRisk= MathMin(freeRisk,equity*maxPosRiskPerc/100);
 return(freeRisk);
}

double calcLotSize(string symbol,double stopdiff,double riskAbs) {
 double lots=(riskAbs*MarketInfo(symbol,MODE_TICKSIZE))/(stopdiff*MarketInfo(symbol,MODE_TICKVALUE));

 //producing a valid lotsize
 double lot_step= MarketInfo(symbol,MODE_LOTSTEP);
 double minlot= MarketInfo(symbol,MODE_MINLOT);
 double maxlot= MarketInfo(symbol,MODE_MAXLOT);
 lots= MathFloor(lots/lot_step)*lot_step;
 lots= MathMin(maxlot,lots); // no empty orders, not trading too much ;)
 if(lots < minlot)
   return(0);
 else
   return(lots);
}

 

mögliche Anwendung:

Positionsrisiko 2%, Poolrisk 30%, da ich hier AccountEquity nehm verwende ich das offene Risiko (useOpenRisk = true) weil ja der offene Gewinn auch im AccountEquity einberechnet ist)

double risk= calcPossibleRisk(MAGIC_NUMBER,2,30,AccountEquity(),true);
double lots= calcLotSize(symbol,stopdiff,risk);
if(lots > 0)
 OrderSend(...)

 

PS natürlich alles ohne Gewähr ;)

Also,

ich hab mal ein bissl gebastelt.

 

PS natürlich alles ohne Gewähr ;)

 

Gerade wollte ich mich wieder dranmachen ...

 

Danke!

 

hinter curPrice= ist ein = zu viel, ansonsten nimmt es der Compiler.

 

Ich werde mal testen.

 

Lutz

hinter curPrice= ist ein = zu viel, ansonsten nimmt es der Compiler.

 

stimmt, danke. Meine Aufmerksamkeit war auch schon mal höher...

 

Ich werde mal testen.

 

 

Sieht gut aus, die Funktion calcLotSize tut was sie soll.

 

Bei 20 Pips im EURUSD, 1% Risiko und 16200 Euro Kapital kommen exakt 1.0 Lot heraus (geht bei dem Broker nur mit einer Stelle nach dem Komma), das scheint zu passen.

 

Die andere Funktion habe ich mangels Verwendung bisher nicht getestet, ich bin mit dem Risiko eigentlich immer bei recht geringen Marginanforderungen bzw. habe auch selten mehr als 2 Positionen gleichzeitig offen so dass das Gesamtrisko überschaubar bleibt.

 

Lutz