Implementaciones alternativas de funciones/enfoques estándar - página 3

Nuevo comentario
 
fxsaber:
Resulta que #import ex5 es el mal de la optimización.

En términos de poder optimizar globalmente, sí.

Tenemos un inlining bastante agresivo sin tratar de hacer el código más pequeño. Así que en el modo de optimización global generamos un código muy bueno.

Esto se puede ver en el tiempo de compilación, donde ponemos la velocidad resultante en la parte superior de la lista.

 
prostotrader:

fxsaber

Hay un error en su código

Gracias, lo he corregido.
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:
Gracias, corregido.

Sigue siendo un error.

Debería ser un 5 al final.

 
prostotrader:

Sigue siendo un error

No es un error, es un redondeo. Esto es exactamente lo que hace la versión estándar.
 
fxsaber:
Esto no es un error, es un redondeo. Así es como lo hace la versión estándar.
Me equivoqué con la captura de pantalla equivocada, mira de nuevo (reemplaza la imagen)
 

Aquí está el código para que lo pruebes

//+------------------------------------------------------------------+
//|                                                         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:

Aquí está tu código, pruébalo.

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 - correcto. Val3 después de la conversión a largo - no es correcto. Al parecer, se trata de alguna peculiaridad de la representación doble de los números en coma flotante. Necesitamos incrementar EPSILON. No puedo distinguirlo con mi cabeza dormida. Tal vez algunas personas conocedoras puedan darme una pista.

Tengo que averiguar qué consideraciones utilizaron los desarrolladores para escribir esto

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

Aquí parece que está enterrado el perro.

 
Ahora siempre funciona correctamente, pero sólo un 10% más rápido que el original
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, ¡Gracias por encontrar las discrepancias!
 
fxsaber:

Aquí parece que está enterrado el perro.

Las raíces crecen desde el foro de RSDN

DBL_EPSILON define una diferencia de 1 (¡un!) bit significativo de un exponente cuando se aplica al número 1,0. En la práctica, no existe tal diferencia: los números son estrictamente iguales o pueden diferir en más de un bit significativo. Por lo tanto, hay que tomar algo así como 16*DBL_EPSILON para ignorar la diferencia de 4 bits menos significativos (o aproximadamente un dígito decimal y medio de los últimos disponibles).

Por supuesto, hay casos en los que la gama de números es más o menos conocida y predecible. Digamos, 0...1000. En este caso, puedes tomar una constante como 1000*16*DBL_EPSILON para una comparación aproximada. Pero hay que tener en cuenta que esa comparación convierte en realidad toda la idea de punto flotante en punto fijo (adivina por qué).

 

Una variante de CopyTicks, que a veces es varios órdenes de magnitud más rápida que la original (desde > 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
Nuevo comentario