Jede Anfängerfrage, um das Forum nicht zu überladen. Fachleute, gehen Sie nicht vorbei. Nirgendwo ohne dich - 6. - Seite 987

Neuer Kommentar
 
mario_SC--:

Ich weiß nicht, was Sie mit diesem Code beweisen wollen, aber ich weiß mit Sicherheit, dass ich nicht in die Kategorie der Prüferinnen und Prüfer passen kann... Wenn Sie also Hilfe wollen, müssen Sie selbst zum Fragesteller werden. Ein solcher Kreislauf kann sich unter bestimmten Bedingungen leicht schließen, und nur der Zufall kann ihn verhindern.
 

Warum "stürzt" der Debugger beim Debuggen des Indikators ab (weil er auf die Array-Grenzen zugreift), aber gleichzeitig wird alles normal auf dem Chart gezeichnet?

MT4 Build 950, Alpari Demo.

Der Indikator ist beigefügt.

//+------------------------------------------------------------------+
//|                                     FX5_MACD_Divergence_V1.1.mq4 |
//|                                                              FX5 |
//|                                                    hazem@uk2.net |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2007, FX5"
#property link      "hazem@uk2.net"
//----
#property indicator_separate_window
#property indicator_buffers 4
#property  indicator_color1 Green
#property  indicator_color2 Red
#property  indicator_color3 Magenta
#property  indicator_color4 Blue
//----
#define  arrowsDisplacement 0.0001
//---- input parameters
extern string separator1 = "*** MACD Settings ***";
extern int    fastEMA = 12;
extern int    slowEMA = 26;
extern int    signalSMA = 9;
extern string separator2 = "*** Indicator Settings ***";
extern bool   drawIndicatorTrendLines = true;
extern bool   drawPriceTrendLines = true;
extern bool   displayAlert = true;
//---- buffers
double bullishDivergence[];
double bearishDivergence[];
double macd[];
double signal[];
//----
static datetime lastAlertTime;
static string   indicatorName;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   SetIndexStyle(0, DRAW_ARROW);
   SetIndexStyle(1, DRAW_ARROW);
   SetIndexStyle(2, DRAW_LINE);
   SetIndexStyle(3, DRAW_LINE);
//----   
   SetIndexBuffer(0, bullishDivergence);
   SetIndexBuffer(1, bearishDivergence);
   SetIndexBuffer(2, macd);
   SetIndexBuffer(3, signal);   
//----   
   SetIndexArrow(0, 233);
   SetIndexArrow(1, 234);
//----
   indicatorName = "FX5_MACD_Divergence_v1.1(" + fastEMA + ", " + 
                                 slowEMA + ", " + signalSMA + ")";
   SetIndexDrawBegin(3, signalSMA);
   IndicatorDigits(Digits + 2);
   IndicatorShortName(indicatorName);

   return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
   for(int i = ObjectsTotal() - 1; i >= 0; i--)
     {
       string label = ObjectName(i);
       if(StringSubstr(label, 0, 19) != "MACD_DivergenceLine")
           continue;
       ObjectDelete(label);   
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int countedBars = IndicatorCounted();
   if(countedBars < 0)
       countedBars = 0;
   CalculateIndicator(countedBars);
//---- 
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CalculateIndicator(int countedBars)
  {
   for(int i = Bars - countedBars; i >= 0; i--)
     {
       CalculateMACD(i);
       CatchBullishDivergence(i + 2);
       CatchBearishDivergence(i + 2);
     }              
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CalculateMACD(int i)
  {
   macd[i] = iMACD(NULL, 0, fastEMA, slowEMA, signalSMA, 
                   PRICE_CLOSE, MODE_MAIN, i);
   
   signal[i] = iMACD(NULL, 0, fastEMA, slowEMA, signalSMA, 
                     PRICE_CLOSE, MODE_SIGNAL, i);         
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CatchBullishDivergence(int shift)
  {
   if(IsIndicatorTrough(shift) == false)
       return;  
   int currentTrough = shift;
   int lastTrough = GetIndicatorLastTrough(shift);
//----   
   if(macd[currentTrough] > macd[lastTrough] && 
      Low[currentTrough] < Low[lastTrough])
     {
       bullishDivergence[currentTrough] = macd[currentTrough] - 
                                          arrowsDisplacement;
       //----
       if(drawPriceTrendLines == true)
           DrawPriceTrendLine(Time[currentTrough], Time[lastTrough], 
                              Low[currentTrough], 
                             Low[lastTrough], Green, STYLE_SOLID);
       //----
       if(drawIndicatorTrendLines == true)
          DrawIndicatorTrendLine(Time[currentTrough], 
                                 Time[lastTrough], 
                                 macd[currentTrough],
                                 macd[lastTrough], 
                                 Green, STYLE_SOLID);
       //----
       if(displayAlert == true)
          DisplayAlert("Classical bullish divergence on: ", 
                        currentTrough);  
     }
//----   
   if(macd[currentTrough] < macd[lastTrough] && 
      Low[currentTrough] > Low[lastTrough])
     {
       bullishDivergence[currentTrough] = macd[currentTrough] - 
                                          arrowsDisplacement;
       //----
       if(drawPriceTrendLines == true)
           DrawPriceTrendLine(Time[currentTrough], Time[lastTrough], 
                              Low[currentTrough], 
                              Low[lastTrough], Green, STYLE_DOT);
       //----
       if(drawIndicatorTrendLines == true)                            
           DrawIndicatorTrendLine(Time[currentTrough], 
                                  Time[lastTrough], 
                                  macd[currentTrough],
                                  macd[lastTrough], 
                                  Green, STYLE_DOT);
       //----
       if(displayAlert == true)
           DisplayAlert("Reverse bullish divergence on: ", 
                        currentTrough);   
     }      
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CatchBearishDivergence(int shift)
  {
   if(IsIndicatorPeak(shift) == false)
       return;
   int currentPeak = shift;
   int lastPeak = GetIndicatorLastPeak(shift);
//----   
   if(macd[currentPeak] < macd[lastPeak] && 
      High[currentPeak] > High[lastPeak])
     {
       bearishDivergence[currentPeak] = macd[currentPeak] + 
                                        arrowsDisplacement;
      
       if(drawPriceTrendLines == true)
           DrawPriceTrendLine(Time[currentPeak], Time[lastPeak], 
                              High[currentPeak], 
                              High[lastPeak], Red, STYLE_SOLID);
                            
       if(drawIndicatorTrendLines == true)
           DrawIndicatorTrendLine(Time[currentPeak], Time[lastPeak], 
                                  macd[currentPeak],
                                  macd[lastPeak], Red, STYLE_SOLID);

       if(displayAlert == true)
           DisplayAlert("Classical bearish divergence on: ", 
                        currentPeak);  
     }
   if(macd[currentPeak] > macd[lastPeak] && 
      High[currentPeak] < High[lastPeak])
     {
       bearishDivergence[currentPeak] = macd[currentPeak] + 
                                        arrowsDisplacement;
       //----
       if(drawPriceTrendLines == true)
           DrawPriceTrendLine(Time[currentPeak], Time[lastPeak], 
                              High[currentPeak], 
                              High[lastPeak], Red, STYLE_DOT);
       //----
       if(drawIndicatorTrendLines == true)
           DrawIndicatorTrendLine(Time[currentPeak], Time[lastPeak], 
                                  macd[currentPeak],
                                  macd[lastPeak], Red, STYLE_DOT);
       //----
       if(displayAlert == true)
           DisplayAlert("Reverse bearish divergence on: ", 
                        currentPeak);   
     }   
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool IsIndicatorPeak(int shift)
  {
   if(macd[shift] >= macd[shift+1] && macd[shift] > macd[shift+2] && 
      macd[shift] > macd[shift-1])
       return(true);
   else 
       return(false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool IsIndicatorTrough(int shift)
  {
   if(macd[shift] <= macd[shift+1] && macd[shift] < macd[shift+2] && 
      macd[shift] < macd[shift-1])
       return(true);
   else 
       return(false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int GetIndicatorLastPeak(int shift)
  {
   for(int i = shift + 5; i < Bars; i++)
     {
       if(signal[i] >= signal[i+1] && signal[i] >= signal[i+2] &&
          signal[i] >= signal[i-1] && signal[i] >= signal[i-2])
         {
           for(int j = i; j < Bars; j++)
             {
               if(macd[j] >= macd[j+1] && macd[j] > macd[j+2] &&
                  macd[j] >= macd[j-1] && macd[j] > macd[j-2])
                   return(j);
             }
         }
     }
   return(-1);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int GetIndicatorLastTrough(int shift)
  {
    for(int i = shift + 5; i < Bars; i++)
      {
        if(signal[i] <= signal[i+1] && signal[i] <= signal[i+2] &&
           signal[i] <= signal[i-1] && signal[i] <= signal[i-2])
          {
            for (int j = i; j < Bars; j++)
              {
                if(macd[j] <= macd[j+1] && macd[j] < macd[j+2] &&
                   macd[j] <= macd[j-1] && macd[j] < macd[j-2])
                    return(j);
              }
          }
      }
    return(-1);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DisplayAlert(string message, int shift)
  {
   if(shift <= 2 && Time[shift] != lastAlertTime)
     {
       lastAlertTime = Time[shift];
       Alert(message, Symbol(), " , ", Period(), " minutes chart");
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DrawPriceTrendLine(datetime x1, datetime x2, double y1, 
                        double y2, color lineColor, double style)
  {
   string label = "MACD_DivergenceLine_v1.0# " + DoubleToStr(x1, 0);
   ObjectDelete(label);
   ObjectCreate(label, OBJ_TREND, 0, x1, y1, x2, y2, 0, 0);
   ObjectSet(label, OBJPROP_RAY, 0);
   ObjectSet(label, OBJPROP_COLOR, lineColor);
   ObjectSet(label, OBJPROP_STYLE, style);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DrawIndicatorTrendLine(datetime x1, datetime x2, double y1, 
                            double y2, color lineColor, double style)
  {
   int indicatorWindow = WindowFind(indicatorName);
   if(indicatorWindow < 0)
       return;
   string label = "MACD_DivergenceLine_v1.0$# " + DoubleToStr(x1, 0);
   ObjectDelete(label);
   ObjectCreate(label, OBJ_TREND, indicatorWindow, x1, y1, x2, y2, 
                0, 0);
   ObjectSet(label, OBJPROP_RAY, 0);
   ObjectSet(label, OBJPROP_COLOR, lineColor);
   ObjectSet(label, OBJPROP_STYLE, style);
  }
//+------------------------------------------------------------------+
 
r772ra:
In Ihrer Frage nach dem höchsten Kurs im weiteren Tagesverlauf nach einer Haussekerze wurde der Teil über die Zeitzone der Serverzeit aus irgendeinem Grund ausgelassen. Die Aufgabe ist streng an die Grenzen des Tages gebunden, und diese Grenzen sind in den verschiedenen Unternehmen unterschiedlich. Die Kerzenständer, die zu den verschiedenen Tagen gehören, sind unterschiedlich. Je nach Zeitzone des Servers gehören die höchsten Werte, die Sie finden, zu unterschiedlichen Tagen. Ist dies in Ihrem Fall normal?
 
Hallo zusammen!

Ich bin kein Neuling, aber ich habe eine "dumme" Frage, denn ich bin kaum je mit einer solchen Situation konfrontiert worden.

Angenommen, es ist bereits ein schwebender Auftrag eingestellt.
Wir verwenden den Indikator, um seinen Preis zu bewegen.
Zu einem bestimmten Zeitpunkt kann der Auftrag nicht geändert werden, da der neue Preis in den verbotenen Bereich gelangt ist, der durch die Stoppzeichen wie Ask/Bid +/- MarketInfo(Symbol(), MODE_STOPLEVEL / MODE_FREEZELEVEL) festgelegt ist.

Der Auftrag muss jedoch "vom Markt" eröffnet werden.

Was können wir in diesem Fall tun?

Können wir den schwebenden Auftrag löschen und einen neuen Auftrag auf dem Markt eröffnen?

Oder ist es möglich, den schwebenden Auftrag in einen offenen Auftrag umzuwandeln?
 
mt4trade:
Hallo zusammen!

Ich bin kein Neuling, aber es ist eine "dumme" Frage, denn ich bin kaum je mit einer solchen Situation konfrontiert worden.

Angenommen, es ist bereits ein schwebender Auftrag eingestellt.
Wir verwenden den Indikator, um seinen Preis zu bewegen.
Zu einem bestimmten Zeitpunkt kann der Auftrag nicht geändert werden, da der neue Preis in den verbotenen Bereich gelangt ist, der durch die Stoppzeichen wie Ask/Bid +/- MarketInfo(Symbol(), MODE_STOPLEVEL / MODE_FREEZELEVEL) festgelegt ist.

Der Auftrag muss jedoch "vom Markt" eröffnet werden.

Was können wir in diesem Fall tun?

Können wir den schwebenden Auftrag löschen und einen neuen Auftrag auf dem Markt eröffnen?

Oder kann der schwebende Auftrag irgendwie in einen offenen Auftrag umgewandelt werden?
Wenn es so nah am Preis ist, wird der Preis es finden, aber nicht, vielleicht ist es besser, wenn es ein Stopp ist! Und wenn es eine Grenze ist, dann Geduld. Versuchen Sie, im Tester zu experimentieren, und die Optimierung wird die beste Variante ermitteln! Viel Glück!
 

Bitte um Hilfe.

Wenn ich einen EA auf einem Stand-Alone-Chart installiere, funktioniert der EA nicht, weil die start()-Funktion nicht gestartet wird.

Wie kann ich eine Diagrammaktualisierung von einem EA, der es erstellt, oder von einem EA, der mit diesem Diagramm verbunden ist, implementieren?

 
borilunad:
Wenn sie so nahe am Preis liegen, wird der Preis sie von selbst finden, und wenn nicht, ist es vielleicht besser, wenn es ein Stopp ist! Und der Grenzwert, dann Geduld. Versuchen Sie, im Tester zu experimentieren, und die Optimierung wird die beste Variante bestimmen! Viel Glück!
Ich danke Ihnen! Es ist alles so klar. Aber ich möchte die Antwort auf meine Frage wissen - was soll ich tun, wenn ich unbedingt möchte, dass der Auftrag unabhängig von der Richtung des Kurses ausgelöst wird? Soll ich den schwebenden Auftrag löschen und einen regulären Auftrag eröffnen oder gibt es andere Varianten?
 
mt4trade:
Ich danke Ihnen! Aber ich brauche eine Antwort auf meine Frage - was soll ich tun, wenn ein Auftrag ausgelöst werden muss, unabhängig davon, wie der Kurs sich jetzt entwickelt? Soll ich den schwebenden Auftrag löschen und einen regulären Auftrag eröffnen?
Ich würde nicht empfehlen, sie auf halbem Wege zu ändern, denn ohne bestimmte Ergebnisse (positiv oder negativ) kann man sich der Rationalität seiner Strategie nicht sicher sein. Das war's!
 
borilunad:
Ich empfehle nicht, die Strategie auf halbem Wege zu ändern, denn ohne sichere Ergebnisse (positiv oder negativ) kann man sich der Rationalität seiner Strategie nicht sicher sein. Das war's!
Nochmals vielen Dank! Sie sagen die richtigen Dinge, die aber für die Frage irrelevant sind. Noch einmal: Wenn der berechnete Preis der Pending Order den verbotenen Bereich erreicht hat und sie nicht geändert werden kann, sondern (gemäß der Strategie) zum berechneten Preis ausgelöst werden muss - wie "verwandeln" Sie sie in eine ausgelöste Order? Um sie zu löschen und als normale Datei zu öffnen? Oder gibt es andere Möglichkeiten? Bitte beantworten Sie genau diese Frage.
 
mt4trade:
Nochmals vielen Dank! Sie sagen die richtigen Dinge, die aber für die Frage irrelevant sind. :) Noch einmal: Wenn der berechnete Preis einer Pending Order den verbotenen Bereich erreicht hat und sie nicht geändert werden kann, sondern (gemäß der Strategie) zum berechneten Preis ausgelöst werden muss - wie "verwandle" ich sie in eine ausgelöste Order? Um sie zu löschen und als normale Datei zu öffnen? Oder gibt es andere Möglichkeiten? Bitte beantworten Sie genau diese Frage.
Dieser Ansatz ist inkonsequent. Wenn erwartet wird, dass eine Position in der Freeze-Zone (sie kann nicht geändert werden) aus einem schwebenden Auftrag heraus eröffnet wird, sollte der Auftrag zunächst zu einem anderen Preis an der Grenze dieser Freeze-Zone platziert werden. Aus diesem Grund wird Ihr Ansatz von vielen Menschen nicht akzeptiert.

Um konkret auf Ihre Frage einzugehen. Entfernen Sie zunächst den schwebenden Auftrag und eröffnen Sie dann sofort eine Position zum aktuellen Kurs. Das Problem ist, dass sich der Preis während dieser Aktionen aus der Freeze-Zone herausbewegen kann (zum Schlechteren) und die Position zu einem falschen Preis eröffnet wird. Eine andere Möglichkeit besteht darin, keine Pending Order zu erstellen und den Wert zur Eröffnung der Position in einer Variablen im Programm zu speichern. Vergleichen Sie ihn mit dem aktuellen Kurs, und wenn die Bedingung erfüllt ist (unter Berücksichtigung der Einfrierzone), eröffnen Sie eine Position.
1...980981982983984985986987988989990991992993994...1178
Neuer Kommentar
Grund der Beschwerde: