TickCompressor - com compactação de 1 tick para 2-3 bytes em média - biblioteca para MetaTrader 5

Compactação de dados de ticks para armazenamento em um formato compacto, até 3,5 vezes mais compacto do que os arquivos .tcs MQ. E para trabalhar rapidamente com eles, pois leva menos tempo para ler 3 bytes do que 60 bytes da estrutura MqlTick.

O tamanho do arquivo para 2023 com Ask, Bid, time com compressão ZIP adicional de blocos de dados pode ser visto na captura de tela:

Tamanho do arquivo no formato .tcs para 2023:

3,56 vezes a compactação.

Para armazenar ticks, são usadas as diferenças dos preços Ask e Bid em relação ao preço anterior. Frequentemente (até 50...70% de todos os ticks), ela não excede (-8...7) pontos e pode ser registrada com 4 bits. Ask e Bid são combinados em 1 byte.
Mais 1 byte para armazenar a diferença de tempo de 0 a 255 milissegundos (no código até 229, os valores acima de 229 são usados para codificar os ticks que estão além de -8...7 pontos).

Se os preços ou as horas diferirem em valores maiores, eles serão compactados em um número maior de bytes.

Para compactação adicional, você pode aplicar o arquivamento ZIP. O tamanho dos dados é reduzido em até duas vezes.

Como alternativa, pode ser feita a compactação para 3 bytes, com Ask e Bid de -129 a 128 compactados para 8 bits ou 1 byte cada. Mais 1 byte para o tempo, totalizando 3 bytes para a maioria dos ticks.
Às vezes(https://www.mql5.com/ru/forum/499639/page6#comment_58544810), se houver mais ticks compactados em 2 bytes do que em 4 bytes, é mais eficiente compactar em 3 bytes. É preciso dar uma olhada nas estatísticas do instrumento.
Você pode mudar a compactação máxima para 3 bytes com o comando:

#define  compressTo3Bytes // comprimir os ticks para 3 bytes em vez de 2.

Elementos de tique a serem armazenados em formato compactado

Estão programadas 3 variantes de elementos de tick para armazenamento:

1. Ask, Bid, time_msc
2. Ask, Bid, time_msc, volume_real
3. Todos os elementos Ask, Bid, Last, time_msc, volume_real, flags (o volume int é calculado a partir de volume_real).

Eles também podem ser compactados adicionalmente em ZIP. Haverá 6 variantes no total

method=1;//1...6 BidAsk_=1, BidAskVolume_=2, All_=3, BidAsk_Zipped=4, BidAskVolume_Zipped=5, All_Zipped=6

Antes de iniciar a compactação, você precisa passar para a classe a variante de armazenamento de ticks e alguns parâmetros padrão usados para cálculos e normalização de preços.

    TickCompressor Compressor2;
    double VolumeStep_=SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_STEP);
    Compressor2.Start(method,_Point,VolumeStep_,_Digits);

Se o Expert Advisor usar sinalizadores, eles poderão ser restaurados das alterações de preço pelo comando

#define  RestoreFlags // restaurar os sinalizadores de tique da alteração de ask, bid, volume - adicionará 7% ao tempo de geração de tique 931 em vez de 869ms

O Expert Advisor para teste de compressão está anexado e fornecerá estatísticas sobre a velocidade e a taxa de compressão. Você pode ver um exemplo de compressão e descompressão de ticks nele.

Um exemplo do Expert Advisor para negociação pode ser visto aqui https://www.mql5.com/pt/code/65821.

Estatísticas para compressão de 2 e 3 bytes:

Exemplos de código

Compressão de ticks

Bloco por bloco:

    int ZIPpos=0;//contador de bytes compactados
    if(Amount>ticks_per_block){// > 1 bloco - colagem de blocos de tmp para Ticks2
       for(int start=0; start<Amount; start+=ticks_per_block){
          Compressor2.Compress(Ticks, tmp, start, (Amount > start + ticks_per_block ? ticks_per_block : Amount - start));
          ZIPpos+=ArrayCopy(Ticks2,tmp,ZIPpos); //copiar para o final de Ticks2
       }
    }else{//1 bloco - descompactando diretamente no Ticks2
       Compressor2.Compress(Ticks, Ticks2, 0, Amount);
    } 

Se você definir o número de ticks em um bloco como maior que o total de ticks na matriz, ele será compactado em um bloco.

Se você sempre precisar de compressão em um bloco, poderá usar

Compressor2.Compress(Ticks,Ticks2); 

Mas a velocidade de descompressão de um bloco tão grande ou muito grande pode ser 2 vezes mais lenta. Além disso, haverá um grande consumo de memória para um bloco grande.

Desempacotamento de ticks

Ao desempacotar, é desejável saber o número de ticks empacotados. A matriz do receptor deve ter esse tamanho.

ArrayResize(Ticks3,Amount);

O tamanho pode ser salvo em um arquivo, por exemplo. E então usá-lo ao desempacotar.

Se o tamanho for desconhecido, você poderá alterar o tamanho dentro do loop pelo número de ticks no bloco

       /lento 
ArrayResize(Ticks3,total_ticks+ticks_per_block,10000000); //redimensionar uma matriz grande - é mais lento do que substituir um bloco pequeno

Esse código obtém os ticks bloco por bloco. Se houver apenas um bloco grande, ele também o conta corretamente. Os ticks não são coletados em uma grande matriz, mas podem ser processados imediatamente por sua estratégia Strategy(Ticks3[j]);

    while (ZIPpos<ArraySize(Ticks2)){
       nextSize=Compressor3.ArrToInt(Ticks2,ZIPpos);//tamanho do próximo bloco, aumente o ZIPpos em 4

       uint s = ArrayCopy(tmp,Ticks2,0,ZIPpos,nextSize); // copiar o novo bloco para tmp com o tamanho nextSize
       /mais lento por um fator de 3 ArrayResize(Ticks3,total_ticks+ticks_per_block,10000000); //redimensiona uma matriz grande - é mais lento do que substituir um bloco pequeno
       //total_ticks=Compressor3.DeCompress(tmp,Ticks3,nextSize,total_ticks);//desempacotar o bloco e adicioná-lo a Ticks3.
       
       total_ticks+=Compressor3.DeCompress(tmp,Ticks3,nextSize,0); //desempacotar o bloco e sobrescrevê-lo em Ticks3
       ZIPpos+=nextSize;
       for (int j = 0; j < ticks; j++){ Strategy(Ticks3[j]);}//estratégia
    };

Coleta os ticks de todos os blocos em uma grande matriz:

    while (ZIPpos<ArraySize(Ticks2)){
       nextSize=Compressor3.ArrToInt(Ticks2,ZIPpos);//tamanho do próximo bloco, aumente o ZIPpos em 4

       uint s = ArrayCopy(tmp,Ticks2,0,ZIPpos,nextSize); // copiar o novo bloco para tmp com o tamanho nextSize
       /mais lento ArrayResize(Ticks3,total_ticks+ticks_per_block,10000000); //redimensionar uma matriz grande - é mais lento do que substituir um bloco pequeno
       total_ticks=Compressor3.DeCompress(tmp,Ticks3,nextSize,total_ticks);//desempacotar o bloco e adicioná-lo ao Ticks3
       
       //total_ticks+=Compressor3.DeCompress(tmp,Ticks3,nextSize,0); //desempacotar o bloco e sobrescrevê-lo em Ticks3
       ZIPpos+=nextSize;
       //for (int j = 0; j < ticks; j++){ Strategy(Ticks3[j]);}//strategy
    };

Ou em uma única linha. Apenas 1 bloco deve ser registrado. Se houver mais, use as duas variantes de código acima.

total_ticks=Compressor3.DeCompress(Ticks2,Ticks3);