Obtener el número de decimales de cualquier número (no sólo las comillas) evitando Digits() en MQL4 y MQL5 - página 14

Nuevo comentario
 

¿Puedo pensar en una implementación rápida de la traducción de una matriz de estructuras (longitud múltiplo de sizeof(int)) hacia y desde una matriz int[]?

La aplicación práctica es el intercambio rápido de datos a través de los recursos. Mi variante es demasiado universal, por lo que se ralentiza.


Estas funciones aparecieron en MT5

StructToCharArray
CharArrayToStruct

No existen en MT4 y probablemente no existirán. Por lo tanto, tenemos que resolver el problema con y sin estas funciones (si son útiles).

El resultado será útil para un gran número de usuarios del foro.


He escrito una plantilla muy sencilla para el brainstorming con mi solución a este problema.

// Решения задачи: https://www.mql5.com/ru/forum/287618/page14#comment_9806429

#define  BENCH(A)                                                              \
{                                                                             \
  const ulong StartTime = GetMicrosecondCount();                              \
  A;                                                                          \
  Print("Time[" + #A + "] = " + (string)(GetMicrosecondCount() - StartTime)); \
}  

// Инициализация исходных данных
int InitData( MqlTick &Ticks[], const int Amount = 1 e6, const double Price = 1.2345)
{
  const int Size = ArrayResize(Ticks, Amount);
  
  for (int i = 0; i < Size; i++)
    Ticks[i].bid = Price;
    
  return(Size);
}

MqlTick TicksIn[];                  // Массив с исходными данными.
const int Init = InitData(TicksIn); // Инициализировали его.

// Проверка, что два массива совпадают.
bool IsCompare( const MqlTick &Ticks1[], const MqlTick &Ticks2[] )
{
  const int Size = ArraySize(Ticks1);  
  bool Res = (Size == ArraySize(Ticks2));
  
  for (int i = 0; (i < Size) && Res; i++)
    Res = (Ticks1[i].bid == Ticks2[i].bid);
    
  return(Res);
}

void OnStart()
{
  MqlTick TicksOut[];
  int Array[];
  
  BENCH(TicksToIntArray_fxsaber1(TicksIn, Array));  // Замерили конвертацию MqlTick[] -> int[].
  BENCH(IntArrayToTicks_fxsaber1(Array, TicksOut)); // Замерили конвертацию int[] -> MqlTick[].
  
  Print(IsCompare(TicksIn, TicksOut)); // Убедились, что тики на входе и выходе совпадают.
}

// Варианты реализаций
/***********************************************/
#include <TypeToBytes.mqh> // https://www.mql5.com/ru/code/16280

template <typename T1, typename T2>
int ArrayToArray( const T1 &Source[], T2 &Target[] )
{
  return(_ArrayCopy(Target, Source) / sizeof(T2));
}

// Перевод массива тиков в массив int[].
int TicksToIntArray_fxsaber1( const MqlTick &Ticks[], int &Array[] )
{
  return(ArrayToArray(Ticks, Array));
}

// Перевод массива int[] в массив тиков.
int IntArrayToTicks_fxsaber1( const int &Array[], MqlTick &Ticks[] )
{
  return(ArrayToArray(Array, Ticks));
}
/***********************************************/


Resultado

Time[TicksToIntArray_fxsaber1(TicksIn,Array)] = 2036468
Time[IntArrayToTicks_fxsaber1(Array,TicksOut)] = 2253915
true
 
Otra variante
template <typename T>
union INTEGER
{
  T Data;
  int Integer[sizeof(T) / sizeof(int)];
};

// Перевод массива тиков в массив int[].
int TicksToIntArray_fxsaber2( const MqlTick &Ticks[], int &Array[] )
{
  INTEGER<MqlTick> TickInteger;
  
  const int Size1 = ArraySize(Ticks);
  const int Size2 = ArrayResize(Array, Size1 * sizeof(MqlTick) / sizeof(int));
  int j = 0;
  
  for (int i = 0; (i < Size1) && (j < Size2); i++)
  {
    TickInteger.Data = Ticks[i];
    
    j += ArrayCopy(Array, TickInteger.Integer, j);
  }    
  
  return(j);
}

// Перевод массива int[] в массив тиков.
int IntArrayToTicks_fxsaber2( const int &Array[], MqlTick &Ticks[] )
{
  INTEGER<MqlTick> TickInteger;
  
  const int Size1 = ArraySize(Array);
  const int Size2 = ArrayResize(Ticks, Size1 * sizeof(int) / sizeof(MqlTick));
  int j = 0;
  
  for (int i = 0; (i < Size1) && (j < Size2); j++)
  {
    i += ArrayCopy(TickInteger.Integer, Array, 0, i, sizeof(MqlTick) / sizeof(int));

    Ticks[j] = TickInteger.Data;        
  }    
  
  return(j);
}


Resultado

Time[TicksToIntArray_fxsaber2(TicksIn,Array)] = 91967
Time[IntArrayToTicks_fxsaber2(Array,TicksOut)] = 79630
true


Algo considerablemente más rápido que la segunda opción. Probablemente no hay forma de acelerarlo.

 

¿unaimplementación rápida de la traducción de una matriz de estructuras (longitud múltiplo de sizeof(int)) a y desde una matriz int[]?

Algo así

#property strict

template< typename S, typename T >
union UDT{
  UDT(){for(int i=0;i<sizeof(S)/sizeof(T);i++)t[i]=0;}
  UDT(S&src){s=src;}
  UDT(T&src[],int k=0){for(int i=0;i<sizeof(S)/sizeof(T);i++)t[i]=src[i+k];}
  void to(S&dst){dst=s;}
  void to(T&dst[],int k=0){for(int i=0;i<sizeof(S)/sizeof(T);i++)dst[i+k]=t[i];}
  S s; T t[sizeof(S)/sizeof(T)];};

template< typename S, typename T >
void StructToArray(S&src[],T&dst[]){
  ArrayResize(dst,ArraySize(src)*(sizeof(S)/sizeof(T)));
  for(int i=0;i<ArraySize(dst)/(sizeof(S)/sizeof(T));i++){UDT<S,T>u(src[i]);u.to(dst,i*(sizeof(S)/sizeof(T)));}}

template< typename S, typename T >
void ArrayToStruct(T&src[],S&dst[]){
  ArrayResize(dst,ArraySize(src)/(sizeof(S)/sizeof(T)));
  for(int i=0;i<ArraySize(dst);i++){UDT<S,T>u(src,i*(sizeof(S)/sizeof(T)));u.to(dst[i]);}}

void OnStart()
 {
  MqlRates rates[],r2[];
  int l[];
  CopyRates(_Symbol,_Period,0,10,rates);
  for(int i=0;i<10;i++)printf("open=%f, high=%f, low=%f, close=%f, time=%s",rates[i].open,rates[i].high,rates[i].low,rates[i].close,TimeToStr(rates[i].time));
  Print("");
  StructToArray(rates,l);
  ArrayToStruct(l,r2);
  for(int i=0;i<ArraySize(r2);i++)printf("open=%f, high=%f, low=%f, close=%f, time=%s",r2[i].open,r2[i].high,r2[i].low,r2[i].close,TimeToStr(r2[i].time));
 }  


 
Ilya Malev:

Algo así.

https://www.mql5.com/ru/forum/287618/page14#comment_9807465
TicksToIntArray_fxsaber2
Time[TicksToIntArray(TicksIn,Array)] = 735252
IntArrayToTicks_fxsaber2
Time[IntArrayToTicks(Array,TicksOut)] = 591458
true

https://www.mql5.com/ru/forum/287618/page14#comment_9808274
TicksToIntArray_antfx1
Time[TicksToIntArray(TicksIn,Array)] = 398796
IntArrayToTicks_antfx1
Time[IntArrayToTicks(Array,TicksOut)] = 296646
true

¡Bien hecho! Me pondré a buscar el código, gracias.


Parece que ArrayCopy es un verdadero lentorro.


ZY De una carrera a otra, obtengo resultados muy diferentes. Por ejemplo, si cambio el orden de las Pruebas, casi todo se invierte. Aparentemente, necesito una medida de velocidad más objetiva.

Archivos adjuntos:
StructToArray.mq5  6 kb
 
Sin pensarlo mucho y sin depurar escribí lo primero que se me ocurrió, así que puede haber muchos fallos. Yo mismo no me he encontrado con esta tarea antes (aunque he trabajado mucho con los sindicatos).
 
fxsaber:

ZZZ, ArrayCopy parece ser un poco pesado.

Recuerdo haber medido en alguna tarea local, donde tenía que copiar un pequeño número de elementos. Hasta 16 elementos el bucle for era mucho más rápido que el ArrayCopy, cuando el número de elementos era mayor, el ArrayCopy era más rápido. Por supuesto, la variante más rápida sin bucles en absoluto (como mis funciones en la página anterior)

 
Ilya Malev:

La forma más rápida es hacerlo sin bucles en absoluto (como mis funciones en la página anterior).

No lo entiendo.

 
fxsaber:

No lo entiendo.

Lo que quiero decir es que for(int i=0; i<5; i++) dst[i]=src[i]; funciona más lento que dst[0]=src[0];dst[1]=src[1];dst[2]=src[2];dst[3]=src[3];dst[4]=src[4];

que es bastante obvio en vista de las operaciones adicionales relacionadas con el control del bucle)

Y CopyArray funciona mucho más rápido que ambos, como he comprobado ahora. Tal vez dependa de la situación, por supuesto.

 

Sí, esto funcionará mucho más rápido (sustituido en lo posible por ArrayCopy, el resto es lo mismo):

template< typename S, typename T >
union UTS2{
  UTS2(){for(int i=0;i<sizeof(S)/sizeof(T);i++)t[i]=0;}
  UTS2(S&src){s=src;}
  UTS2(T&src[],int k=0){ArrayCopy(t,src,0,k,sizeof(S)/sizeof(T));}//for(int i=0;i<sizeof(S)/sizeof(T);i++)t[i]=src[i+k];}
  void to(S&dst){dst=s;}
  void to(T&dst[],int k=0){ArrayCopy(dst,t,k,0,sizeof(S)/sizeof(T));}//for(int i=0;i<sizeof(S)/sizeof(T);i++)dst[i+k]=t[i];}
  S s; T t[sizeof(S)/sizeof(T)];};

template< typename S, typename T >
void StructToArray2(S&src[],T&dst[]){
  ArrayResize(dst,ArraySize(src)*(sizeof(S)/sizeof(T)));
  for(int i=0;i<ArraySize(dst)/(sizeof(S)/sizeof(T));i++){UTS2<S,T>u(src[i]);u.to(dst,i*(sizeof(S)/sizeof(T)));}}

template< typename S, typename T >
void ArrayToStruct2(T&src[],S&dst[]){
  ArrayResize(dst,ArraySize(src)/(sizeof(S)/sizeof(T)));
  for(int i=0;i<ArraySize(dst);i++){UTS2<S,T>u(src,i*(sizeof(S)/sizeof(T)));u.to(dst[i]);}}

Ya te dije que escribí lo primero que se me ocurrió sin hacer pruebas))

 
Ilya Malev:

Y CopyArray, tal y como lo he comprobado ahora, funciona mucho más rápido que ambas opciones, parece. Tal vez dependa de la situación, por supuesto.

Si ArrayCopy() se hace según el principio de Cish memmove(),

Creo que la velocidad de ArrayCopy() depende de la velocidad de asignación de la memoria, si la memoria intermedia del buffer está lista para ser copiada, ArrayCopy() se ejecutará muy rápidamente, si la memoria no está asignada, empezará a solicitar al sistema operativo que asigne memoria

puedes probar - hacer una llamada a ArrayCopy() con un volumen de datos grande, preparando así la memoria intermedia para el intercambio, y luego hacer un bucle con ArrayCopy() con un volumen de datos más pequeño para copiar y con la medición de la velocidad

1...78910111213141516171819202122
Nuevo comentario