ForumKategorien

Fragen von Anfängern MQL5 MT5 MetaTrader 5 - Seite 1322

Neuer Kommentar
Guten Tag, es gibt eine Menge von Indikatorpuffern des gleichen Typs, die in der Schleife berechnet werden können, aber wie kann man ein Array von Indikatorpuffern erstellen? Ich habe versucht, es durch die Seitenstruktur, und alles war ok, SetIndexBuffer() arbeitete ohne Fehler, aber wenn OnCalculate() kommt, die Array-Größen nicht ändern und bleiben 0. Bitte beraten Sie, wie die Berechnung der Indikator-Puffer in der Schleife zu organisieren, vielleicht durch Namen, wie zum Beispiel: "buff_0", "buff_1", usw., aber wie dies zu tun, weiß ich nicht(( Andernfalls ist es ein sehr langes Blatt kommt aus(
SanAlex:

Ich nehme an, dass Sie genau das vorhatten - es scheint funktioniert zu haben.

Danke!

Alles ist richtig, abernicht genau das, was ich im Sinn hatte!!! Die Order wird entlang des Trends platziert (entsprechend dem Indikator) und bei Take geschlossen und sobald sie geschlossen ist - wird eine neue Order in die gleiche Richtung (entlang des Trends) eröffnet, aber das ist nur ein Teil meiner Idee.

Der zweite Teil ist, dass ein Auftrag , der von Takei nicht geschlossen wurde, wenn sich der Trend umkehrt (wenn der Indikator ein Signal für eine Änderung der Preisrichtung gibt), nicht geschlossen werden sollte (was Sie getan haben).

Kurz gesagt, die beiden Teile sollten als Paar funktionieren.

Alexey Viktorov:

Gestern habe ich dieses Wunder heruntergeladen, um es zu sehen... Plötzlich hatte ich kein Internet. Nach einem Gewitter hatte ich für den Rest des Tages technische Probleme. Also beschloss ich, es aus Faulheit in MQL5 neu zu schreiben und hier zu veröffentlichen.

Jede Wolke hat also einen Silberstreif.........

Herzlichen Dank!

Das könnte sich als nützlich erweisen, wenn meine Idee wahr wird!

[Gelöscht]
VANDER:
Ich habe es über die Seite ausprobiert und es schien gut zu funktionieren.

Funktioniert das nicht so?

int size=100;

struct All
   {
   double buff[];
   } all[];

int OnInit()
   {
   IndicatorBuffers(size);
   ArrayResize(all,size);
   for(int i=0; i<size; i++)
      {
      SetIndexBuffer(i,all[i].buff);
      SetIndexStyle(i,DRAW_LINE);
      }
   return(INIT_SUCCEEDED);
   }

int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
   {
   for(int i=0; i<size; i++)
      {
      all[i].buff[shift]=i;
      }
   return(rates_total);
   }
[Gelöscht]

Sprut 185:

Jetzt müssen wir Martingale darauf anwenden, d.h. Nicht-Trend-Orders mit einem bestimmten Schritt, Multiplikator und Mittelwertbildung eröffnen.

Kurz gesagt, die beiden Teile sollten als Paar funktionieren.

Sie meinen, die nächste Position sollte mit dem doppelten Lot 2-4-8-16 auf BUY und umgekehrt 2-4-8-16 auf SELL eröffnet werden?

Ich habe eine solche Funktion - ich habe sie irgendwie selbst gebaut.

//+------------------------------------------------------------------+
//| ENUM_LOT_RISK                                                    |
//+------------------------------------------------------------------+
enum LotMax
  {
   Lot=0,   // Lots
   Lotx2=1, // Lots*2
   Risk=2,  // Risk
  };
//+------------------------------------------------------------------+
input LotMax InpLotRisk              = Risk;         // : Lots,- Lots*2,- Risk
input double MaximumRisk             = 0.02;         // : Maximum Risk in percentage
input double DecreaseFactor          = 3;            // : Descrease factor
//+------------------------------------------------------------------+
//| Calculate optimal lot size                                       |
//+------------------------------------------------------------------+
double TradeSizeOptimized(void)
  {
   double price=0.0;
   double margin=0.0;
//--- select lot size
   if(!SymbolInfoDouble(_Symbol,SYMBOL_ASK,price))
      return(0.0);
   if(!OrderCalcMargin(ORDER_TYPE_BUY,_Symbol,1.0,price,margin))
      return(0.0);
   if(margin<=0.0)
      return(0.0);
   double lot=NormalizeDouble(AccountInfoDouble(ACCOUNT_MARGIN_FREE)*MaximumRisk/margin,2);
//--- calculate number of losses orders without a break
   if(DecreaseFactor>0)
     {
      //--- select history for access
      HistorySelect(0,TimeCurrent());
      //---
      int    orders=HistoryDealsTotal();  // total history deals
      int    losses=0;                    // number of losses orders without a break
      for(int i=orders-1; i>=0; i--)
        {
         ulong ticket=HistoryDealGetTicket(i);
         if(ticket==0)
           {
            Print("HistoryDealGetTicket failed, no trade history");
            break;
           }
         //--- check symbol
         if(HistoryDealGetString(ticket,DEAL_SYMBOL)!=_Symbol)
            continue;
         //--- check Expert Magic number
         if(HistoryDealGetInteger(ticket,DEAL_MAGIC)!=UNO_MAGIC)
            continue;
         //--- check profit
         double profit=HistoryDealGetDouble(ticket,DEAL_PROFIT);
         if(profit>0.0)
            break;
         if(profit<0.0)
            losses++;
        }
      //---
      if(losses>1)
         lot=NormalizeDouble(lot-lot*losses/DecreaseFactor,1);
     }
//--- normalize and check limits
   double stepvol=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_STEP);
   lot=stepvol*NormalizeDouble(lot/stepvol,0);
   double minvol=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MIN);
   if(lot<minvol)
      lot=minvol;
   double maxvol=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MAX);
   if(lot>maxvol)
      lot=maxvol;
//--- return trading volume
   return(lot);
  }
//+------------------------------------------------------------------+
//| Calculate optimal lot size                                       |
//+------------------------------------------------------------------+
double OptimizedBuy(void)
  {
   double PROFIT_BUY=0.00;
   for(int i=PositionsTotal()-1; i>=0; i--) // returns the number of open positions
     {
      string   position_GetSymbol=PositionGetSymbol(i); // GetSymbol позиции
      if(position_GetSymbol==m_symbol.Name())
        {
         if(m_position.PositionType()==POSITION_TYPE_BUY)
           {
            PROFIT_BUY=PROFIT_BUY+m_position.Select(Symbol());
           }
        }
     }
   double Lots=MaximumRisk;
   double ab=PROFIT_BUY;
   switch(InpLotRisk)
     {
      case Lot:
         Lots=MaximumRisk;
         break;
      case Lotx2:
         if(ab>0 && ab<=1)
            Lots=MaximumRisk*2;
         if(ab>1 && ab<=2)
            Lots=MaximumRisk*4;
         if(ab>2 && ab<=3)
            Lots=MaximumRisk*8;
         if(ab>3)
            Lots=TradeSizeOptimized();
         break;
      case Risk:
         Lots=TradeSizeOptimized();
         break;
     }
   return(Lots);
  }
//+------------------------------------------------------------------+
//| Calculate optimal lot size                                       |
//+------------------------------------------------------------------+
double OptimizedSell(void)
  {
   double PROFIT_SELL=0.00;
   for(int i=PositionsTotal()-1; i>=0; i--) // returns the number of open positions
     {
      string   position_GetSymbol=PositionGetSymbol(i); // GetSymbol позиции
      if(position_GetSymbol==m_symbol.Name())
        {
         if(m_position.PositionType()==POSITION_TYPE_SELL)
           {
            PROFIT_SELL=PROFIT_SELL+m_position.Select(Symbol());
           }
        }
     }
   double Lots=MaximumRisk;
   double ab=PROFIT_SELL;
   switch(InpLotRisk)
     {
      case Lot:
         Lots=MaximumRisk;
         break;
      case Lotx2:
         if(ab>0 && ab<=1)
            Lots=MaximumRisk*2;
         if(ab>1 && ab<=2)
            Lots=MaximumRisk*4;
         if(ab>2 && ab<=3)
            Lots=MaximumRisk*8;
         if(ab>3)
            Lots=TradeSizeOptimized();
         break;
      case Risk:
         Lots=TradeSizeOptimized();
         break;
     }
   return(Lots);
  }
//+------------------------------------------------------------------+

\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

Sie müssen in der Positionseröffnung - hier anstelle von InpLots mit OptimizedBuy() und OptimizedSell() ersetzen

      if(m_trade.PositionOpen(Symbol(),ORDER_TYPE_BUY,OptimizedBuy(),price,0.0,0.0))

      if(m_trade.PositionOpen(Symbol(),ORDER_TYPE_SELL,OptimizedSell(),price,0.0,0.0))
[Gelöscht]
SanAlex:

Sie meinen, die nächste Position wird mit dem doppelten Lot 2-4-8-16 in BUY und gegenüber 2-4-8-16 in SELL eröffnet?

Ich habe eine solche Funktion - ich habe sie irgendwie selbst gebaut.

\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

Sie müssen es in der Positionseröffnung ersetzen - hier anstelle von InpLots mit OptimizedBuy() und OptimizedSell()

aber für diese Funktion wäre es besser, diese Funktion zu haben - sie würde mit Gewinn schließen (in Währung)

input double InpTProfit              = 40000;        // : Take Profit --> (In currency the amount)
input double InpSLoss                = 1000000;      // : Stop Loss --> (In currency the amount)
//+------------------------------------------------------------------+
//| ProfitOnTick closing                                             |
//+------------------------------------------------------------------+
void ProfitOnTick(void)
  {
//---
   double PROFIT_BUY=0.00;
   double PROFIT_SELL=0.00;
   int total=PositionsTotal();
   for(int i=total-1; i>=0; i--)
     {
      string   position_GetSymbol=PositionGetSymbol(i);
      if(position_GetSymbol==m_symbol.Name())
        {
         if(m_position.PositionType()==POSITION_TYPE_BUY)
           {
            PROFIT_BUY=PROFIT_BUY+PositionGetDouble(POSITION_PROFIT);
           }
         else
           {
            PROFIT_SELL=PROFIT_SELL+PositionGetDouble(POSITION_PROFIT);
           }
        }
      if(PROFIT_BUY<-InpSLoss || PROFIT_BUY>=InpTProfit)
        {
         CheckForCloseBuy();
        }
      if(PROFIT_SELL<-InpSLoss || PROFIT_SELL>=InpTProfit)
        {
         CheckForCloseSell();
        }
     }
  }
//+------------------------------------------------------------------+
SanAlex:

Aber für diese Funktion wäre es wünschenswert, diese Funktion zu haben, die auf Gewinn (in Währung) schließen würde

Lassen Sie mich versuchen, die Bedeutung meiner Idee und die Funktionsweise des von mir entwickelten EA deutlicher zu erklären.

Sie brauchen einen einfachen Martin - zum Beispiel AutoProfit 3, bei dem Sie nur hinzufügen müssen, dass die Eröffnung von Aufträgen auf Indikatorsignalen (entsprechend dem Trend) beruht, aber nicht wie bei AutoProfit - da die Karten auf ......... fallen und das ist alles.

Mit ungefähr denselben Ausgabeparametern wie in der beigefügten Datei.
Dateien:
pbx0dcw.jpg  201 kb
[Gelöscht]
Sprut 185:

Lassen Sie mich versuchen, die Bedeutung meiner Idee und der Arbeit des entstehenden EA deutlicher zu erklären.

Sie brauchen einen einfachen Martin - zum Beispiel AutoProfit 3, in dem Sie nur hinzufügen müssen, dass die Eröffnung von Aufträgen auf das Signal des Indikators (der Trend) war, anstatt wie in AutoProfit - wie die Karte liegt ......... und das ist alles.

Sie wird also auf ein Signal des Indikators hin eröffnet - wenn jedoch ein entgegengesetztes Signal erscheint, wird sie in die andere Richtung eröffnet. Und wenn diese Position nicht mit Gewinn geschlossen wird, bleibt sie hängen, bis sie mit Gewinn geschlossen wird. Wenn das Signal auf die andere Seite umschlägt und die offene Position schließt, funktioniert es nicht für Sie.

SanAlex:

Wenn sich das Signal in die andere Richtung dreht, wird die Position in die andere Richtung geöffnet, und wenn die Position nicht mit Gewinn geschlossen wurde, bleibt sie dort hängen, bis sie mit Gewinn geschlossen wird. Wenn ein Signal an die andere Seite umgedreht und geschlossen, dass offene Position, wird es Ihnen nicht passen.

Richtig .......... und wenn diese Position nicht mit Gewinn geschlossen wurde, bleibt sie dort, bis sie mit Gewinn geschlossen wird.

Aber die Position, die nicht mit Gewinn geschlossen wurde(z.B. im Kauf), sollte bestehen bleiben und bis zu einer bestimmten Stufe hinuntergehen, wo ein weiterer Auftrag (im Kauf) mit dem multiplizierten Volumen und dem durchschnittlichen Zeitverlust usw. eröffnet wird, bis sich der Trend umkehrt, aber die Eröffnung von Positionen in der Spur wird nicht aufhören.

Deshalb habe ich geschrieben, dass 2 Blöcke gleichzeitig arbeiten sollten - Martin und per Indikator.

Wenn ich etwas nicht gut erklärt habe, bin ich gerne bereit, es Ihnen per Skype zu demonstrieren und Ihnen zu zeigen, wie es aussehen sollte.

Sprut 185:

Alles ist korrekt .......... und wenn diese Position nicht mit Gewinn geschlossen wurde, bleibt sie dort, bis sie mit Gewinn geschlossen wird.

Aber die Position, die nicht mit Gewinn geschlossen wurde(z.B. im Kauf), sollte bestehen bleiben und bis zu einer bestimmten Stufe sinken, wo ein weiterer Auftrag (im Kauf) mit dem vervielfachten Volumen eröffnet wird und das durchschnittliche Timing sinkt, usw., bis der Trend sich umkehrt, aber die Eröffnung von Positionen im Handel nicht aufhört.

Deshalb habe ich geschrieben, dass 2 Blöcke gleichzeitig arbeiten sollten - Martin und per Indikator.

Wenn etwas nicht gut erklärt ist, bin ich bereit, es Ihnen über Skype zu demonstrieren und Ihnen zu zeigen, wie es aussehen sollte.

Martin darf nur aktiviert werden, wenn das Blinkersignal entgegengesetzt ist oder nicht von ihm abhängt?

Beispiel: Ich habe eine Kaufposition gemäß dem Indikator eröffnet. Der Kurs hat sich um die festgelegte Strecke nach unten bewegt, und der Indikator zeigt bereits "Verkaufen" an. Soll die Kaufposition eröffnet werden?

1...131513161317131813191320132113221323132413251326132713281329...1504
Neuer Kommentar