Valor del tick anterior - página 4

Nuevo comentario
 
Gracias Nicholi por ese código más racionalizado. Después de algunos experimentos, encontré que declarar ask_diff como float producía diferencias con el número correcto de dígitos pero un error de compilación sobre la posible pérdida de datos por la conversión de tipos. Parece que tengo que elegir entre tener inexactitudes muy pequeñas en mis diferencias o tener una advertencia de compilación. Esto último sería mejor para las decisiones comerciales, pero ¿alguien más tiene una solución para obtener como máximo cinco decimales en ask_diff?
 
rdone:
Gracias Nicholi por ese código más racionalizado. Después de algunos experimentos, encontré que declarar ask_diff como float producía diferencias con el número correcto de dígitos pero un error de compilación sobre la posible pérdida de datos por la conversión de tipo. Parece que tengo que elegir entre tener inexactitudes muy pequeñas en mis diferencias o tener una advertencia de compilación. Esto último sería mejor para las decisiones comerciales, pero ¿alguien más tiene una solución para obtener como máximo cinco decimales en ask_diff?

tu ask_diff debería ser de tipo int y tener este aspecto.

int diff = int(round((current.ask - last.ask) / _Point));
 
Acabo de descubrir NormalizeDouble y DoubleToString. Oye, es mi primer día en esto...
 
rdone:
Acabo de descubrir NormalizeDouble y DoubleToString. Es mi primer día en esto...
Mi objetivo es determinar la diferencia entre el Ask actual y el Ask anterior (Parte 1) y luego mantener un total de esas diferencias (Parte 2). La parte 1 funciona, pero la parte 2 sólo devuelve el importe de la demanda anterior. ¿Alguien puede ver en qué me estoy equivocando y corregir el rumbo?
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 suele ocurrir, el código estaba haciendo lo que se suponía que debía hacer en lugar de lo que yo quería que hiciera. La lógica requiere que tick_prev esté siempre poblada pero no es verdadera en el primer tick. Estoy interesado en una lógica que no requiera que tick_prev sea poblado en el primer tick, pero por lo demás esto funciona.
 
rdone:
Como suele ocurrir, el código estaba haciendo lo que se suponía que debía hacer en lugar de lo que yo quería que hiciera. La lógica requiere que tick_prev esté siempre poblado pero no es verdadera en el primer tick. Me interesa una lógica que no requiera que tick_prev sea poblado en el primer tick, pero por lo demás esto funciona.
Y ahora con el 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 suele ocurrir, el código estaba haciendo lo que se suponía que debía hacer en lugar de lo que yo quería que hiciera. La lógica requiere que tick_prev esté siempre poblada pero no es verdadera en el primer tick. Estoy interesado en una lógica que no requiera que tick_prev sea poblado en el primer tick, pero por lo demás esto 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 es un nivel de codificación al que aspiro llegar. ¡Gracias Ernst!
diff_ask += tick_prev.ask!=0.0?(tick_curr.ask-tick_prev.ask):0.0;
 
rdone:
Este es un nivel de codificación al que aspiro llegar. ¡Gracias Ernst!

No quieres almacenar la diferencia de puntos como un doble, ya que los dobles rara vez son iguales. Quieres almacenarlo como un valor entero. Por ejemplo (1.00001 - 1.00000) / 0.00001 = 1 punto. Así que si sólo estás comparando dos ticks entonces puedes hacer tu código más compacto y simplemente subclasificar MqlTick y añadir un atributo int para la diferencia de puntos.

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
Nuevo comentario