Implementazioni alternative di funzioni/approcci standard - pagina 3

Nuovo commento
 
fxsaber:
Si scopre che #import ex5 è il male dell'ottimizzazione.

In termini di capacità di ottimizzazione globale, sì.

Abbiamo un inlining abbastanza aggressivo senza cercare di rendere il codice più piccolo. Quindi in modalità di ottimizzazione globale generiamo un codice molto buono.

Questo può essere visto nel tempo di compilazione, dove abbiamo messo la velocità risultante in cima alla lista.

 
prostotrader:

fxsaber

C'è un errore nel tuo codice

Grazie, l'ho corretto.
double MyNormalizeDouble( const double Value, const uint digits )
{
  static const double Points[] = {1.0 e-0, 1.0 e-1, 1.0 e-2, 1.0 e-3, 1.0 e-4, 1.0 e-5, 1.0 e-6, 1.0 e-7, 1.0 e-8};
  const double point = digits > 8 ? 1.0 e-8 : Points[digits];

  return((long)((Value > 0) ? Value / point + HALF_PLUS : Value / point - HALF_PLUS) * point);
}
 
fxsaber:
Grazie, corretto.

Ancora un errore.

Dovrebbe essere un 5 alla fine.

 
prostotrader:

Ancora un errore

Non è un errore, è un arrotondamento. Questo è esattamente ciò che fa la versione standard.
 
fxsaber:
Questo non è un errore, è un arrotondamento. È così che fa la versione standard.
Ho fatto un errore con lo screenshot sbagliato, guarda di nuovo (sostituisci l'immagine)
 

Ecco il codice da testare

//+------------------------------------------------------------------+
//|                                                         Test.mq5 |
//|                        Copyright 2016, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2016, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#define  EPSILON (1.0 e-7 + 1.0 e-13)
#define  HALF_PLUS  (0.5 + EPSILON)
#property indicator_separate_window
#property indicator_plots   1
#property indicator_buffers 1
double d_value = 12345.012345;
//
double MyNormalizeDouble( const double Value, const uint digits )
{
  static const double Points[] = {1.0 e-0, 1.0 e-1, 1.0 e-2, 1.0 e-3, 1.0 e-4, 1.0 e-5, 1.0 e-6, 1.0 e-7, 1.0 e-8};
  const double point = digits > 8 ? 1.0 e-8 : Points[digits];

  return((long)((Value > 0) ? Value / point + HALF_PLUS : Value / point - HALF_PLUS) * point);
}
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   double new_value = MyNormalizeDouble(d_value, 0);
   new_value = NormalizeDouble(d_value, 0);
   new_value = MyNormalizeDouble(d_value, 1);
   new_value = NormalizeDouble(d_value, 1);
   new_value = MyNormalizeDouble(d_value, 2);
   new_value = NormalizeDouble(d_value, 2);
   new_value = MyNormalizeDouble(d_value, 3);
   new_value = NormalizeDouble(d_value, 3);
   new_value = MyNormalizeDouble(d_value, 4);
   new_value = NormalizeDouble(d_value, 4);
   new_value = MyNormalizeDouble(d_value, 5);
   new_value = NormalizeDouble(d_value, 5);
   new_value = MyNormalizeDouble(d_value, 6);
   new_value = NormalizeDouble(d_value, 6);
   new_value = MyNormalizeDouble(d_value, 7);
   new_value = NormalizeDouble(d_value, 7);
   new_value = MyNormalizeDouble(d_value, 8);
   new_value = NormalizeDouble(d_value, 8);
   new_value = MyNormalizeDouble(d_value, 9);
   new_value = NormalizeDouble(d_value, 9);
   if (new_value ==0.0)
   {}  
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const int begin,
                const double &price[])
  {
//---
   
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+
 
prostotrader:

Ecco il vostro codice, testatelo.

void OnStart( void )
{
  double Val = 12345.012345;
  
  double Val2 = Val / 1.0 e-5;
  Val2 += HALF_PLUS; // Val2 == 1234501235.0
  
  long Val3 = (long)Val2; // Val3 == 1234501234
    
  return;
};

Val2 - corretto. Val3 dopo la conversione in lungo - non corretto. Apparentemente, è qualche peculiarità della doppia rappresentazione dei numeri in virgola mobile. Dobbiamo incrementare EPSILON. Non riesco a capirlo nella mia testa assonnata. Forse qualche persona esperta può darmi un suggerimento.

Devo capire quali considerazioni hanno usato gli sviluppatori per scrivere questo

//+------------------------------------------------------------------+
//| Сравнивает два значения типа double.                             |
//| RESULT                                                           |
//|   Возвращает истину, если значения равны и                       |
//|   ложь в противном случе.                                        |
//+------------------------------------------------------------------+
bool CEnvironment::DoubleEquals(const double a,const double b)
  {
//---
   return(fabs(a-b)<=16*DBL_EPSILON*fmax(fabs(a),fabs(b)));
//---
  }

Sembra che il cane sia sepolto qui.

 
Ora funziona sempre correttamente, ma solo il 10% più veloce dell'originale
double MyNormalizeDouble( const double Value, const uint digits )
{
  static const double Points[] = {1.0 e-0, 1.0 e-1, 1.0 e-2, 1.0 e-3, 1.0 e-4, 1.0 e-5, 1.0 e-6, 1.0 e-7, 1.0 e-8};
  const double point = digits > 8 ? 1.0 e-8 : Points[digits];
  const long Integer = (long)Value; // чтобы не создавать крайне медленный относительный epsilon

  return((long)((Value > 0) ? (Value - Integer) / point + HALF_PLUS : (Value - Integer) / point - HALF_PLUS) * point + Integer);
}
prostotrader, Grazie per aver trovato le discrepanze!
 
fxsaber:

Sembra che il cane sia sepolto qui.

Le radici crescono dal forum RSDN

DBL_EPSILON definisce una differenza di 1 (uno!) bit significativo di un esponente quando viene applicato al numero 1,0. In pratica, non c'è questa differenza - i numeri sono strettamente uguali o possono differire di più di un bit significativo. Quindi, dovete prendere qualcosa come 16*DBL_EPSILON per ignorare la differenza di 4 bit meno significativi (o circa una e mezza ultima cifra decimale significativa su circa 16 disponibili).

Naturalmente, ci sono casi in cui la gamma di numeri è più o meno nota e prevedibile. Diciamo, 0...1000. In questo caso, potete prendere una costante come 1000*16*DBL_EPSILON per un confronto approssimativo. Ma dobbiamo tenere a mente che un tale confronto trasforma effettivamente l'intera idea della virgola mobile in una virgola fissa (indovinate perché).

 

Una variante di CopyTicks, che a volte è diversi ordini di grandezza più veloce dell'originale (da > 0)

int MyCopyTicks( const string Symb, MqlTick& Ticks[], const uint flags = COPY_TICKS_ALL, const ulong from = 0, const uint count = 0 )
{
  int Res = (from == 0) ? CopyTicks(Symb, Ticks, flags, 0, count) : -1;
  
  if (from > 0)
  {    
    uint count2 = 1;
    
    MqlTick NewTicks[];    
    int Amount = CopyTicks(Symb, NewTicks, flags, 0, count2);
    
    while ((Amount > 0) && ((ulong)NewTicks[0].time_msc >= from))
    {
      count2 <<= 1;
      
      Amount = CopyTicks(Symb, NewTicks, flags, 0, count2);
    }

    for (int i = 1; i < Amount; i++)
      if ((ulong)NewTicks[i].time_msc >= from)
      {
        Res = ArrayCopy(Ticks, NewTicks, 0, i, (count == 0) ? 2000 : count);
        
        break;
      }    
  }
  
  return(Res);
}
12345678910...13
Nuovo commento