TickCompressor - avec compression d'un tick en 2-3 octets en moyenne - bibliothèque pour MetaTrader 5

Compression des données de tic-tac pour un stockage sous une forme compacte jusqu'à 3,5 fois plus compacte que les fichiers MQ .tcs. Et pour travailler rapidement avec eux, car il faut moins de temps pour lire 3 octets que 60 octets de la structure MqlTick.

La taille du fichier pour 2023 avec Ask, Bid, time avec une compression ZIP supplémentaire des blocs de données est visible sur la capture d'écran :

Taille du fichier au format .tcs pour 2023 :

3,56 fois la compression.

Pour enregistrer les ticks, on utilise les différences entre les cours acheteur et vendeur et le cours précédent. Souvent (jusqu'à 50...70% de tous les ticks) elle ne dépasse pas (-8...7) points, et elle peut être enregistrée avec 4 bits. Le cours vendeur et le cours acheteur sont combinés en un seul octet.
Plus 1 octet pour stocker la différence de temps de 0 à 255 millisecondes (dans le code jusqu'à 229, les valeurs supérieures à 229 sont utilisées pour encoder les ticks qui sont au-delà de -8...7 points).

Si les prix ou les heures diffèrent par des valeurs plus importantes, ils sont regroupés dans un plus grand nombre d'octets.

Pour une compression supplémentaire, vous pouvez appliquer l'archivage ZIP. La taille des données est alors réduite jusqu'à deux fois.

Il est également possible d'effectuer une compression sur 3 octets, les valeurs Ask et Bid de -129 à 128 étant comprimées sur 8 bits ou 1 octet chacune. Plus 1 octet pour l'heure, soit un total de 3 octets pour la plupart des ticks.
Parfois(https://www.mql5.com/ru/forum/499639/page6#comment_58544810), s'il y a plus de ticks compressés en 2 octets qu'en 4 octets, il est plus efficace de compresser en 3 octets. Il faut regarder les statistiques de l'instrument.
Vous pouvez passer à une compression maximale de 3 octets à l'aide de la commande :

#define  compressTo3Bytes // compresser les ticks en 3 octets au lieu de 2.

Éléments d'affichage à stocker sous forme comprimée

3 variantes d'éléments de tic-tac à stocker sont programmées :

1. Ask, Bid, time_msc
2. Ask, Bid, time_msc, volume_real
3. Tous les éléments Ask, Bid, Last, time_msc, volume_real, flags (le volume int est calculé à partir du volume_real).

Ils peuvent également être compressés en ZIP. Il y aura 6 variantes au total

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

Avant de commencer la compression, vous devez transmettre à la classe la variante de stockage des ticks et certains paramètres standard utilisés pour les calculs et la normalisation des prix.

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

Si le Conseiller Expert utilise des drapeaux, ils peuvent être restaurés à partir des changements de prix par la commande

#define  RestoreFlags // restaurer les drapeaux de tick à partir des changements de ask, bid, volume - ajoutera 7% au temps de génération du tick 931 au lieu de 869ms

Le Conseiller Expert pour le test de compression est joint, il donnera des statistiques sur la vitesse et le taux de compression. Vous pouvez y voir un exemple de compression et de décompression de ticks.

Un exemple de l'Expert Advisor pour le trading peut être visualisé ici https://www.mql5.com/fr/code/65821.

Statistiques pour la compression à 2 et 3 octets :

Exemples de code

Compression de tic-tac

Bloc par bloc :

    int ZIPpos=0;//compteur d'octets compressés
    if(Amount>ticks_per_block){// > 1 bloc - collage des blocs de tmp à 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); //copier à la fin de Ticks2
       }
    }else{//1 bloc - déballage direct dans Ticks2
       Compressor2.Compress(Ticks, Ticks2, 0, Amount);
    } 

Si le nombre de ticks dans un bloc est supérieur au nombre total de ticks dans le tableau, il sera compressé en un seul bloc.

Si vous avez toujours besoin d'une compression en 1 bloc, vous pouvez utiliser

Compressor2.Compress(Ticks,Ticks2); 

Mais la vitesse de décompression d'un bloc aussi grand ou très grand peut être deux fois plus lente. De plus, la consommation de mémoire sera importante pour un bloc de grande taille.

Décompression des ticks

Lors de la décompression, il est souhaitable de connaître le nombre de ticks emballés. Le tableau récepteur doit avoir cette taille.

ArrayResize(Ticks3,Amount);

La taille peut être sauvegardée dans un fichier, par exemple. Elle sera ensuite utilisée lors du déballage.

Si la taille est inconnue, vous pouvez changer la taille à l'intérieur de la boucle par le nombre de ticks dans le bloc

       // ralentir 
ArrayResize(Ticks3,total_ticks+ticks_per_block,10000000); //redimensionnement d'un grand tableau - plus lent que l'écrasement d'un petit bloc

Ce code récupère les ticks bloc par bloc. S'il n'y a qu'un seul grand bloc, il le compte aussi correctement. Les ticks ne sont pas rassemblés dans un grand tableau, mais peuvent être traités immédiatement par votre stratégie Strategy(Ticks3[j]) ;

    while (ZIPpos<ArraySize(Ticks2)){
       nextSize=Compressor3.ArrToInt(Ticks2,ZIPpos);//taille du bloc suivant, augmentation du ZIPpos de 4

       uint s = ArrayCopy(tmp,Ticks2,0,ZIPpos,nextSize); // copie le nouveau bloc dans tmp avec la taille nextSize
       /plus lent d'un facteur 3 ArrayResize(Ticks3,total_ticks+ticks_per_block,10000000) ; //redimensionnement d'un grand tableau - plus lent que l'écrasement d'un petit bloc
       //total_ticks=Compressor3.DeCompress(tmp,Ticks3,nextSize,total_ticks);//déballez le bloc et ajoutez-le à Ticks3.
       
       total_ticks+=Compressor3.DeCompress(tmp,Ticks3,nextSize,0); //déballe le bloc et l'écrase dans Ticks3
       ZIPpos+=nextSize;
       for (int j = 0; j < ticks; j++){ Strategy(Ticks3[j]);}//stratégie
    };

Rassemble les ticks de tous les blocs dans un grand tableau :

    while (ZIPpos<ArraySize(Ticks2)){
       nextSize=Compressor3.ArrToInt(Ticks2,ZIPpos);//taille du bloc suivant, augmentation du ZIPpos de 4

       uint s = ArrayCopy(tmp,Ticks2,0,ZIPpos,nextSize); // copie le nouveau bloc dans tmp avec la taille nextSize
       /plus lent ArrayResize(Ticks3,total_ticks+ticks_per_block,10000000) ; //redimensionne un grand tableau - plus lent que l'écrasement d'un petit bloc
       total_ticks=Compressor3.DeCompress(tmp,Ticks3,nextSize,total_ticks);//déballe le bloc et l'ajoute à Ticks3
       
       //total_ticks+=Compressor3.DeCompress(tmp,Ticks3,nextSize,0) ; //déballe le bloc et l'écrase dans Ticks3
       ZIPpos+=nextSize;
       //for (int j = 0 ; j < ticks ; j++){ Strategy(Ticks3[j]);}//strategy
    };

Ou une seule ligne. Un seul bloc doit être enregistré. S'il y en a plus, utilisez les deux variantes de code ci-dessus.

total_ticks=Compressor3.DeCompress(Ticks2,Ticks3);