Pergunta indicadora - página 3

Novo comentário
 
Agent86:
.

De qualquer forma, eu estava tentando fazer com que os fractais altos só se formassem quando outra condição ocorresse, como as cruzes iMACD, ou cruzes EMA ou algumas outras cruzes indicadoras.
Para que os fractais só se formem no indicador quando todas as condições forem atendidas.


Não tinha certeza exatamente o que você estava tentando fazer, mas tente isto, observe as entradas externas.

#property indicator_chart_window      extern bool condition1 = true;
#property indicator_buffers 3         extern bool condition2 = true;
#property indicator_color1 Red
#property indicator_color2 Blue
#property indicator_color3 White

//---- buffers
double v1[];
double v2[];
double v3[];
double val1;
double val2;
double val3;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int init()
  {
//----
   IndicatorBuffers(3);

   SetIndexArrow(0, 111);
   SetIndexStyle(0,DRAW_ARROW,STYLE_DOT,1,Blue);
   SetIndexBuffer(0, v1);
   SetIndexLabel(0,"Resistance");

   SetIndexArrow(1, 111);
   SetIndexStyle(1,DRAW_ARROW,STYLE_DOT,1,Red);
   SetIndexBuffer(1, v2);
   SetIndexLabel(1,"Support");

   SetIndexArrow(2, 111);
   SetIndexStyle(2,DRAW_ARROW,STYLE_DOT,1,White);
   SetIndexBuffer(2, v3);
   SetIndexLabel(2,"High A"); 
//----
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
  {
    
   double   faster = iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,1), //MODE_MAIN
            slower = iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,1); //MODE_SIGNAL
           
            
   int bars = Bars;
//----
  
   for(int i=bars; i>=0; i--)
    {
     if(condition1)
       {
        val1=iFractals(NULL, 0, MODE_UPPER,i);
        if (val1 > 0) v1[i]=High[i];       
       }   
     if(condition2)
       {      
        val2=iFractals(NULL, 0, MODE_LOWER,i);
        if (val2 > 0) v2[i]=Low[i];
       }
     }    
//----
   return(0);
  }
//+------------------------------------------------------------------+
 
WHRoeder:
Exatamente como você chegou a essa conclusão e qual é a diferença funcional?

Cheguei a essa conclusão, porque provavelmente, eu estava olhando da perspectiva do OOP. sim, isso não é verdade para o caso da MQL4, eu me lembro agora. Embora possa ser uma boa prática?



 

Ou talvez algo parecido com isto?

você realmente deveria usar IndicatorCounted(), porque se você fizer isso assim, seu indicador está redesenhando todos esses objetos a cada novo tick em vez de desenhá-los apenas uma vez e adicionando novos objetos à medida que novas barras são formadas 

#property indicator_chart_window
#property indicator_buffers 3
#property indicator_color1 Red
#property indicator_color2 Blue
#property indicator_color3 White

//---- buffers
double v1[];
double v2[];
double v3[];
double val1;
double val2;
double val3;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int init()
  {
//----
   IndicatorBuffers(3);

   SetIndexArrow(0, 111);
   SetIndexStyle(0,DRAW_ARROW,STYLE_DOT,1,Blue);
   SetIndexBuffer(0, v1);
   SetIndexLabel(0,"Resistance");

   SetIndexArrow(1, 111);
   SetIndexStyle(1,DRAW_ARROW,STYLE_DOT,1,Red);
   SetIndexBuffer(1, v2);
   SetIndexLabel(1,"Support");

   SetIndexArrow(2, 111);
   SetIndexStyle(2,DRAW_ARROW,STYLE_DOT,1,White);
   SetIndexBuffer(2, v3);
   SetIndexLabel(2,"High A"); 
//----
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
  {
    
   double   faster=0;
   double   slower=0;         
   int      bars = Bars;
//----
  
   for(int i=bars; i>=0; i--)
    {
     faster = iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,i); //MODE_MAIN
     slower = iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,i); //MODE_SIGNAL
     val1=iFractals(NULL, 0, MODE_UPPER,i);
     val2=iFractals(NULL, 0, MODE_LOWER,i);
     
     if(faster > 0)
      {
       if (val1 > 0) v1[i]=High[i];
      }
      
     if(faster < 0)
      {
       if (val2 > 0) v2[i]=Low[i];
      }        
    }   
//----
   return(0);
  }
//+------------------------------------------------------------------+
 
diostar:
Cheguei a essa conclusão, porque provavelmente, eu estava olhando da perspectiva OOP. sim, isto não é verdade para o caso da MQL4, eu me lembro agora. Embora possa ser uma boa prática?

É sempre uma boa prática limitar o escopo. é sempre uma boa prática definir variável/objeto onde foi utilizado e inicializá-los naquele ponto.

A definição de um objeto fora do laço resulta em uma construção padrão mais N atribuições. Definido dentro do laço resulta em N construções com valor - geralmente mais rápido.

Nunca se preocupe com otimizações até que você possa provar que a mudança faz a diferença.

 
WHRoeder:

É sempre uma boa prática limitar o escopo. é sempre uma boa prática definir variável/objeto onde foi utilizado e inicializá-los naquele ponto.

A definição de um objeto fora do laço resulta em uma construção padrão mais N atribuições. Definido dentro do laço resulta em construções N com valor - geralmente mais rápido.

Nunca se preocupe com otimizações até que você possa provar que a mudança faz a diferença.

Isto deve se aplicar também a seu iterador para (int i=0; ...
 
diostar:
Isto deve se aplicar também a seu iterador para (int i=0; ...
Eu me irrito, mas eu não escrevi esse código.
 
Ok, parece que agora tenho algumas variações de um código de trabalho, obrigado.

Embora eu esteja um pouco confuso sobre o porquê de a declaração das variáveis (mais rápida e lenta) fora do laço não ser boa enquanto estiver tudo bem dentro do laço.

E ainda assim a int i = Barras funcionará fora do laço ou dentro do laço ?


De qualquer forma, é bom ver que algumas das minhas idéias nas quais eu estava trabalhando já estão postadas neste tópico, então esta é uma boa notícia e significa que um dia estarei me aproximando um pouco mais de poder codificar algo por conta própria. Portanto, um pouco de progresso é melhor do que não. Obrigado

Portanto, agora posso trabalhar na comparação de alguns dos tempos indicadores, vou tentar descobrir isso agora.

Como por exemplo:
Comparar v1[i] com v2[i] indicador de tempos atualmente formado && / || se(v1[i] tempo é > v2[i] tempo) e outras comparações como esta.

Obrigado por todas as dicas que todos têm dado, isso tem sido de grande ajuda.
 
WHRoeder:

É sempre uma boa prática limitar o escopo. é sempre uma boa prática definir variável/objeto onde foi utilizado e inicializá-los naquele ponto.

A definição de um objeto fora do laço resulta em uma construção padrão mais N atribuições. Definido dentro do laço resulta em construções N com valor - geralmente mais rápido.

Nunca se preocupe com otimizações até que você possa provar que a mudança faz a diferença.

Presumo que isto seja verdade para todos, e não apenas indicadores / indicadores personalizados?
 
Agent86:
Ok, parece que agora tenho algumas variações de um código de trabalho, obrigado.

Embora eu esteja um pouco confuso sobre o porquê de a declaração das variáveis (mais rápida e mais lenta) fora do loop não ser boa enquanto está tudo bem dentro do loop

E ainda assim a int i = Barras funcionará fora do laço ou dentro do laço ?


Você tem que considerar o que está fazendo, ao criar um indicador você está aplicando seu código a cada barra no gráfico, isto significa que você precisa obter o valor do indicador macd como era para cada uma dessas barras históricas.

em seu código original que você fez:

double   faster = iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,1),
o último parâmetro 1 é o valor do macd como estava na barra 1 do gráfico, a barra anterior à barra atual que é indexada como barra 0

Obviamente você não quer usar esse valor único do macd em seu operador condicional sobre todo o gráfico histórico .

Você precisa indexar o macd ao mesmo índice de barras que cada barra, portanto, por exemplo, na barra 500, você precisa disto

faster = iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,500)

que o último parâmetro deve mudar para corresponder ao número de barras ao qual seu indicador está aplicando seus algoritmos.

É por isso que você precisa dele dentro do loop, para poder usar o iterador de ciclo de loop ( i ) para o último parâmetro, para que você obtenha seu valor macd como era para cada barra do gráfico histórico.

faster = iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,i),

Espero que isso ajude a esclarecer um pouco as coisas.

 
WHRoeder:
Tente esta mudança
Por que para(int i = Bars-1 ?

E por que isso é melhor que para(int i = Barras ??

Por favor, agradeça

12345678
Novo comentário