Especialistas: Diff_TF_MA_EA - página 3

Novo comentário
 
Rashid Umarov:
Os códigos foram atualizados.

Aparentemente, é um tipo de escola de pensamento quando eles escrevem dessa forma

   int total=PositionsTotal();
   for(int i=total-1; i>=0; i--)
     {
      ulong ticket=PositionGetTicket(i);
      if(ticket==0) continue;
      if(PositionGetInteger(POSITION_MAGIC)!=InpMagic)   continue;
      if(PositionGetString(POSITION_SYMBOL)!=symb)       continue;
      ENUM_POSITION_TYPE type=(ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
      double volume=PositionGetDouble(POSITION_VOLUME);
      if(type==POSITION_TYPE_BUY)
        {
         list_tickets_buy.Add(ticket);
         total_volume_buy+=volume;
        }
      else if(type==POSITION_TYPE_SELL)
        {
         list_tickets_sell.Add(ticket);
         total_volume_sell+=volume;
        }
     }
Por que não assim?
  for(int i=PositionsTotal()-1; i>=0; i--)
    if (PositionGetTicket(i) &&
        (PositionGetInteger(POSITION_MAGIC)==InpMagic) &&
        (PositionGetString(POSITION_SYMBOL)==symb))  
    {
      double volume=PositionGetDouble(POSITION_VOLUME);
      if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY)
        {
         list_tickets_buy.Add(ticket);
         total_volume_buy+=volume;
        }
      else
        {
         list_tickets_sell.Add(ticket);
         total_volume_sell+=volume;
        }
    }


ZY

CorrectStopLoss(POSITION_TYPE_BUY,InpStopLoss)
 
fxsaber:

Aparentemente, é um tipo de escola de pensamento escrever dessa forma

Por que não assim?
Talvez porque os códigos sejam necessários na base não para deduções lógicas e aninhamento centuplicado, mas para que os iniciantes entendam?
 
fxsaber:
...

ZY

CorrectStopLoss(POSITION_TYPE_BUY,InpStopLoss)

Qual é a diferença? Não olhei o código - esse é um erro de digitação ou é essa a sua pergunta?

 
Artyom Trishkin:
Talvez porque os códigos sejam necessários na base, não para deduções lógicas e aninhamento de centenas de vezes, mas para que os iniciantes possam entender?

Onde está a inversão? Se uma posição satisfizer as condições, trabalharemos com ela. continue - output.

 
Artyom Trishkin:

Existe alguma diferença? Não dei uma olhada no código - há um erro de digitação ou é essa a sua pergunta?

//+------------------------------------------------------------------+
//| Retorna o StopLoss correto em relação ao StopLevel
//+------------------------------------------------------------------+
double CorrectStopLoss(const ENUM_POSITION_TYPE position_type,const int stop_loss)
  {
   if(stop_loss==0) return 0;
   double pt = _Point;
   double price=(position_type==POSITION_TYPE_BUY ? SymbolInfoDouble(_Symbol,SYMBOL_ASK) : SymbolInfoDouble(_Symbol,SYMBOL_BID));
   int lv=StopLevel();
   return(NormalizeDouble((position_type==POSITION_TYPE_BUY) ? fmin(price-lv*pt,price-stop_loss*pt)
                                                             : fmax(price+lv*pt,price+stop_loss*pt),_Digits));
  }    
 
fxsaber:

Onde está a reviravolta? Se uma posição satisfaz as condições, nós trabalhamos com ela. É uma diversão.

Ah... Então são apenas as preferências de alguém.

Por exemplo, os códigos de Igor Kim têm esse aninhamento. Esse código pode ser escrito de forma mais compacta (é estranho que você, com seu apego à brevidade, sugira vários aninhamentos de blocos de código que podem ser facilmente evitados limpando o código e tornando-o mais ilustrativo):

Você propõe essa lógica:

  • Verifique a condição 1, ela se encaixa
    • Verifique a condição 2, ela se encaixa
      • Verificar a condição 3, ela se encaixa
        • Verificar a condição 4, é adequado
          • Trabalho
        • Fim do bloco de verificação da condição 4
      • Fim do bloco de verificação da condição 3
    • Fim do bloco de verificação da condição 2
  • Fim do bloco de verificação da condição 1

Ou você pode fazer isso desta forma:

  • a condição 1 não se encaixa - não é necessário
  • a condição 2 não se encaixa - não há necessidade
  • a condição 3 não é adequada - não é necessária
  • a condição 4 não se encaixa - não é necessária
  • todas as condições se encaixam - nós trabalhamos.

O segundo código é mais claro e mais curto

 

fxsaber:

//+------------------------------------------------------------------+
//| Retorna o StopLoss correto em relação ao StopLevel
//+------------------------------------------------------------------+
double CorrectStopLoss(const ENUM_POSITION_TYPE position_type,const int stop_loss)
  {
   if(stop_loss==0) return 0;
   double pt = _Point;
   double price=(position_type==POSITION_TYPE_BUY ? SymbolInfoDouble(_Symbol,SYMBOL_ASK) : SymbolInfoDouble(_Symbol,SYMBOL_BID));
   int lv=StopLevel();
   return(NormalizeDouble((position_type==POSITION_TYPE_BUY) ? fmin(price-lv*pt,price-stop_loss*pt)
                                                             : fmax(price+lv*pt,price+stop_loss*pt),_Digits));
  }    

O que há de errado? Bem, acho que eles decidiram consertar isso para que não houvesse dúvidas como as que você teve anteriormente.

Mas agora, se alguém decidir modificar o Expert Advisor para trabalhar com ordens pendentes, ele terá que mudar de um lado para o outro, porque haverá um erro na enumeração de entrada.

E ORDER_TYPE_BUY == POSITION_TYPE_BUY e ORDER_TYPE_SELL == POSITION_TYPE_SELL são 0 e 1. Portanto, não há diferença. Mas a entrada ENUM_ORDER_TYPE facilita a modificação para outros tipos de ordens.

 
Artyom Trishkin:

Ahhhh. Essa é apenas a preferência de alguém.

Por exemplo, os códigos de Igor Kim têm esse tipo de aninhamento. Esse código pode ser escrito de forma mais compacta (é estranho que você, com seu apego à brevidade, sugira o aninhamento múltiplo de blocos de código, o que pode ser facilmente evitado limpando o código e tornando-o mais ilustrativo):

Você propõe essa lógica:

  • Verifique a condição 1, ela se encaixa
    • Verifique a condição 2, ela se encaixa
      • Verifique a condição 3, ela se encaixa.
        • Verifica a condição 4, ela se encaixa.
          • Trabalho
        • Fim do bloco de verificação da condição 4
      • Fim do bloco de verificação da condição 3
    • Fim do bloco de verificação da condição 2
  • Fim do bloco de verificação da condição 1

Não mostrava nada parecido com isso. Kim foi forçado a fazer isso devido à falta de uma diretriz rígida na época.

Ele sugeriu esta opção:

Você pode fazer dessa forma:

  • a condição 1 não se encaixa - não é necessário
  • a condição 2 não se encaixa - não é necessário
  • a condição 3 não se encaixa - não é necessária
  • a condição 4 não é adequada - não é necessária
  • todas as condições se encaixam - nós funcionamos.

O segundo código é mais claro e mais curto

 
fxsaber:

Não mostrou nada disso. Kim foi forçado a fazer isso porque não havia nenhuma diretriz na época.

Foi isso que ele sugeriu:

E isso?

Fórum sobre negociação, sistemas de negociação automatizados e teste de estratégias de negociação.

Expert Advisors: Diff_TF_MA_EA

fxsaber, 2018.02.02 09:36 pm.

Onde está a reversão? Se a posição atender às condições, trabalhe com ela. Se a posição atender às condições, trabalhamos com ela.


 
fxsaber:

Não mostrou nada disso. Kim foi forçado a fazer isso porque não havia nenhuma diretriz na época.


Estranho, como eu consegui trabalhar com o continue sem restrições naquela época? E eu não fui o único - Vitya Nikolaev (Vinin) me disse para fazer isso naquela época.

Portanto, não entendo sua reclamação sobre o código e o programador que o escreveu em algumas de suas preferências.

12345
Novo comentário