Valeur du tick précédent - page 4

Nouveau commentaire
 
Merci Nicholi pour ce code plus rationnel. Après quelques expériences, j'ai trouvé que déclarer ask_diff comme float produisait des différences avec le nombre correct de chiffres mais une erreur de compilation sur une possible perte de données due à la conversion de type. Il semble que je doive choisir entre avoir de très petites imprécisions dans mes différences ou avoir un avertissement de compilation. Cette dernière solution serait préférable pour les décisions commerciales, mais quelqu'un d'autre a-t-il une solution pour obtenir au maximum cinq décimales dans ask_diff ?
 
rdone:
Merci Nicholi pour ce code plus rationnel. Après quelques expériences, j'ai trouvé que déclarer ask_diff comme float produisait des différences avec le nombre correct de chiffres mais une erreur de compilation sur une possible perte de données due à la conversion de type. Il semble que je doive choisir entre avoir de très petites imprécisions dans mes différences ou avoir un avertissement de compilation. Cette dernière solution serait préférable pour les décisions commerciales, mais quelqu'un d'autre a-t-il une solution pour obtenir au maximum cinq décimales dans ask_diff ?

votre ask_diff devrait être de type int et ressembler à ceci à la place.

int diff = int(round((current.ask - last.ask) / _Point));
 
Je viens de découvrir NormalizeDouble et DoubleToString. Hé, c'est mon premier jour à ce...
 
rdone:
Je viens de découvrir NormalizeDouble et DoubleToString. C'est mon premier jour de travail...
Mon objectif est de déterminer la différence entre la demande actuelle et la demande précédente (partie 1) et ensuite de garder un total courant de ces différences (partie 2). La partie 1 fonctionne mais la partie 2 ne renvoie que le montant de la demande précédente. Quelqu'un peut-il voir où je fais fausse route et me fournir une correction de trajectoire ?
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());
  }
 
Comme cela arrive souvent, le code faisait ce qu'il était censé faire au lieu de ce que je voulais qu'il fasse. La logique exige que tick_prev soit toujours rempli, mais ce n'est pas le cas lors du premier tick. Je suis intéressé par une logique qui n'exige pas que tick_prev soit rempli au premier tick, mais sinon cela fonctionne.
 
rdone:
Comme cela arrive souvent, le code faisait ce qu'il était censé faire au lieu de ce que je voulais qu'il fasse. La logique exige que tick_prev soit toujours rempli, mais ce n'est pas le cas lors du premier tick. Je suis intéressé par une logique qui n'exige pas que tick_prev soit rempli au premier tick, mais sinon cela fonctionne.
Et maintenant avec le code.
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:
Comme cela arrive souvent, le code faisait ce qu'il était censé faire au lieu de ce que je voulais qu'il fasse. La logique exige que tick_prev soit toujours rempli, mais ce n'est pas le cas lors du premier tick. Je suis intéressé par une logique qui n'exige pas que tick_prev soit rempli au premier tick, mais sinon cela fonctionne.
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:
C'est un niveau de codage que j'aspire à atteindre. Merci Ernst !
diff_ask += tick_prev.ask!=0.0?(tick_curr.ask-tick_prev.ask):0.0;
 
rdone:
C'est un niveau de codage que j'aspire à atteindre. Merci Ernst !

Vous ne voulez pas stocker la différence de points sous forme de double, car les doubles sont rarement égaux. Il faut la stocker sous forme de valeur entière. Par exemple (1.00001 - 1.00000) / 0.00001 = 1 point. Donc, si vous ne comparez que deux ticks, vous pouvez rendre votre code plus compact et simplement sous-classer MqlTick et ajouter un attribut int pour la différence de points.

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
Nouveau commentaire