Fragen von Neueinsteigern zu MQL4 und MQL5, Hilfe und Diskussion über Algorithmen und Codes - Seite 1920

[Artyom Trishkin]

MrBrooklin #:

Danke für den Tipp, Alexey! Ich werde zunächst in diesem Thread auf eine Antwort warten, aber wenn nichts passiert, werde ich mich an den Thread " Fehler, Bugs, Fragen" wenden.

Mit freundlichen Grüßen, Vladimir.

Sie werden in diesem Thread keine Antworten von den Entwicklern erhalten. Wenn Sie einen Fehler gefunden haben, vergewissern Sie sich, dass es sich wirklich um einen Fehler handelt, und melden Sie ihn der von Alexey vertretenen Zweigstelle. Sie brauchen keine Maßnahmen von den Moderatoren zu erwarten - auch wir sind Menschen, und auch wir haben manchmal keine Zeit.

[MrBrooklin]

Artyom Trishkin #:

Es ist unwahrscheinlich, dass Sie in diesem Thread Antworten von den Entwicklern erhalten. Wenn Sie einen Fehler finden, vergewissern Sie sich, dass es sich wirklich um einen Fehler handelt, und melden Sie ihn der Zweigstelle von Alexey. Es gibt keinen Grund, von den Moderatoren Maßnahmen zu erwarten - auch wir sind Menschen, und auch wir haben keine Zeit.

Hallo Artem!

Alles ist klar.

Mit freundlichen Grüßen, Vladimir.

[EVGENII SHELIPOV]

Guten Tag!!!!

Hier sind zwei Funktionen für den Grid Advisor erste Funktion ist die Gewinnberechnung, unter Berücksichtigung der teilweisen Schließung von Verlustaufträgen

//+----------------------------------------------------------------------------+
//| Калькуляция сетки ордеров                                                  |
//+----------------------------------------------------------------------------+
bool CalculiteProfit()
  {
   double oProfit=0,oLoss=0,percent;
   int i;
   nOrd=0;
   for(i = OrdersTotal()-1; i>=0; i--)
     {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES) || OrderSymbol()!=Symbol() || OrderMagicNumber()!=Magic || OrderType()>OP_SELL)
         continue;
      if(OrderProfit()>=0)
         oProfit += OrderProfit();
      else
        {
         oLoss+=OrderProfit();
         Ord_ticket[nOrd]=OrderTicket();
         Ord_lot[nOrd]=OrderLots();
         nOrd++;
        }
     }
   oLoss = MathAbs(oLoss+GetOrderSwap()+GetOrderCommission());
   if(oLoss>0)
      percent=oProfit/oLoss*100;
   else
      percent=100;
   if(percent<MinPercentForClose) //MinPercentForClose переменная из настроек 
      return(false);
   for(i=0; i<nOrd; i++)
     {
      Ord_lot[i]=(MathCeil((Ord_lot[i]*RowLots)*percent)/100)/RowLots;
     }
   return(true);
  }

Die zweite Funktion ist die Schließung von Aufträgen mit teilweiser Schließung von Verlustaufträgen

//+----------------------------------------------------------------------------+
//| Закрытие сетки ордеров при заданной команде с учетом части ордеров         |
//+----------------------------------------------------------------------------+
void ClosseAll()
  {
   int i,j,tkt;

   for(i = OrdersTotal()-1; i>=0; i--)
     {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES) || OrderSymbol()!=Symbol() || OrderMagicNumber()!=Magic)
         continue;
      tkt=OrderTicket();
      RefreshRates();
      if(OrderProfit()>=0)
        {
         if(OrderType() == OP_BUY)
           {
            if(!OrderClose(OrderTicket(), OrderLots(), Bid, slip))
               Print("Не удалось закрыть ордера на покупку!");
           }
         else
            if(OrderType() == OP_SELL)
              {
               if(!OrderClose(OrderTicket(), OrderLots(), Ask, slip))
                  Print("Не удалось закрыть ордер на продажу!");
              }
        }
      else
         for(j=0; j<nOrd; j++)
            if(tkt==Ord_ticket[j])
              {
               if(OrderLots()<Ord_lot[j])
                  Ord_lot[j]=OrderLots();
               Ord_lot[j]=NRL(Ord_lot[j]);
               if(OrderType() == OP_BUY)
                 {
                  if(!OrderClose(OrderTicket(), Ord_lot[j], Bid, slip))
                     Print("Не удалось закрыть ордера на покупку!");
                 }
               else
                  if(OrderType() == OP_SELL)
                    {
                     if(!OrderClose(OrderTicket(), Ord_lot[j], Ask, slip))
                        Print("Не удалось закрыть ордер на продажу!");
                    }
               break;
              }
     }
  }

Die Situation stellt sich wie folgt dar: Wenn ich eine Reihe von Aufträgen schließe und dabei die teilweise Schließung von Verlustaufträgen berücksichtige, erhalte ich einen Verlust als Ergebnis der Aufrundung auf die größere Seite einiger Lose, die geschlossen werden müssen

Die Frage ist, ob Sie diese beiden Funktionen verwenden können, um eine Funktion zur Berechnung von Verlustaufträgen bzw. eines Teils eines zu schließenden Auftrags zu schreiben.

Wenn ja, dann helfen Sie mir bitte, ihn zu schreiben.

Dankeschön

[Andrei Sokolov]

EVGENII SHELIPOV #:

Guten Tag!!!!

Wenn ja, helfen Sie mir, ihn zu schreiben.

Das ist kein guter Zeitpunkt.

Sie meinen, ich soll es für Sie schreiben?

[EVGENII SHELIPOV]

Andrey Sokolov #:

Es sind keine guten Zeiten.

Sie meinen, ich soll für Sie schreiben?

Mach dich nicht kaputt Alexander

[Roman Shiredchenko]

in den elementaren Dingen verloren:

Wie organisiere ich eine Schleppnetz-Pose - Co-directed, aus irgendeinem Grund schleppt es eine Pose, d.h. es schleppt nicht... MT5

for (i=0; i<PositionsTotal(); i++)   
     if (a_position.Select(_Symbol))       
     if (PositionSelect(_Symbol)) if(Symbol()==PositionGetSymbol(i))  
     if (Magic==PositionGetInteger(POSITION_MAGIC))  
   //  magic = myposition.Magic();   
      {
         //  ------------   перевод в бу  BUY   ------------    
         //if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY) 
         if (a_position.PositionType() == POSITION_TYPE_BUY)
          if (NLb_fun > 0)
            {
                Print(" перевод в безубыток BUY, _SL = ", _SL, " POSITION_PRICE_OPEN: ",
                     NormalizeDouble(PositionGetDouble(POSITION_PRICE_OPEN),_Digits),
                     " NLb_fun = ", NormalizeDouble(NLb_fun,_Digits));
               Modify = true;
 if(Modify)
              {
               Print(" серия рыночных позиций BUY назначена к переводу в безубыток, текущией позы POSITION_PRICE_OPEN = ",
               NormalizeDouble(PositionGetDouble(POSITION_PRICE_OPEN),_Digits)," тикет = ",PositionGetInteger(POSITION_TICKET));
                
               trade.PositionModify(_Symbol,SymbolInfoDouble(_Symbol, SYMBOL_BID) - 50*_Point,PositionGetDouble(POSITION_TP));
               Print(" Перенос в бу стоп лосса позиции Buy № ",  PositionGetInteger(POSITION_TICKET));
    ...
           } // к if(Modify)
        }    // к if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY) 

...

ich kann einen einfachen Codeabschnitt als Aufzählung von Positionen für ein Schleppnetz mit HEDGE-Marktpositionen verwenden - vielen Dank.

das Problem ist gelöst! Nochmals herzlichen Glückwunsch an Vladimir Karputov!!!

mit seinem Schleppnetz!

https://www.mql5.com/ru/code/17263

Der entscheidende Trick besteht darin, sich den Index in der Schleife anzusehen und ihn mit der Ticketoption zu ändern!!!

//--- при таком методе мы будет сюда попадать на каждом тике.
   for(int i=PositionsTotal()-1;i>=0;i--)
      if(m_position.SelectByIndex(i))
         if(m_position.Symbol()==Symbol() && m_position.Magic()==m_magic)
           {
            //--- TrailingStop -> подтягивание StopLoss у ПРИБЫЛЬНОЙ позиции
            if(m_position.PositionType()==POSITION_TYPE_BUY)
              {
               //--- когда у позиции ещё нет StopLoss
               if(m_position.StopLoss()==0)
                 {
                  //--- пока StopLoss равен 0.0, TrailingStep не учитываем
                  if(m_symbol.Bid()-ExtTrailingStop>m_position.PriceOpen())
                    {
                     //--- модификация позиции
                     m_trade.PositionModify(m_position.Ticket(),m_position.PriceOpen(),0.0);
                    }
                 } 

[x572intraday]

Eine einfache Aufgabe: Sie müssen alle Elemente aus ArrayJ stoßen, die den gleichen Index und Wert wie Elemente von ArrayI haben:

int OnInit()
  {
   int CommonArray[]={1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 13, 13, 13, 13, 13, 13, 13};
   int ArrayI[20]=   {0, 0, 0, 0, 0, 0, 0, 8, 9, 10,  0, 12, 13, 13, 13, 13,  0,  0, 13,  0};
   int ArrayJ[];

   for(int j=0; j<ArraySize(ArrayI); j++)
   {
      ArrayResize(ArrayJ,j+1);
      ArrayJ[j]=CommonArray[j];
   }

   ArrayPrint(ArrayI);
   ArrayPrint(ArrayJ);

   for(int i=0; i<ArraySize(ArrayI); i++)
      if(ArrayI[i])
         for(int j=0; j<ArraySize(ArrayJ); j++)
            if(ArrayI[i]==ArrayJ[j])
               ArrayRemove(ArrayJ,j,1);

   ArrayPrint(ArrayJ);
//---
   return(INIT_SUCCEEDED);
  }

Die Tastenfolge wird hervorgehoben. Ergebnis:

2022.02.26 13:56:48.489 test (NZDUSD,H4)         0  0  0  0  0  0  0  8  9 10  0 12 13 13 13 13  0  0 13  0
2022.02.26 13:56:48.489 test (NZDUSD,H4)         1  2  3  4  5  6  7  8  9 10 11 12 13 13 13 13 13 13 13 13
2022.02.26 13:56:48.489 test (NZDUSD,H4)         1  2  3  4  5  6  7 11

Erwartet:

2022.02.26 13:56:48.489 test (NZDUSD,H4)         0  0  0  0  0  0  0  8  9 10  0 12 13 13 13 13  0  0 13  0
2022.02.26 13:56:48.489 test (NZDUSD,H4)         1  2  3  4  5  6  7  8  9 10 11 12 13 13 13 13 13 13 13 13
2022.02.26 13:56:48.489 test (NZDUSD,H4)         1  2  3  4  5  6  7          11                13 13    13

ArrayJ ist dynamisch, es scheint etwas damit nicht zu stimmen... Aber ich brauche auch kein statisches Gerät.

Das hat mich umgehauen. WAS GIBT'S NEUES? Oder ist dies das Äquivalent zu dem alten Lied:

https://www.mql5.com/ru/forum/1111/page3141#comment_27152680

и

https://www.mql5.com/ru/forum/1111/page3142#comment_27371998

über benannte Konstanten?

[JRandomTrader]

x572intraday Elemente von ArrayI haben:

Die Tastenfolge wird hervorgehoben. Ergebnis:

Erwartet:

ArrayJ ist dynamisch, es scheint etwas damit nicht zu stimmen... Aber ich brauche auch kein statisches Gerät.

1) ArrayResize sollte besser aus der Schleife entfernt werden.

ArrayResize(ArrayJ,ArraySize(ArrayI));
for(int j=0; j<ArraySize(ArrayI); j++)
   {
      ArrayJ[j]=CommonArray[j];
   }

2. ArrayRemove macht ein Array-Element nicht "leer", sondern "verschiebt" nachfolgende Elemente an dessen Stelle. Dadurch wird der Abgleich von Elementen in nachfolgenden Indizes unterbrochen.

[x572intraday]

JRandomTrader #:

1) ArrayResize sollte aus der Schleife herausgenommen werden

2. ArrayRemove macht ein Arrayelement nicht "leer", sondern "verschiebt" nachfolgende Elemente an dessen Stelle. Dadurch wird der Abgleich von Elementen in nachfolgenden Indizes unterbrochen.

Die Zahl 2 steht außer Frage, ich habe nur die Intervalle eingefügt, um es deutlicher zu machen. Außerdem heißt es in Help über ein statisches Array:"Wenn die Funktion für ein Array mit fester Größe verwendet wird, ändert sich die Größe des Arrays selbst nicht: der verbleibende "Schwanz" wird physisch an die Startpositionkopiert ."Das Beispiel in der Hilfe verwendet ebenfalls ein Array mit fester Größe, während ich ein dynamisches Array habe.

Zu 1. Wir können sie nicht außerhalb einer Schleife platzieren, da wir in einer realen Aufgabe weder die Größe von ArrayJ noch von ArrayI im Voraus kennen, geschweige denn die Größe von CommonArray, da sie nicht alle übereinstimmen.

Ich habe auch ein Beispiel, bei dem das Mischen der Elemente nicht auf halber Strecke unterbrochen wird, wie im obigen Beispiel:

int OBJTFVArray[]={1, 2, 3, 4, 5, 6, 10, 12, 15, 20, 30, 16385, 16386, 16387, 16388, 16390, 16392, 16396, 16408, 32769, 49153, 49154, 49155, 49156, 49157, 49158, 49159, 49160};
int PArray[20]={0, 0, 0, 0, 0, 0, 0, 16390, 16392, 16396, 0, 32769, 49153, 49153, 49153, 49153, 0, 0, 49153, 0};
int PArray_[];

int OnInit()
  {
   for(int p_=0; p_<ArraySize(PArray); p_++)
   {
      ArrayResize(PArray_,p_+1);
      PArray_[p_]=OBJTFVArray[p_+8];
   }

   ArrayPrint(PArray);
   ArrayPrint(PArray_);

   for(int p=0; p<ArraySize(PArray); p++)
      if(PArray[p])
         for(int p_=0; p_<ArraySize(PArray_); p_++)
            if(PArray[p]==PArray_[p_])
               ArrayRemove(PArray_,p_,1);

   ArrayPrint(PArray_);

   return(INIT_SUCCEEDED);
  }

Das Ergebnis ist gut:

 0     0     0     0     0     0     0 16390 16392 16396     0 32769 49153 49153 49153 49153     0     0 49153     0
15    20    30 16385 16386 16387 16388 16390 16392 16396 16408 32769 49153 49154 49155 49156 49157 49158 49159 49160
15    20    30 16385 16386 16387 16388                   16408             49154 49155 49156 49157 49158 49159 49160

Aber Sie brauchen diese Variante, um zu funktionieren. Das Problem tritt offenbar auf, wenn es Elemente mit demselben Wert (siehe vorheriger Beitrag) im rechten Ende gibt - was dem Problem ähnelt, auf das ich mich oben bezogen habe.

[JRandomTrader]

x572intraday #:

Es gibt keine Fragen zu 2, ich habe die Intervalle zur Verdeutlichung angegeben. Außerdem heißt es in der Hilfe zu statischen Arrays:"Wenn die Funktion für ein Array fester Größe verwendet wird, ändert sich die Größe des Arrays selbst nicht: Sie kopiert den verbleibenden "Schwanz" physisch an die Startposition."Das Beispiel in der Hilfe verwendet ebenfalls ein Array mit fester Größe, während ich ein dynamisches Array habe.

Zu 1. Wir können sie nicht außerhalb einer Schleife platzieren, da wir in einer realen Aufgabe weder die Größe von ArrayJ noch von ArrayI im Voraus kennen, geschweige denn die Größe von CommonArray, da sie nicht alle übereinstimmen.

Ich habe auch ein Beispiel, bei dem das Element Dumping nicht auf halbem Weg abbricht, wie in diesem Beispiel:

Das Ergebnis ist gut:

Aber ich brauche diese Variante, um zu funktionieren. Das Problem tritt offenbar auf, wenn es Elemente mit demselben Wert im rechten Ende gibt (siehe vorheriger Beitrag) - was dem Problem ähnelt, auf das ich oben hingewiesen habe.

1. Sie können und sollten es aus der Schleife herausnehmen, so wie ich es gezeigt habe. Es sei denn, die Größe von ArrayI ändert sich während der Schleife.

2. Dann etwas wie dies

int k=0; // объявляем до цикла - чтобы использовать после
for(int i=0; i<ArraySize(ArrayI); i++) // после предыдущего кода (1) размеры ArrayI и ArrayJ равны
  if(ArrayI[i]!=ArrayJ[i])
    {
     ArrayJ[k++]=ArrayI[i];
    }
ArrayResize(ArrayJ,k);