TickCompressor - con compressione di 1 tick a 2-3 byte in media - libreria per MetaTrader 5

Compressione dei dati di tick per l'archiviazione in forma compatta fino a 3,5 volte più compatta dei file MQ .tcs. E per lavorare velocemente con essi, dato che la lettura di 3 byte richiede meno tempo rispetto ai 60 byte della struttura MqlTick.

La dimensione del file per il 2023 con Ask, Bid, time con compressione ZIP aggiuntiva dei blocchi di dati è visibile nella schermata:

Dimensione del file in formato .tcs per il 2023:

3,56 volte la compressione.

Per memorizzare i tick, vengono utilizzate le differenze dei prezzi Ask e Bid rispetto al prezzo precedente. Spesso (fino al 50-70% di tutti i tick) non supera i (-8-7) punti e può essere registrata con 4 bit. Ask e Bid sono combinati in 1 byte.
Più 1 byte per memorizzare la differenza di tempo da 0 a 255 millisecondi (nel codice fino a 229, i valori superiori a 229 sono utilizzati per codificare i tick che sono oltre i -8...7 punti).

Se i prezzi o i tempi differiscono per valori maggiori, vengono impacchettati in un numero maggiore di byte.

Per un'ulteriore compressione è possibile applicare l'archiviazione ZIP. La dimensione dei dati viene ridotta fino a 2 volte.

In alternativa, è possibile effettuare una compressione a 3 byte, con Ask e Bid da -129 a 128 compressi a 8 bit o 1 byte ciascuno. Più 1 byte per l'ora, per un totale di 3 byte per la maggior parte dei tick.
A volte(https://www.mql5.com/ru/forum/499639/page6#comment_58544810), se ci sono più tick compressi a 2 byte che a 4 byte, è più efficiente comprimere a 3 byte. È necessario esaminare le statistiche dello strumento.
È possibile modificare la compressione massima a 3 byte con il comando:

#define  compressTo3Bytes // comprimere i tick a 3 byte invece che a 2.

Elementi di spunta per la memorizzazione in forma compressa

Sono programmate 3 varianti di elementi di tick per la memorizzazione:

1. Ask, Bid, time_msc
2. Ask, Bid, time_msc, volume_reale
3. Tutti gli elementi Ask, Bid, Last, time_msc, volume_real, flag (il volume int è calcolato dal volume_real).

Possono anche essere ulteriormente compressi in ZIP. In totale ci saranno 6 varianti

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

Prima di avviare la compressione, è necessario passare alla classe la variante di memorizzazione dei tick e alcuni parametri standard utilizzati per i calcoli e la normalizzazione dei prezzi.

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

Se l'Expert Advisor utilizza dei flag, questi possono essere ripristinati dalle variazioni di prezzo con il comando

#define  RestoreFlags // ripristina i flag dei tick dal cambio di ask, bid, volume - aggiungerà il 7% al tempo di generazione dei tick 931 invece di 869ms

Si allega l'Expert Advisor per il test di compressione, che fornirà statistiche sulla velocità e sul tasso di compressione. È possibile vedere un esempio di compressione e decompressione dei tick.

Un esempio di Expert Advisor per il trading può essere visualizzato qui https://www.mql5.com/it/code/65821.

Statistiche per la compressione a 2 e 3 byte:

Esempi di codice

Compressione dei tick

Blocco per blocco:

    int ZIPpos=0;/contatore di byte compressi
    if(Amount>ticks_per_block){// > 1 blocco - incollare i blocchi da tmp a 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); //copiare alla fine di Ticks2
       }
    }else{//1 blocco - decompressione direttamente in Ticks2
       Compressor2.Compress(Ticks, Ticks2, 0, Amount);
    } 

Se si imposta che il numero di tick in 1 blocco sia maggiore del totale dei tick nell'array, questo verrà compresso in 1 blocco.

Se si ha sempre bisogno di una compressione in 1 blocco, si può usare il comando

Compressor2.Compress(Ticks,Ticks2); 

Ma la velocità di decompressione di un blocco così grande o molto grande potrebbe essere 2 volte più lenta. Inoltre, un blocco di grandi dimensioni comporta un notevole consumo di memoria.

Disimballaggio dei tick

Quando si scompatta è auspicabile conoscere il numero di tick impacchettati. L'array del ricevitore deve avere questa dimensione.

ArrayResize(Ticks3,Amount);

La dimensione può essere salvata in un file, ad esempio. Per poi utilizzarla al momento del disimballaggio.

Se la dimensione non è nota, è possibile modificare la dimensione all'interno del ciclo in base al numero di tick nel blocco.

       /rallentare 
ArrayResize(Ticks3,total_ticks+ticks_per_block,10000000); //ridimensiona un array di grandi dimensioni: funziona più lentamente rispetto alla sovrascrittura di un piccolo blocco

Questo codice ottiene i tick blocco per blocco. Se c'è un solo blocco grande, lo conta correttamente. I tick non vengono raccolti in un grande array, ma possono essere elaborati immediatamente dalla strategia Strategy(Ticks3[j]);

    while (ZIPpos<ArraySize(Ticks2)){
       nextSize=Compressor3.ArrToInt(Ticks2,ZIPpos);//dimensionare il blocco successivo, aumentare ZIPpos di 4

       uint s = ArrayCopy(tmp,Ticks2,0,ZIPpos,nextSize); // copia del nuovo blocco in tmp con dimensione nextSize
       //più lento di un fattore 3 ArrayResize(Ticks3,total_ticks+ticks_per_block,10000000); //ridimensiona un array di grandi dimensioni - funziona più lentamente della sovrascrittura di un piccolo blocco
       //total_ticks=Compressor3.DeCompress(tmp,Ticks3,nextSize,total_ticks);//disimpacchetta il blocco e lo aggiunge a Ticks3.
       
       total_ticks+=Compressor3.DeCompress(tmp,Ticks3,nextSize,0); //disimpacchetta il blocco e lo sovrascrive in Ticks3
       ZIPpos+=nextSize;
       for (int j = 0; j < ticks; j++){ Strategy(Ticks3[j]);}//strategia
    };

Raccoglie i tick di tutti i blocchi in un unico grande array:

    while (ZIPpos<ArraySize(Ticks2)){
       nextSize=Compressor3.ArrToInt(Ticks2,ZIPpos);//dimensionare il blocco successivo, aumentare ZIPpos di 4

       uint s = ArrayCopy(tmp,Ticks2,0,ZIPpos,nextSize); // copia del nuovo blocco in tmp con dimensione nextSize
       //più lento ArrayResize(Ticks3,total_ticks+ticks_per_block,10000000); //ridimensiona un array di grandi dimensioni - funziona più lentamente della sovrascrittura di un piccolo blocco
       total_ticks=Compressor3.DeCompress(tmp,Ticks3,nextSize,total_ticks);//disimpacchetta il blocco e lo aggiunge a Ticks3
       
       //total_ticks+=Compressor3.DeCompress(tmp,Ticks3,nextSize,0); //scompatta il blocco e lo sovrascrive in Ticks3
       ZIPpos+=nextSize;
       //per (int j = 0; j < ticks; j++){ Strategia(Ticks3[j]);}/strategia
    };

O una riga. Deve essere registrato solo 1 blocco. Se sono di più, utilizzare le due varianti di codice sopra descritte.

total_ticks=Compressor3.DeCompress(Ticks2,Ticks3);