Ottenere il numero di posizioni decimali di qualsiasi numero (non solo le virgolette) bypassando Digits() in MQL4 e MQL5 - pagina 14

Nuovo commento
 

Posso fare un brainstorming su un'implementazione veloce per tradurre un array di strutture (lunghezza multipla di sizeof(int)) da e verso un array int[]?

L'applicazione pratica è lo scambio veloce di dati attraverso le risorse. La mia variante è troppo universale, quindi rallenta.


Queste funzioni sono apparse in MT5

StructToCharArray
CharArrayToStruct

Non esistono e probabilmente non esisteranno in MT4. Quindi dobbiamo risolvere il problema con e senza queste funzioni (se sono utili).

Il risultato sarà utile a un gran numero di utenti del forum qui.


Ho scritto un modello molto semplice per il brainstorming con la mia soluzione a questo 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));
}
/***********************************************/


Risultato

Time[TicksToIntArray_fxsaber1(TicksIn,Array)] = 2036468
Time[IntArrayToTicks_fxsaber1(Array,TicksOut)] = 2253915
true
 
Un'altra 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);
}


Risultato

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


Qualcosa di considerevolmente più veloce della seconda opzione. Probabilmente non c'è modo di accelerarlo.

 

un'implementazione veloce per tradurre un array di strutture (lunghezza multipla di sizeof(int)) in e da un array int[]?

Qualcosa del genere

#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:

Qualcosa del genere.

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

Ben fatto! Entrerò nel codice, grazie.


Sembra che ArrayCopy sia davvero lento.


ZY Da un'esecuzione all'altra, ottengo risultati molto diversi. Per esempio, se cambio l'ordine dei Test, tutto viene quasi invertito. A quanto pare, ho bisogno di una misurazione della velocità più oggettiva.

File:
StructToArray.mq5  6 kb
 
Senza molta riflessione e debugging ho scritto la prima cosa che mi è venuta in mente, quindi ci possono essere molti difetti. Non ho mai incontrato un compito del genere (anche se ho lavorato molto con i sindacati).
 
fxsaber:

ZZZ, ArrayCopy sembra essere un po' una seccatura.

Mi ricordo di aver misurato su qualche compito locale, dove dovevo copiare un piccolo numero di elementi. Fino a 16 elementi il ciclo for era molto più veloce di quello ArrayCopy, quando il numero di elementi era maggiore, quello ArrayCopy era più veloce. Naturalmente, la variante più veloce senza loop (come le mie funzioni nella pagina precedente)

 
Ilya Malev:

Il modo più veloce è quello di farlo senza loop (come le mie funzioni nella pagina precedente).

Non capisco.

 
fxsaber:

Non capisco.

Il mio punto è che for(int i=0; i<5; i++) dst[i]=src[i]; funziona più lentamente di dst[0]=src[0]; dst[1]=src[1]; dst[2]=src[2]; dst[3]=src[3]; dst[4]=src[4];

il che è abbastanza ovvio in vista delle operazioni aggiuntive relative al controllo del ciclo)

E CopyArray funziona molto più velocemente di entrambi, come ho controllato ora. Forse dipende dalla situazione, ovviamente.

 

Sì, questo funzionerà molto più velocemente (sostituito dove possibile da ArrayCopy, il resto è lo stesso):

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]);}}

Te l'ho detto, ho scritto la prima cosa che mi è venuta in mente senza nessun test))

 
Ilya Malev:

E CopyArray, come ho controllato ora, funziona molto più velocemente di entrambe le opzioni, sembra. Forse dipende dalla situazione, naturalmente.

Se ArrayCopy() è fatta sul principio di Cish memmove(),

Penso che la velocità di ArrayCopy() dipenda dalla velocità di allocazione della memoria, se la memoria intermedia del buffer è pronta per la copia, ArrayCopy() sarà eseguita molto rapidamente, se la memoria non è allocata, si avvieranno richieste al sistema operativo per allocare la memoria

si può provare a testare - fare una chiamata a ArrayCopy() con un grande volume di dati, preparando così la memoria del buffer per lo scambio, e poi fare un ciclo con ArrayCopy() con un volume di dati più piccolo per la copia e con la misurazione della velocità

1...78910111213141516171819202122
Nuovo commento
Motivazione: