Библиотеки: MathTicker - генератор тиков в математическом режиме - страница 13

Код выложил. 
Файл TickCompressor.mqh при просмотре в браузере показывает испорченные русские комментарии, а при скачивании - они в порядке. Остальные файлы в порядке в обоих местах.

Aleksei Kuznetsov #:

Новый режим NormalizeMqlTick — лучший баланс скорости и точности:

Он работает в 1.6 раза быстрее стандартной NormalizeDouble и всего на ~4% (10 мс) медленнее самого быстрого режима без нормализации, но при этом обеспечивает 100% точное совпадение (0 расхождений и maxDiff = 0.00e+00) с оригинальными тиками терминала MT5.

Возможно, я неправильно понял.
int Sum = 0;
int Total = 0;

bool IsNorm( const double Price )
{
  static const int Pow10 = (int)MathPow(10, _Digits);
  const int PricePips = (int)(Price * Pow10 + 0.01);
  
  return(Price == PricePips / Pow10);
}

void OnTick()
{
  MqlTick Tick;  
  
  Total += SymbolInfoTick(_Symbol, Tick) << 1;
  Sum += IsNorm(Tick.bid) + IsNorm(Tick.ask);
}

double OnTester() { return(100.0 * Sum / Total); } // 0.99%
fxsaber #:
Возможно, я неправильно понял.
Вот так
double Sum1 = 0;     // Накопленная сумма исходных цен (Bid + Ask) от сервера MT5
double Sum2 = 0;     // Накопленная сумма цен после восстановления через (double)PricePips / Pow10
long   DiffBits = 0; // Счётчик строгих побитовых несовпадений (0 ULP) между исходной и восстановленной ценой

// Объединение для чтения 64-битного представления double как целого беззнакового числа ulong
union DoubleBits {
   double d;
   ulong  u;
};

// Перевод цены в целые пункты, обратное восстановление и побитовая сверка с оригиналом
double NormPrice(const double Price) {
   static const double Pow10 = MathPow(10.0, _Digits);   // Множитель 10^Digits (вычисляется один раз при первом вызове)
   const long PricePips = (long)MathRound(Price * Pow10); // Точное округление цены в целые пункты (long защищает от переполнения)
   const double Res = (double)PricePips / Pow10;          // Восстановление цены делением двух точных чисел IEEE 754

   // Строгая побитовая проверка всех 64 бит (оператор == в MQL5 допускает погрешность ~1e-15, поэтому сравниваем через union)
   DoubleBits a, b;
   a.d = Price;
   b.d = Res;
   if(a.u != b.u) DiffBits++;

   return Res; // Возвращаем восстановленную цену для накопления контрольной суммы Sum2
}

void OnTick() {
   MqlTick Tick;
   if(!SymbolInfoTick(_Symbol, Tick)) return; // Получаем текущий тик из тестера стратегий

   Sum1 += Tick.bid + Tick.ask;                       // Суммируем оригинальные цены тика
   Sum2 += NormPrice(Tick.bid) + NormPrice(Tick.ask); // Суммируем восстановленные цены и проверяем каждый тик побитово
}

double OnTester() {
   // Выводим контрольные суммы, их разницу и точное количество побитовых расхождений за весь прогон
   PrintFormat("Sum1=%.5f - Sum2=%.5f = %.2e | Bitwise diffs=%I64d", Sum1, Sum2, Sum1 - Sum2, DiffBits);
   return (double)DiffBits; // Возвращаем число побитовых расхождений как результат прогона (идеал = 0)
}
2026.11.16 23:49:58   Sum1=16501035889.38952 - Sum2=16501035889.38952 = 0.00e+00 | Bitwise diffs=0
final balance 1000000.00 RUB
OnTester result 0


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

Библиотеки: MathTicker - генератор тиков в математическом режиме

fxsaber, 2026.11.18 14:59

178 млн. тиков золота, виртуалка выключена. Замеры - в секундах shortest pass оптимизации на одном Агенте.


Библиотека Нет нормализации NormalizeDouble
MathTicker 1.792 3.570
EAToMath 1.557 2.608

На новой версии с нормализацией: 

shortest pass 0:00:03.120, longest pass 0:00:03.166, average pass 0:00:03.144


Без нормализации:

shortest pass 0:00:01.771, longest pass 0:00:01.810, average pass 0:00:01.785


Заметное ускорение, отлично!


ЗЫ Без нормализации на границе 100 млн тиков в секунду.

Aleksei Kuznetsov #:
Вот так

Да, у меня ошибка при делении была.

Ваш результат - это что-то новое для меня. Будто NormalizeDouble  в Тестере и в Терминале - это две разные функции.

fxsaber #:

Да, у меня ошибка при делении была.

Ваш результат - это что-то новое для меня. Будто NormalizeDouble  в Тестере и в Терминале - это две разные функции.

Кажется все таки новая нормализация не совпадает с MqlTick.
До этого я проверял на 2 значтом символе. И был 0.
На 5 знаке так:


Core 1    2026.11.16 23:59:58   Sum1=196757739.43119 - Sum2=196757739.43119 = 0.00e+00 | Bitwise diffs=8484997

Битовых расхождений много, но дельта = 0.
Чуть позже еще поэкспериментирую. 

fxsaber #:

Будто NormalizeDouble  в Тестере и в Терминале - это две разные функции.

Вроде, одинаковые.
bool IsNorm( const double Price ) { return(Price == NormalizeDouble(Price, _Digits)); }

int OnInit()
{
  const double Pow10 = MathPow(10, _Digits);
  int Sum = 0;
  
  for (int i = 0; i < 1e5; i++)
    Sum += !IsNorm(i / Pow10);
    
  Print(Sum); // Tester - 43, Terminal - 43.
  
  return(INIT_FAILED); 
}
Но результат ненулевой. Digits = 2.

Идея с быстрой нормализацией не оказалась точной. Вот новый эксперт

double SumOrig    = 0; // Накопленная сумма исходных цен (Bid + Ask) от сервера MT5
double SumNew     = 0; // Накопленная сумма цен после деления (double)PricePips / Pow10
double SumStd     = 0; // Накопленная сумма цен после стандартной NormalizeDouble(...)
double SumRaw     = 0; // Накопленная сумма цен без нормализации (PricePips * _Point)
long   DiffNew    = 0; // Счётчик побитовых расхождений (0 ULP) для (double)PricePips / Pow10
long   DiffStd    = 0; // Счётчик побитовых расхождений (0 ULP) для NormalizeDouble(...)
long   DiffRaw    = 0; // Счётчик побитовых расхождений (0 ULP) для варианта без нормализации
bool   PrintedNew = false; // Флаг вывода первого примера расхождения для New
bool   PrintedRaw = false; // Флаг вывода первого примера расхождения для Raw (без нормализации)

union DoubleBits {
   double d;
   ulong  u;
};

void CheckPrice(const double Price, double &resNew, double &resStd, double &resRaw) {
   static const double Pow10 = MathPow(10.0, _Digits);        // Множитель 10^Digits
   const long PricePips = (long)MathRound(Price * Pow10);      // Точное округление цены в целые пункты

   resNew = (double)PricePips / Pow10;                         // 1) Деление (double)LP / MathPow(10, Digits)
   resStd = NormalizeDouble(PricePips * _Point, _Digits);      // 2) Стандартная функция MQL5 NormalizeDouble
   resRaw = PricePips * _Point;                                // 3) Без нормализации (LP * point)

   DoubleBits orig, bNew, bStd, bRaw;
   orig.d = Price;
   bNew.d = resNew;
   bStd.d = resStd;
   bRaw.d = resRaw;

   if(orig.u != bNew.u) {
      DiffNew++;
      if(!PrintedNew) {
         PrintedNew = true;
         PrintFormat("Пример расхождения New: Orig=%.17g (0x%016I64X) | New=%.17g (0x%016I64X) | Разница=%+.2e",
                     Price, orig.u, resNew, bNew.u, resNew - Price);
      }
   }
   if(orig.u != bStd.u) DiffStd++;
   if(orig.u != bRaw.u) {
      DiffRaw++;
      if(!PrintedRaw) {
         PrintedRaw = true;
         PrintFormat("Пример расхождения Raw (без норм.): Orig=%.17g (0x%016I64X) | Raw=%.17g (0x%016I64X) | Разница=%+.2e",
                     Price, orig.u, resRaw, bRaw.u, resRaw - Price);
      }
   }
}

void OnTick() {
   MqlTick Tick;
   if(!SymbolInfoTick(_Symbol, Tick)) return;

   double bidNew, bidStd, bidRaw, askNew, askStd, askRaw;
   CheckPrice(Tick.bid, bidNew, bidStd, bidRaw);
   CheckPrice(Tick.ask, askNew, askStd, askRaw);

   SumOrig += Tick.bid + Tick.ask;
   SumNew  += bidNew + askNew;
   SumStd  += bidStd + askStd;
   SumRaw  += bidRaw + askRaw;
}

double OnTester() {
   PrintFormat("[%s | Digits=%d | Point=%g] Orig=%.5f | New=%.5f (delta=%+.2e, BitDiffs=%I64d) | NormalizeDouble=%.5f (delta=%+.2e, BitDiffs=%I64d) | Raw=%.5f (delta=%+.2e, BitDiffs=%I64d)",
               _Symbol, _Digits, _Point,
               SumOrig,
               SumNew, SumNew - SumOrig, DiffNew,
               SumStd, SumStd - SumOrig, DiffStd,
               SumRaw, SumRaw - SumOrig, DiffRaw);
   return (double)DiffStd;
}
2024.01.02 00:00:00   Пример расхождения Raw (без норм.): Orig=1.1046199999999999 (0x3FF1AC8605681ECD) | Raw=1.1046200000000002 (0x3FF1AC8605681ECE) | Разница=+2.22e-16
2024.01.02 00:21:29   Пример расхождения New: Orig=1.1044100000000001 (0x3FF1ABA9D1F6017A) | New=1.1044099999999999 (0x3FF1ABA9D1F60179) | Разница=-2.22e-16
2026.11.16 23:59:58   [EURUSD | Digits=5 | Point=1e-05] Orig=196757739.43119 | New=196757739.43119 (delta=+0.00e+00, BitDiffs=8484997) | NormalizeDouble=196757739.43119 (delta=+0.00e+00, BitDiffs=0) | Raw=196757739.43119 (delta=+0.00e+00, BitDiffs=72497682)

Новая нормализация так же как и без нормализации имеет отличия.
И оказалось, что тики из MqlTick точно совпадают с нормализованными. Это сервер MQ демо. На F-ам 4 знака. Можете проверить на еще каком то дилере?
ИИ предполагает, что каждый ДЦ сам формирует тики как хочет...

А новую нормализацию убираю. Оставлю только стандартную

Aleksei Kuznetsov #:

Можете проверить на еще каком то дилере?

RannForex.

[SP500 | Digits=1 | Point=0.1] Orig=22866876203.58401 | New=22866876203.58401 (delta=+0.00e+00, BitDiffs=0) | NormalizeDouble=22866876203.58401 (delta=+0.00e+00, BitDiffs=0) | Raw=22866876203.58401 (delta=+0.00e+00, BitDiffs=1121122)

[XAUUSD | Digits=2 | Point=0.01] Orig=244226494454.41660 | New=244226494454.41660 (delta=+0.00e+00, BitDiffs=0) | NormalizeDouble=244226494454.41660 (delta=+0.00e+00, BitDiffs=0) | Raw=244226494454.41660 (delta=+0.00e+00, BitDiffs=7264665)

[XTIUSD | Digits=2 | Point=0.01] Orig=476327985.37002 | New=476327985.37002 (delta=+0.00e+00, BitDiffs=0) | NormalizeDouble=476327985.37002 (delta=+0.00e+00, BitDiffs=0) | Raw=476327985.37002 (delta=+0.00e+00, BitDiffs=692625)

[XAGUSD | Digits=3 | Point=0.001] Orig=1628844377.06485 | New=1628844377.06485 (delta=+0.00e+00, BitDiffs=0) | NormalizeDouble=1628844377.06485 (delta=+0.00e+00, BitDiffs=0) | Raw=1628844377.06485 (delta=+0.00e+00, BitDiffs=4767096)

[USDJPY | Digits=3 | Point=0.001] Orig=0.00000 | New=0.00000 (delta=+0.00e+00, BitDiffs=0) | NormalizeDouble=0.00000 (delta=+0.00e+00, BitDiffs=0) | Raw=0.00000 (delta=+0.00e+00, BitDiffs=0)

[EURNOK | Digits=5 | Point=1e-05] Orig=110262349.30390 | New=110262349.30390 (delta=+0.00e+00, BitDiffs=297607) | NormalizeDouble=110262349.30390 (delta=+0.00e+00, BitDiffs=0) | Raw=110262349.30390 (delta=+0.00e+00, BitDiffs=5093218)

[AUDUSD | Digits=5 | Point=1e-05] Orig=0.00000 | New=0.00000 (delta=+0.00e+00, BitDiffs=0) | NormalizeDouble=0.00000 (delta=+0.00e+00, BitDiffs=0) | Raw=0.00000 (delta=+0.00e+00, BitDiffs=0)

[EURUSD | Digits=5 | Point=1e-05] Orig=8384822.26556 | New=8384822.26556 (delta=+0.00e+00, BitDiffs=255958) | NormalizeDouble=8384822.26556 (delta=+0.00e+00, BitDiffs=0) | Raw=8384822.26556 (delta=+0.00e+00, BitDiffs=3097900)

Тики всегда нормализованы. При этом простые методы нормализации показали совпадение при малых Digits. Но это именно совпадение, а не правило.

Но есть вариант всегда. Обратите внимание на AUDUSD. На интервале его цена все время ниже единицы.


Алгоритм NormalzieDouble состоит из двух слагаемых (факт):

  1. Целая часть цены.
  2. Дробная часть в пипсах деленная на степень 10.
Соответственно, если цена ниже единицы, то первое слагаемое всегда ноль. Именно по этой причине AUDUSD выдал такой результат.
fxsaber #:

Алгоритм NormalzieDouble состоит из двух слагаемых (факт):

  1. Целая часть цены.
  2. Дробная часть в пипсах деленная на степень 10.
Из этого факта следует, что идеальная замена для распаковки тиков будет подобная.
double Norm( const long PricePips, const int Digits )
{
  static const int iPow10[] = {1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8};
  static const int dPow10[] = {1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8};

  const long Num = PricePips / iPow10[Digits];
  
  return((double)(Num + (PricePips - Num * iPow10[Digits]) / dPow10[Digits]));
}

Не проверял, но уверен, что будет работать. Нужны замеры, чтобы выявить наиболее оптимальный код. Например, два массива, допускаю, не лучший вариант.