Valor do tick anterior - página 4

Novo comentário
 
Obrigado Nicholi por esse código mais racionalizado. Após algumas experiências, descobri que declarar ask_diff como flutuador produziu diferenças com o número correto de dígitos, mas um erro de compilação sobre a possível perda de dados da conversão do tipo. Parece que tenho que escolher entre ter muito pequenas imprecisões em minhas diferenças ou ter um aviso de compilação. Este último seria melhor para as decisões comerciais, mas alguém mais tem uma solução para obter no máximo cinco casas decimais em ask_diff?
 
rdone:
Obrigado Nicholi por esse código mais simplificado. Depois de algumas experiências, descobri que declarar ask_diff como float produziu diferenças com o número correto de dígitos, mas um erro de compilação sobre possível perda de dados da conversão do tipo. Parece que tenho que escolher entre ter muito pequenas imprecisões em minhas diferenças ou ter um aviso de compilação. Este último seria melhor para as decisões comerciais, mas alguém mais tem uma solução para obter no máximo cinco casas decimais em ask_diff?

seu ask_diff deve ser datilografado e ter este aspecto.

int diff = int(round((current.ask - last.ask) / _Point));
 
Acabo de descobrir o NormalizeDouble e o DoubleToString. Ei, é meu primeiro dia neste...
 
rdone:
Acabo de descobrir o NormalizeDouble e o DoubleToString. Ei, é meu primeiro dia neste...
Meu objetivo é determinar a diferença entre o Ask atual e o Ask anterior (Parte 1) e depois manter um total corrido dessas diferenças (Parte 2). A Parte 1 funciona, mas a Parte 2 apenas devolve o valor do Ask anterior. Alguém pode ver onde estou indo errado e fornecer alguma correção de curso?
double ask_curr;
double ask_prev;
double ask_diff;
double diff_ask;
MqlTick tick_curr, tick_prev;
void OnTick()
  {
   if(SymbolInfoTick(Symbol(),tick_curr))
     {
      /* Part 1 */
      ask_curr = tick_curr.ask;
      ask_prev = tick_prev.ask;
      ask_diff = ask_curr - ask_prev;
      Print(DoubleToString(ask_diff,5));
      /* Part 2 */
      diff_ask = diff_ask + ask_diff;
      Print(DoubleToString(diff_ask,5));     
      tick_prev = tick_curr;
     }
   else Print("SymbolInfoTick() failed, error = ",GetLastError());
  }
 
Como muitas vezes acontece, o código estava fazendo o que deveria fazer, ao invés do que eu queria que fizesse. A lógica exige que o tick_prev seja sempre preenchido, mas não é verdade no primeiro tick. Estou interessado em uma lógica que não requer que o tick_prev seja populado no primeiro tick, mas caso contrário isto funciona.
 
rdone:
Como muitas vezes acontece, o código estava fazendo o que deveria fazer, ao invés do que eu queria que fizesse. A lógica exige que o tick_prev seja sempre preenchido, mas não é verdade no primeiro tick. Estou interessado em uma lógica que não requer que o tick_prev seja populado no primeiro tick, mas caso contrário isto funciona.
E agora com código.
double ask_curr;
double ask_prev;
double ask_diff;
double diff_ask;
int notfirst;
MqlTick tick_curr, tick_prev;
void OnTick()
  {
   if(SymbolInfoTick(Symbol(),tick_curr))
     {
      if (notfirst > 0)
      {
      /* Part 1 */
      ask_curr = tick_curr.ask;
      ask_prev = tick_prev.ask;
      ask_diff = ask_curr - ask_prev;
      Print(DoubleToString(ask_diff,5));
      /* Part 2 */
      diff_ask = diff_ask + ask_diff;
      Print(DoubleToString(diff_ask,5));
      }
      tick_prev = tick_curr;
      notfirst = 1;  
     }
   else Print("SymbolInfoTick() failed, error = ",GetLastError());
  }
 
rdone:
Como muitas vezes acontece, o código estava fazendo o que deveria fazer, ao invés do que eu queria que fizesse. A lógica exige que o tick_prev seja sempre preenchido, mas não é verdade no primeiro tick. Estou interessado em uma lógica que não requer que o tick_prev seja populado no primeiro tick, mas caso contrário isto funciona.
double diff_ask=0;
MqlTick tick_curr, tick_prev={0};
void OnTick()
  {
   if(SymbolInfoTick(Symbol(),tick_curr))
     {
      /* Part 1 */
      diff_ask += tick_prev.ask!=0.0?(tick_curr.ask-tick_prev.ask):0.0;
      Print(DoubleToString(diff_ask,5));
      /* Part 2 */
      //diff_ask = diff_ask + ask_diff;
      //Print(DoubleToString(diff_ask,5));     
      tick_prev = tick_curr;
     }
   else Print("SymbolInfoTick() failed, error = ",GetLastError());
  }
 
Ernst Van Der Merwe:
Este é um nível de codificação que eu aspiro alcançar. Obrigado Ernst!
diff_ask += tick_prev.ask!=0.0?(tick_curr.ask-tick_prev.ask):0.0;
 
rdone:
Este é um nível de codificação que eu aspiro atingir. Obrigado Ernst!

Você não quer armazenar a diferença de pontos como um duplo, uma vez que as duplas raramente são iguais. Você quer armazená-la como um valor inteiro. Por exemplo (1,00001 - 1,00000) / 0,00001 = 1 ponto. Assim, se você estiver comparando apenas dois tiquetaques, então você pode tornar seu código mais compacto e apenas subclasse MqlTick e adicionar um atributo int para a diferença de pontos.

struct MyTick : public MqlTick{int point_diff;} tick_curr={0}, tick_prev={0};
void OnStart()
{
   tick_prev = tick_curr;
   SymbolInfoTick(_Symbol, tick_curr);
   if(tick_prev.ask != 0.0){
      tick_curr.point_diff = int(round(
         (tick_curr.ask - tick_prev.ask) / _Point
      ));
      printf("%.5f -> %.5f: %d point diff",
         tick_prev.ask,
         tick_curr.ask,
         tick_curr.point_diff
      );
   }
}
1234
Novo comentário