FórumSeções

Erros, bugs, perguntas - página 3129

Novo comentário
Alexey Viktorov #:

No seu caso, não é este o caso, pois ambas as condições devem ser satisfeitas. Mas se colocar isto

então, sim. Se a condição "a" for satisfeita, a segunda condição não será verificada. Há muitos anos que lutam por ela e agora propõem-se regressar ao século anterior...

Estranhamente, mas com a=verdadeiro não só em ||| mas também em && não há verificação do resto. Caso contrário, como explicar isto (não procure significado no funcionamento do indicador, estamos a falar do código aqui):

#property indicator_chart_window
#property indicator_buffers 1
#property indicator_plots   1
#property indicator_type1   DRAW_ARROW
#property indicator_color1  Gray
#property indicator_label1  "Fractal Up"
//--- indicator buffers
double ExtUpperBuffer[];
//--- 10 pixels upper from high price
int    ExtArrowShift=-10;

void OnInit()
  {
//--- indicator buffers mapping
   SetIndexBuffer(0,ExtUpperBuffer,INDICATOR_DATA);
   IndicatorSetInteger(INDICATOR_DIGITS,_Digits);
//--- sets first bar from what index will be drawn
   PlotIndexSetInteger(0,PLOT_ARROW,217);
//--- arrow shifts when drawing
   PlotIndexSetInteger(0,PLOT_ARROW_SHIFT,ExtArrowShift);
//--- sets drawing line empty value--
   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,EMPTY_VALUE);
  }

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[])
  {
   if(rates_total<5)
      return(0);

   int start;
//--- clean up arrays
   if(prev_calculated<7)
     {
      start=2;
      ArrayInitialize(ExtUpperBuffer,EMPTY_VALUE);
     }
   else
      start=rates_total-5;

   for(int i=start; i<rates_total-3 && !IsStopped(); i++)
     {
      //--- Upper Fractal
      if(high[i]>high[i+1] && high[i]>high[i+2] && high[i]>high[i+3] && high[i]>high[i+4])
         ExtUpperBuffer[i]=high[i];
      else
         ExtUpperBuffer[i]=EMPTY_VALUE;
     }

   return(rates_total);
  }

O terminal é silencioso. Mas se mudar

if(high[i]>high[i+1] && high[i]>high[i+2] && high[i]>high[i+3] && high[i]>high[i+4])

para

if(high[i]>high[i+4] && high[i]>high[i+2] && high[i]>high[i+3] && high[i]>high[i+1])

o programador altera-o e a notória mensagem 'array out of range' aparece porque o programador tropeça imediatamente num array com um índice excessivo, ao contrário do primeiro caso.

x572intraday #:

Não me atrevo a chamar-lhe um insecto. Portanto, direi apenas que notei uma peculiaridade da declaração do "se". Suspeito que isto possa aplicar-se também a outras línguas.

Se um se revelar verdadeiro, verifique os saltos para Array[over_index] e aqui o terminal começa a colidir através da parte'array out of range', o que é bem verdade. Mas se um terminal se revelar falso, o terminal não verificará a condição de Array[over_index] e, portanto, a redundância do índice, e se irá saltar mais e o codificador não saberá que existe um array com um índice inexistente no seu programa... ou antes uma existente, mas redundante.

Talvez devesse haver uma correcção para que a verificação de "matriz fora de alcance" fosse efectuada até ao fim do laço e a mesma mensagem fosse emitida? Ou irá reduzir significativamente a velocidade do operador?


Em que língua é diferente a sintaxe? "A sintaxe significa literalmente não só compor, mas também arranjar...".

Se quiser verificar se existe um 'array fora de alcance', altere a encomenda.

if(Array[over_index]>val && a) {...}
Lilita Bogachkova #:

Em que língua é diferente a sintaxe?"A sintaxe significa literalmente não só compor, mas também ordenar...".

Se quiser verificar se existe um 'array fora de alcance', altere a ordem.

A encomenda é desejável, pois precisa de verificar.

Por exemplo, se 'a' for alterado mais frequentemente, é melhor colocá-lo como primeiro argumento.

Vitaly Muzichenko #:

A encomenda é desejável, uma vez que são necessários controlos.

Por exemplo, se "a" mudar mais frequentemente, é melhor colocá-lo como primeiro argumento.

Não, a primeira depende das condições principais, as outras são apenas condições adicionais.

Por exemplo, é irrelevante verificar a hora do tempo de trabalho actual se o tempo de trabalho ainda não tiver começado.

Na verdade, deparei-me com esta característica por acidente. Não era isso que eu queria...

if(high[i]>high[i+1] && high[i]>high[i+2] && high[i]>high[i+3] && ... && high[i]>high[i+n])

ou

if(high[i]>high[i+1])
   if(high[i]>high[i+2])
      if(high[i]>high[i+3])
         if(...)
            if(high[i]>high[i+n])

O problema é que n pode ser bastante grande, por isso quis embrulhar esta longa cadeia de condições num compacto para. Tentei desta forma:

for(int i=start; i<rates_total-3 && !IsStopped(); i++)
{
   bool h_plus=true; //false?
   for(int increment=1; increment<=n; increment++)
      h_plus&=high[i]>high[i+increment];
   if(h_plus) {...}
   ...
}

mas acabou por ser um pouco confuso. Bem, pelo menos porque h_plus com este algoritmo terá de tomar toda a soma das condições verificadas, incluindo a condição com verificação de matriz de índice redundante, o que não aconteceu no primeiro desembrulhado se, sem para isso. E outras varizes estragam o quadro.

Será isto sequer digno de consideração? É possível fazer isto?

Lilita Bogachkova #:

Em que língua é diferente a sintaxe? "A sintaxe significa literalmente não só compor, mas também ordenar...".

Se quiser verificar se existe um 'array fora de alcance', altere a ordem.

Nem sempre se sabe com antecedência o que colocar antes e o que colocar depois.

Lilita Bogachkova #:

Não, o primeiro determina as condições básicas, os outros são apenas condições adicionais.

Por exemplo, é irrelevante verificar a hora do tempo de trabalho actual se o tempo de trabalho ainda não tiver começado.

Sim, primeiro verificamos as condições do sinal, passamos pela matriz e comparamos, verificamos o preço actual, e depois verificamos que não é a altura certa, mas antes disso são realizadas muitas acções complicadas.

Certo?

Vitaly Muzichenko #:

Sim, primeiro verificamos as condições do sinal, passamos pela matriz e comparamos, verificamos o preço actual, e depois verificamos que não é a altura certa, mas muitas acções complicadas já foram feitas antes disso.

Certo?

Certo, não se deve fazer isso.
Vitaly Muzichenko #:

Verifique

Quem lhe disse que "a" da condição acima seria sempre falso?

x572intraday #:

Na verdade, deparei-me com esta característica por acidente. Não era isso que eu queria...

ou

O problema é que n pode ser bastante grande, por isso quis embrulhar esta longa cadeia de condições num compacto para. Tentei desta forma:

mas acabou por ser um pouco confuso. Bem, pelo menos porque h_plus com este algoritmo terá de tomar toda a soma das condições verificadas, incluindo a condição com verificação de matriz de índice redundante, o que não aconteceu no primeiro desembrulhado se, sem para isso. E outras varizes estragam o quadro.

Será isto sequer digno de consideração? É possível exagerar?

Aqui está este código que não compreendo de todo

for(int i=start; i<rates_total-3 && !IsStopped(); i++)
{
   bool h_plus=true; //false?
   for(int increment=1; increment<=n; increment++)
      h_plus&=high[i]>high[i+increment];
   if(h_plus) {...}
   ...
}

O que significa a marca & neste código? E em que laço deve ser executado se(h_plus)? Não lhe escapou nenhum parêntesis curvos?

1...312231233124312531263127312831293130313131323133313431353136...3184
Novo comentário