[AVISO FECHADO!] Qualquer pergunta de novato, para não desorganizar o fórum. Profissionais, não passem por aqui. Não posso ir a lugar algum sem você. - página 608

Novo comentário
 
artmedia70:
Como você acha que vai decidir se é um recuo ou um recuo? Ou você abrirá duas posições em cada recuo? É um busto...

Eu gostaria que funcionasse primeiro, e depois gostaria de executar a EA no testador para encontrar o tamanho do parâmetro lim.
 
Olá a todos, estou tentando fazer um programa e estou tendo

Não consigo entender porque não está funcionando.

Eu posso explicar isso :-)

Eu gostaria de fazer uma linha que muda de cor dependendo da tendência por assim dizer (indicador primitivo)

Parece mudar, mas há lacunas como se ele falhasse uma barra no cálculo

qual é o meu erro?



//--------------------------------------------------------------------
#janela_do_cartão_indicador de propriedade
#property indicator_buffers 2
#Indicador de propriedade_color1 Azul // Cor da primeira linha
#Indicador de propriedade_color2 Vermelho // cor da segunda linha

duplo Buf_0[],Buf_1[]; //arrays indicadores abertos
//--------------------------------------------------------------------
int init() // Função especial init()
{
//--------------------------------------------------------------------
SetIndexBuffer(0,Buf_0); // Atribuição de uma matriz para o buffer
SetIndexStyle(0,DRAW_LINE,STYLE_SOLID,2);// Estilo de linha
//--------------------------------------------------------------------
SetIndexBuffer(1,Buf_1);
SetIndexStyle(1,DRAW_LINE,STYLE_SOLID,2);
//--------------------------------------------------------------------
retornar;
}
//--------------------------------------------------------------------
int start()
{
int i,counted_bars;
//--------------------------------------------------------------------
Counted_bars=IndicatorCounted(); // Número de barras calculadas
i=Bars-Counted_bars-1; // Índice do primeiro não contado
while(i>=0) // Ciclo através das barras não contadas
{
double a=(High[i]+Low[i])/2;
double b=(High[i+1]+Low[i+1])/2;
se (a=>b) Buf_0[i]=a; //alterar ou não mudar de cor
se (a<b) Buf_1[i]=a;
i--;
}
//--------------------------------------------------------------------
retornar;
}
//--------------------------------------------------------------------
 
Olá!!! Você pode, por favor, aconselhar como implementar isto em código? Eu deveria ter 3 (Montantes são definidos separadamente) ordens de corte não lucrativas para abrir duas ordens de compra e venda. A distância entre eles deve ser definida em uma variável separada.
 
Olá, quero calcular o 'ATR histórico intradiário' (ou seja, dizer média de cada hora nos últimos 30 dias) e gostaria de acreditar que algo assim já deveria existir - talvez o indicador seja chamado de outra coisa ou os existentes podem ser ajustados de alguma forma? se alguém souber, por favor, avise!
 
zelek:

Eu gostaria de colocá-lo funcionando primeiro, e depois executar o 'EA' no testador para dimensionar o parâmetro de cal.
E você pode anexá-lo à ATR. Haverá dinâmica e não haverá necessidade de ajuste - tudo dependerá da volatilidade do mercado
 
Top2n:
Olá!!! Você pode, por favor, aconselhar como implementar isto em código? Eu deveria ter 3 (número total é definido separadamente) ordens de perda sl deve abrir duas ordens de compra e venda. A distância entre eles deve ser definida em uma variável separada.


Definimos uma variável igual a zero e a aumentamos em 1 quando a posição está perdendo. Uma vez atingido o valor requerido, abrimos as posições requeridas.
Essa é a lógica...
 

Você pode me dizer quais robôs trabalham por 15 dias e quais não diferem em lucro do Cheetah 2.5?

Por favor, me dê um link ou website, etc.

Obrigado antecipadamente por seu tempo

 
artmedia70:
E você o liga à ATR. Será dinâmico e não há necessidade de ajuste - dependerá da volatilidade do mercado


Por favor, dê uma olhada no código, eu não entendo porque os pedidos não são fechados

extern int     lim=20;             // Дистанция возврата курса

/
int init()
  {
 

   return(0);
  }
/
int deinit()
  {
//----
   
//----
   return(0);
  }

int start()
  {
 
  double 
   max, min;                                            
  int b, s;
   if (Bid>max) max=Bid; 
    if (Ask<min) min=Ask;  
       if (OrdersTotal()>0)
       {                                   
           if ((max-Bid)>=lim*Point) 
           {                   
          OrderSelect(b,SELECT_BY_TICKET);                                  
          b=OrderClose(OrderTicket(),0.1,Bid,3,Blue);
          }
          
          
          if ((Ask-min)>=lim*Point)  
          {         
      OrderSelect(s,SELECT_BY_TICKET); 
      s=OrderClose(OrderTicket(),0.1,Ask,3,Red);
         }
}
else
{
  if (OrdersTotal()<1)
  {
 b=OrderSend(Symbol(),OP_BUY,0.1,Ask,5,0,0,"",5,0);
      
 s=OrderSend(Symbol(),OP_SELL,0.1,Bid,5,0,0,"",5,0); 
    }                           
   }
         return;

   return(0);
  }
 
zelek:


Por favor, dê uma olhada no código, não consigo entender porque os pedidos não estão fechando

estrutura interessante:
if (Licitação>max) max=Bid;
se (Pergunte<min) min=Ask;

Você tem certeza de que se o preço subir, então se ((max-Bid)>=lim*Point) será executado?

Eu faria o seguinte - na seção init(), por exemplo, eu memorizaria o preço quando a EA começasse (pode não estar no init) - e então eu dançaria a partir deste preço.

Se você tiver um consultor especializado, você memorizaria o preço, mas como parece que você dividirá seus min e max por ticks e então controlará seus pedidos neste corredor


 
Logicamente deveria funcionar, mas por que não, você pode explicar?
1...601602603604605606607608609610611612613614615...1145
Novo comentário
Razão: