Qualquer pergunta de novato, de modo a não desorganizar o fórum. Profissionais, não passem por aqui. Em nenhum lugar sem você - 6. - página 987

Novo comentário
 
mario_SC--:

Não sei o que você está tentando provar com este código, mas sei de fato que não posso me encaixar na categoria de examinadores... Portanto, se você quiser ajuda, você mesmo terá que se tornar um questionador. Tal ciclo pode facilmente, sob certas condições, fazer loops, e somente o acaso pode impedir que isso aconteça.
 

Por que o depurador "trava" ao depurar o indicador (porque ele acessa os limites da matriz), mas ao mesmo tempo tudo é desenhado normalmente no gráfico?

MT4 construir 950, demonstração Alpari.

O indicador está anexado.

//+------------------------------------------------------------------+
//|                                     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:
Em sua pergunta sobre encontrar a maior taxa no restante do dia após uma vela em alta, a parte sobre o fuso horário do servidor foi deixada de fora por algum motivo. A tarefa está estritamente ligada ao limite do dia, e estes limites são diferentes em empresas diferentes. Os castiçais pertencentes a dias diferentes são diferentes. Dependendo do fuso horário do servidor, os valores mais altos que você encontrar pertencerão a dias diferentes. Isto é normal para o seu caso?
 
Olá a todos!

Não é um novato, mas há uma pergunta "boba", pois quase nunca encontrei tal situação.

Suponha que haja uma ordem pendente já estabelecida.
Usamos o indicador para mover seu preço.
Em um momento, o pedido não pode ser modificado porque o novo preço entrou na faixa proibida devido aos sinais de parada como Ask/Bid +/- MarketInfo(Symbol(), MODE_STOPLEVEL / MODE_FREEZELEVEL).

Mas a ordem tem que ser aberta "pelo mercado".

O que podemos fazer neste caso?

Podemos apagar a ordem pendente e abrir uma nova ordem pelo mercado?

Ou é possível mudar a ordem pendente para uma ordem aberta?
 
mt4trade:
Olá a todos!

Não é um novato, mas há uma questão "tola", pois quase nunca encontrei tal situação.

Suponha que haja uma ordem pendente já estabelecida.
Usamos o indicador para mover seu preço.
Em um momento, o pedido não pode ser modificado porque o novo preço entrou na faixa proibida devido aos sinais de parada como Ask/Bid +/- MarketInfo(Symbol(), MODE_STOPLEVEL / MODE_FREEZELEVEL).

Mas a ordem tem que ser aberta "pelo mercado".

O que podemos fazer neste caso?

Podemos apagar a ordem pendente e abrir uma nova ordem pelo mercado?

Ou a ordem pendente pode ser de alguma forma transformada em aberta?
Se estiver tão perto do preço, o preço o encontrará, mas não, talvez seja melhor se for uma parada! E se for um limite, então paciência. Tente experimentar no testador e a otimização determinará a melhor variante! Boa sorte!
 

Por favor, ajude.

Quando instalo uma EA em um gráfico independente, a EA não funciona, porque a função start() não é iniciada.

Como posso implementar uma atualização do gráfico a partir de uma EA que o constrói, ou a partir de uma EA que está anexada a este gráfico?

 
borilunad:
Se estiver tão perto do preço, o preço o encontrará por si só, e se não for, talvez seja melhor se for uma parada! E o limite, depois a paciência. Tente experimentar no testador, e a otimização determinará a melhor variante! Boa sorte!
Obrigado! É tudo tão claro. Mas eu quero saber a resposta à pergunta - o que fazer, se eu tiver absolutamente que fazer o pedido funcionar, não importa para onde o preço irá? Devo apagar a ordem pendente e abrir uma ordem regular ou ter outras variantes?
 
mt4trade:
Obrigado! Mas eu preciso de uma resposta à minha pergunta - se uma ordem tem que ser acionada independentemente de para onde o preço vai agora, o que devo fazer? Devo apagar a ordem pendente e abrir uma ordem regular?
Para mim, se você seguir sua estratégia, então faça-o! Eu não recomendaria mudá-la pela metade, caso contrário, sem certos resultados (positivos ou negativos), você não pode ter certeza sobre a racionalidade de sua estratégia. É isso aí!
 
borilunad:
Para mim, se você seguir sua estratégia, então siga-a! Não recomendo mudá-la pela metade, caso contrário, sem certos resultados (positivos ou negativos), você não pode ter certeza da racionalidade de sua estratégia. É isso aí!
Mais uma vez, obrigado! Você diz as coisas certas, mas irrelevantes para a pergunta. Mais uma vez: se o preço calculado do pedido pendente atingiu a faixa proibida e não pode ser modificado, mas deve (de acordo com a estratégia) ser acionado pelo preço calculado - como "transformá-lo" em um acionado? Para apagá-lo e abri-lo como um normal? Ou existem outras opções? Por favor, responda exatamente esta pergunta.
 
mt4trade:
Mais uma vez obrigado! Você diz as coisas certas, mas irrelevantes para a pergunta. :) Mais uma vez: se o preço calculado de um pedido pendente atingiu a faixa proibida e não pode ser modificado, mas deve (de acordo com a estratégia) acionar o preço calculado - como posso "transformá-lo" em um acionado? Para apagá-lo e abri-lo como um normal? Ou existem outras opções? Por favor, responda exatamente esta pergunta.
Há uma inconsistência nesta abordagem. Se se espera que uma posição seja aberta na zona de congelamento (não pode ser modificada) a partir de uma ordem pendente, então a ordem deve ser colocada inicialmente a um preço diferente, no limite desta zona de congelamento. É por isso que sua abordagem não é aceita por muitas pessoas.

Para ser específico a sua pergunta. Primeiro retire a ordem pendente e depois abra imediatamente uma posição ao preço atual. O problema é que durante estas ações, o preço pode sair da zona de congelamento (para pior) e a posição será aberta a um preço errado. Outra opção é não criar uma ordem pendente e armazenar o valor para abrir a posição em uma variável do programa. Compare com o preço atual e se a condição for atendida (levando em conta a zona de congelamento), você abre uma posição.
1...980981982983984985986987988989990991992993994...1178
Novo comentário
Razão: