TickCompressor - con compresión de 1 tick a 2-3 bytes de media - librería para MetaTrader 5

Compresión de los datos de tick para su almacenamiento de forma compacta hasta 3,5 veces más compacta que los archivos .tcs MQ. Y para trabajar rápidamente con ellos, ya que se tarda menos tiempo en leer 3 bytes que 60 bytes de la estructura MqlTick.

El tamaño del archivo para 2023 con Ask, Bid, tiempo con compresión ZIP adicional de bloques de datos se puede ver en la captura de pantalla:

Tamaño del archivo en formato .tcs para 2023:

3,56 veces la compresión.

Para almacenar los ticks se utilizan las diferencias de los precios Ask y Bid respecto al precio anterior. A menudo (hasta el 50...70% de todos los ticks) no supera los (-8...7) puntos, y puede registrarse con 4 bits. Ask y Bid se combinan en 1 byte.
Más 1 byte para almacenar la diferencia de tiempo de 0 a 255 milisegundos (en el código hasta 229, los valores por encima de 229 se utilizan para codificar los ticks que están más allá de -8...7 puntos).

Si los precios o los tiempos difieren en valores mayores, se empaquetan en un número mayor de bytes.

Para una compresión adicional se puede aplicar el archivado ZIP. El tamaño de los datos se reduce hasta 2 veces.

Alternativamente, se puede realizar la compresión a 3 bytes, con Ask y Bid de -129 a 128 comprimidos a 8 bits o 1 byte cada uno. Más 1 byte para el tiempo - totalizando 3 bytes para la mayoría de los ticks.
A veces(https://www.mql5.com/ru/forum/499639/page6#comment_58544810), si hay más ticks comprimidos a 2 bytes que a 4 bytes, es más eficiente comprimir a 3 bytes. Tienes que mirar las estadísticas del instrumento.
Puede cambiar la compresión máxima a 3 bytes con el comando:

#define  compressTo3Bytes // comprimir los ticks a 3 bytes en lugar de 2.

Elementos de tick a almacenar comprimidos

Se programan 3 variantes de elementos de tick para almacenar:

1. Ask, Bid, time_msc
2. Ask, Bid, time_msc, volume_real
3. Todos los elementos Ask, Bid, Last, time_msc, volume_real, flags (el volumen int se calcula a partir de volume_real).

También se pueden comprimir adicionalmente en ZIP. Habrá 6 variantes en total

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

Antes de iniciar la compresión, es necesario pasar a la clase la variante de almacenamiento de ticks y algunos parámetros estándar utilizados para los cálculos y la normalización de los precios.

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

Si el Asesor Experto utiliza banderas, se pueden restaurar de los cambios de precios por el comando

#define  RestoreFlags // restablecer las banderas de tick de cambio ask, bid, volume - añadirá un 7% al tiempo de generación de tick 931 en lugar de 869ms

Se adjunta el Asesor Experto para la prueba de compresión, que dará estadísticas sobre la velocidad y la tasa de compresión. Puede ver un ejemplo de compresión y descompresión de ticks en él.

Puede ver un ejemplo del Asesor Experto para operaciones aquí https://www.mql5.com/es/code/65821.

Estadísticas para compresión a 2 y 3 bytes:

Ejemplos de código

Compresión de ticks

Bloque a bloque:

    int ZIPpos=0;//contador de bytes comprimidos
    if(Amount>ticks_per_block){// > 1 bloque - pegado de bloques de 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); //copiar al final de Ticks2
       }
    }else{//1 bloque - descomprimir directamente en Ticks2
       Compressor2.Compress(Ticks, Ticks2, 0, Amount);
    } 

Si el número de ticks en 1 bloque es mayor que el número total de ticks en el array, se comprimirá en 1 bloque.

Si necesita comprimir siempre en 1 bloque, puede utilizar

Compressor2.Compress(Ticks,Ticks2); 

Pero la velocidad de descompresión de un bloque tan grande o muy grande puede ser 2 veces más lenta. También habrá un gran consumo de memoria para un bloque grande.

Desempaquetar ticks

Al desempaquetar es deseable conocer el número de ticks empaquetados. El array receptor debe tener este tamaño.

ArrayResize(Ticks3,Amount);

El tamaño se puede guardar en un archivo, por ejemplo. Y luego utilizarlo al desempaquetar.

Si se desconoce el tamaño, se puede cambiar el tamaño dentro del bucle por el número de ticks del bloque

       /disminuye la velocidad 
ArrayResize(Ticks3,total_ticks+ticks_per_block,10000000); //redimensionar un array grande - funciona más lento que sobrescribir un bloque pequeño

Este código obtiene los ticks bloque a bloque. Si sólo hay un bloque grande, también lo cuenta correctamente. Los ticks no son recolectados en un array grande, sino que pueden ser procesados inmediatamente por su estrategia Strategy(Ticks3[j]);

    while (ZIPpos<ArraySize(Ticks2)){
       nextSize=Compressor3.ArrToInt(Ticks2,ZIPpos);//dimensiona el siguiente bloque, incrementa ZIPpos en 4

       uint s = ArrayCopy(tmp,Ticks2,0,ZIPpos,nextSize); // copiar nuevo bloque a tmp con tamaño nextSize
       //más lento por un factor de 3 ArrayResize(Ticks3,total_ticks+ticks_per_block,10000000); //redimensionar un array grande - funciona más lento que sobrescribir un bloque pequeño
       //total_ticks=Compressor3.DeCompress(tmp,Ticks3,nextSize,total_ticks);//descomprime el bloque y añádelo a Ticks3.
       
       total_ticks+=Compressor3.DeCompress(tmp,Ticks3,nextSize,0); //descomprimir el bloque y sobrescribirlo en Ticks3
       ZIPpos+=nextSize;
       for (int j = 0; j < ticks; j++){ Strategy(Ticks3[j]);}/estrategia
    };

Recoge los ticks de todos los bloques en un array grande:

    while (ZIPpos<ArraySize(Ticks2)){
       nextSize=Compressor3.ArrToInt(Ticks2,ZIPpos);//dimensiona el siguiente bloque, incrementa ZIPpos en 4

       uint s = ArrayCopy(tmp,Ticks2,0,ZIPpos,nextSize); // copiar nuevo bloque a tmp con tamaño nextSize
       /más lento ArrayResize(Ticks3,total_ticks+ticks_per_block,10000000); //redimensionar un array grande - funciona más lento que sobrescribir un bloque pequeño
       total_ticks=Compressor3.DeCompress(tmp,Ticks3,nextSize,total_ticks);//descomprimir el bloque y añadirlo a Ticks3
       
       //total_ticks+=Compressor3.DeCompress(tmp,Ticks3,nextSize,0); //descomprimir el bloque y sobrescribirlo en Ticks3
       ZIPpos+=nextSize;
       //for (int j = 0; j < ticks; j++){ Estrategia(Ticks3[j]);}//estrategia
    };

O una sola línea. Sólo debe registrarse 1 bloque. Si hay más, utilice las dos variantes de código anteriores.

total_ticks=Compressor3.DeCompress(Ticks2,Ticks3);