Библиотеки: TickCompressor - со сжатием 1 тика до 2-3 байт в срднем - страница 4

      if (blockSize==0){
         blockSize   = this.ArrToInt2(m,r);   // размер данных блока (байт)
         ticks_count = this.ArrToInt2(m,r+4); // точное количество тиков в блоке
         // r+8..r+11: uint last_time (время последнего тика блока)
         r += 12; // пропускаем 12-байтный заголовок 
         if(ArraySize(T) < dst_start + ticks_count){
            ArrayResize(T, dst_start + ticks_count, ticks_count);
         }
      }
Здесь можно посчитать сразу общее число тиков в архиве со всеми блоками. И тогда сделать один ArrayResize.
fxsaber #:

Int - для скорости? Потому что для приращения в пипсах он явно избыточен.

Какая то не та версия у вас.
Сейчас распаковка такая

         case 1:{//распаковка 3-байтных тиков (98.5% тиков) 125mb
//без нормализации     shortest pass 0:00:00.264, longest pass 0:00:00.289, average pass 0:00:00.269
//с нормализацией.     shortest pass 0:00:00.456, longest pass 0:00:00.487, average pass 0:00:00.464  1 файл примерно та же скорость
//ZIP без нормализации shortest pass 0:00:00.677, longest pass 0:00:00.707, average pass 0:00:00.687
//ZIP с нормализацией  shortest pass 0:00:00.864, longest pass 0:00:00.912, average pass 0:00:00.873
            long l_tp=this.tp, l_ap=this.ap, l_bp=this.bp;
            ushort dt_u;
            while (r < end_pos){
               dt_u = (ushort)(m[r] | (m[r+1] << 8));
               if(dt_u < 65528){
                  l_tp += dt_u; db = m[r+2]; l_bp += (db & 15) - 8; l_ap += (db >> 4) - 8;
                  r += 3;
               }else{
                  r += 2;
                  #define C(i, f1, f2, f3) case 65535-i: l_tp+=ArrTo##f1(m,r); l_bp+=ArrTo##f2(m,r); l_ap+=ArrTo##f3(m,r); break;
                  switch(dt_u){
                     C(7,Long,Int,Int)   C(6,Ushort,Int,Int)
                     C(5,Long,Char,Int)  C(4,Ushort,Char,Int)
                     C(3,Long,Int,Char)  C(2,Ushort,Int,Char)
                     C(1,Long,Char,Char) C(0,Ushort,Char,Char)
                  }
                  #undef C
               }
               SetAskBid(T[tick++], l_tp, l_ap, l_bp);
            }
            this.tp=l_tp; this.ap=l_ap; this.bp=l_bp;
            break;
         }

         case 4:{//сверхбыстрая распаковка всех полей тика (линейные 6 байт напрямую из массива) 313mb
//без нормализации     shortest pass 0:00:00.491, longest pass 0:00:00.580, average pass 0:00:00.503
//с нормализацией      shortest pass 0:00:00.946, longest pass 0:00:01.046, average pass 0:00:00.961
//ZIP без нормализации shortest pass 0:00:01.525, longest pass 0:00:01.573, average pass 0:00:01.536
//ZIP с нормализацией  shortest pass 0:00:01.943, longest pass 0:00:01.972, average pass 0:00:01.956
            long l_tp=this.tp, l_ap=this.ap, l_bp=this.bp, l_lp=this.lp;
            uchar ba, lv_hi;
            ushort dt_u;
            while (r < end_pos){
               dt_u = (ushort)(m[r] | (m[r+1]<<8));
               if(dt_u < 65535){//98% тиков: читаем 6 байт напрямую в поля
                  l_tp += dt_u;
                  fl = m[r+2];
                  ba = m[r+3];
                  l_bp += (ba & 15) - 8;
                  l_ap += (ba >> 4) - 8;
                  lv_hi = m[r+5];
                  v = m[r+4] | ((lv_hi & 15) << 8);
                  l_lp += (lv_hi >> 4) - 8;
                  r += 6;
               }else{//2% редких тиков
                  r += 2;
                  fl = m[r++];
                  l_tp += ArrToUint(m,r);
                  l_bp += ArrToInt(m,r);
                  l_ap += ArrToInt(m,r);
                  l_lp += ArrToInt(m,r);
                  v = ArrToUint(m,r);
               }
               SetAllTick(T[tick++], l_tp, l_ap, l_bp, l_lp, v, fl);
            }
            this.tp=l_tp; this.ap=l_ap; this.bp=l_bp; this.lp=l_lp;
            break;
         }
Aleksei Kuznetsov #:

Какая то не та версия у вас.
Сейчас распаковка такая

Такая же версия. Вы почему-то иногда отдаете четыре байта на хранение приращения цены.


Да и здесь избыток, вроде.

      // каждый блок автономный: первый тик блока записан полностью
      this.tp=ArrToLong(m,r); this.ap=ArrToLong(m,r); this.bp=ArrToLong(m,r);

Int(четыре байта) хватает с запасом для хранения целочисленной цены, включая отрицательные (нефть...).

Новый кодек жмет на ~40% слабее старого. Проверял на золоте. Скорость буду смотреть.
fxsaber #:
Здесь можно посчитать сразу общее число тиков в архиве со всеми блоками. И тогда сделать один ArrayResize.

MathTicker не собирает все тики в один большой массив, а работает блоками по 50000 тиков. Т.е. расширение размера 1 раз на первом блоке.

Но теоретически такое использование возможно. ИИ написал быстро.

   int CalcTotalTicks(const uchar &m[], int src_start=0, int m_size=0){
      if(m_size <= 0){ m_size = ArraySize(m); }
      int pos = src_start, total_ticks = 0;
      while(pos + 12 <= m_size){
         int bSize  = this.ArrToInt2(m, pos);
         int bTicks = this.ArrToInt2(m, pos + 4);
         if(bSize <= 0 || pos + 12 + bSize > m_size){ break; }
         total_ticks += bTicks;
         pos += 12 + bSize;
      }
      return total_ticks;
   }

   int DeCompressAll(uchar &m[], MqlTick &T[], int src_start=0){
      int m_size = ArraySize(m);
      int total_ticks = this.CalcTotalTicks(m, src_start, m_size);
      if(total_ticks <= 0){ return 0; }
      ArrayResize(T, total_ticks);
      int pos = src_start, dst = 0;
      while(pos + 12 <= m_size && dst < total_ticks){
         int bSize = this.ArrToInt2(m, pos);
         if(bSize <= 0 || pos + 12 + bSize > m_size){ break; }
         dst = this.DeCompress(m, T, pos, 0, dst);
      }
      return dst;
   }

Остальной код без изменений.

Файл TickCompressor обновил.

fxsaber #:
Новый кодек жмет на ~40% слабее старого. Проверял на золоте. Скорость буду смотреть.
Значит хорошо сожмется в ZIP. А с 1й распаковкой на оптимизацию скорость будет как от несжатого.
Кодек Размер (Gb) Время на распаковку (секунды) Время на распаковку (секунды) + Normalize.mqh
Старый 2.1 26.3 14.9
Новый 2.7 20.3 13.4

Сохранил золото с 2020 года - 877 млн тиков (3.5 Gb в tkc): каждый месяц отдельный файл с единственным блоком (по аналогии с tkc). Все результаты с нормализацией.

Aleksei Kuznetsov #:

MathTicker не собирает все тики в один большой массив, а работает блоками по 50000 тиков.

Рассматриваю еще другой вариант использования Вашей библиотеки. Обновленный MathTicker еще не смотрел.
fxsaber #:

Такая же версия. Вы почему-то иногда отдаете четыре байта на хранение приращения цены.


Да и здесь избыток, вроде.

Int(четыре байта) хватает с запасом для хранения целочисленной цены, включая отрицательные (нефть...).

Блоки теперь независимы  и в начале каждого пишутся точные цены, все остальное  - дельты.

Это сделано для распаковки ZIP с нужной даты, чтобы не распаковывать весь год и искать дату - быстро ищется нужный блок и в нем уже есть начальная цена, распаковываем начиная с него.
Aleksei Kuznetsov #:
Блоки теперь независимы  и в начале каждого пишутся точные цены, все остальное  - дельты.

Это сделано для распаковки ZIP с нужной даты, чтобы не распаковывать весь год и искать дату - быстро ищется нужный блок и в нем уже есть начальная цена, распаковываем начиная с него.

Я про другое.

long   ArrToLong  (const uchar &m[], int &r) { r += 8; return (long)((ulong)(uint)(m[r-8] | (m[r-7] << 8) | (m[r-6] << 16) | ((uint)m[r-5] << 24)) | ((ulong)(uint)(m[r-4] | (m[r-3] << 8) | (m[r-2] << 16) | ((uint)m[r-1] << 24)) << 32)); }

Вы на полноценную цену выделяете восемь байтов, когда четырех хватает.

А на дельту выделяете четыре байта в 75% switch-вариантов.


Вот здесь на дельту было по два байта.

Форум по трейдингу, автоматическим торговым системам и тестированию торговых стратегий

Библиотеки: TickCompressor - со сжатием 1 тика до 2-3 байт в срднем

fxsaber, 2026.11.14 16:23

    case 12: this.tp+=ArrToUchar (m,r); this.bp+=ArrToShort(m,r); this.ap+=ArrToShort(m,r); break;
    case 13: this.tp+=ArrToUshort(m,r); this.bp+=ArrToShort(m,r); this.ap+=ArrToShort(m,r); break;
    case 14: this.tp+=ArrToLong  (m,r); this.bp+=ArrToShort(m,r); this.ap+=ArrToShort(m,r); break;
Возможно, по этой причине вырос размер файла.
fxsaber #:

Такая же версия. Вы почему-то иногда отдаете четыре байта на хранение приращения цены.


Да и здесь избыток, вроде.

Int(четыре байта) хватает с запасом для хранения целочисленной цены, включая отрицательные (нефть...).

Уже обсуждал это с ИИ потому и сделал long. 
Переход на 32-битный int для хранения опорных цен ( ap , bp , lp ) в начале блока требует строгого контроля диапазона значений, так как максимальное положительное значение int составляет 2 147 483 647 (около 2.14 млрд пунктов).
Плюсы хранения опорных цен в int
  • Экономия места на диске: Вы экономите 8 байт на блок в режиме BidAsk (два поля по 4 байта вместо 8) и 12 байт на блок в режиме All ( ap , bp , lp ).
  • Чуть быстрее чтение заголовка блока: Меньше сдвигов при сборке 32-битного числа из байтового массива по сравнению с 64-битным long .
Минусы и критические риски
  • Риск переполнения (главный минус): На инструментах с высокой ценой и мелким шагом ( Point ) значение ToLong(price) легко превышает 2.14 млрд. Например:
    • Индексы (US30, DAX, NAS100) при цене 45 000.00 и Point = 0.01 дают 4 500 000 (пока влезает), но при Point = 0.001 или на криптовалютах ( BTCUSD при цене 100 000.00 и Point = 0.0001 или 0.00001 ) число достигает 10 000 000 000 , что вызовет переполнение int , уход цены в минус и полное искажение котировок.
    • Аномальные выбросы (шпильки) на неликвидных бумагах или некорректные нулевые/огромные тики в истории также могут превысить лимит int .
  • Ничтожный выигрыш в масштабе архива: Блок содержит 50 000 тиков и весит ~150–300 КБ. Экономия 8–12 байт раз в 50 000 тиков составит менее 0.005% от размера файла (~8 КБ на 100 МБ архива).
  • Ломка обратной совместимости: Все уже записанные .bin -архивы перестанут читаться и потребуют полной перезаписи.
Вывод
Овчинка не стоит выделки. Экономия в 8–12 байт на блок из 50 000 тиков практически равна нулю, а риск словить переполнение на криптовалютах, индексах или инструментах с высокой точностью ( Digits >= 5 при цене > 21.4) слишком высок. Лучше оставить опорные цены в long .
Оставляем опорные цены в long или хотите реализовать гибридный вариант с проверкой диапазона int при записи?