TickCompressor - mit Komprimierung von 1 Tick auf durchschnittlich 2-3 Bytes - Bibliothek für den MetaTrader 5

Komprimierung der Tick-Daten zur Speicherung in einer kompakten Form, die bis zu 3,5 Mal kompakter ist als .tcs MQ-Dateien. Und für schnelles Arbeiten mit ihnen, da es weniger Zeit braucht, 3 Bytes als 60 Bytes der MqlTick-Struktur zu lesen.

Die Dateigröße für 2023 mit Ask, Bid, Time mit zusätzlicher ZIP-Kompression der Datenblöcke ist auf dem Screenshot zu sehen:

Dateigröße im .tcs-Format für 2023:

3,56-fache Komprimierung.

Zur Speicherung von Ticks werden die Differenzen von Ask und Bid zum vorherigen Kurs verwendet. Oft (bis zu 50...70% aller Ticks) übersteigt sie (-8...7) Punkte nicht und kann mit 4 Bit aufgezeichnet werden. Ask und Bid werden in 1 Byte zusammengefasst.
Plus 1 Byte zur Speicherung der Zeitdifferenz von 0 bis 255 Millisekunden (im Code bis 229, Werte über 229 werden zur Codierung von Ticks verwendet, die über -8...7 Punkte hinausgehen).

Wenn sich Preise oder Zeiten um größere Werte unterscheiden, werden sie in eine größere Anzahl von Bytes gepackt.

Zur zusätzlichen Komprimierung können Sie die ZIP-Archivierung anwenden. Die Größe der Daten wird dabei um das bis zu 2-fache reduziert.

Alternativ kann eine Komprimierung auf 3 Byte erfolgen, wobei Ask und Bid von -129 bis 128 auf 8 Bit bzw. je 1 Byte komprimiert werden. Plus 1 Byte für die Zeit - insgesamt 3 Byte für die meisten Ticks.
Manchmal(https://www.mql5.com/ru/forum/499639/page6#comment_58544810), wenn mehr Ticks auf 2 Byte als auf 4 Byte komprimiert sind, ist es effizienter, auf 3 Byte zu komprimieren. Sie müssen sich die Instrumentenstatistiken ansehen.
Sie können die maximale Komprimierung mit dem Befehl auf 3 Bytes umstellen:

#define  compressTo3Bytes // Komprimierung der Ticks auf 3 statt 2 Bytes.

Zu speichernde Tick-Elemente in komprimierter Form

Es sind 3 Varianten von Tick-Elementen für die Speicherung programmiert:

1. Ask, Bid, time_msc
2. Ask, Bid, time_msc, volume_real
3. Alle Elemente Ask, Bid, Last, time_msc, volume_real, flags (int volume wird aus volume_real berechnet).

Sie können auch zusätzlich in ZIP komprimiert werden. Es wird insgesamt 6 Varianten geben

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

Bevor Sie die Komprimierung starten, müssen Sie der Klasse die Variante der Tick-Speicherung und einige Standardparameter übergeben, die für die Berechnungen und die Normalisierung der Preise verwendet werden.

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

Wenn der Expert Advisor Flags verwendet, können diese bei Preisänderungen mit dem Befehl

#define  RestoreFlags // Wiederherstellung der Tick-Flags aus der Änderung von Ask, Bid, Volume - fügt 7% zur Tick-Erzeugungszeit hinzu 931 statt 869ms

Der Expert Advisor für den Kompressionstest ist beigefügt, er liefert Statistiken über die Geschwindigkeit und die Komprimierungsrate. Sie können ein Beispiel für die Komprimierung und Dekomprimierung von Ticks in ihm sehen.

Ein Beispiel für den Expert Advisor für den Handel ist hier zu sehen: https://www.mql5.com/de/code/65821.

Statistiken für die Komprimierung auf 2 und 3 Bytes:

Code-Beispiele

Tick-Komprimierung

Block für Block:

    int ZIPpos=0;//komprimierter Byte-Zähler
    if(Amount>ticks_per_block){> 1 Block - Kleben von Blöcken aus tmp in 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); //Kopieren an das Ende von Ticks2
       }
    }else{//1 Block - Entpacken direkt in Ticks2
       Compressor2.Compress(Ticks, Ticks2, 0, Amount);
    } 

Wenn Sie die Anzahl der Ticks in einem Block größer als die Gesamtzahl der Ticks im Array einstellen, wird dieser in 1 Block komprimiert.

Wenn Sie immer eine Komprimierung in 1 Block benötigen, können Sie

Compressor2.Compress(Ticks,Ticks2); 

Aber die Geschwindigkeit der Dekomprimierung eines solchen großen oder sehr großen Blocks kann 2 mal langsamer sein. Außerdem wird für einen großen Block viel Speicherplatz benötigt.

Entpacken von Ticks

Beim Entpacken ist es wünschenswert, die Anzahl der gepackten Ticks zu kennen. Das Empfänger-Array muss diese Größe haben.

ArrayResize(Ticks3,Amount);

Die Größe kann z.B. in einer Datei gespeichert werden. Dann kann man sie beim Auspacken verwenden.

Wenn die Größe nicht bekannt ist, kann man die Größe innerhalb der Schleife um die Anzahl der Ticks im Block ändern

       //langsamer fahren 
ArrayResize(Ticks3,total_ticks+ticks_per_block,10000000); //Großes Array neu skalieren - arbeitet langsamer als das Überschreiben eines kleinen Blocks

Dieser Code erhält die Ticks blockweise. Wenn es nur einen großen Block gibt, wird auch dieser korrekt gezählt. Die Ticks werden nicht in einem großen Array gesammelt, sondern können sofort von Ihrer Strategy(Ticks3[j]) Strategie verarbeitet werden;

    while (ZIPpos<ArraySize(Ticks2)){
       nextSize=Compressor3.ArrToInt(Ticks2,ZIPpos);//Größe des nächsten Blocks, ZIPpos um 4 erhöhen

       uint s = ArrayCopy(tmp,Ticks2,0,ZIPpos,nextSize); // neuen Block nach tmp mit Größe nextSize kopieren
       //sind um den Faktor 3 langsamer ArrayResize(Ticks3,total_ticks+ticks_per_block,10000000); //neue Größe eines großen Arrays - arbeitet langsamer als das Überschreiben eines kleinen Blocks
       //total_ticks=Compressor3.DeCompress(tmp,Ticks3,nextSize,total_ticks);//entpacken Sie den Block und fügen Sie ihn zu Ticks3 hinzu.
       
       total_ticks+=Compressor3.DeCompress(tmp,Ticks3,nextSize,0); //Den Block auspacken und in Ticks3 überschreiben
       ZIPpos+=nextSize;
       for (int j = 0; j < ticks; j++){ Strategy(Ticks3[j]);}//strategie
    };

Sammelt die Ticks aus allen Blöcken in einem großen Array:

    while (ZIPpos<ArraySize(Ticks2)){
       nextSize=Compressor3.ArrToInt(Ticks2,ZIPpos);//Größe des nächsten Blocks, ZIPpos um 4 erhöhen

       uint s = ArrayCopy(tmp,Ticks2,0,ZIPpos,nextSize); // neuen Block nach tmp mit Größe nextSize kopieren
       //slower ArrayResize(Ticks3,total_ticks+ticks_per_block,10000000); //resize a large array - arbeitet langsamer als das Überschreiben eines kleinen Blocks
       total_ticks=Compressor3.DeCompress(tmp,Ticks3,nextSize,total_ticks);//Den Block auspacken und zu Ticks3 hinzufügen
       
       //total_ticks+=Compressor3.DeCompress(tmp,Ticks3,nextSize,0); //den Block entpacken und in Ticks3 überschreiben
       ZIPpos+=nextSize;
       //for (int j = 0; j < ticks; j++){ Strategie(Ticks3[j]);}///Strategie
    };

Oder eine Zeile. Es sollte nur 1 Block aufgezeichnet werden. Wenn mehr - verwenden Sie die 2 obigen Code-Varianten.

total_ticks=Compressor3.DeCompress(Ticks2,Ticks3);