Obter o número de casas decimais de quaisquer números (não apenas citações) contornando Dígitos() em MQL4 e MQL5 - página 14

Novo comentário
 

Posso fazer um brainstorming sobre uma rápida implementação da tradução de uma série de estruturas (comprimento múltiplo de tamanho do(int)) de e para uma série int[]?

A aplicação prática é a troca rápida de dados através de recursos. Minha variante é muito universal, por isso é mais lenta.


Estas funções apareceram no MT5

StructToCharArray
CharArrayToStruct

Eles não existem no MT4 e provavelmente não existirão. Portanto, temos que resolver o problema com e sem estas funções (se elas forem úteis).

O resultado será útil para um grande número de usuários do fórum aqui.


Escrevi um modelo muito simples de brainstorming com minha solução para 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
 
Outra 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 consideravelmente mais rápido do que a segunda opção. Provavelmente não há como acelerar o processo.

 

umarápida implementação da tradução de um conjunto de estruturas (comprimento múltiplo de tamanho do(int)) de e para um conjunto int[]?

Algo como isto

#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 parecido com isto.

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

Muito bem feito! Vou entrar no código, obrigado.


Parece que o ArrayCopy é um verdadeiro slowpoke.


ZY De corrida em corrida, eu obtenho resultados muito diferentes. Por exemplo, se eu mudar a ordem dos Testes, tudo quase se inverte. Aparentemente, eu preciso de uma medição de velocidade mais objetiva.

Arquivos anexados:
StructToArray.mq5  6 kb
 
Sem muito pensar e depurar, escrevi a primeira coisa que me veio à mente, então talvez haja muitas falhas. Eu mesmo não encontrei tal tarefa antes (embora tenha trabalhado muito com os sindicatos).
 
fxsaber:

ZZZ, ArrayCopy parece ser um pouco arrasador.

Lembro-me de medir em alguma tarefa local, onde eu tinha que copiar um pequeno número de elementos. Até 16 elementos o para loop era muito mais rápido que o ArrayCopy, quando o número de elementos era maior, o ArrayCopy era mais rápido. É claro, a variante mais rápida sem loops (como minhas funções na página anterior)

 
Ilya Malev:

A maneira mais rápida é fazê-lo sem nenhum laço (como minhas funções na página anterior).

Eu não entendo.

 
fxsaber:

Eu não entendo.

Meu ponto é que para(int i=0; i<5; i++) dst[i]=src[i]; funciona mais lentamente que dst[0]=src[0];dst[1]=src[1];dst[2]=src[2];dst[3]=src[3];dst[4]=src[4];

o que é bastante óbvio em vista de operações adicionais relacionadas ao controle de loop)

E CopyArray funciona muito mais rápido do que ambos, como verifiquei agora. Talvez dependa da situação, é claro.

 

Sim, isto funcionará muito mais rápido (substituído, quando possível, pelo ArrayCopy, o resto é o mesmo):

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

Eu lhe disse, escrevi a primeira coisa que me veio à mente sem testes))

 
Ilya Malev:

E a CopyArray, como eu verifiquei agora, funciona muito mais rápido do que as duas opções, ao que parece. Talvez dependa da situação, é claro.

Se ArrayCopy() é feito com base no princípio de Cish memmove(),

Eu acho que a velocidade do ArrayCopy() depende da velocidade de alocação de memória, se a memória intermediária do buffer estiver pronta para copiar, o ArrayCopy() será executado muito rapidamente, se a memória não for alocada, você iniciará solicitações ao sistema operacional para alocar memória

você pode tentar testar - fazer uma chamada para o ArrayCopy() com um grande volume de dados, preparando assim a memória buffer para troca, e então fazer um loop com o ArrayCopy() com um volume de dados menor para cópia e com a medição da velocidade

1...78910111213141516171819202122
Novo comentário