Valore della zecca precedente - pagina 4

Nuovo commento
 
Grazie Nicholi per questo codice più snello. Dopo alcuni esperimenti, ho scoperto che dichiarare ask_diff come float ha prodotto differenze con il numero corretto di cifre ma un errore di compilazione sulla possibile perdita di dati dalla conversione del tipo. Sembra che io debba scegliere tra avere imprecisioni molto piccole nelle mie differenze o avere un avviso di compilazione. Quest'ultimo sarebbe meglio per le decisioni di trading, ma qualcun altro ha una soluzione per ottenere al massimo cinque cifre decimali in ask_diff?
 
rdone:
Grazie Nicholi per questo codice più snello. Dopo alcuni esperimenti, ho scoperto che dichiarare ask_diff come float ha prodotto differenze con il numero corretto di cifre ma un errore di compilazione sulla possibile perdita di dati dalla conversione del tipo. Sembra che io debba scegliere tra avere imprecisioni molto piccole nelle mie differenze o avere un avviso di compilazione. Quest'ultimo sarebbe meglio per le decisioni di trading, ma qualcun altro ha una soluzione per ottenere al massimo cinque cifre decimali in ask_diff?

il vostro ask_diff dovrebbe essere di tipo int e assomigliare a questo.

int diff = int(round((current.ask - last.ask) / _Point));
 
Ho appena scoperto NormalizeDouble e DoubleToString. Ehi, è il mio primo giorno...
 
rdone:
Ho appena scoperto NormalizeDouble e DoubleToString. Ehi, è il mio primo giorno...
Il mio obiettivo è quello di determinare la differenza tra l'attuale Ask e l'Ask precedente (Parte 1) e poi mantenere un totale corrente di queste differenze (Parte 2). La parte 1 funziona, ma la parte 2 restituisce solo l'importo della domanda precedente. Qualcuno può vedere dove sto sbagliando e fornire qualche correzione?
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());
  }
 
Come spesso accade, il codice stava facendo quello che doveva fare invece di quello che volevo che facesse. La logica richiede che tick_prev sia sempre popolato ma non è vero al primo tick. Sono interessato a una logica che non richieda che tick_prev sia popolato sul primo tick, ma altrimenti questo funziona.
 
rdone:
Come spesso accade, il codice stava facendo quello che doveva fare invece di quello che volevo che facesse. La logica richiede che tick_prev sia sempre popolato ma non è vero al primo tick. Mi interessa una logica che non richieda che tick_prev sia popolato sul primo tick, ma per il resto questo funziona.
E ora con il codice.
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:
Come spesso accade, il codice stava facendo quello che doveva fare invece di quello che volevo che facesse. La logica richiede che tick_prev sia sempre popolato ma non è vero al primo tick. Sono interessato a una logica che non richieda che tick_prev sia popolato sul primo tick, ma altrimenti questo funziona.
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:
Questo è un livello di codifica che aspiro a raggiungere. Grazie Ernst!
diff_ask += tick_prev.ask!=0.0?(tick_curr.ask-tick_prev.ask):0.0;
 
rdone:
Questo è un livello di codifica che aspiro a raggiungere. Grazie Ernst!

Non volete memorizzare la differenza di punti come un doppio, poiché i doppi sono raramente uguali. Volete memorizzarla come un valore intero. Per esempio (1.00001 - 1.00000) / 0.00001 = 1 punto. Quindi, se state confrontando solo due tick, allora potete rendere il vostro codice più compatto e semplicemente sottoclasse MqlTick e aggiungere un attributo int per il punto diff.

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
Nuovo commento