Spread und Hedgeproblem

Einloggen oder registrieren, um einen Kommentar zu schreiben
Oldtimer507
16
Oldtimer507  

Mein Martingale-Problem ist:

Ich habe eine Short- und Long-Position im DAX. Die Long hat 0,5 Lot und wird bei 13050 Punkten ausgeführt mit einem Kursziel von 13060 - also 10 Punkte. Wird der TP nicht erreicht und der Kurs dreht, wird ein Shorttrade bei 13040 mit 1,0 Lot ausgelöst auch mit einem TP von 10 Punkte - also 13030.

Long-Trade: Entry 13050 TP 13060 SL 13030
Short-Trade: Entry 13040 TP 13030 SL 13060

Nun mein Problem???

Wird der Shorttrade ausgeführt, wird der TP über die ASK-Line erreicht - allerdings wird der SL der Longposition durch den Spread von der BID-Line ausgeführt. Das bedeutet, unter Umständen wird der SL ausgelöst, aber nicht der TP - naja, und wenn der Trade dann dreht kann das ganz gut nach hinten losgehen. Wie kann ich das Spreadproblem lösen??

Problem 2:

Wenn ich einen Hedge setze - das funktioniert nur bedingt - er errechnet mir zwar die richtige Lotzahl, aber die SL's und TP's werden nicht gelöscht - heißt mein Hedge funktioniert nicht, weil der Kurs irgendwann den SL oder TP erreicht

Hier mal was ich mir zusammenprogrammiert habe mit lesen, Hilfe und Recherche - klappt eigentlich schon ganz gut - wenn ich jetzt noch die beiden Fehler finde bzw eliminiert bekomme ....


hier der Code:



Die executeLong Funktion eröffnet eine Long Position.

*/

int executeLong(){

   //calculate entry

   double entry = ObjectGetDouble(0,"Rect [260145-1]",OBJPROP_PRICE2);

   entry = roundUp(entry);


   //calculate SL

   double sl = 0;

   if(SLPoints > 0) sl = entry - SLPoints * Point;

   sl = roundUp(sl);


   //calculate TP

   double tp = 0;

   if(TPPoints > 0) tp = entry + TPPoints * Point;

   tp = roundUp(tp); 


   //calc lots

   double lots = Lots;

   switch(tradeCounter){

      case 2: lots *= 4; break;

      case 3: lots *= 12; break;

      case 4: lots *= 36; break;

   }

   if(MarketInfo(Symbol(),MODE_LOTSTEP) == 0.01){

      lots = NormalizeDouble(lots,2);

   }else if(MarketInfo(Symbol(),MODE_LOTSTEP) == 0.1){

      lots = NormalizeDouble(lots,1);

   }else if(MarketInfo(Symbol(),MODE_LOTSTEP) == 1){

      lots = NormalizeDouble(lots,0);

   }

   

   //open position 

   int ticket = OrderSend(Symbol(),OP_BUYSTOP,lots,entry,1000,sl,tp,"Trade "+IntegerToString(tradeCounter)+"|"+Commentary,Magic,0);

   if(ticket > 0) addToArray(tickets,OrderTicket());


   return ticket;

}


/*

Die executeShort Funktion eröffnet eine Short Position.

*/

int executeShort(){ 

   //calculatae entry

   double entry = ObjectGetDouble(0,"Rect [260145-1]",OBJPROP_PRICE);

   entry = roundDn(entry);


   //calculate SL

   double sl = 0;

   if(SLPoints > 0) sl = entry + SLPoints * Point;

   sl = roundDn(sl);

   

   //calculate tp

   double tp = 0;

   if(TPPoints > 0) tp = entry - TPPoints * Point;

   tp = roundDn(tp);

 

   //calc lots

   double lots = Lots;

   switch(tradeCounter){

      case 2: lots *= 4; break;

      case 3: lots *= 12; break;

      case 4: lots *= 36; break;

   }

   if(MarketInfo(Symbol(),MODE_LOTSTEP) == 0.01){

      lots = NormalizeDouble(lots,2);

   }else if(MarketInfo(Symbol(),MODE_LOTSTEP) == 0.1){

      lots = NormalizeDouble(lots,1);

   }else if(MarketInfo(Symbol(),MODE_LOTSTEP) == 1){

      lots = NormalizeDouble(lots,0);

   }

   

   //open position

   int ticket = OrderSend(Symbol(),OP_SELLSTOP,lots,entry,1000,sl,tp,"Trade "+IntegerToString(tradeCounter)+"|"+Commentary,Magic,0);  

   if(ticket > 0) addToArray(tickets,OrderTicket());


   return ticket;                   

}


/*

Die countAll Funktion zählt alle offenen Market-Order.

*/

int countAll(){

   int counter = 0;

   for(int i = 0; i < OrdersTotal(); i++){

      if(OrderSelect(i,SELECT_BY_POS) && OrderMagicNumber() == Magic && OrderSymbol() == Symbol()){

         if(OrderType() == OP_BUY || OrderType() == OP_SELL){

            counter++;

         }

      }

   }

   return counter;

}


/*

Die countLong Funktion zählt alle offenen Long-Market-Order.

*/

int countLong(){

   int counter = 0;

   for(int i = 0; i < OrdersTotal(); i++){

      if(OrderSelect(i,SELECT_BY_POS) && OrderMagicNumber() == Magic && OrderSymbol() == Symbol()){

         if(OrderType() == OP_BUY){

            counter++;

         }

      }

   }

   return counter;

}


/*

Die countLongStop Funktion zählt alle Long-Stop-Order.

*/

int countLongStop(){

   int counter = 0;

   for(int i = 0; i < OrdersTotal(); i++){

      if(OrderSelect(i,SELECT_BY_POS) && OrderMagicNumber() == Magic && OrderSymbol() == Symbol()){

         if(OrderType() == OP_BUYSTOP){

            counter++;

         }

      }

   }

   return counter;

}


/*

Die countLongLimit Funktion zählt alle Long-Limit-Order.

*/

int countLongLimit(){

   int counter = 0;

   for(int i = 0; i < OrdersTotal(); i++){

      if(OrderSelect(i,SELECT_BY_POS) && OrderMagicNumber() == Magic && OrderSymbol() == Symbol()){

         if(OrderType() == OP_BUYLIMIT){

            counter++;

         }

      }

   }

   return counter;

}


/*

Die countShort Funktion zählt alle offenen Short-Market-Order.

*/

int countShort(){

   int counter = 0;

   for(int i = 0; i < OrdersTotal(); i++){

      if(OrderSelect(i,SELECT_BY_POS) && OrderMagicNumber() == Magic && OrderSymbol() == Symbol()){

         if(OrderType() == OP_SELL){

            counter++;

         }

      }

   }

   return counter;

}


/*

Die countShortStop Funktion zählt alle Short-Stop-Order.

*/

int countShortStop(){

   int counter = 0;

   for(int i = 0; i < OrdersTotal(); i++){

      if(OrderSelect(i,SELECT_BY_POS) && OrderMagicNumber() == Magic && OrderSymbol() == Symbol()){

         if(OrderType() == OP_SELLSTOP){

            counter++;

         }

      }

   }

   return counter;

}


/*

Die countShortLimit Funktion zählt alle Short-Limit-Order.

*/

int countShortLimit(){

   int counter = 0;

   for(int i = 0; i < OrdersTotal(); i++){

      if(OrderSelect(i,SELECT_BY_POS) && OrderMagicNumber() == Magic && OrderSymbol() == Symbol()){

         if(OrderType() == OP_SELLLIMIT){

            counter++;

         }

      }

   }

   return counter;

}


/*

Die calcLots Funktion berechnet die Anzahl der Lots, die bei einer übergebenen Stopp-Distanz einen definierten maximalen Verlust ausmachen.

*/

double calcLots(double slPoints, double riskInPercent){

   double riskPerTradeMoney = AccountEquity() * (riskInPercent/100);

   double moneyPerLotstep = (slPoints / MarketInfo(Symbol(),MODE_TICKSIZE)) * MarketInfo(Symbol(),MODE_TICKVALUE) * MarketInfo(Symbol(),MODE_LOTSTEP);

   return MathFloor(riskPerTradeMoney / moneyPerLotstep) * MarketInfo(Symbol(),MODE_LOTSTEP);

}


/*

Die roundUp Funktion rundet einen übergebenen Preis auf die nächste Ticksize auf.

*/

double roundUp(double price){

   double ticksize = NormalizeDouble(MarketInfo(Symbol(),MODE_TICKSIZE),Digits);

   price = NormalizeDouble(price,Digits);

   

   double rest = price - NormalizeDouble(price/ticksize,0)*ticksize;

   rest = NormalizeDouble(rest,Digits);

   if(rest != 0){

      for(double i = Point;i <= ticksize;i = i + Point){

         price = NormalizeDouble(price + Point,Digits);

         rest = price - NormalizeDouble(price/ticksize,0)*ticksize;

         rest = NormalizeDouble(rest,Digits);

         if(rest == 0) break;

      }

   }

   return price;

}


/*

Die roundDn Funktion rundet einen übergebenen Preis auf die nächste Ticksize ab.

*/

double roundDn(double price){

   double ticksize = MarketInfo(Symbol(),MODE_TICKSIZE);

   price = NormalizeDouble(price,Digits);

   

   double rest = price - (NormalizeDouble(price/ticksize,0)*ticksize);

   rest = NormalizeDouble(rest,Digits);

   if(rest != 0){

      for(double i = Point;i <= ticksize;i = i + Point){

         price = NormalizeDouble(price - Point,Digits);

         rest = price - NormalizeDouble(price/ticksize,0)*ticksize;

         rest = NormalizeDouble(rest,Digits);

         if(rest == 0) break;

      }

   }

   return price;

}


/*

Die calculateRange Funktion berechnet eine zeitliche Range.

*/

double calculateRange(datetime sTime, datetime eTime){

   //Calculate the number of bars between start and end time  

   int indexFirstCandle = iBarShift(Symbol(),PERIOD_M1,sTime,false);

   int indexLastCandle = iBarShift(Symbol(),PERIOD_M1,eTime,false);

   int candlesInBetween = indexFirstCandle-indexLastCandle+1;

      

   //Find the highest and lowest bar 

   int candleHighest = iHighest(Symbol(),PERIOD_M1,MODE_HIGH,candlesInBetween,indexLastCandle);

   int candleLowest = iLowest(Symbol(),PERIOD_M1,MODE_LOW,candlesInBetween,indexLastCandle);


   //Find the highest an lowest price and calculate range pips 

   double high = NormalizeDouble(iHigh(Symbol(),PERIOD_M1,candleHighest),Digits);

   double low = NormalizeDouble(iLow(Symbol(),PERIOD_M1,candleLowest),Digits);

   double points = NormalizeDouble((high-low),Digits)/Point;

      

   //Draw range    

   string name = "Range" + IntegerToString(DayOfYear());

   ObjectDelete(0,name); 

   ObjectCreate(0,name,OBJ_RECTANGLE,0,sTime,low,eTime,high);

   ObjectSetInteger(0,name,OBJPROP_COLOR,clrGreen);

   ObjectSetInteger(0,name,OBJPROP_BACK,true);

   ObjectSetInteger(0,name,OBJPROP_SELECTABLE,false);    

   

   return points;

}


/*

Die closeAll Funktion schließt alle offenen Market-Orders.

*/

int closeAll(){

   int counter = 0;

   for(int i = 0; i < OrdersTotal(); i++){

      if(OrderSelect(i,SELECT_BY_POS) && OrderMagicNumber() == Magic && OrderSymbol() == Symbol()){

         if(OrderType() == OP_BUY){

            for(int j = 0; j < 5; j++){

               if(OrderClose(OrderTicket(),OrderLots(),Bid,1000)){

                  i--;

                  counter++;

                  break;

               }

               else if(GetLastError() == ERR_TRADE_CONTEXT_BUSY){

                  Sleep(2000);

                  i--;

               }            

            }

         }

         else if(OrderType() == OP_SELL){

            for(int j = 0; j < 5; j++){

               if(OrderClose(OrderTicket(),OrderLots(),Ask,1000)){

                  i--;

                  counter++;

                  break;

               }            

               else if(GetLastError() == ERR_TRADE_CONTEXT_BUSY){

                  Sleep(2000);

                  i--;

               }            

            }

         }

      }

   }

   return counter;

}


/*

Die closeLong Funktion schließt alle offenen Long-Market-Order.

*/

int closeLong(){

   int counter = 0;

   for(int i = 0; i < OrdersTotal(); i++){

      if(OrderSelect(i,SELECT_BY_POS) && OrderMagicNumber() == Magic && OrderSymbol() == Symbol()){

         if(OrderType() == OP_BUY){

            for(int j = 0; j < 5; j++){

               if(OrderClose(OrderTicket(),OrderLots(),Bid,1000)){

                  i--;

                  counter++;

                  break;

               }            

               else if(GetLastError() == ERR_TRADE_CONTEXT_BUSY){

                  Sleep(2000);

                  i--;

               }            

            }

         }

      }

   }

   return counter;

}


/*

Die closeShort Funktion schließt alle offenen Short-Market-Order.

*/

int closeShort(){

   int counter = 0;

   for(int i = 0; i < OrdersTotal(); i++){

      if(OrderSelect(i,SELECT_BY_POS) && OrderMagicNumber() == Magic && OrderSymbol() == Symbol()){

         if(OrderType() == OP_SELL){

            for(int j = 0; j < 5; j++){

               if(OrderClose(OrderTicket(),OrderLots(),Ask,1000)){

                  i--;

                  counter++;

                  break;

               }            

               else if(GetLastError() == ERR_TRADE_CONTEXT_BUSY){

                  Sleep(2000);

                  i--;

               }            

            }

         }

      }

   }

   return counter;

}


/*

Die deleteAll Funktion löscht alle bestehenden Pending-Order.

*/

int deleteAll(){

   int counter = 0;

   for(int i = 0; i < OrdersTotal(); i++){

      if(OrderSelect(i,SELECT_BY_POS) && OrderMagicNumber() == Magic && OrderSymbol() == Symbol()){

         if(OrderType() == OP_BUYSTOP){

            for(int j = 0; j < 5; j++){

               if(OrderDelete(OrderTicket())){

                  i--;

                  counter++;

                  break;

               }            

               else if(GetLastError() == ERR_TRADE_CONTEXT_BUSY){

                  Sleep(2000);

                  i--;

               }            

            }

         }

         else if(OrderType() == OP_BUYLIMIT){

            for(int j = 0; j < 5; j++){

               if(OrderDelete(OrderTicket())){

                  i--;

                  counter++;

                  break;

               }  

               else if(GetLastError() == ERR_TRADE_CONTEXT_BUSY){

                  Sleep(2000);

                  i--;

               }          

            }

         } 

         else if(OrderType() == OP_SELLSTOP){

            for(int j = 0; j < 5; j++){

               if(OrderDelete(OrderTicket())){

                  i--;

                  counter++;

                  break;

               }            

               else if(GetLastError() == ERR_TRADE_CONTEXT_BUSY){

                  Sleep(2000);

                  i--;

               }          

            }

         }

         else if(OrderType() == OP_SELLLIMIT){

            for(int j = 0; j < 5; j++){

               if(OrderDelete(OrderTicket())){

                  i--;

                  counter++;

                  break;

               }            

               else if(GetLastError() == ERR_TRADE_CONTEXT_BUSY){

                  Sleep(2000);

                  i--;

               }          

            }

         }

      }

   }   

   return counter;

}


/*

Die deleteLong Funktion löscht alle bestehenden Long-Pending-Order.

*/

int deleteLong(){

   int counter = 0;

   for(int i = 0; i < OrdersTotal(); i++){

      if(OrderSelect(i,SELECT_BY_POS) && OrderMagicNumber() == Magic && OrderSymbol() == Symbol()){

         if(OrderType() == OP_BUYSTOP){

            for(int j = 0; j < 5; j++){

               if(OrderDelete(OrderTicket())){

                  i--;

                  counter++;

                  break;

               }            

            }

         }

         else if(OrderType() == OP_BUYLIMIT){

            for(int j = 0; j < 5; j++){

               if(OrderDelete(OrderTicket())){

                  i--;

                  counter++;

                  break;

               }             

            }

         } 

      }

   }   

   return counter;

}


/*

Die deleteShort Funktion löscht alle bestehenden Short-Pending-Order.

*/

int deleteShort(){

   int counter = 0;

   for(int i = 0; i < OrdersTotal(); i++){

      if(OrderSelect(i,SELECT_BY_POS) && OrderMagicNumber() == Magic && OrderSymbol() == Symbol()){

         if(OrderType() == OP_SELLSTOP){

            for(int j = 0; j < 5; j++){

               if(OrderDelete(OrderTicket())){

                  i--;

                  counter++;

                  break;

               }            

            }

         }

         else if(OrderType() == OP_SELLLIMIT){

            for(int j = 0; j < 5; j++){

               if(OrderDelete(OrderTicket())){

                  i--;

                  counter++;

                  break;

               }            

            }

         }

      }

   }   

   return counter;

}


/*

Die trailingStopClassic Funktion zieht bei allen Order den Stopp im gleichbleibenden Abstand (points) nach.

*/

void trailingStopClassic(double points){

   for(int i = 0; i < OrdersTotal(); i++){

      if(OrderSelect(i,SELECT_BY_POS) && OrderMagicNumber() == Magic && OrderSymbol() == Symbol()){

         if(OrderType() == OP_BUY){

            double sl = Bid - points * Point;

            sl = roundDn(sl);

            if(OrderStopLoss() < sl){

               bool res = OrderModify(OrderTicket(),OrderOpenPrice(),sl,OrderTakeProfit(),OrderExpiration());

            }

         }

         else if(OrderType() == OP_SELL){

            double sl = Ask + points * Point;

            sl = roundUp(sl);

            if(OrderStopLoss() > sl || OrderStopLoss() == 0){

               bool res = OrderModify(OrderTicket(),OrderOpenPrice(),sl,OrderTakeProfit(),OrderExpiration());

            }

         }

      }

   }

}


/*

Die trailingStopBreakEven Funktion zieht bei allen Order den Stopp auf Break Even, sobald der Trade um x Points im Gewinn ist.

*/

void trailingStopBreakEven(double profitPoints){

   for(int i = 0; i < OrdersTotal(); i++){

      if(OrderSelect(i,SELECT_BY_POS) && OrderMagicNumber() == Magic && OrderSymbol() == Symbol()){

         if(OrderType() == OP_BUY){

            if(Bid >= OrderOpenPrice()+profitPoints*Point){

               double sl = OrderOpenPrice();

               if(OrderStopLoss() < sl){

                  bool res = OrderModify(OrderTicket(),OrderOpenPrice(),sl,OrderTakeProfit(),OrderExpiration());

               }

            }         

         }

         else if(OrderType() == OP_SELL){

            if(Ask <= OrderOpenPrice()-profitPoints*Point){

               double sl = OrderOpenPrice();

               if(OrderStopLoss() > sl || OrderStopLoss() == 0){

                  bool res = OrderModify(OrderTicket(),OrderOpenPrice(),sl,OrderTakeProfit(),OrderExpiration());

               }

            }         

         }

      }

   }

}


/*

Die trailingStopCRV Funktion zieht bei allen Order den Stopp so nach, dass immer ein CRV von 1:1 entsteht.

*/

void trailingStopCRV(){

   for(int i = 0; i < OrdersTotal(); i++){

      if(OrderSelect(i,SELECT_BY_POS) && OrderMagicNumber() == Magic && OrderSymbol() == Symbol()){

         if(OrderType() == OP_BUY && OrderTakeProfit() != 0){

            double sl = Bid - (OrderTakeProfit() - Bid);

            if(OrderStopLoss() < sl){

               bool res = OrderModify(OrderTicket(),OrderOpenPrice(),sl,OrderTakeProfit(),OrderExpiration());

            }

         }

         else if(OrderType() == OP_SELL && OrderTakeProfit() != 0){

            double sl = Ask + (Ask - OrderTakeProfit());

            if(OrderStopLoss() > sl || OrderStopLoss() == 0){

               bool res = OrderModify(OrderTicket(),OrderOpenPrice(),sl,OrderTakeProfit(),OrderExpiration());

            }

         }         

      }

   }

}


/*

Die trailingStopCRV Funktion zieht bei allen Order den Stopp so nach, dass immer ein CRV von 1:1 entsteht.

*/

void trailingStopEndgame(int pointsToGo){

   for(int i = 0; i < OrdersTotal(); i++){

      if(OrderSelect(i,SELECT_BY_POS) && OrderMagicNumber() == Magic && OrderSymbol() == Symbol()){

         if(OrderType() == OP_BUY && OrderTakeProfit() != 0 && (OrderTakeProfit() - Bid)/Point <= pointsToGo){

            double sl = Bid - (OrderTakeProfit() - Bid);

            if(OrderStopLoss() < sl){

               bool res = OrderModify(OrderTicket(),OrderOpenPrice(),sl,OrderTakeProfit(),OrderExpiration());

            }

         }

         else if(OrderType() == OP_SELL && OrderTakeProfit() != 0 && (Bid - OrderTakeProfit())/Point <= pointsToGo){

            double sl = Ask + (Ask - OrderTakeProfit());

            if(OrderStopLoss() > sl || OrderStopLoss() == 0){

               bool res = OrderModify(OrderTicket(),OrderOpenPrice(),sl,OrderTakeProfit(),OrderExpiration());

            }

         }         

      }

   }

}


/*

Die trailingStopTime Funktion schließt eine Order, wenn eine bestimme Zeit überschritten wurde.

*/

void trailingStopTime(datetime timeMinutes){

   for(int i = 0; i < OrdersTotal(); i++){

      if(OrderSelect(i,SELECT_BY_POS) && OrderMagicNumber() == Magic && OrderSymbol() == Symbol()){

         if(OrderOpenTime() < TimeCurrent() - timeMinutes * 60){

            if(OrderType() == OP_BUY){

               if(OrderClose(OrderTicket(),OrderLots(),Bid,1000)){

                  i--;

               }

            }

            if(OrderType() == OP_SELL){

               if(OrderClose(OrderTicket(),OrderLots(),Ask,1000)){

                  i--;

               }

            }

         }

      }

   }

}


/*

Die removeFromArray Funktion entfernt einen Wert aus einem Array.

*/

int removeFromArray(double& array[], double value){

   int counter = 0;

   double temp[];

   

   for(int i = 0; i < ArraySize(array); i++){

      if(array[i] == value) continue;

      ArrayResize(temp,ArraySize(temp)+1);

      temp[ArraySize(temp)-1] = array[i];

      counter++;

   }

   ArrayFree(array);

   ArrayCopy(array,temp);

   

   return counter;

}


int removeFromArray(int& array[], int value){

   int counter = 0;

   int temp[];

   

   for(int i = 0; i < ArraySize(array); i++){

      if(array[i] == value) continue;

      ArrayResize(temp,ArraySize(temp)+1);

      temp[ArraySize(temp)-1] = array[i];

      counter++;

   }

   ArrayFree(array);

   ArrayCopy(array,temp);

   

   return counter;

}


int removeFromArray(string& array[], string value){

   int counter = 0;

   string temp[];

   

   for(int i = 0; i < ArraySize(array); i++){

      if(array[i] == value) continue;

      ArrayResize(temp,ArraySize(temp)+1);

      temp[ArraySize(temp)-1] = array[i];

      counter++;

   }

   ArrayFree(array);

   ArrayCopy(array,temp);

   

   return counter;

}

Carl Schreiber
Moderator
7307
Carl Schreiber  
  1. Hallo erstmal und herzlich willkommen :)
  2. Für Code gibt es ein spez. Format: ALT+s oder der Knopf </>
  3. Ich wollte Dir das selber ändern, aber esklappte nicht  :( Du kannst es aber selber versuchen.
  4. Für Dein Problem sehe ich nur zwei Lösungen (die Broker machen es einem halt nicht eo einfach Geld zu verdienen:
    a) Nimm die Spreads weiter auseinander oder
    b) verwende nur Desaster-SL und -TG, ganz weit weg sind und regele die Ausstiege selber mit 'hidden" oder internen SL und TG und einem Algorithmus sie anzuwenden oder nicht.
amando
971
amando  

also ganz kann ich dein Problem nicht greifen, ich versteh einfach nicht wo das Problem bei den SL und den TP liegt.


aber du kannst in so einem System gleich mal Spread sparen, das wurde hier schon diskutiert


https://www.mql5.com/de/forum/258881


damit spart du gleich 2x den spread was dein Problem mal gewaltig verringern sollte

CloseBy
CloseBy
  • 2018.06.17
  • www.mql5.com
Hallo, gibts die Funktion eigentlich auch für MQL5? https://www.metatrader5...
Einloggen oder registrieren, um einen Kommentar zu schreiben